@ansonlai/docx-redline-js 0.8.3 → 0.9.0

package/orchestration/list-structural-fallback.js

@@ -5,7 +5,9 @@
 
 import { createSerializer, parseOoxmlSafe } from '../adapters/xml-adapter.js';
 import { getXmlParseError } from '../core/xml-query.js';
-import { NS_W } from '../core/types.js';
+import { NS_W, createRevisionMetadata } from '../core/types.js';
+import { clonePropertiesWithoutRevisionHistory } from '../core/revision-cloning.js';
+import { getCurrentNumIdElements } from '../core/current-properties.js';
 import { createWordElement } from '../core/word-xml.js';
 import {
     getDocumentParagraphNodes,
@@ -62,12 +64,47 @@ export function stripSingleLineListMarkerPrefix(text) {
     return String(candidate.contentText || '').trim();
 }
 
-function parseMarkerStart(marker, numberingStyle) {
-    if (numberingStyle !== 'decimal') return null;
-    const match = String(marker || '').trim().match(/^(\d+)\.?$/);
-    if (!match) return null;
-    const value = Number.parseInt(match[1], 10);
-    return Number.isFinite(value) && value > 0 ? value : null;
+const ROMAN_VALUES = { i: 1, v: 5, x: 10, l: 50, c: 100, d: 500, m: 1000 };
+
+function parseRomanNumeral(text) {
+    const letters = String(text || '').toLowerCase();
+    if (!/^[ivxlcdm]+$/.test(letters)) return null;
+    let total = 0;
+    for (let i = 0; i < letters.length; i++) {
+        const value = ROMAN_VALUES[letters[i]];
+        const next = ROMAN_VALUES[letters[i + 1]] || 0;
+        total += value < next ? -value : value;
+    }
+    return total;
+}
+
+/**
+ * Derives the numeric start a literal marker implies: `7.` -> 7, `C.` -> 3, `iv.` -> 4.
+ * Decimal markers keep every positive value (including 1). Letter and roman markers report only
+ * values above 1, because the default start (1) needs no override and keeps the shared-list behavior.
+ *
+ * @param {string} marker
+ * @param {string} numberingStyle
+ * @returns {number|null}
+ */
+export function parseMarkerStart(marker, numberingStyle) {
+    const text = String(marker || '').trim();
+    let value = null;
+    if (numberingStyle === 'decimal') {
+        const match = text.match(/^(\d+)\.?$/);
+        value = match ? Number.parseInt(match[1], 10) : null;
+    } else if (numberingStyle === 'lowerRoman' || numberingStyle === 'upperRoman') {
+        const match = text.match(/^([A-Za-z]+)[.)]?$/);
+        value = match ? parseRomanNumeral(match[1]) : null;
+    } else if (numberingStyle === 'lowerAlpha' || numberingStyle === 'upperAlpha') {
+        const match = text.match(/^([A-Za-z])[.)]?$/);
+        value = match ? match[1].toLowerCase().charCodeAt(0) - 96 : null;
+    } else {
+        return null;
+    }
+    if (!Number.isFinite(value) || value < 1) return null;
+    if (numberingStyle !== 'decimal' && value === 1) return null;
+    return value;
 }
 
 /**
@@ -199,7 +236,8 @@ function getDirectWordChild(element, localName) {
  *   numId: string|number,
  *   ilvl?: number,
  *   clearParagraphPropertyChanges?: boolean,
- *   removeListPropertyNode?: boolean
+ *   removeListPropertyNode?: boolean,
+ *   trackPropertyChange?: { author?: string, revisionIdAllocator?: object|null }|null
  * }} options - Binding options
  * @returns {number} Number of paragraph nodes updated
  */
