@ansonlai/docx-redline-js 0.1.4 → 0.1.6

package/engine/reconstruction-mapper.js

@@ -109,11 +109,12 @@ export function buildReconstructionMapping(xmlDoc, modifiedText) {
         });
     });
 
-    let processedModifiedText = modifiedText;
-    tokenToCharMap.forEach((char, tokenString) => {
-        const escapedToken = tokenString.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
-        processedModifiedText = processedModifiedText.replace(new RegExp(escapedToken, 'g'), char);
-    });
+    let processedModifiedText = modifiedText;
+    tokenToCharMap.forEach((char, tokenString) => {
+        const escapedToken = tokenString.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+        processedModifiedText = processedModifiedText.replace(new RegExp(escapedToken, 'g'), char);
+    });
+    processedModifiedText = preserveReferencePlaceholders(originalFullText, processedModifiedText, referenceMap);
 
     const containerFragments = new Map();
     uniqueContainers.forEach(container => {
@@ -169,9 +170,35 @@ export function buildReconstructionMapping(xmlDoc, modifiedText) {
         getPropertySpanLength,
         isParagraphStart: index => paragraphStarts.has(index)
     };
-}
-
-function processChildNode(child, originalFullText, propertyMap, sentinelMap, referenceMap, tokenToCharMap, nextCharCode) {
+}
+
+function preserveReferencePlaceholders(originalFullText, modifiedText, referenceMap) {
+    let result = modifiedText;
+
+    for (const referenceChar of referenceMap.keys()) {
+        if (result.includes(referenceChar)) continue;
+
+        const originalIndex = originalFullText.indexOf(referenceChar);
+        if (originalIndex < 0) continue;
+
+        const prefix = originalFullText.slice(0, originalIndex);
+        const suffix = originalFullText.slice(originalIndex + referenceChar.length);
+
+        if (prefix && result.startsWith(prefix)) {
+            result = `${result.slice(0, prefix.length)}${referenceChar}${result.slice(prefix.length)}`;
+            continue;
+        }
+
+        if (suffix && result.endsWith(suffix)) {
+            const insertAt = result.length - suffix.length;
+            result = `${result.slice(0, insertAt)}${referenceChar}${result.slice(insertAt)}`;
+        }
+    }
+
+    return result;
+}
+
+function processChildNode(child, originalFullText, propertyMap, sentinelMap, referenceMap, tokenToCharMap, nextCharCode) {
     if (child.nodeName === 'w:r') {
         return processRunForReconstruction(child, originalFullText, propertyMap, sentinelMap, referenceMap, tokenToCharMap, nextCharCode);
     }

package/engine/reconstruction-mode.js

@@ -5,6 +5,7 @@
 import { computeWordDiffs } from '../pipeline/diff-engine.js';
 import { buildReconstructionMapping } from './reconstruction-mapper.js';
 import { applyReconstructionDiffs } from './reconstruction-writer.js';
+import { withOoxmlSourceType } from '../core/word-xml.js';
 
 /**
  * Applies reconstruction mode reconciliation.
@@ -19,20 +20,20 @@ import { applyReconstructionDiffs } from './reconstruction-writer.js';
  * @returns {{ oxml: string, hasChanges: boolean }}
  */
 export function applyReconstructionMode(xmlDoc, originalText, modifiedText, serializer, author, formatHints, generateRedlines = true) {
-    const mapping = buildReconstructionMapping(xmlDoc, modifiedText);
-    if (mapping.paragraphs.length === 0) {
-        return { oxml: serializer.serializeToString(xmlDoc), hasChanges: false };
-    }
+    const mapping = buildReconstructionMapping(xmlDoc, modifiedText);
+    if (mapping.paragraphs.length === 0) {
+        return withOoxmlSourceType({ oxml: serializer.serializeToString(xmlDoc), hasChanges: false });
+    }
 
     const diffs = computeWordDiffs(mapping.originalFullText, mapping.processedModifiedText);
 
-    return applyReconstructionDiffs(
+    return withOoxmlSourceType(applyReconstructionDiffs(
         xmlDoc,
-        diffs,
-        mapping,
-        serializer,
-        author,
-        formatHints,
-        generateRedlines
-    );
-}
+        diffs,
+        mapping,
+        serializer,
+        author,
+        formatHints,
+        generateRedlines
+    ));
+}

package/engine/reconstruction-writer.js

@@ -4,9 +4,15 @@
  * Applies diff segments to mapped reconstruction context and writes updated DOM content.
  */
 
-import { getApplicableFormatHints } from '../pipeline/markdown-processor.js';
-import { createTrackChange, createFormattedRuns } from './run-builders.js';
-import { getFirstElementByTag } from '../core/xml-query.js';
+import { getApplicableFormatHints } from '../pipeline/markdown-processor.js';
+import {
+    createTrackChange,
+    createFormattedRuns,
+    markParagraphMarkDeleted,
+    markParagraphMarkInserted
+} from './run-builders.js';
+import { getFirstElementByTag } from '../core/xml-query.js';
+import { createWordElement } from '../core/word-xml.js';
 
 /**
  * Applies diffs to reconstruction context and writes updated XML.
@@ -32,23 +38,24 @@ export function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, aut
         getRunProperties,
         getPropertySpanLength,
         isParagraphStart
-    } = context;
-
-    const createNewParagraph = (pPr) => {
-        const newParagraph = xmlDoc.createElement('w:p');
-        if (pPr) newParagraph.appendChild(pPr.cloneNode(true));
-        return newParagraph;
-    };
+    } = context;
+
+    const createNewParagraph = (pPr) => {
+        const newParagraph = createWordElement(xmlDoc, 'w:p');
+        if (pPr) newParagraph.appendChild(pPr.cloneNode(true));
+        return newParagraph;
+    };
 
     const startInfo = getParagraphInfo(0);
-    let currentParagraph = createNewParagraph(startInfo.pPr);
-    const initialFragment = containerFragments.get(startInfo.container);
-    if (initialFragment) {
-        initialFragment.appendChild(currentParagraph);
-    }
-
-    let currentOriginalIndex = 0;
-    let currentInsertOffset = 0;
+    let currentParagraph = createNewParagraph(startInfo.pPr);
+    const initialFragment = containerFragments.get(startInfo.container);
+    if (initialFragment) {
+        initialFragment.appendChild(currentParagraph);
+    }
+
+    let currentOriginalIndex = 0;
+    let currentInsertOffset = 0;
+    const emittedCommentMarkers = new WeakSet();
 
     for (const [op, text] of diffs) {
         if (op === 0 || op === -1) {
@@ -61,9 +68,9 @@ export function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, aut
                 const chunkLength = getPropertySpanLength(chunkStart, text.length - offset);
                 const chunk = text.substring(offset, offset + chunkLength);
 
-                appendTextToCurrent(
-                    xmlDoc,
-                    chunk,
+                const appendResult = appendTextToCurrent(
+                    xmlDoc,
+                    chunk,
                     type,
                     properties.rPr,
                     properties.wrapper,
@@ -76,13 +83,15 @@ export function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, aut
                     getParagraphInfo,
                     createNewParagraph,
                     author,
-                    formatHints,
-                    currentInsertOffset,
-                    generateRedlines
-                );
-
-                if (op === 0) {
-                    currentInsertOffset += chunkLength;
+                    formatHints,
+                    currentInsertOffset,
+                    generateRedlines,
+                    emittedCommentMarkers
+                );
+                currentParagraph = appendResult.currentParagraph;
+
+                if (op === 0) {
+                    currentInsertOffset += chunkLength;
                 }
                 offset += chunkLength;
             }
@@ -96,9 +105,9 @@ export function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, aut
                 ? getRunProperties(currentOriginalIndex - 1)
                 : getRunProperties(currentOriginalIndex);
 
-            appendTextToCurrent(
-                xmlDoc,
-                text,
+            const appendResult = appendTextToCurrent(
+                xmlDoc,
+                text,
                 'insert',
                 properties.rPr,
                 properties.wrapper,
@@ -111,13 +120,15 @@ export function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, aut
                 getParagraphInfo,
                 createNewParagraph,
                 author,
-                formatHints,
-                currentInsertOffset,
-                generateRedlines
-            );
-            currentInsertOffset += text.length;
-        }
-    }
+                formatHints,
+                currentInsertOffset,
+                generateRedlines,
+                emittedCommentMarkers
+            );
+            currentParagraph = appendResult.currentParagraph;
+            currentInsertOffset += text.length;
+        }
+    }
 
     paragraphs.forEach(paragraph => {
         if (paragraph.parentNode) {
@@ -163,8 +174,9 @@ function appendTextToCurrent(
     author,
     formatHints = [],
     insertOffset = 0,
-    generateRedlines = true
-) {
+    generateRedlines = true,
+    emittedCommentMarkers = new WeakSet()
+) {
     let localBaseIndex = baseIndex;
     let localInsertOffset = insertOffset;
     let localParagraph = currentParagraphRef;
@@ -173,30 +185,35 @@ function appendTextToCurrent(
 
     parts.forEach(part => {
         const sentinelsAtOffset = sentinelMapByStart.get(localBaseIndex) || [];
-        const commentMarkers = sentinelsAtOffset.filter(sentinel => sentinel.isCommentMarker);
-
-        commentMarkers.forEach(marker => {
-            if (marker.node.nodeName === 'w:commentReference') {
-                const run = xmlDoc.createElement('w:r');
-                run.appendChild(marker.node.cloneNode(true));
-                localParagraph.appendChild(run);
-            } else {
+        const commentMarkers = sentinelsAtOffset.filter(sentinel => sentinel.isCommentMarker && !emittedCommentMarkers.has(sentinel.node));
+
+        commentMarkers.forEach(marker => {
+            emittedCommentMarkers.add(marker.node);
+            if (marker.node.nodeName === 'w:commentReference') {
+                const run = createWordElement(xmlDoc, 'w:r');
+                run.appendChild(marker.node.cloneNode(true));
+                localParagraph.appendChild(run);
+            } else {
                 localParagraph.appendChild(marker.node.cloneNode(true));
             }
         });
 
-        if (part === '\n') {
-            if (type !== 'delete') {
-                const info = getParagraphInfo(localBaseIndex);
-                const nextParagraph = createNewParagraph(info.pPr);
-                const fragment = containerFragments.get(info.container);
-                if (fragment) {
-                    fragment.appendChild(nextParagraph);
-                    localParagraph = nextParagraph;
-                }
-            }
-            localBaseIndex++;
-            if (type !== 'delete') localInsertOffset++;
+        if (part === '\n') {
+            const info = getParagraphInfo(localBaseIndex + 1);
+            const nextParagraph = createNewParagraph(info.pPr);
+            if (generateRedlines && type === 'insert') {
+                markParagraphMarkInserted(xmlDoc, nextParagraph, author);
+            } else if (generateRedlines && type === 'delete') {
+                markParagraphMarkDeleted(xmlDoc, nextParagraph, author);
+            }
+
+            const fragment = containerFragments.get(info.container);
+            if (fragment) {
+                fragment.appendChild(nextParagraph);
+                localParagraph = nextParagraph;
+            }
+            localBaseIndex++;
+            if (type !== 'delete') localInsertOffset++;
             return;
         }
 
@@ -220,13 +237,13 @@ function appendTextToCurrent(
 
         if (referenceMap.has(part)) {
             if (type !== 'delete') {
-                const refNode = referenceMap.get(part);
-                if (refNode) {
-                    const clone = refNode.cloneNode(true);
-                    const run = xmlDoc.createElement('w:r');
-                    if (rPr) run.appendChild(rPr.cloneNode(true));
-                    run.appendChild(clone);
-                    localParagraph.appendChild(run);
+                const refNode = referenceMap.get(part);
+                if (refNode) {
+                    const clone = refNode.cloneNode(true);
+                    const run = createWordElement(xmlDoc, 'w:r');
+                    if (rPr) run.appendChild(rPr.cloneNode(true));
+                    run.appendChild(clone);
+                    localParagraph.appendChild(run);
                 }
             }
             localBaseIndex++;
@@ -242,14 +259,14 @@ function appendTextToCurrent(
             parent = wrapperClone;
             localParagraph.appendChild(wrapperClone);
         }
-
-        if (type === 'delete') {
-            const run = xmlDoc.createElement('w:r');
-            if (rPr) run.appendChild(rPr.cloneNode(true));
-            const delText = xmlDoc.createElement('w:delText');
-            delText.setAttribute('xml:space', 'preserve');
-            delText.textContent = part;
-            run.appendChild(delText);
+
+        if (type === 'delete') {
+            const run = createWordElement(xmlDoc, 'w:r');
+            if (rPr) run.appendChild(rPr.cloneNode(true));
+            const delText = createWordElement(xmlDoc, 'w:delText');
+            delText.setAttribute('xml:space', 'preserve');
+            delText.textContent = part;
+            run.appendChild(delText);
 
             if (generateRedlines) {
                 const del = createTrackChange(xmlDoc, 'del', run, author);
@@ -271,6 +288,8 @@ function appendTextToCurrent(
         if (type !== 'delete') {
             localInsertOffset += part.length;
         }
-        localBaseIndex += part.length;
-    });
-}
+        localBaseIndex += part.length;
+    });
+
+    return { currentParagraph: localParagraph };
+}

package/engine/rpr-helpers.js

@@ -2,10 +2,12 @@
  * Run property (w:rPr) helper utilities.
  *
  * This module owns low-level formatting element operations, including
- * schema-order insertion, format extraction, and format add/remove transforms.
- */
-
-/**
+ * schema-order insertion, format extraction, and format add/remove transforms.
+ */
+
+import { createWordElement } from '../core/word-xml.js';
+
+/**
  * Canonical OOXML run-property schema ordering.
  * Shared by all rPr synchronizers.
  */
@@ -82,33 +84,33 @@ function _applyOverrides(xmlDoc, rPr, formatFlags, mode) {
         }
     }
 
