@ansonlai/docx-redline-js 0.8.2 → 0.8.4

package/engine/reconstruction-mode.js

@@ -1,183 +1,183 @@
-/**
- * Reconstruction reconciliation mode orchestration.
- */
-
-import { computeWordDiffs } from '../pipeline/diff-engine.js';
-import { buildReconstructionMapping, findReconstructionParagraphRange } from './reconstruction-mapper.js';
-import { applyReconstructionDiffs } from './reconstruction-writer.js';
-import { withOoxmlSourceType } from '../core/word-xml.js';
-
-/**
- * Applies reconstruction mode reconciliation.
- *
- * @param {Document} xmlDoc - XML document
- * @param {string} originalText - Original text (kept for signature compatibility)
- * @param {string} modifiedText - Modified text
- * @param {XMLSerializer} serializer - Serializer instance
- * @param {string} author - Author name
- * @param {Array} formatHints - Format hints
- * @param {boolean} [generateRedlines=true] - Track change toggle
- * @param {{ diffTimeoutSeconds?: number }} [diffOptions={}] - Diff configuration
- * @returns {{ oxml: string, hasChanges: boolean }}
- */
-export function applyReconstructionMode(xmlDoc, originalText, modifiedText, serializer, author, formatHints, generateRedlines = true, diffOptions = {}, options = {}) {
-    const selectedParagraphs = findReconstructionParagraphRange(xmlDoc, originalText);
-    if (selectedParagraphs === null) {
-        return withOoxmlSourceType({
-            oxml: serializer.serializeToString(xmlDoc),
-            hasChanges: false,
-            status: 'error',
-            error: {
-                code: 'PARTIAL_TARGET',
-                message: 'Original text did not identify a complete contiguous paragraph range for reconstruction.'
-            }
-        });
-    }
-
-    const mapping = buildReconstructionMapping(xmlDoc, modifiedText, selectedParagraphs);
-    if (mapping.paragraphs.length === 0) {
-        return withOoxmlSourceType({ oxml: serializer.serializeToString(xmlDoc), hasChanges: false });
-    }
-
-    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,
-        mapping,
-        serializer,
-        author,
-        formatHints,
-        generateRedlines,
-        options
-    ));
-}
-
-/** Splits diffs into runs of equal parts and change groups (deleted + inserted text). */
-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(([, text]) => text).join(''),
-            group.filter(([op]) => op === 1).map(([, text]) => text).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]);
-}
-
-/**
- * The writer keeps a reference placeholder (manual break, note reference) that
- * appears in both the deleted and inserted text of one change group, but only
- * emits it with the insertion, after all deleted text. Semantic cleanup can
- * merge edits on both sides of a break into such a group, so Reject All would
- * move deleted text across the break. Split the group at shared references so
- * each one stays an unchanged anchor between its own before/after edits.
- */
-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;
-}
-
-/**
- * Word tokens can span a hyperlink boundary (`example.org` + plain `.`), so a
- * replaced token would delete and reinsert unchanged text across it and move
- * that text into or out of the link. Where the replacement's shared prefix or
- * suffix reaches a wrapper boundary in the original, keep that part unchanged.
- */
-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;
-        // Only a boundary strictly inside the deleted text splits it; an edge
-        // of the whole change (`link` -> `hyperlink` inside a link) does not.
-        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;
-}
+/**
+ * Reconstruction reconciliation mode orchestration.
+ */
+
+import { computeWordDiffs } from '../pipeline/diff-engine.js';
+import { buildReconstructionMapping, findReconstructionParagraphRange } from './reconstruction-mapper.js';
+import { applyReconstructionDiffs } from './reconstruction-writer.js';
+import { withOoxmlSourceType } from '../core/word-xml.js';
+
+/**
+ * Applies reconstruction mode reconciliation.
+ *
+ * @param {Document} xmlDoc - XML document
+ * @param {string} originalText - Original text (kept for signature compatibility)
+ * @param {string} modifiedText - Modified text
+ * @param {XMLSerializer} serializer - Serializer instance
+ * @param {string} author - Author name
+ * @param {Array} formatHints - Format hints
+ * @param {boolean} [generateRedlines=true] - Track change toggle
+ * @param {{ diffTimeoutSeconds?: number }} [diffOptions={}] - Diff configuration
+ * @returns {{ oxml: string, hasChanges: boolean }}
+ */
+export function applyReconstructionMode(xmlDoc, originalText, modifiedText, serializer, author, formatHints, generateRedlines = true, diffOptions = {}, options = {}) {
+    const selectedParagraphs = findReconstructionParagraphRange(xmlDoc, originalText);
+    if (selectedParagraphs === null) {
+        return withOoxmlSourceType({
+            oxml: serializer.serializeToString(xmlDoc),
+            hasChanges: false,
+            status: 'error',
+            error: {
+                code: 'PARTIAL_TARGET',
+                message: 'Original text did not identify a complete contiguous paragraph range for reconstruction.'
+            }
+        });
+    }
+
+    const mapping = buildReconstructionMapping(xmlDoc, modifiedText, selectedParagraphs);
+    if (mapping.paragraphs.length === 0) {
+        return withOoxmlSourceType({ oxml: serializer.serializeToString(xmlDoc), hasChanges: false });
+    }
+
+    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,
+        mapping,
+        serializer,
+        author,
+        formatHints,
+        generateRedlines,
+        options
+    ));
+}
+
+/** Splits diffs into runs of equal parts and change groups (deleted + inserted text). */
+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(([, text]) => text).join(''),
+            group.filter(([op]) => op === 1).map(([, text]) => text).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]);
+}
+
+/**
+ * The writer keeps a reference placeholder (manual break, note reference) that
+ * appears in both the deleted and inserted text of one change group, but only
+ * emits it with the insertion, after all deleted text. Semantic cleanup can
+ * merge edits on both sides of a break into such a group, so Reject All would
+ * move deleted text across the break. Split the group at shared references so
+ * each one stays an unchanged anchor between its own before/after edits.
+ */
+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;
+}
+
+/**
+ * Word tokens can span a hyperlink boundary (`example.org` + plain `.`), so a
+ * replaced token would delete and reinsert unchanged text across it and move
+ * that text into or out of the link. Where the replacement's shared prefix or
+ * suffix reaches a wrapper boundary in the original, keep that part unchanged.
+ */
+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;
+        // Only a boundary strictly inside the deleted text splits it; an edge
+        // of the whole change (`link` -> `hyperlink` inside a link) does not.
+        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;
+}

