@haklex/rich-diff-core 0.0.94

package/dist/compute-diff.d.ts

@@ -0,0 +1,19 @@
+import { SerializedEditorState, SerializedLexicalNode } from 'lexical';
+export type DiffOpType = 'equal' | 'insert' | 'delete';
+export interface DiffHunk {
+    nodes: SerializedLexicalNode[];
+    type: DiffOpType;
+}
+export type MarkKind = 'insert' | 'delete';
+export declare function decorateSubtree(node: SerializedLexicalNode, kind: MarkKind): SerializedLexicalNode;
+export declare function diffModifiedNode(oldNode: SerializedLexicalNode, newNode: SerializedLexicalNode): {
+    oldNode: SerializedLexicalNode;
+    newNode: SerializedLexicalNode;
+};
+/**
+ * Produces a **single** merged node with both deletions (strikethrough) and
+ * insertions (green highlight) interleaved inline – like VS Code's inline diff.
+ */
+export declare function diffMergedNode(oldNode: SerializedLexicalNode, newNode: SerializedLexicalNode): SerializedLexicalNode;
+export declare function computeDiff(oldState: SerializedEditorState, newState: SerializedEditorState): DiffHunk[];
+//# sourceMappingURL=compute-diff.d.ts.map

package/dist/compute-diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute-diff.d.ts","sourceRoot":"","sources":["../src/compute-diff.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAE5E,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAEvD,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,qBAAqB,EAAE,CAAC;IAC/B,IAAI,EAAE,UAAU,CAAC;CAClB;AAUD,MAAM,MAAM,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;AA+E3C,wBAAgB,eAAe,CAC7B,IAAI,EAAE,qBAAqB,EAC3B,IAAI,EAAE,QAAQ,GACb,qBAAqB,CAYvB;AAyXD,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,qBAAqB,EAC9B,OAAO,EAAE,qBAAqB,GAC7B;IACD,OAAO,EAAE,qBAAqB,CAAC;IAC/B,OAAO,EAAE,qBAAqB,CAAC;CAChC,CAUA;AAkED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,qBAAqB,EAC9B,OAAO,EAAE,qBAAqB,GAC7B,qBAAqB,CAgBvB;AAED,wBAAgB,WAAW,CACzB,QAAQ,EAAE,qBAAqB,EAC/B,QAAQ,EAAE,qBAAqB,GAC9B,QAAQ,EAAE,CA6CZ"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+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

@@ -0,0 +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"}

package/dist/index.mjs