-    if (applyBold) {
-        const b = xmlDoc.createElement('w:b');
-        b.setAttribute('w:val', mode === 'add' ? '1' : '0');
-        insertRPrChildInOrder(rPr, b);
-
-        const bCs = xmlDoc.createElement('w:bCs');
-        bCs.setAttribute('w:val', mode === 'add' ? '1' : '0');
-        insertRPrChildInOrder(rPr, bCs);
-    }
-    if (applyItalic) {
-        const i = xmlDoc.createElement('w:i');
-        i.setAttribute('w:val', mode === 'add' ? '1' : '0');
-        insertRPrChildInOrder(rPr, i);
-
-        const iCs = xmlDoc.createElement('w:iCs');
-        iCs.setAttribute('w:val', mode === 'add' ? '1' : '0');
-        insertRPrChildInOrder(rPr, iCs);
-    }
-    if (applyUnderline) {
-        const u = xmlDoc.createElement('w:u');
-        u.setAttribute('w:val', mode === 'add' ? 'single' : 'none');
-        insertRPrChildInOrder(rPr, u);
-    }
-    if (applyStrike) {
-        const strike = xmlDoc.createElement('w:strike');
-        strike.setAttribute('w:val', mode === 'add' ? '1' : '0');
-        insertRPrChildInOrder(rPr, strike);
+    if (applyBold) {
+        const b = createWordElement(xmlDoc, 'w:b');
+        b.setAttribute('w:val', mode === 'add' ? '1' : '0');
+        insertRPrChildInOrder(rPr, b);
+
+        const bCs = createWordElement(xmlDoc, 'w:bCs');
+        bCs.setAttribute('w:val', mode === 'add' ? '1' : '0');
+        insertRPrChildInOrder(rPr, bCs);
+    }
+    if (applyItalic) {
+        const i = createWordElement(xmlDoc, 'w:i');
+        i.setAttribute('w:val', mode === 'add' ? '1' : '0');
+        insertRPrChildInOrder(rPr, i);
+
+        const iCs = createWordElement(xmlDoc, 'w:iCs');
+        iCs.setAttribute('w:val', mode === 'add' ? '1' : '0');
+        insertRPrChildInOrder(rPr, iCs);
+    }
+    if (applyUnderline) {
+        const u = createWordElement(xmlDoc, 'w:u');
+        u.setAttribute('w:val', mode === 'add' ? 'single' : 'none');
+        insertRPrChildInOrder(rPr, u);
+    }
+    if (applyStrike) {
+        const strike = createWordElement(xmlDoc, 'w:strike');
+        strike.setAttribute('w:val', mode === 'add' ? '1' : '0');
+        insertRPrChildInOrder(rPr, strike);
     }
 }
 
@@ -123,7 +125,7 @@ function _applyOverrides(xmlDoc, rPr, formatFlags, mode) {
  */
 export function buildOverrideRPrXml(xmlDoc, originalRun, formatToRemove, serializer) {
     const baseRPr = originalRun.getElementsByTagName('w:rPr')[0] || null;
-    const rPr = baseRPr ? baseRPr.cloneNode(true) : xmlDoc.createElement('w:rPr');
+    const rPr = baseRPr ? baseRPr.cloneNode(true) : createWordElement(xmlDoc, 'w:rPr');
     _applyOverrides(xmlDoc, rPr, formatToRemove, 'remove');
 
     let rPrXml = serializer.serializeToString(rPr);