xml-diff-kit 0.1.0

package/dist/index.js

@@ -0,0 +1,736 @@
+// src/utils.ts
+function isElementNode(node) {
+  return node.type === "element";
+}
+function cloneXmlNode(node) {
+  return structuredClone(node);
+}
+function sortRecord(record) {
+  return Object.fromEntries(
+    Object.entries(record).sort(([left], [right]) => left.localeCompare(right))
+  );
+}
+function escapeXmlText(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function escapeXmlAttr(value) {
+  return escapeXmlText(value).replaceAll('"', "&quot;");
+}
+function getNodeKey(node, keyAttrs = []) {
+  if (!isElementNode(node)) return void 0;
+  for (const keyAttr of keyAttrs) {
+    const value = node.attrs[keyAttr];
+    if (value !== void 0) {
+      return `${node.name}:${keyAttr}=${value}`;
+    }
+  }
+  return void 0;
+}
+function formatPathSegment(node, index, keyAttrs = []) {
+  if (node.type === "text") return `text()[${index}]`;
+  if (node.type === "comment") return `comment()[${index}]`;
+  const keyAttr = keyAttrs.find((attr) => node.attrs[attr] !== void 0);
+  const keyValue = keyAttr ? node.attrs[keyAttr] : void 0;
+  const keyPart = keyAttr && keyValue !== void 0 ? `[@${keyAttr}="${keyValue}"]` : "";
+  return `${node.name}${keyPart}[${index}]`;
+}
+
+// src/normalize.ts
+function normalizeXml(node, options = {}) {
+  const cloned = cloneXmlNode(node);
+  const normalized = normalizeNode(cloned, options);
+  if (!normalized) {
+    throw new Error("Cannot normalize an empty XML document.");
+  }
+  return normalized;
+}
+function normalizeNode(node, options) {
+  if (node.type === "text") {
+    const text = options.trimText ? node.text.trim() : node.text;
+    if (options.ignoreWhitespaceText && text.trim() === "") {
+      return null;
+    }
+    return {
+      type: "text",
+      text
+    };
+  }
+  if (node.type === "comment") {
+    if (options.ignoreComments) return null;
+    return node;
+  }
+  const children = node.children.map((child) => normalizeNode(child, options)).filter((child) => Boolean(child));
+  return {
+    ...node,
+    attrs: options.sortAttributes ? sortRecord(node.attrs) : { ...node.attrs },
+    children
+  };
+}
+
+// src/parse.ts
+import { DOMParser } from "@xmldom/xmldom";
+function parseXml(xml) {
+  const doc = new DOMParser({
+    errorHandler: {
+      warning: (message) => {
+        throw new Error(`Invalid XML: ${message}`);
+      },
+      error: (message) => {
+        throw new Error(`Invalid XML: ${message}`);
+      },
+      fatalError: (message) => {
+        throw new Error(`Invalid XML: ${message}`);
+      }
+    }
+  }).parseFromString(xml, "application/xml");
+  if (!doc.documentElement) {
+    throw new Error("Invalid XML: missing document element.");
+  }
+  return fromDomNode(doc.documentElement);
+}
+function fromDomNode(node) {
+  if (node.nodeType === 1) {
+    const element = node;
+    const attrs = {};
+    for (let index = 0; index < element.attributes.length; index += 1) {
+      const attr = element.attributes.item(index);
+      if (attr) attrs[attr.name] = attr.value;
+    }
+    const children = [];
+    for (let index = 0; index < element.childNodes.length; index += 1) {
+      const child = element.childNodes.item(index);
+      if (child.nodeType === 1 || child.nodeType === 3 || child.nodeType === 8) {
+        children.push(fromDomNode(child));
+      }
+    }
+    return {
+      type: "element",
+      name: element.nodeName,
+      namespaceURI: element.namespaceURI ?? null,
+      attrs,
+      children
+    };
+  }
+  if (node.nodeType === 3) {
+    return {
+      type: "text",
+      text: node.nodeValue ?? ""
+    };
+  }
+  if (node.nodeType === 8) {
+    return {
+      type: "comment",
+      text: node.nodeValue ?? ""
+    };
+  }
+  throw new Error(`Unsupported XML node type: ${node.nodeType}`);
+}
+
+// src/text-diff.ts
+function diffText(oldValue, newValue) {
+  if (oldValue === newValue) {
+    return {
+      changes: [],
+      segments: [{ type: "equal", text: oldValue }]
+    };
+  }
+  const oldChars = Array.from(oldValue);
+  const newChars = Array.from(newValue);
+  const segments = buildDiffSegments(oldChars, newChars);
+  return {
+    changes: segmentsToChanges(segments),
+    segments
+  };
+}
+function buildDiffSegments(oldChars, newChars) {
+  const rows = oldChars.length + 1;
+  const cols = newChars.length + 1;
+  const dp = Array.from({ length: rows }, () => Array.from({ length: cols }, () => 0));
+  for (let oldIndex2 = oldChars.length - 1; oldIndex2 >= 0; oldIndex2 -= 1) {
+    for (let newIndex2 = newChars.length - 1; newIndex2 >= 0; newIndex2 -= 1) {
+      if (oldChars[oldIndex2] === newChars[newIndex2]) {
+        dp[oldIndex2][newIndex2] = dp[oldIndex2 + 1][newIndex2 + 1] + 1;
+      } else {
+        dp[oldIndex2][newIndex2] = Math.max(dp[oldIndex2 + 1][newIndex2], dp[oldIndex2][newIndex2 + 1]);
+      }
+    }
+  }
+  const segments = [];
+  let oldIndex = 0;
+  let newIndex = 0;
+  while (oldIndex < oldChars.length && newIndex < newChars.length) {
+    if (oldChars[oldIndex] === newChars[newIndex]) {
+      pushSegment(segments, { type: "equal", text: oldChars[oldIndex] });
+      oldIndex += 1;
+      newIndex += 1;
+    } else if (dp[oldIndex + 1][newIndex] >= dp[oldIndex][newIndex + 1]) {
+      pushSegment(segments, { type: "delete", text: oldChars[oldIndex] });
+      oldIndex += 1;
+    } else {
+      pushSegment(segments, { type: "insert", text: newChars[newIndex] });
+      newIndex += 1;
+    }
+  }
+  while (oldIndex < oldChars.length) {
+    pushSegment(segments, { type: "delete", text: oldChars[oldIndex] });
+    oldIndex += 1;
+  }
+  while (newIndex < newChars.length) {
+    pushSegment(segments, { type: "insert", text: newChars[newIndex] });
+    newIndex += 1;
+  }
+  return segments;
+}
+function segmentsToChanges(segments) {
+  const changes = [];
+  let offset = 0;
+  let index = 0;
+  while (index < segments.length) {
+    const segment = segments[index];
+    if (segment.type === "equal") {
+      offset += Array.from(segment.text).length;
+      index += 1;
+      continue;
+    }
+    if (segment.type === "delete") {
+      const next = segments[index + 1];
+      if (next?.type === "insert") {
+        changes.push({
+          op: "replaceTextRange",
+          offset,
+          oldText: segment.text,
+          newText: next.text
+        });
+        offset += Array.from(segment.text).length;
+        index += 2;
+        continue;
+      }
+      changes.push({
+        op: "deleteText",
+        offset,
+        oldText: segment.text
+      });
+      offset += Array.from(segment.text).length;
+      index += 1;
+      continue;
+    }
+    changes.push({
+      op: "insertText",
+      offset,
+      text: segment.text
+    });
+    index += 1;
+  }
+  return changes;
+}
+function pushSegment(segments, next) {
+  const previous = segments.at(-1);
+  if (previous?.type === next.type) {
+    previous.text += next.text;
+    return;
+  }
+  segments.push({ ...next });
+}
+
+// src/diff.ts
+function diffXml(oldInput, newInput, options = {}) {
+  const oldNode = normalizeXml(typeof oldInput === "string" ? parseXml(oldInput) : oldInput, options);
+  const newNode = normalizeXml(typeof newInput === "string" ? parseXml(newInput) : newInput, options);
+  const ops = [];
+  diffNode(oldNode, newNode, `/${formatPathSegment(oldNode, 0, options.keyAttrs)}`, options, ops);
+  return ops;
+}
+function diffNode(oldNode, newNode, path, options, ops) {
+  if (oldNode.type !== newNode.type) {
+    ops.push({ op: "replaceNode", path, oldValue: oldNode, newValue: newNode });
+    return;
+  }
+  if (oldNode.type === "text" && newNode.type === "text") {
+    if (oldNode.text !== newNode.text) {
+      const textDiff = diffText(oldNode.text, newNode.text);
+      ops.push({
+        op: "replaceText",
+        path,
+        oldValue: oldNode.text,
+        newValue: newNode.text,
+        changes: textDiff.changes,
+        segments: textDiff.segments
+      });
+    }
+    return;
+  }
+  if (oldNode.type === "comment" && newNode.type === "comment") {
+    if (oldNode.text !== newNode.text) {
+      ops.push({ op: "replaceNode", path, oldValue: oldNode, newValue: newNode });
+    }
+    return;
+  }
+  if (oldNode.type !== "element" || newNode.type !== "element") return;
+  if (oldNode.name !== newNode.name || oldNode.namespaceURI !== newNode.namespaceURI) {
+    ops.push({ op: "replaceNode", path, oldValue: oldNode, newValue: newNode });
+    return;
+  }
+  diffAttributes(oldNode.attrs, newNode.attrs, path, ops);
+  diffChildren(oldNode.children, newNode.children, path, options, ops);
+}
+function diffAttributes(oldAttrs, newAttrs, path, ops) {
+  for (const [name, oldValue] of Object.entries(oldAttrs)) {
+    const newValue = newAttrs[name];
+    if (newValue === void 0) {
+      ops.push({ op: "removeAttr", path, name, oldValue });
+    } else if (newValue !== oldValue) {
+      ops.push({ op: "updateAttr", path, name, oldValue, newValue });
+    }
+  }
+  for (const [name, value] of Object.entries(newAttrs)) {
+    if (oldAttrs[name] === void 0) {
+      ops.push({ op: "addAttr", path, name, value });
+    }
+  }
+}
+function diffChildren(oldChildren, newChildren, parentPath, options, ops) {
+  const keyAttrs = options.keyAttrs ?? [];
+  if (keyAttrs.length > 0) {
+    const oldKeyed = /* @__PURE__ */ new Map();
+    const newKeyed = /* @__PURE__ */ new Map();
+    oldChildren.forEach((node, index) => {
+      const key = getNodeKey(node, keyAttrs);
+      if (key) oldKeyed.set(key, { node, index });
+    });
+    newChildren.forEach((node, index) => {
+      const key = getNodeKey(node, keyAttrs);
+      if (key) newKeyed.set(key, { node, index });
+    });
+    if (oldKeyed.size > 0 || newKeyed.size > 0) {
+      for (const [key, { node, index }] of oldKeyed) {
+        const next = newKeyed.get(key);
+        const childPath = `${parentPath}/${formatPathSegment(node, index, keyAttrs)}`;
+        if (!next) {
+          ops.push({ op: "removeNode", path: childPath, oldValue: node });
+        } else {
+          const newPath = `${parentPath}/${formatPathSegment(next.node, next.index, keyAttrs)}`;
+          if (options.detectMoves === true && index !== next.index) {
+            ops.push({
+              op: "moveNode",
+              path: childPath,
+              fromPath: childPath,
+              toPath: newPath,
+              value: next.node
+            });
+          }
+          diffNode(node, next.node, childPath, options, ops);
+        }
+      }
+      for (const [, { node, index }] of newKeyed) {
+        const key = getNodeKey(node, keyAttrs);
+        if (key && !oldKeyed.has(key)) {
+          const childPath = `${parentPath}/${formatPathSegment(node, index, keyAttrs)}`;
+          ops.push({ op: "addNode", path: childPath, value: node });
+        }
+      }
+      const oldUnkeyed = oldChildren.map((node, index) => ({ node, index })).filter(({ node }) => !getNodeKey(node, keyAttrs));
+      const newUnkeyed = newChildren.map((node, index) => ({ node, index })).filter(({ node }) => !getNodeKey(node, keyAttrs));
+      diffChildrenByIndex(oldUnkeyed, newUnkeyed, parentPath, options, ops);
+      return;
+    }
+  }
+  diffChildrenByIndex(
+    oldChildren.map((node, index) => ({ node, index })),
+    newChildren.map((node, index) => ({ node, index })),
+    parentPath,
+    options,
+    ops
+  );
+}
+function diffChildrenByIndex(oldChildren, newChildren, parentPath, options, ops) {
+  const max = Math.max(oldChildren.length, newChildren.length);
+  for (let index = 0; index < max; index += 1) {
+    const oldItem = oldChildren[index];
+    const newItem = newChildren[index];
+    if (!oldItem && newItem) {
+      const childPath = `${parentPath}/${formatPathSegment(newItem.node, newItem.index, options.keyAttrs)}`;
+      ops.push({ op: "addNode", path: childPath, value: newItem.node });
+      continue;
+    }
+    if (oldItem && !newItem) {
+      const childPath = `${parentPath}/${formatPathSegment(oldItem.node, oldItem.index, options.keyAttrs)}`;
+      ops.push({ op: "removeNode", path: childPath, oldValue: oldItem.node });
+      continue;
+    }
+    if (oldItem && newItem) {
+      const childPath = `${parentPath}/${formatPathSegment(oldItem.node, oldItem.index, options.keyAttrs)}`;
+      diffNode(oldItem.node, newItem.node, childPath, options, ops);
+    }
+  }
+}
+
+// src/serialize.ts
+function serializeXml(node, options = {}) {
+  return serializeNode(node, options, 0);
+}
+function serializeNode(node, options, level) {
+  if (node.type === "text") {
+    return escapeXmlText(node.text);
+  }
+  if (node.type === "comment") {
+    return `<!--${node.text}-->`;
+  }
+  const attrs = Object.entries(node.attrs).map(([name, value]) => ` ${name}="${escapeXmlAttr(value)}"`).join("");
+  if (node.children.length === 0) {
+    return `${indent(options, level)}<${node.name}${attrs}/>`;
+  }
+  if (!options.pretty || node.children.every((child) => child.type === "text")) {
+    const children2 = node.children.map((child) => serializeNode(child, options, level + 1)).join("");
+    return `${indent(options, level)}<${node.name}${attrs}>${children2}</${node.name}>`;
+  }
+  const children = node.children.map((child) => serializeNode(child, options, level + 1)).join("\n");
+  return `${indent(options, level)}<${node.name}${attrs}>
+${children}
+${indent(
+    options,
+    level
+  )}</${node.name}>`;
+}
+function indent(options, level) {
+  if (!options.pretty) return "";
+  return (options.indent ?? "  ").repeat(level);
+}
+
+// src/format.ts
+function formatDiff(ops, options = {}) {
+  if (options.format === "markdown") {
+    return toMarkdown(ops);
+  }
+  return ops.map(toSummaryItem);
+}
+function toMarkdown(ops) {
+  if (ops.length === 0) {
+    return "# XML Diff\n\nNo XML differences.";
+  }
+  return [
+    "# XML Diff",
+    "",
+    `Total changes: ${ops.length}`,
+    "",
+    ...ops.flatMap((op, index) => formatMarkdownOp(op, index + 1))
+  ].join("\n");
+}
+function formatMarkdownOp(op, index) {
+  switch (op.op) {
+    case "addNode":
+      return [
+        `## ${index}. Added node`,
+        "",
+        `- Path: \`${op.path}\``,
+        "",
+        codeBlock("xml", serializeForMarkdown(op.value)),
+        ""
+      ];
+    case "removeNode":
+      return [
+        `## ${index}. Removed node`,
+        "",
+        `- Path: \`${op.path}\``,
+        "",
+        codeBlock("xml", serializeForMarkdown(op.oldValue)),
+        ""
+      ];
+    case "replaceNode":
+      return [
+        `## ${index}. Replaced node`,
+        "",
+        `- Path: \`${op.path}\``,
+        "",
+        "**Before**",
+        "",
+        codeBlock("xml", serializeForMarkdown(op.oldValue)),
+        "",
+        "**After**",
+        "",
+        codeBlock("xml", serializeForMarkdown(op.newValue)),
+        ""
+      ];
+    case "moveNode":
+      return [
+        `## ${index}. Moved node`,
+        "",
+        `- From: \`${op.fromPath}\``,
+        `- To: \`${op.toPath}\``,
+        "",
+        codeBlock("xml", serializeForMarkdown(op.value)),
+        ""
+      ];
+    case "replaceText":
+      return [
+        `## ${index}. Changed text`,
+        "",
+        `- Path: \`${op.path}\``,
+        "",
+        "**Before**",
+        "",
+        codeBlock("text", op.oldValue),
+        "",
+        "**After**",
+        "",
+        codeBlock("text", op.newValue),
+        "",
+        "**Text segments**",
+        "",
+        ...op.segments.map((segment) => `- ${segment.type}: \`${escapeInlineCode(segment.text)}\``),
+        ""
+      ];
+    case "addAttr":
+      return [
+        `## ${index}. Added attribute`,
+        "",
+        `- Path: \`${op.path}\``,
+        `- Name: \`${op.name}\``,
+        `- Value: \`${escapeInlineCode(op.value)}\``,
+        ""
+      ];
+    case "updateAttr":
+      return [
+        `## ${index}. Updated attribute`,
+        "",
+        `- Path: \`${op.path}\``,
+        `- Name: \`${op.name}\``,
+        `- Before: \`${escapeInlineCode(op.oldValue)}\``,
+        `- After: \`${escapeInlineCode(op.newValue)}\``,
+        ""
+      ];
+    case "removeAttr":
+      return [
+        `## ${index}. Removed attribute`,
+        "",
+        `- Path: \`${op.path}\``,
+        `- Name: \`${op.name}\``,
+        `- Old value: \`${escapeInlineCode(op.oldValue)}\``,
+        ""
+      ];
+  }
+}
+function toSummaryItem(op) {
+  switch (op.op) {
+    case "addNode":
+      return {
+        type: "nodeAdded",
+        path: op.path,
+        message: `Added node at ${op.path}`,
+        after: op.value
+      };
+    case "removeNode":
+      return {
+        type: "nodeRemoved",
+        path: op.path,
+        message: `Removed node at ${op.path}`,
+        before: op.oldValue
+      };
+    case "replaceNode":
+      return {
+        type: "nodeReplaced",
+        path: op.path,
+        message: `Replaced node at ${op.path}`,
+        before: op.oldValue,
+        after: op.newValue
+      };
+    case "moveNode":
+      return {
+        type: "nodeMoved",
+        path: op.path,
+        message: `Moved node from ${op.fromPath} to ${op.toPath}`,
+        before: op.fromPath,
+        after: op.toPath
+      };
+    case "replaceText":
+      return {
+        type: "textChanged",
+        path: op.path,
+        message: `Changed text at ${op.path}`,
+        before: op.oldValue,
+        after: op.newValue
+      };
+    case "addAttr":
+      return {
+        type: "attrAdded",
+        path: op.path,
+        message: `Added attribute ${op.name} at ${op.path}`,
+        after: op.value
+      };
+    case "updateAttr":
+      return {
+        type: "attrUpdated",
+        path: op.path,
+        message: `Updated attribute ${op.name} at ${op.path}`,
+        before: op.oldValue,
+        after: op.newValue
+      };
+    case "removeAttr":
+      return {
+        type: "attrRemoved",
+        path: op.path,
+        message: `Removed attribute ${op.name} at ${op.path}`,
+        before: op.oldValue
+      };
+  }
+}
+function serializeForMarkdown(node) {
+  if (node.type === "text" || node.type === "comment") {
+    return serializeXml(node);
+  }
+  return serializeXml(node, {
+    pretty: true
+  });
+}
+function codeBlock(language, value) {
+  return `\`\`\`${language}
+${escapeCodeFence(value)}
+\`\`\``;
+}
+function escapeCodeFence(value) {
+  return value.replaceAll("```", "`\u200B``");
+}
+function escapeInlineCode(value) {
+  return value.replaceAll("`", "\\`");
+}
+
+// src/patch.ts
+function patchXml(input, ops, options = {}) {
+  const root = cloneXmlNode(typeof input === "string" ? parseXml(input) : input);
+  for (const op of ops) {
+    applyOp(root, op);
+  }
+  const normalized = normalizeXml(root, { sortAttributes: true });
+  if (typeof input === "string") {
+    return serializeXml(normalized, options);
+  }
+  return normalized;
+}
+function applyOp(root, op) {
+  if (op.op === "replaceNode" && isRootPath(op.path)) {
+    Object.assign(root, cloneXmlNode(op.newValue));
+    return;
+  }
+  if (op.op === "addNode") {
+    const parentPath = getParentPath(op.path);
+    const parent = getTarget(root, parentPath).node;
+    assertElement(parent, parentPath);
+    const insertIndex = getLastIndex(op.path);
+    parent.children.splice(insertIndex, 0, cloneXmlNode(op.value));
+    return;
+  }
+  if (op.op === "moveNode") {
+    moveNode(root, op.fromPath, op.toPath);
+    return;
+  }
+  const target = getTarget(root, op.path);
+  switch (op.op) {
+    case "addAttr":
+      assertElement(target.node, op.path);
+      target.node.attrs[op.name] = op.value;
+      break;
+    case "updateAttr":
+      assertElement(target.node, op.path);
+      target.node.attrs[op.name] = op.newValue;
+      break;
+    case "removeAttr":
+      assertElement(target.node, op.path);
+      delete target.node.attrs[op.name];
+      break;
+    case "replaceText":
+      if (target.node.type !== "text") {
+        throw new Error(`Cannot replace text at non-text path: ${op.path}`);
+      }
+      target.node.text = op.newValue;
+      break;
+    case "replaceNode":
+      if (!target.parent) throw new Error("Cannot replace root node without root replace path.");
+      target.parent.children[target.index] = cloneXmlNode(op.newValue);
+      break;
+    case "removeNode":
+      if (!target.parent) throw new Error("Cannot remove root node.");
+      target.parent.children.splice(target.index, 1);
+      break;
+  }
+}
+function moveNode(root, fromPath, toPath) {
+  const source = getTarget(root, fromPath);
+  if (!source.parent) {
+    throw new Error("Cannot move root node.");
+  }
+  const [removed] = source.parent.children.splice(source.index, 1);
+  if (!removed) {
+    throw new Error(`Path not found: ${fromPath}`);
+  }
+  const parentPath = getParentPath(toPath);
+  const targetParent = getTarget(root, parentPath).node;
+  assertElement(targetParent, parentPath);
+  const targetIndex = getLastIndex(toPath);
+  targetParent.children.splice(targetIndex, 0, removed);
+}
+function getTarget(root, path) {
+  const indexes = getPathIndexes(path);
+  if (indexes.length === 0) {
+    return {
+      node: root,
+      index: 0
+    };
+  }
+  let current = root;
+  let parent;
+  let currentIndex = 0;
+  for (const index of indexes.slice(1)) {
+    assertElement(current, path);
+    parent = current;
+    currentIndex = index;
+    const child = current.children[index];
+    if (!child) {
+      throw new Error(`Path not found: ${path}`);
+    }
+    current = child;
+  }
+  const result = {
+    node: current,
+    index: currentIndex
+  };
+  if (parent) {
+    result.parent = parent;
+  }
+  return result;
+}
+function getPathIndexes(path) {
+  const matches = path.match(/\[(\d+)\]/g) ?? [];
+  return matches.map((match) => Number.parseInt(match.slice(1, -1), 10));
+}
+function getLastIndex(path) {
+  const indexes = getPathIndexes(path);
+  const index = indexes.at(-1);
+  if (index === void 0) {
+    throw new Error(`Path has no numeric index: ${path}`);
+  }
+  return index;
+}
+function getParentPath(path) {
+  const parts = path.split("/").filter(Boolean);
+  if (parts.length <= 1) {
+    return path;
+  }
+  return `/${parts.slice(0, -1).join("/")}`;
+}
+function isRootPath(path) {
+  return path.split("/").filter(Boolean).length === 1;
+}
+function assertElement(node, path) {
+  if (node.type !== "element") {
+    throw new Error(`Expected element node at path: ${path}`);
+  }
+}
+export {
+  diffText,
+  diffXml,
+  formatDiff,
+  normalizeXml,
+  parseXml,
+  patchXml,
+  serializeXml
+};
+//# sourceMappingURL=index.js.map