@ansonlai/docx-redline-js 0.8.1 → 0.8.2

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## Unreleased
 
+### Fixed
+
+- **Replacement next to a hyperlink no longer pulls adjacent plain text into the link** ([#3](https://github.com/AnsonLai/docx-redline-js/issues/3)):
+  replacing `example.org` with `example.net` (localized `replacements` or full `modified`) in a hyperlink followed by a
+  plain `.` run produced a link showing `example.net.` after Accept All. The reconstruction-mode word diff treated
+  `example.org.` as one token spanning the hyperlink edge. Where a replacement's shared prefix or suffix reaches a wrapper
+  boundary inside the deleted text, it is now kept unchanged.
+- **Reject All no longer reorders text around a manual line break** ([#4](https://github.com/AnsonLai/docx-redline-js/issues/4)):
+  replacing `tabbed` with `aligned` in `<tab>tabbed<w:br/>Line with ` rejected to `<tab>tabbedLine<break> with `, moving
+  deleted text across the break. Break and note-reference placeholders are now standalone word-diff tokens (new internal
+  `atomicChars` option), and change groups are split at references present on both sides. Covered by `tests/reconstruction_boundary_fidelity_tests.mjs`.
+
+## 0.8.1
+
 ### Added
 
 - **Header and footer editing:** add `part` to an operation (a selector `{ kind, type?, section? }` or a part path) to edit a

package/dist/docx-redline-js.esm.js

@@ -1,4 +1,4 @@
-// @ansonlai/docx-redline-js v0.8.1 — https://github.com/AnsonLai/docx-redline-js
+// @ansonlai/docx-redline-js v0.8.2 — https://github.com/AnsonLai/docx-redline-js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -2522,15 +2522,29 @@ function createDiffEngine(options = {}) {
   engine.Diff_Timeout = timeout;
   return engine;
 }
-function tokenize(text2) {
+function tokenize(text2, atomicChars = null) {
   const tokens = [];
+  const pushWord = (word) => {
+    if (!atomicChars || atomicChars.size === 0) {
+      tokens.push(word);
+      return;
+    }
+    let start = 0;
+    for (let index = 0; index < word.length; index++) {
+      if (!atomicChars.has(word[index])) continue;
+      if (index > start) tokens.push(word.slice(start, index));
+      tokens.push(word[index]);
+      start = index + 1;
+    }
+    if (start < word.length) tokens.push(word.slice(start));
+  };
   const leading = text2.match(/^\s+/);
   if (leading) tokens.push(leading[0]);
   const regex = /(\S+)(\s*)/g;
   regex.lastIndex = leading?.[0].length || 0;
   let match;
   while ((match = regex.exec(text2)) !== null) {
-    if (match[1]) tokens.push(match[1]);
+    if (match[1]) pushWord(match[1]);
     if (match[2]) tokens.push(match[2]);
   }
   return tokens;
@@ -2558,8 +2572,8 @@ function wordsToChars(text1, text2, options = {}) {
     }
     return { chars, tokenIds };
   }
-  const tokens1 = tokenize(text1);
-  const tokens2 = tokenize(text2);
+  const tokens1 = tokenize(text1, options.atomicChars);
+  const tokens2 = tokenize(text2, options.atomicChars);
   const encoded1 = mapTokensToChars(tokens1);
   const encoded2 = mapTokensToChars(tokens2);
   return {
@@ -7964,7 +7978,11 @@ function applyReconstructionMode(xmlDoc, originalText, modifiedText, serializer,
   if (mapping.paragraphs.length === 0) {
     return withOoxmlSourceType({ oxml: serializer.serializeToString(xmlDoc), hasChanges: false });
   }
-  const diffs = computeWordDiffs(mapping.originalFullText, mapping.processedModifiedText, diffOptions);
+  const wordDiffs = computeWordDiffs(mapping.originalFullText, mapping.processedModifiedText, {
+    ...diffOptions,
+    atomicChars: new Set(mapping.referenceMap.keys())
+  });
+  const diffs = keepUnchangedTextOutsideWrappers(anchorSharedReferences(wordDiffs, mapping.referenceMap), mapping);
   return withOoxmlSourceType(applyReconstructionDiffs(
     xmlDoc,
     diffs,
@@ -7976,6 +7994,109 @@ function applyReconstructionMode(xmlDoc, originalText, modifiedText, serializer,
     options
   ));
 }
+function forEachChangeGroup(diffs, onEqual, onGroup) {
+  let index = 0;
+  while (index < diffs.length) {
+    if (diffs[index][0] === 0) {
+      onEqual(diffs[index]);
+      index++;
+      continue;
+    }
+    const group = [];
+    while (index < diffs.length && diffs[index][0] !== 0) group.push(diffs[index++]);
+    onGroup(
+      group,
+      group.filter(([op]) => op === -1).map(([, text2]) => text2).join(""),
+      group.filter(([op]) => op === 1).map(([, text2]) => text2).join("")
+    );
+  }
+}
+function pushChange(result, deleted, inserted) {
+  if (deleted === inserted) {
+    if (deleted) result.push([0, deleted]);
+    return;
+  }
+  if (deleted) result.push([-1, deleted]);
+  if (inserted) result.push([1, inserted]);
+}
+function anchorSharedReferences(diffs, referenceMap) {
+  if (referenceMap.size === 0) return diffs;
+  const result = [];
+  forEachChangeGroup(diffs, (part) => result.push(part), (group, deleted, inserted) => {
+    const deletedRefs = [...deleted].filter((char) => referenceMap.has(char) && inserted.includes(char));
+    const insertedRefs = [...inserted].filter((char) => deletedRefs.includes(char));
+    if (deletedRefs.length === 0 || deletedRefs.join("") !== insertedRefs.join("")) {
+      result.push(...group);
+      return;
+    }
+    let deletedStart = 0;
+    let insertedStart = 0;
+    for (const ref of deletedRefs) {
+      const deletedAt = deleted.indexOf(ref, deletedStart);
+      const insertedAt = inserted.indexOf(ref, insertedStart);
+      pushChange(result, deleted.slice(deletedStart, deletedAt), inserted.slice(insertedStart, insertedAt));
+      result.push([0, ref]);
+      deletedStart = deletedAt + 1;
+      insertedStart = insertedAt + 1;
+    }
+    pushChange(result, deleted.slice(deletedStart), inserted.slice(insertedStart));
+  });
+  return result;
+}
+function commonPrefixLength(left, right) {
+  const limit = Math.min(left.length, right.length);
+  let length = 0;
+  while (length < limit && left[length] === right[length]) length++;
+  return length;
+}
+function commonSuffixLength(left, right, limit) {
+  let length = 0;
+  while (length < limit && left[left.length - 1 - length] === right[right.length - 1 - length]) length++;
+  return length;
+}
+function keepUnchangedTextOutsideWrappers(diffs, mapping) {
+  const wrapperAt = (index) => mapping.getRunProperties(index).wrapper || null;
+  const result = [];
+  let originalOffset = 0;
+  forEachChangeGroup(diffs, (part) => {
+    result.push(part);
+    originalOffset += part[1].length;
+  }, (group, deleted, inserted) => {
+    const start = originalOffset;
+    const end = start + deleted.length;
+    originalOffset = end;
+    const isWrapperBoundary = (index) => index > start && index < end && wrapperAt(index - 1) !== wrapperAt(index);
+    let prefix = 0;
+    let suffix = 0;
+    if (deleted && inserted) {
+      const sharedSuffix = commonSuffixLength(deleted, inserted, Math.min(deleted.length, inserted.length));
+      for (let length = sharedSuffix; length > 0; length--) {
+        if (isWrapperBoundary(end - length)) {
+          suffix = length;
+          break;
+        }
+      }
+      const sharedPrefix = Math.min(
+        commonPrefixLength(deleted, inserted),
+        Math.min(deleted.length, inserted.length) - suffix
+      );
+      for (let length = sharedPrefix; length > 0; length--) {
+        if (isWrapperBoundary(start + length)) {
+          prefix = length;
+          break;
+        }
+      }
+    }
+    if (prefix === 0 && suffix === 0) {
+      result.push(...group);
+      return;
+    }
+    if (prefix > 0) result.push([0, deleted.slice(0, prefix)]);
+    pushChange(result, deleted.slice(prefix, deleted.length - suffix), inserted.slice(prefix, inserted.length - suffix));
+    if (suffix > 0) result.push([0, deleted.slice(deleted.length - suffix)]);
+  });
+  return result;
+}
 
 // engine/table-mode.js
 function noChanges(serializer, xmlDoc) {