custom transform

Author: MrWangJustToDo

packages/core/index.d.ts

@@ -17,6 +17,10 @@ declare class File$1 {
 	hasDoRaw: boolean;
 	rawLength?: number;
 	syntaxFile: Record<number, SyntaxLineWithTemplate>;
+	plainFile: Record<number, {
+		value: string;
+		template?: string;
+	}>;
 	hasDoSyntax: boolean;
 	syntaxLength?: number;
 	highlighterName?: DiffHighlighter["name"];
@@ -93,7 +97,15 @@ export declare class DiffFile {
 	onAllCollapse: (mode: "split" | "unified") => void;
 	getOldFileContent: () => string;
 	getNewFileContent: () => string;
+	getOldPlainLine: (lineNumber: number) => {
+		value: string;
+		template?: string;
+	};
 	getOldSyntaxLine: (lineNumber: number) => SyntaxLineWithTemplate;
+	getNewPlainLine: (lineNumber: number) => {
+		value: string;
+		template?: string;
+	};
 	getNewSyntaxLine: (lineNumber: number) => SyntaxLineWithTemplate;
 	subscribe: (listener: (() => void) & {
 		isSyncExternal?: boolean;
@@ -108,10 +120,18 @@ export declare class DiffFile {
 		hasBuildUnified: boolean;
 		oldFileLines: Record<number, string>;
 		oldFileDiffLines: Record<string, DiffLineItem>;
+		oldFilePlainLines: Record<number, {
+			value: string;
+			template?: string;
+		}>;
 		oldFileSyntaxLines: Record<number, SyntaxLineWithTemplate>;
 		oldFilePlaceholderLines: Record<string, boolean>;
 		newFileLines: Record<number, string>;
 		newFileDiffLines: Record<string, DiffLineItem>;
+		newFilePlainLines: Record<number, {
+			value: string;
+			template?: string;
+		}>;
 		newFileSyntaxLines: Record<number, SyntaxLineWithTemplate>;
 		newFilePlaceholderLines: Record<string, boolean>;
 		splitLineLength: number;
@@ -157,10 +177,18 @@ export declare class DiffFile {
 		hasBuildUnified: boolean;
 		oldFileLines: Record<number, string>;
 		oldFileDiffLines: Record<string, DiffLineItem>;
+		oldFilePlainLines: Record<number, {
+			value: string;
+			template?: string;
+		}>;
 		oldFileSyntaxLines: Record<number, SyntaxLineWithTemplate>;
 		oldFilePlaceholderLines: Record<string, boolean>;
 		newFileLines: Record<number, string>;
 		newFileDiffLines: Record<string, DiffLineItem>;
+		newFilePlainLines: Record<number, {
+			value: string;
+			template?: string;
+		}>;
 		newFileSyntaxLines: Record<number, SyntaxLineWithTemplate>;
 		newFilePlaceholderLines: Record<string, boolean>;
 		splitLineLength: number;
@@ -384,35 +412,64 @@ export declare const checkCurrentLineIsHidden: (diffFile: DiffFile, lineNumber:
 };
 export declare const checkDiffLineIncludeChange: (diffLine?: DiffLine) => boolean;
 export declare const disableCache: () => void;
+export declare const doAfterTransform: (content: string) => string;
+export declare const doPreTransform: (content: string) => string;
 export declare const getDiffRange: (additions: DiffLine[], deletions: DiffLine[], { getAdditionRaw, getDeletionRaw, getAdditionSyntax, getDeletionSyntax, }: {
 	getAdditionRaw: (lineNumber: number) => string;
 	getDeletionRaw: (lineNumber: number) => string;
 	getAdditionSyntax: (lineNumber: number) => SyntaxLineWithTemplate;
 	getDeletionSyntax: (lineNumber: number) => SyntaxLineWithTemplate;
 }) => void;
 export declare const getLang: (fileName: string) => string;
-export declare const getPlainTemplate: ({ diffLine, rawLine, operator, }: {
+export declare const getPlainDiffTemplate: ({ diffLine, rawLine, operator, }: {
 	diffLine: DiffLine;
 	rawLine: string;
 	operator: "add" | "del";
 }) => void;
+export declare const getPlainLineTemplate: (line: string) => string;
 export declare const getSplitContentLines: (diffFile: DiffFile) => DiffSplitContentLineItem[];
 export declare const getSplitLines: (diffFile: DiffFile) => DiffSplitLineItem[];
-export declare const getSyntaxTemplate: ({ diffLine, syntaxLine, operator, }: {
+export declare const getSyntaxDiffTemplate: ({ diffLine, syntaxLine, operator, }: {
 	diffLine: DiffLine;
 	syntaxLine: SyntaxLineWithTemplate;
 	operator: "add" | "del";
 }) => void;
+export declare const getSyntaxLineTemplate: (line: SyntaxLine) => string;
 export declare const getUnifiedContentLine: (diffFile: DiffFile) => DiffUnifiedContentLineItem[];
 export declare const getUnifiedLines: (diffFile: DiffFile) => DiffUnifiedLineItem[];
 export declare const highlighter: DiffHighlighter;
+export declare const isTransformEnabled: () => boolean;
 export declare const numIterator: <T>(num: number, cb: (index: number) => T) => T[];
 export declare const parseInstance: DiffParser;
 export declare const processAST: (ast: DiffAST) => {
 	syntaxFileObject: Record<number, SyntaxLine>;
 	syntaxFileLineNumber: number;
 };
 export declare const resetDefaultComposeLength: () => void;
+export declare const resetTransform: () => void;
+export declare const setAfterTransform: (fn: (content: string) => string) => void;
+/**
+ * ⚠️ **WARNING: DANGEROUS OPERATION** ⚠️
+ *
+ * Sets a pre-transformation function that will be applied to content before processing.
+ * This is a global state modification that affects all subsequent operations.
+ *
+ * **CAUTION**:
+ * - This function modifies global state and may cause unexpected side effects
+ * - The transformation will be applied to ALL content processing operations
+ * - Multiple calls will overwrite the previous transform function
+ * - Ensure proper error handling in your transform function to avoid breaking the entire pipeline
+ *
+ * @param fn - The transformation function to apply before processing content
+ * @throws {Error} Throws an error if the provided parameter is not a function
+ *
+ * @example
+ * ```typescript
+ * // Use with caution - this affects global behavior
+ * setPreTransform((content) => content.trim());
+ * ```
+ */
+export declare const setPreTransform: (fn: (content: string) => string) => void;
 export declare const versions: string;
 export declare enum DiffFileLineType {
 	hunk = 1,

packages/core/src/diff-file.ts

@@ -105,6 +105,10 @@ export class DiffFile {
 
   #newFileLines?: File["rawFile"];
 
+  #oldFilePlainLines?: File["plainFile"];
+
+  #newFilePlainLines?: File["plainFile"];
+
   #oldFileSyntaxLines?: File["syntaxFile"];
 
   #newFileSyntaxLines?: File["syntaxFile"];
@@ -306,10 +310,14 @@ export class DiffFile {
 
     this.#oldFileLines = this.#oldFileResult?.rawFile;
 
+    this.#oldFilePlainLines = this.#oldFileResult?.plainFile;
+
     this.#newFileResult?.doRaw();
 
     this.#newFileLines = this.#newFileResult?.rawFile;
 
+    this.#newFilePlainLines = this.#newFileResult?.plainFile;
+
     this.fileLineLength = Math.max(
       this.fileLineLength,
       this.#oldFileResult?.maxLineNumber || 0,
@@ -634,10 +642,18 @@ export class DiffFile {
     return this.#oldFileLines?.[lineNumber];
   }
 
+  #getOldPlainLine(lineNumber: number) {
+    return this.#oldFilePlainLines?.[lineNumber];
+  }
+
   #getNewRawLine(lineNumber: number) {
     return this.#newFileLines?.[lineNumber];
   }
 
+  #getNewPlainLine(lineNumber: number) {
+    return this.#newFilePlainLines?.[lineNumber];
+  }
+
   #getOldSyntaxLine(lineNumber: number) {
     return this.#oldFileSyntaxLines?.[lineNumber];
   }
@@ -1349,10 +1365,18 @@ export class DiffFile {
     return this.#newFileResult?.raw;
   };
 
+  getOldPlainLine = (lineNumber: number) => {
+    return this.#oldFilePlainLines?.[lineNumber];
+  };
+
   getOldSyntaxLine = (lineNumber: number) => {
     return this.#oldFileSyntaxLines?.[lineNumber];
   };
 
+  getNewPlainLine = (lineNumber: number) => {
+    return this.#newFilePlainLines?.[lineNumber];
+  };
+
   getNewSyntaxLine = (lineNumber: number) => {
     return this.#newFileSyntaxLines?.[lineNumber];
   };
@@ -1393,10 +1417,12 @@ export class DiffFile {
     const hasBuildUnified = this.#hasBuildUnified;
     const oldFileLines = this.#oldFileLines;
     const oldFileDiffLines = this.#oldFileDiffLines;
+    const oldFilePlainLines = this.#oldFilePlainLines;
     const oldFileSyntaxLines = this.#oldFileSyntaxLines;
     const oldFilePlaceholderLines = this.#oldFilePlaceholderLines;
     const newFileLines = this.#newFileLines;
     const newFileDiffLines = this.#newFileDiffLines;
+    const newFilePlainLines = this.#newFilePlainLines;
     const newFileSyntaxLines = this.#newFileSyntaxLines;
     const newFilePlaceholderLines = this.#newFilePlaceholderLines;
     const splitLineLength = this.splitLineLength;
@@ -1430,10 +1456,12 @@ export class DiffFile {
       hasBuildUnified,
       oldFileLines,
       oldFileDiffLines,
+      oldFilePlainLines,
       oldFileSyntaxLines,
       oldFilePlaceholderLines,
       newFileLines,
       newFileDiffLines,
+      newFilePlainLines,
       newFileSyntaxLines,
       newFilePlaceholderLines,
       splitLineLength,
@@ -1473,10 +1501,12 @@ export class DiffFile {
 
     this.#oldFileLines = data.oldFileLines;
     this.#oldFileDiffLines = data.oldFileDiffLines;
+    this.#oldFilePlainLines = data.oldFilePlainLines;
     this.#oldFileSyntaxLines = data.oldFileSyntaxLines;
     this.#oldFilePlaceholderLines = data.oldFilePlaceholderLines;
     this.#newFileLines = data.newFileLines;
     this.#newFileDiffLines = data.newFileDiffLines;
+    this.#newFilePlainLines = data.newFilePlainLines;
     this.#newFileSyntaxLines = data.newFileSyntaxLines;
     this.#newFilePlaceholderLines = data.newFilePlaceholderLines;
     this.splitLineLength = data.splitLineLength;

packages/core/src/file.ts

@@ -1,8 +1,7 @@
 import { highlighter } from "@git-diff-view/lowlight";
 
 import { Cache } from "./cache";
-import { escapeHtml } from "./escape-html";
-
+import { getPlainLineTemplate, getSyntaxLineTemplate } from "./parse";
 
 import type { DiffAST, DiffHighlighter, DiffHighlighterLang, SyntaxLine } from "@git-diff-view/lowlight";
 
@@ -32,18 +31,6 @@ export type SyntaxLineWithTemplate = SyntaxLine & {
   template?: string;
 };
 
-const getSyntaxLineTemplate = (line: SyntaxLine) => {
-  let template = "";
-
-  line?.nodeList?.forEach(({ node, wrapper }) => {
-    template += `<span data-start="${node.startIndex}" data-end="${node.endIndex}" class="${(
-      wrapper?.properties?.className || []
-    )?.join(" ")}" style="${wrapper?.properties?.style || ""}">${escapeHtml(node.value)}</span>`;
-  });
-
-  return template;
-};
-
 export class File {
   ast?: DiffAST;
 
@@ -55,6 +42,8 @@ export class File {
 
   syntaxFile: Record<number, SyntaxLineWithTemplate> = {};
 
+  plainFile: Record<number, { value: string; template?: string }> = {};
+
   hasDoSyntax: boolean = false;
 
   syntaxLength?: number;
@@ -70,13 +59,15 @@ export class File {
 
     file.ast = data?.ast;
 
-    file.rawFile = data?.rawFile;
+    file.rawFile = data?.rawFile || {};
+
+    file.plainFile = data?.plainFile || {};
 
     file.hasDoRaw = data?.hasDoRaw;
 
     file.rawLength = data?.rawLength;
 
-    file.syntaxFile = data?.syntaxFile;
+    file.syntaxFile = data?.syntaxFile || {};
 
     file.hasDoSyntax = data?.hasDoSyntax;
 
@@ -177,8 +168,14 @@ export class File {
 
     this.rawFile = {};
 
+    this.plainFile = {};
+
     for (let i = 0; i < rawArray.length; i++) {
       this.rawFile[i + 1] = i < rawArray.length - 1 ? rawArray[i] + "\n" : rawArray[i];
+      this.plainFile[i + 1] = {
+        value: this.rawFile[i + 1],
+        template: getPlainLineTemplate(this.rawFile[i + 1]),
+      }
     }
 
     this.hasDoRaw = true;

packages/core/src/parse/diff-tool.ts

@@ -1,7 +1,7 @@
 import { relativeChanges } from "./change-range";
 import { DiffLineType } from "./diff-line";
 import { DiffHunkExpansionType } from "./raw-diff";
-import { getPlainTemplate, getSyntaxTemplate } from "./template";
+import { getPlainDiffTemplate, getSyntaxDiffTemplate } from "./template";
 
 import type { SyntaxLineWithTemplate } from "../file";
 import type { DiffLine } from "./diff-line";
@@ -123,16 +123,16 @@ export const getDiffRange = (
         deletion.changes = delRange;
       }
       if (!addition.plainTemplate || !deletion.plainTemplate) {
-        getPlainTemplate({ diffLine: addition, rawLine: getAdditionRaw(addition.newLineNumber), operator: "add" });
-        getPlainTemplate({ diffLine: deletion, rawLine: getDeletionRaw(deletion.oldLineNumber), operator: "del" });
+        getPlainDiffTemplate({ diffLine: addition, rawLine: getAdditionRaw(addition.newLineNumber), operator: "add" });
+        getPlainDiffTemplate({ diffLine: deletion, rawLine: getDeletionRaw(deletion.oldLineNumber), operator: "del" });
       }
       if (!addition.syntaxTemplate || !deletion.syntaxTemplate) {
-        getSyntaxTemplate({
+        getSyntaxDiffTemplate({
           diffLine: addition,
           syntaxLine: getAdditionSyntax(addition.newLineNumber),
           operator: "add",
         });
-        getSyntaxTemplate({
+        getSyntaxDiffTemplate({
           diffLine: deletion,
           syntaxLine: getDeletionSyntax(deletion.oldLineNumber),
           operator: "del",

packages/core/src/parse/index.ts

@@ -3,5 +3,6 @@ export * from "./change-range";
 export * from "./diff-line";
 export * from "./diff-tool";
 export * from "./template";
+export * from "./transform";
 // main export
 export * from "./diff-parse";