package/index.d.ts

@@ -105,6 +105,10 @@ export interface RedlineOptions {
   structuredContent?: boolean;
   pairReplacements?: boolean;
   insertionAffinity?: InsertionAffinity;
+  /** Source numbering part; generated list definitions are remapped to IDs that do not collide with it. */
+  numberingXml?: string | null;
+  /** Shared numbering ID state (from `createDynamicNumberingIdState`) for allocation across calls. */
+  numberingIdState?: unknown;
   [key: string]: unknown;
 }
 

package/index.js

@@ -21,10 +21,44 @@ import {
     executeSingleLineListStructuralFallback
 } from './orchestration/list-structural-fallback.js';
 import { withOoxmlSourceType } from './core/word-xml.js';
+import { createDynamicNumberingIdState, remapNumberingPayloadForDocument } from './services/numbering-helpers.js';
 export { containsTrackedChanges, getTrackedChangeAuthors } from './core/word-xml.js';
 export { validateRedlineOoxml } from './core/redline-validation.js';
 export { analyzeStructuredContent, planStructuredReplacement } from './pipeline/structured-content.js';
 
+/**
+ * When the caller supplies the source `numberingXml` (or a numbering ID state), generated list
+ * definitions are remapped to IDs that cannot collide with any existing `w:num`/`w:abstractNum`.
+ */
+function remapGeneratedNumberingForSource(result, options) {
+    const sourceNumbering = typeof options?.numberingXml === 'string' && options.numberingXml.trim()
+        ? options.numberingXml
+        : null;
+    const state = options?.numberingIdState && typeof options.numberingIdState === 'object'
+        ? options.numberingIdState
+        : (sourceNumbering ? createDynamicNumberingIdState(sourceNumbering) : null);
+    if (!state || !result?.hasChanges || typeof result.oxml !== 'string' || !result.oxml.includes('/word/numbering.xml')) {
+        return result;
+    }
+    const pkgDoc = parseOoxml(result.oxml);
+    const parts = Array.from(pkgDoc.getElementsByTagNameNS('*', 'part'));
+    const payloadOf = name => {
+        const part = parts.find(candidate => (candidate.getAttribute('pkg:name') || candidate.getAttribute('name')) === name);
+        const xmlData = part?.getElementsByTagNameNS('*', 'xmlData')[0];
+        return xmlData ? Array.from(xmlData.childNodes).find(node => node.nodeType === 1) || null : null;
+    };
+    const numberingNode = payloadOf('/word/numbering.xml');
+    const body = payloadOf('/word/document.xml')?.getElementsByTagNameNS('*', 'body')[0];
+    if (!numberingNode || !body) return result;
+
+    const bodyNodes = Array.from(body.childNodes).filter(node => node.nodeType === 1 && node.localName !== 'sectPr');
+    const remapped = remapNumberingPayloadForDocument(serializeOoxml(numberingNode), bodyNodes, state);
+    const newNumbering = pkgDoc.importNode(parseOoxml(remapped.numberingXml).documentElement, true);
+    numberingNode.parentNode.replaceChild(newNumbering, numberingNode);
+    bodyNodes.forEach((node, index) => body.replaceChild(remapped.replacementNodes[index], node));
+    return { ...result, oxml: serializeOoxml(pkgDoc) };
+}
+
 /**
  * Standalone-safe redline wrapper.
  *
@@ -33,7 +67,8 @@ export { analyzeStructuredContent, planStructuredReplacement } from './pipeline/
  * complete that native fallback path, so normalize to a no-op with warnings.
  */
 export async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}) {
-    const result = await applyRedlineToOxmlEngine(oxml, originalText, modifiedText, options);
+    const rawResult = await applyRedlineToOxmlEngine(oxml, originalText, modifiedText, options);
+    const result = remapGeneratedNumberingForSource(rawResult, options);
     if (result?.useNativeApi && typeof result?.oxml !== 'string') {
         const existingWarnings = Array.isArray(result?.warnings) ? result.warnings : [];
         return withOoxmlSourceType({

package/node/cli.js

@@ -38,7 +38,8 @@ const CLI_CAPABILITIES = [
     'compact-cli-json-v1',
     'comment-resolve-operation-v1',
     'delete-comments-by-id-v1',
-    'header-footer-parts-v1'
+    'header-footer-parts-v1',
+    'format-text-occurrence-v1'
 ];
 const commandOptions = Object.fromEntries(CLI_COMMANDS.map(command => [command, new Set(commandOptionKeys(command))]));