@@ -0,0 +1,455 @@
+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);";
+function getNodeTypeKey(node) {
+  const n = node;
+  if (n.type === "heading") return `heading:${n.tag}`;
+  if (n.type === "list") return `list:${n.listType}`;
+  return n.type || "unknown";
+}
+function nodesEqual(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function isTextNode(node) {
+  const n = node;
+  return n.type === "text" && typeof n.text === "string";
+}
+function getChildren(node) {
+  const n = node;
+  return Array.isArray(n.children) ? n.children : null;
+}
+function appendStyle(baseStyle, extraStyle) {
+  const normalizedBase = typeof baseStyle === "string" ? baseStyle.trim() : "";
+  if (!normalizedBase) return extraStyle;
+  return `${normalizedBase}${normalizedBase.endsWith(";") ? "" : ";"} ${extraStyle}`;
+}
+function cloneTextNode(node, text, markKind) {
+  let { style } = node;
+  if (markKind === "delete") {
+    style = appendStyle(style, DELETE_MARK_STYLE);
+  } else if (markKind === "insert") {
+    style = appendStyle(style, INSERT_MARK_STYLE);
+  }
+  const cloned = {
+    ...node,
+    text,
+    style
+  };
+  return cloned;
+}
+function cloneNodeWithChildren(node, children) {
+  return {
+    ...node,
+    children
+  };
+}
+function decorateSubtree(node, kind) {
+  if (isTextNode(node)) {
+    return cloneTextNode(node, node.text, kind);
+  }
+  const children = getChildren(node);
+  if (!children) return node;
+  return cloneNodeWithChildren(
+    node,
+    children.map((child) => decorateSubtree(child, kind))
+  );
+}
+function reverseText(value) {
+  return Array.from(value).reverse().join("");
+}
+function mergeTextOps(ops) {
+  const merged = [];
+  for (const op of ops) {
+    if (!op.text) continue;
+    const last = merged.at(-1);
+    if (last && last.kind === op.kind) {
+      last.text += op.text;
+    } else {
+      merged.push({ ...op });
+    }
+  }
+  return merged;
+}
+function diffMiddleChars(oldChars, newChars) {
+  const m = oldChars.length;
+  const n = newChars.length;
+  if (m === 0 && n === 0) return [];
+  if (m === 0) return [{ kind: "insert", text: newChars.join("") }];
+  if (n === 0) return [{ kind: "delete", text: oldChars.join("") }];
+  if (m * n > CHAR_DIFF_MAX_MATRIX_CELLS) {
+    return [
+      { kind: "delete", text: oldChars.join("") },
+      { kind: "insert", text: newChars.join("") }
+    ];
+  }
+  const dp = Array.from(
+    { length: m + 1 },
+    () => Array.from({ length: n + 1 }).fill(0)
+  );
+  for (let i2 = 1; i2 <= m; i2++) {
+    for (let j2 = 1; j2 <= n; j2++) {
+      if (oldChars[i2 - 1] === newChars[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 reversedOps = [];
+  let i = m;
+  let j = n;
+  while (i > 0 && j > 0) {
+    if (oldChars[i - 1] === newChars[j - 1]) {
+      const last = reversedOps.at(-1);
+      if (last && last.kind === "equal") {
+        last.text += oldChars[i - 1];
+      } else {
+        reversedOps.push({ kind: "equal", text: oldChars[i - 1] });
+      }
+      i--;
+      j--;
+      continue;
+    }
+    if (dp[i - 1][j] >= dp[i][j - 1]) {
+      const last = reversedOps.at(-1);
+      if (last && last.kind === "delete") {
+        last.text += oldChars[i - 1];
+      } else {
+        reversedOps.push({ kind: "delete", text: oldChars[i - 1] });
+      }
+      i--;
+    } else {
+      const last = reversedOps.at(-1);
+      if (last && last.kind === "insert") {
+        last.text += newChars[j - 1];
+      } else {
+        reversedOps.push({ kind: "insert", text: newChars[j - 1] });
+      }
+      j--;
+    }
+  }
+  while (i > 0) {
+    const last = reversedOps.at(-1);
+    if (last && last.kind === "delete") {
+      last.text += oldChars[i - 1];
+    } else {
+      reversedOps.push({ kind: "delete", text: oldChars[i - 1] });
+    }
+    i--;
+  }
+  while (j > 0) {
+    const last = reversedOps.at(-1);
+    if (last && last.kind === "insert") {
+      last.text += newChars[j - 1];
+    } else {
+      reversedOps.push({ kind: "insert", text: newChars[j - 1] });
+    }
+    j--;
+  }
+  const forwardOps = reversedOps.reverse().map((op) => ({ kind: op.kind, text: reverseText(op.text) }));
+  return mergeTextOps(forwardOps);
+}
+function diffTextByChar(oldText, newText) {
+  const oldChars = Array.from(oldText);
+  const newChars = Array.from(newText);
+  let prefix = 0;
+  while (prefix < oldChars.length && prefix < newChars.length && oldChars[prefix] === newChars[prefix]) {
+    prefix++;
+  }
+  let oldSuffix = oldChars.length - 1;
+  let newSuffix = newChars.length - 1;
+  while (oldSuffix >= prefix && newSuffix >= prefix && oldChars[oldSuffix] === newChars[newSuffix]) {
+    oldSuffix--;
+    newSuffix--;
+  }
+  const ops = [];
+  if (prefix > 0) {
+    ops.push({
+      kind: "equal",
+      text: oldChars.slice(0, prefix).join("")
+    });
+  }
+  ops.push(
+    ...diffMiddleChars(
+      oldChars.slice(prefix, oldSuffix + 1),
+      newChars.slice(prefix, newSuffix + 1)
+    )
+  );
+  if (oldSuffix < oldChars.length - 1) {
+    ops.push({
+      kind: "equal",
+      text: oldChars.slice(oldSuffix + 1).join("")
+    });
+  }
+  return mergeTextOps(ops);
+}
+function splitTextNodeByCharDiff(oldNode, newNode) {
+  const ops = diffTextByChar(oldNode.text, newNode.text);
+  const oldNodes = [];
+  const newNodes = [];
+  let changed = false;
+  for (const op of ops) {
+    if (!op.text) continue;
+    if (op.kind === "equal") {
+      oldNodes.push(cloneTextNode(oldNode, op.text));
+      newNodes.push(cloneTextNode(newNode, op.text));
+      continue;
+    }
+    changed = true;
+    if (op.kind === "delete") {
+      oldNodes.push(cloneTextNode(oldNode, op.text, "delete"));
+      continue;
+    }
+    newNodes.push(cloneTextNode(newNode, op.text, "insert"));
+  }
+  return {
+    oldNodes: oldNodes.length > 0 ? oldNodes : [oldNode],
+    newNodes: newNodes.length > 0 ? newNodes : [newNode],
+    changed
+  };
+}
+function alignNodes(oldNodes, newNodes) {
+  const m = oldNodes.length;
+  const n = newNodes.length;
+  const dp = Array.from(
+    { length: m + 1 },
+    () => Array.from({ length: n + 1 }).fill(0)
+  );
+  for (let i2 = 1; i2 <= m; i2++) {
+    for (let j2 = 1; j2 <= n; j2++) {
+      const skip = Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
+      if (getNodeTypeKey(oldNodes[i2 - 1]) === getNodeTypeKey(newNodes[j2 - 1])) {
+        const score = nodesEqual(oldNodes[i2 - 1], newNodes[j2 - 1]) ? 2 : 1;
+        dp[i2][j2] = Math.max(skip, dp[i2 - 1][j2 - 1] + score);
+      } else {
+        dp[i2][j2] = skip;
+      }
+    }
+  }
+  const ops = [];
+  let i = m;
+  let j = n;
+  while (i > 0 && j > 0) {
+    const typeMatch = getNodeTypeKey(oldNodes[i - 1]) === getNodeTypeKey(newNodes[j - 1]);
+    if (typeMatch) {
+      const exact = nodesEqual(oldNodes[i - 1], newNodes[j - 1]);
+      const score = exact ? 2 : 1;
+      if (dp[i][j] === dp[i - 1][j - 1] + score) {
+        ops.push(
+          exact ? { kind: "equal", node: oldNodes[i - 1] } : {
+            kind: "modify",
+            oldNode: oldNodes[i - 1],
+            newNode: newNodes[j - 1]
+          }
+        );
+        i--;
+        j--;
+        continue;
+      }
+    }
+    if (dp[i - 1][j] >= dp[i][j - 1]) {
+      ops.push({ kind: "delete", node: oldNodes[i - 1] });
+      i--;
+    } else {
+      ops.push({ kind: "insert", node: newNodes[j - 1] });
+      j--;
+    }
+  }
+  while (i > 0) {
+    ops.push({ kind: "delete", node: oldNodes[--i] });
+  }
+  while (j > 0) {
+    ops.push({ kind: "insert", node: newNodes[--j] });
+  }
+  ops.reverse();
+  return ops;
+}
+function diffChildrenInline(oldChildren, newChildren) {
+  const ops = alignNodes(oldChildren, newChildren);
+  const nextOldChildren = [];
+  const nextNewChildren = [];
+  let changed = false;
+  for (const op of ops) {
+    switch (op.kind) {
+      case "equal": {
+        nextOldChildren.push(op.node);
+        nextNewChildren.push(op.node);
+        break;
+      }
+      case "delete": {
+        changed = true;
+        nextOldChildren.push(decorateSubtree(op.node, "delete"));
+        break;
+      }
+      case "insert": {
+        changed = true;
+        nextNewChildren.push(decorateSubtree(op.node, "insert"));
+        break;
+      }
+      case "modify": {
+        changed = true;
+        if (isTextNode(op.oldNode) && isTextNode(op.newNode)) {
+          const textDiff = splitTextNodeByCharDiff(op.oldNode, op.newNode);
+          nextOldChildren.push(...textDiff.oldNodes);
+          nextNewChildren.push(...textDiff.newNodes);
+          break;
+        }
+        const nested = diffNodeInline(op.oldNode, op.newNode);
+        if (nested) {
+          nextOldChildren.push(nested.oldNode);
+          nextNewChildren.push(nested.newNode);
+        } else {
+          nextOldChildren.push(decorateSubtree(op.oldNode, "delete"));
+          nextNewChildren.push(decorateSubtree(op.newNode, "insert"));
+        }
+        break;
+      }
+    }
+  }
+  return {
+    oldChildren: nextOldChildren,
+    newChildren: nextNewChildren,
+    changed
+  };
+}
+function diffNodeInline(oldNode, newNode) {
+  if (getNodeTypeKey(oldNode) !== getNodeTypeKey(newNode)) return null;
+  if (nodesEqual(oldNode, newNode)) {
+    return { oldNode, newNode, changed: false };
+  }
+  const oldChildren = getChildren(oldNode);
+  const newChildren = getChildren(newNode);
+  if (!oldChildren || !newChildren) return null;
+  const childDiff = diffChildrenInline(oldChildren, newChildren);
+  if (!childDiff.changed) {
+    return { oldNode, newNode, changed: false };
+  }
+  return {
+    oldNode: cloneNodeWithChildren(oldNode, childDiff.oldChildren),
+    newNode: cloneNodeWithChildren(newNode, childDiff.newChildren),
+    changed: true
+  };
+}
+function diffModifiedNode(oldNode, newNode) {
+  const nested = diffNodeInline(oldNode, newNode);
+  if (nested) {
+    return { oldNode: nested.oldNode, newNode: nested.newNode };
+  }
+  return {
+    oldNode: decorateSubtree(oldNode, "delete"),
+    newNode: decorateSubtree(newNode, "insert")
+  };
+}
+function mergeTextDiffNodes(oldNode, newNode) {
+  const ops = diffTextByChar(oldNode.text, newNode.text);
+  const merged = [];
+  for (const op of ops) {
+    if (!op.text) continue;
+    if (op.kind === "equal") {
+      merged.push(cloneTextNode(newNode, op.text));
+    } else if (op.kind === "delete") {
+      merged.push(cloneTextNode(oldNode, op.text, "delete"));
+    } else {
+      merged.push(cloneTextNode(newNode, op.text, "insert"));
+    }
+  }
+  return merged;
+}
+function diffChildrenMerged(oldChildren, newChildren) {
+  const ops = alignNodes(oldChildren, newChildren);
+  const merged = [];
+  for (const op of ops) {
+    switch (op.kind) {
+      case "equal": {
+        merged.push(op.node);
+        break;
+      }
+      case "delete": {
+        merged.push(decorateSubtree(op.node, "delete"));
+        break;
+      }
+      case "insert": {
+        merged.push(decorateSubtree(op.node, "insert"));
+        break;
+      }
+      case "modify": {
+        if (isTextNode(op.oldNode) && isTextNode(op.newNode)) {
+          merged.push(...mergeTextDiffNodes(op.oldNode, op.newNode));
+          break;
+        }
+        const nestedOld = getChildren(op.oldNode);
+        const nestedNew = getChildren(op.newNode);
+        if (nestedOld && nestedNew) {
+          merged.push(cloneNodeWithChildren(op.newNode, diffChildrenMerged(nestedOld, nestedNew)));
+        } else {
+          merged.push(decorateSubtree(op.oldNode, "delete"));
+          merged.push(decorateSubtree(op.newNode, "insert"));
+        }
+        break;
+      }
+    }
+  }
+  return merged;
+}
+function diffMergedNode(oldNode, newNode) {
+  if (getNodeTypeKey(oldNode) !== getNodeTypeKey(newNode)) {
+    return decorateSubtree(newNode, "insert");
+  }
+  if (nodesEqual(oldNode, newNode)) {
+    return newNode;
+  }
+  const oldChildren = getChildren(oldNode);
+  const newChildren = getChildren(newNode);
+  if (!oldChildren || !newChildren) {
+    return decorateSubtree(newNode, "insert");
+  }
+  return cloneNodeWithChildren(newNode, diffChildrenMerged(oldChildren, newChildren));
+}
+function computeDiff(oldState, newState) {
+  const ops = alignNodes(oldState.root.children, newState.root.children);
+  const hunks = [];
+  for (const op of ops) {
+    switch (op.kind) {
+      case "equal": {
+        const last = hunks.at(-1);
+        if (last && last.type === "equal") {
+          last.nodes.push(op.node);
+        } else {
+          hunks.push({ type: "equal", nodes: [op.node] });
+        }
+        break;
+      }
+      case "modify": {
+        {
+          const inline = diffModifiedNode(op.oldNode, op.newNode);
+          hunks.push(
+            { type: "delete", nodes: [inline.oldNode] },
+            { type: "insert", nodes: [inline.newNode] }
+          );
+        }
+        break;
+      }
+      case "delete": {
+        hunks.push({
+          type: "delete",
+          nodes: [decorateSubtree(op.node, "delete")]
+        });
+        break;
+      }
+      case "insert": {
+        hunks.push({
+          type: "insert",
+          nodes: [decorateSubtree(op.node, "insert")]
+        });
+        break;
+      }
+    }
+  }
+  return hunks;
+}
+export {
+  computeDiff,
+  decorateSubtree,
+  diffMergedNode,
+  diffModifiedNode
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@haklex/rich-diff-core",
+  "version": "0.0.94",
+  "description": "Lexical diff engine — character-level and structural diff with node decoration",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Innei/haklex.git",
+    "directory": "packages/rich-diff-core"
+  },
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {},
+  "devDependencies": {
+    "lexical": "^0.42.0",
+    "typescript": "^5.9.3",
+    "vite": "^7.3.1",
+    "vite-plugin-dts": "^4.5.4"
+  },
+  "peerDependencies": {
+    "lexical": "^0.42.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vite build",
+    "dev:build": "vite build --watch"
+  },
+  "types": "./dist/index.d.ts"
+}