@haklex/rich-diff-core 0.0.94 → 0.0.96

package/dist/compute-delta-stats.d.ts

@@ -0,0 +1,41 @@
+import { SerializedEditorState } from 'lexical';
+export interface DeltaStats {
+    chars: {
+        added: number;
+        removed: number;
+    };
+    lines: {
+        added: number;
+        removed: number;
+    };
+    words: {
+        added: number;
+        removed: number;
+    };
+}
+/**
+ * Computes delta statistics between two Lexical editor states.
+ *
+ * Returns counts of added/removed characters, words, and lines.
+ *
+ * @example
+ * ```ts
+ * const stats = computeDeltaStats(oldState, newState);
+ * console.log(`+${stats.chars.added} / -${stats.chars.removed} chars`);
+ * console.log(`+${stats.words.added} / -${stats.words.removed} words`);
+ * console.log(`+${stats.lines.added} / -${stats.lines.removed} lines`);
+ * ```
+ */
+export declare function computeDeltaStats(oldState: SerializedEditorState, newState: SerializedEditorState): DeltaStats;
+/**
+ * Formats delta stats as a human-readable string.
+ *
+ * @example
+ * ```ts
+ * const stats = computeDeltaStats(oldState, newState);
+ * console.log(formatDeltaStats(stats));
+ * // "+91 lines, +2,122 words, +12,345 chars"
+ * ```
+ */
+export declare function formatDeltaStats(stats: DeltaStats): string;
+//# sourceMappingURL=compute-delta-stats.d.ts.map

package/dist/compute-delta-stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute-delta-stats.d.ts","sourceRoot":"","sources":["../src/compute-delta-stats.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAyB,MAAM,SAAS,CAAC;AAE5E,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1C,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1C,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CAC3C;AAsID;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,qBAAqB,EAC/B,QAAQ,EAAE,qBAAqB,GAC9B,UAAU,CAsBZ;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CA2B1D"}

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+export type { DeltaStats } from './compute-delta-stats';
+export { computeDeltaStats, formatDeltaStats } from './compute-delta-stats';
 export type { DiffHunk, DiffOpType, MarkKind } from './compute-diff';
 export { computeDiff, decorateSubtree, diffMergedNode, diffModifiedNode } from './compute-diff';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACrE,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC5E,YAAY,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACrE,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/index.mjs