@@ -209,6 +247,7 @@ export function enforceListBindingOnParagraphNodes(nodes, options = {}) {
     const ilvl = Number.isInteger(options?.ilvl) ? Math.max(0, options.ilvl) : 0;
     const clearParagraphPropertyChanges = options?.clearParagraphPropertyChanges !== false;
     const removeListPropertyNode = options?.removeListPropertyNode !== false;
+    const trackPropertyChange = options?.trackPropertyChange || null;
 
     const paragraphs = (Array.isArray(nodes) ? nodes : [])
         .filter(node => node && node.nodeType === 1 && node.localName === 'p');
@@ -224,6 +263,9 @@ export function enforceListBindingOnParagraphNodes(nodes, options = {}) {
             paragraph.insertBefore(pPr, paragraph.firstChild);
         }
 
+        // Snapshot the pre-binding pPr so Reject All restores the unnumbered paragraph.
+        const priorPPr = trackPropertyChange ? clonePropertiesWithoutRevisionHistory(pPr) : null;
+
         if (clearParagraphPropertyChanges) {
             const pPrChange = getDirectWordChild(pPr, 'pPrChange');
             if (pPrChange) pPr.removeChild(pPrChange);
@@ -253,6 +295,20 @@ export function enforceListBindingOnParagraphNodes(nodes, options = {}) {
             numPr.appendChild(numIdEl);
         }
         numIdEl.setAttribute('w:val', String(numId));
+
+        if (trackPropertyChange && !getDirectWordChild(pPr, 'pPrChange')) {
+            const metadata = createRevisionMetadata(
+                trackPropertyChange.author,
+                trackPropertyChange.revisionIdAllocator || ownerDoc,
+                'pPrChange'
+            );
+            const pPrChange = createWordElement(ownerDoc, 'w:pPrChange');
+            pPrChange.setAttribute('w:id', String(metadata.id));
+            pPrChange.setAttribute('w:author', metadata.author);
+            pPrChange.setAttribute('w:date', metadata.date);
+            pPrChange.appendChild(priorPPr || createWordElement(ownerDoc, 'w:pPr'));
+            pPr.appendChild(pPrChange);
+        }
         updated++;
     }
 
@@ -311,7 +367,8 @@ function extractFirstParagraphNumIdFromOxml(oxml) {
     // Tracked-change output leads with a deleted-original paragraph that carries
     // no numPr, so the generated list binding is the first paragraph that has one.
     for (const paragraph of paragraphs) {
-        const numIdNodes = Array.from(paragraph.getElementsByTagNameNS('*', 'numId'));
+        // Current numIds only; a pPrChange snapshot must not supply the generated list binding.
+        const numIdNodes = getCurrentNumIdElements(paragraph);
         for (const numIdNode of numIdNodes) {
             const numId = getElementId(numIdNode, ['w:val', 'val']);
             if (numId != null) return String(numId);
@@ -433,6 +490,7 @@ export function buildSingleLineListStructuralFallbackPlan(options = {}) {
         numberingKey: `${modifiedCandidate.type}:${modifiedCandidate.numberingStyle}:single`,
         originalText,
         wasListParagraph: !!existingListInfo,
+        numberingStyle: modifiedCandidate.numberingStyle,
         startAt: modifiedCandidate.startAt
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ansonlai/docx-redline-js",
-  "version": "0.8.3",
+  "version": "0.9.0",
   "description": "Host-independent OOXML reconciliation engine for .docx manipulation with track changes",
   "license": "MIT",
   "type": "module",

package/pipeline/diff-engine.js

@@ -41,9 +41,15 @@ export function createDiffEngine(options = {}) {
     return engine;
 }
 
+// Opening and closing punctuation that hugs a word. Splitting it into its own
+// token lets "agents and attorneys" -> "agents, attorneys," keep both words
+// unchanged instead of replacing the whole phrase.
+const LEADING_PUNCTUATION = /^[("'\[{“‘]+/u;
+const TRAILING_PUNCTUATION = /[)"'\]}”’,.;:!?]+$/u;
+
 function tokenize(text, atomicChars = null) {
     const tokens = [];
-    const pushWord = word => {
+    const pushPiece = word => {
         if (!atomicChars || atomicChars.size === 0) {
             tokens.push(word);
             return;
@@ -59,6 +65,20 @@ function tokenize(text, atomicChars = null) {
         }
         if (start < word.length) tokens.push(word.slice(start));
     };
+    const pushWord = word => {
+        const leading = word.match(LEADING_PUNCTUATION)?.[0] || '';
+        const rest = word.slice(leading.length);
+        const trailing = rest.match(TRAILING_PUNCTUATION)?.[0] || '';
+        const core = rest.slice(0, rest.length - trailing.length);
+        // A token made only of punctuation stays whole.
+        if (!core) {
+            pushPiece(word);
+            return;
+        }
+        for (const char of leading) pushPiece(char);
+        pushPiece(core);
+        for (const char of trailing) pushPiece(char);
+    };
     const leading = text.match(/^\s+/);
     if (leading) tokens.push(leading[0]);
 
@@ -243,11 +263,120 @@ export function computeWordDiffs(originalText, newText, options = {}) {
     const charDiffs = dmp.diff_main(encodeTokenIdsForDmp(tokenIds1), encodeTokenIdsForDmp(tokenIds2));
     if (cleanupSemantic) {
         dmp.diff_cleanupSemantic(charDiffs);
+        refineReplacementsAroundAnchors(dmp, charDiffs, wordArray);
     }
 
     return decodeBmpDiffs(charDiffs, wordArray);
 }
 
+// A token that is a substantive word: four or more letters or digits. Short
+// function words ("a", "the", "and") and punctuation never anchor on their own.
+const ANCHOR_TOKEN = /^[\p{L}\p{N}][\p{L}\p{N}'’-]{3,}$/u;
+
+function isAnchorEquality(chars, wordArray) {
+    for (let index = 0; index < chars.length; index++) {
+        if (ANCHOR_TOKEN.test(wordArray[bmpCharToTokenId(chars.charCodeAt(index))])) return true;
+    }
+    return false;
+}
+
+const MAX_ANCHOR_REFINEMENT_CELLS = 250000;
+
+/**
+ * Token LCS that weights substantive words far above whitespace, punctuation
+ * and function words. A plain LCS would rather keep " and " (three tokens)
+ * than "attorneys" (one token), which is the opposite of a useful redline.
+ * Returns null when the replacement is too large to refine cheaply.
+ *
+ * @param {string} deleted - BMP-encoded deleted tokens
+ * @param {string} inserted - BMP-encoded inserted tokens
+ * @param {string[]} wordArray
+ * @returns {Array<[number, string]>|null}
+ */
+function anchorWeightedDiff(deleted, inserted, wordArray) {
+    const rows = deleted.length;
+    const cols = inserted.length;
+    if (!rows || !cols || (rows + 1) * (cols + 1) > MAX_ANCHOR_REFINEMENT_CELLS) return null;
+
+    const weight = char => {
+        const token = wordArray[bmpCharToTokenId(char.charCodeAt(0))];
+        return ANCHOR_TOKEN.test(token) ? token.length * 100 : token.length;
+    };
+    const width = cols + 1;
+    const scores = new Float64Array((rows + 1) * width);
+    for (let row = rows - 1; row >= 0; row--) {
+        for (let col = cols - 1; col >= 0; col--) {
+            const skip = Math.max(scores[(row + 1) * width + col], scores[row * width + col + 1]);
+            scores[row * width + col] = deleted[row] === inserted[col]
+                ? Math.max(skip, weight(deleted[row]) + scores[(row + 1) * width + col + 1])
+                : skip;
+        }
+    }
+
+    const result = [];
+    const push = (op, char) => {
+        const last = result[result.length - 1];
+        if (last?.[0] === op) last[1] += char;
+        else result.push([op, char]);
+    };
+    let row = 0;
+    let col = 0;
+    while (row < rows && col < cols) {
+        const here = scores[row * width + col];
+        if (deleted[row] === inserted[col]
+            && here === weight(deleted[row]) + scores[(row + 1) * width + col + 1]) {
+            push(0, deleted[row]);
+            row++;
+            col++;
+        } else if (scores[(row + 1) * width + col] >= scores[row * width + col + 1]) {
+            push(-1, deleted[row++]);
+        } else {
+            push(1, inserted[col++]);
+        }
+    }
+    while (row < rows) push(-1, deleted[row++]);
+    while (col < cols) push(1, inserted[col++]);
+    return result;
+}
+
+/**
+ * Semantic cleanup measures equalities in tokens, so a single unchanged word
+ * between two edits ("agents[ and] attorneys[, accountants ...]") is folded
+ * into one whole-phrase replacement. Re-diff each replacement and keep any
+ * unchanged run that contains a substantive word, so the redline only marks
+ * the text that actually changed.
+ */
+function refineReplacementsAroundAnchors(dmp, diffs, wordArray) {
+    for (let index = 0; index < diffs.length; index++) {
+        let deleteIndex = -1;
+        let insertIndex = -1;
+        if (diffs[index][0] === -1 && diffs[index + 1]?.[0] === 1) {
+            deleteIndex = index;
+            insertIndex = index + 1;
+        } else if (diffs[index][0] === 1 && diffs[index + 1]?.[0] === -1) {
+            insertIndex = index;
+            deleteIndex = index + 1;
+        } else {
+            continue;
+        }
+
+        const inner = anchorWeightedDiff(diffs[deleteIndex][1], diffs[insertIndex][1], wordArray);
+        if (!inner?.some(([op, chars]) => op === 0 && isAnchorEquality(chars, wordArray))) continue;
+
+        const refined = [];
+        for (const [op, chars] of inner) {
+            if (op === 0 && !isAnchorEquality(chars, wordArray)) {
+                refined.push([-1, chars], [1, chars]);
+            } else {
+                refined.push([op, chars]);
+            }
+        }
+        dmp.diff_cleanupMerge(refined);
+        diffs.splice(index, 2, ...refined);
+        index += refined.length - 1;
+    }
+}
+
 /**
  * Computes a character-local diff without semantic cleanup. This is used to
  * refine whitespace-only substitutions that a word-level token groups with