@@ -1,3 +1,146 @@
+function extractText(node) {
+  const n = node;
+  if (n.type === "text" && typeof n.text === "string") {
+    return n.text;
+  }
+  if (Array.isArray(n.children)) {
+    return n.children.map(extractText).join("");
+  }
+  return "";
+}
+function extractTextFromState(state) {
+  return state.root.children.map(extractText).join("\n");
+}
+function countWords(text) {
+  if (!text.trim()) return 0;
+  const cjkPattern = /[\u3400-\u4DBF\u4E00-\u9FFF\uF900-\uFAFF]/g;
+  const cjkMatches = text.match(cjkPattern);
+  const cjkCount = cjkMatches ? cjkMatches.length : 0;
+  const nonCjkText = text.replaceAll(cjkPattern, " ");
+  const wordPattern = /[\p{L}\p{N}]+/gu;
+  const wordMatches = nonCjkText.match(wordPattern);
+  const wordCount = wordMatches ? wordMatches.length : 0;
+  return cjkCount + wordCount;
+}
+function countLines(state) {
+  return state.root.children.length;
+}
+function computeCharDiff(oldText, newText) {
+  const oldChars = Array.from(oldText);
+  const newChars = Array.from(newText);
+  const m = oldChars.length;
+  const n = newChars.length;
+  let prefix = 0;
+  while (prefix < m && prefix < n && oldChars[prefix] === newChars[prefix]) {
+    prefix++;
+  }
+  let oldSuffix = m - 1;
+  let newSuffix = n - 1;
+  while (oldSuffix >= prefix && newSuffix >= prefix && oldChars[oldSuffix] === newChars[newSuffix]) {
+    oldSuffix--;
+    newSuffix--;
+  }
+  const oldMiddle = oldChars.slice(prefix, oldSuffix + 1);
+  const newMiddle = newChars.slice(prefix, newSuffix + 1);
+  const MAX_MATRIX_CELLS = 1e5;
+  if (oldMiddle.length * newMiddle.length > MAX_MATRIX_CELLS) {
+    return {
+      removed: oldMiddle.join(""),
+      added: newMiddle.join("")
+    };
+  }
+  if (oldMiddle.length === 0) {
+    return { added: newMiddle.join(""), removed: "" };
+  }
+  if (newMiddle.length === 0) {
+    return { added: "", removed: oldMiddle.join("") };
+  }
+  const om = oldMiddle.length;
+  const nm = newMiddle.length;
+  const dp = Array.from(
+    { length: om + 1 },
+    () => Array.from({ length: nm + 1 }).fill(0)
+  );
+  for (let i2 = 1; i2 <= om; i2++) {
+    for (let j2 = 1; j2 <= nm; j2++) {
+      if (oldMiddle[i2 - 1] === newMiddle[j2 - 1]) {
+        dp[i2][j2] = dp[i2 - 1][j2 - 1] + 1;
+      } else {
+        dp[i2][j2] = Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
+      }
+    }
+  }
+  const removedChars = [];
+  const addedChars = [];
+  let i = om;
+  let j = nm;
+  while (i > 0 && j > 0) {
+    if (oldMiddle[i - 1] === newMiddle[j - 1]) {
+      i--;
+      j--;
+    } else if (dp[i - 1][j] >= dp[i][j - 1]) {
+      removedChars.push(oldMiddle[i - 1]);
+      i--;
+    } else {
+      addedChars.push(newMiddle[j - 1]);
+      j--;
+    }
+  }
+  while (i > 0) {
+    removedChars.push(oldMiddle[--i]);
+  }
+  while (j > 0) {
+    addedChars.push(newMiddle[--j]);
+  }
+  return {
+    added: addedChars.reverse().join(""),
+    removed: removedChars.reverse().join("")
+  };
+}
+function computeDeltaStats(oldState, newState) {
+  const oldText = extractTextFromState(oldState);
+  const newText = extractTextFromState(newState);
+  const oldLines = countLines(oldState);
+  const newLines = countLines(newState);
+  const { added: addedText, removed: removedText } = computeCharDiff(oldText, newText);
+  return {
+    chars: {
+      added: Array.from(addedText).length,
+      removed: Array.from(removedText).length
+    },
+    words: {
+      added: countWords(addedText),
+      removed: countWords(removedText)
+    },
+    lines: {
+      added: Math.max(0, newLines - oldLines),
+      removed: Math.max(0, oldLines - newLines)
+    }
+  };
+}
+function formatDeltaStats(stats) {
+  const parts = [];
+  const formatNumber = (n) => n.toLocaleString();
+  const formatDelta = (added, removed, unit) => {
+    if (added > 0 && removed > 0) {
+      return `+${formatNumber(added)}/-${formatNumber(removed)} ${unit}`;
+    }
+    if (added > 0) {
+      return `+${formatNumber(added)} ${unit}`;
+    }
+    if (removed > 0) {
+      return `-${formatNumber(removed)} ${unit}`;
+    }
+    return "";
+  };
+  const linesStr = formatDelta(stats.lines.added, stats.lines.removed, "lines");
+  const wordsStr = formatDelta(stats.words.added, stats.words.removed, "words");
+  const charsStr = formatDelta(stats.chars.added, stats.chars.removed, "chars");
+  if (linesStr) parts.push(linesStr);
+  if (wordsStr) parts.push(wordsStr);
+  if (charsStr) parts.push(charsStr);
+  return parts.join(", ") || "No changes";
+}
 const CHAR_DIFF_MAX_MATRIX_CELLS = 5e4;
 const DELETE_MARK_STYLE = "background-color: color-mix(in srgb, var(--rc-alert-caution) 22%, transparent); text-decoration: line-through;";
 const INSERT_MARK_STYLE = "background-color: color-mix(in srgb, var(--rc-alert-tip) 22%, transparent);";
@@ -448,8 +591,10 @@ function computeDiff(oldState, newState) {
   return hunks;
 }
 export {
+  computeDeltaStats,
   computeDiff,
   decorateSubtree,
   diffMergedNode,
-  diffModifiedNode
+  diffModifiedNode,
+  formatDeltaStats
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haklex/rich-diff-core",
-  "version": "0.0.94",
+  "version": "0.0.96",
   "description": "Lexical diff engine — character-level and structural diff with node decoration",
   "repository": {
     "type": "git",