@ansonlai/docx-redline-js 0.1.4 → 0.2.0

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);

package/engine/run-builders.js

@@ -5,12 +5,13 @@
  * and `w:pPrChange` elements used by surgical and reconstruction modes.
  */
 
-import { RPR_SCHEMA_ORDER } from './rpr-helpers.js';
-import { createRevisionMetadata, getRevisionTimestamp } from '../core/types.js';
-import { getFirstElementByTag } from '../core/xml-query.js';
-
-/**
- * Creates an insertion/deletion wrapper.
+import { RPR_SCHEMA_ORDER } from './rpr-helpers.js';
+import { createRevisionMetadata } from '../core/types.js';
+import { getFirstElementByTag } from '../core/xml-query.js';
+import { createWordElement } from '../core/word-xml.js';
+
+/**
+ * Creates an insertion/deletion wrapper.
  *
  * @param {Document} xmlDoc - XML document
  * @param {'ins'|'del'} type - Wrapper type
@@ -18,8 +19,8 @@ import { getFirstElementByTag } from '../core/xml-query.js';
  * @param {string} author - Change author
  * @returns {Element}
  */
-export function createTrackChange(xmlDoc, type, run, author) {
-    const wrapper = xmlDoc.createElement(type === 'ins' ? 'w:ins' : 'w:del');
+export function createTrackChange(xmlDoc, type, run, author) {
+    const wrapper = createWordElement(xmlDoc, type === 'ins' ? 'w:ins' : 'w:del');
     const metadata = createRevisionMetadata(author);
     wrapper.setAttribute('w:id', String(metadata.id));
     wrapper.setAttribute('w:author', metadata.author);
@@ -28,7 +29,78 @@ export function createTrackChange(xmlDoc, type, run, author) {
         wrapper.appendChild(run);
     }
     return wrapper;
-}
+}
+
+function getDirectWordChild(node, localName) {
+    return Array.from(node?.childNodes || []).find(child => child.nodeType === 1
+        && (child.localName === localName || child.nodeName === `w:${localName}`)) || null;
+}
+
+function ensureParagraphProperties(xmlDoc, paragraph) {
+    let pPr = getDirectWordChild(paragraph, 'pPr');
+    if (!pPr) {
+        pPr = createWordElement(xmlDoc, 'w:pPr');
+        paragraph.insertBefore(pPr, paragraph.firstChild || null);
+    } else if (paragraph.firstChild !== pPr) {
+        paragraph.insertBefore(pPr, paragraph.firstChild || null);
+    }
+    return pPr;
+}
+
+function ensureParagraphMarkRunProperties(xmlDoc, pPr) {
+    let rPr = getDirectWordChild(pPr, 'rPr');
+    if (!rPr) {
+        rPr = createWordElement(xmlDoc, 'w:rPr');
+        pPr.appendChild(rPr);
+    } else if (pPr.lastChild !== rPr) {
+        pPr.appendChild(rPr);
+    }
+    return rPr;
+}
+
+function markParagraphMark(xmlDoc, paragraph, author, type) {
+    const pPr = ensureParagraphProperties(xmlDoc, paragraph);
+    const rPr = ensureParagraphMarkRunProperties(xmlDoc, pPr);
+
+    for (const child of Array.from(rPr.childNodes || [])) {
+        if (child.nodeType !== 1) continue;
+        if (child.localName === 'ins' || child.localName === 'del' || child.nodeName === 'w:ins' || child.nodeName === 'w:del') {
+            rPr.removeChild(child);
+        }
+    }
+
+    const marker = createWordElement(xmlDoc, type === 'ins' ? 'w:ins' : 'w:del');
+    const metadata = createRevisionMetadata(author);
+    marker.setAttribute('w:id', String(metadata.id));
+    marker.setAttribute('w:author', metadata.author);
+    marker.setAttribute('w:date', metadata.date);
+    rPr.appendChild(marker);
+    return marker;
+}
+
+/**
+ * Marks a paragraph mark as inserted.
+ *
+ * @param {Document} xmlDoc - XML document
+ * @param {Element} paragraph - Paragraph to mark
+ * @param {string} author - Change author
+ * @returns {Element}
+ */
+export function markParagraphMarkInserted(xmlDoc, paragraph, author) {
+    return markParagraphMark(xmlDoc, paragraph, author, 'ins');
+}
+
+/**
+ * Marks a paragraph mark as deleted.
+ *
+ * @param {Document} xmlDoc - XML document
+ * @param {Element} paragraph - Paragraph to mark
+ * @param {string} author - Change author
+ * @returns {Element}
+ */
+export function markParagraphMarkDeleted(xmlDoc, paragraph, author) {
+    return markParagraphMark(xmlDoc, paragraph, author, 'del');
+}
 
 /**
  * Creates a text run with optional formatting.
@@ -39,13 +111,18 @@ export function createTrackChange(xmlDoc, type, run, author) {
  * @param {boolean} isDelete - Use `w:delText` instead of `w:t`
  * @returns {Element}
  */
-export function createTextRun(xmlDoc, text, rPr, isDelete) {
-    const run = xmlDoc.createElement('w:r');
-    if (rPr) run.appendChild(rPr.cloneNode(true));
-
-    const textEl = xmlDoc.createElement(isDelete ? 'w:delText' : 'w:t');
-    textEl.setAttribute('xml:space', 'preserve');
-    textEl.textContent = text;
+export function createTextRun(xmlDoc, text, rPr, isDelete) {
+    const run = createWordElement(xmlDoc, 'w:r');
+    if (rPr) run.appendChild(rPr.cloneNode(true));
+
+    if (!isDelete) {
+        appendVisibleTextPieces(xmlDoc, run, text);
+        return run;
+    }
+
+    const textEl = createWordElement(xmlDoc, isDelete ? 'w:delText' : 'w:t');
+    textEl.setAttribute('xml:space', 'preserve');
+    textEl.textContent = text;
     run.appendChild(textEl);
 
     return run;
@@ -111,17 +188,50 @@ export function createFormattedRuns(xmlDoc, text, baseRPr, formatHints, baseOffs
  * @param {boolean} isDelete - Use `w:delText` instead of `w:t`
  * @returns {Element}
  */
-export function createTextRunWithRPrElement(xmlDoc, text, rPrElement, isDelete) {
-    const run = xmlDoc.createElement('w:r');
-    if (rPrElement) run.appendChild(rPrElement);
-
-    const textEl = xmlDoc.createElement(isDelete ? 'w:delText' : 'w:t');
-    textEl.setAttribute('xml:space', 'preserve');
-    textEl.textContent = text;
+export function createTextRunWithRPrElement(xmlDoc, text, rPrElement, isDelete) {
+    const run = createWordElement(xmlDoc, 'w:r');
+    if (rPrElement) run.appendChild(rPrElement);
+
+    if (!isDelete) {
+        appendVisibleTextPieces(xmlDoc, run, text);
+        return run;
+    }
+
+    const textEl = createWordElement(xmlDoc, isDelete ? 'w:delText' : 'w:t');
+    textEl.setAttribute('xml:space', 'preserve');
+    textEl.textContent = text;
     run.appendChild(textEl);
 
-    return run;
-}
+    return run;
+}
+
+function appendVisibleTextPieces(xmlDoc, run, text) {
+    const source = String(text || '');
+    const parts = source.split(/(\t|\n|\u2011)/);
+
+    for (const part of parts) {
+        if (!part) continue;
+        if (part === '\t') {
+            run.appendChild(createWordElement(xmlDoc, 'w:tab'));
+            continue;
+        }
+        if (part === '\n') {
+            run.appendChild(createWordElement(xmlDoc, 'w:br'));
+            continue;
+        }
+        if (part === '\u2011') {
+            run.appendChild(createWordElement(xmlDoc, 'w:noBreakHyphen'));
+            continue;
+        }
+
+        const textEl = createWordElement(xmlDoc, 'w:t');
+        if (/^\s|\s$/.test(part)) {
+            textEl.setAttribute('xml:space', 'preserve');
+        }
+        textEl.textContent = part;
+        run.appendChild(textEl);
+    }
+}
 
 /**
  * Creates a new rPr synchronized to the requested core formatting flags.
@@ -133,8 +243,8 @@ export function createTextRunWithRPrElement(xmlDoc, text, rPrElement, isDelete)
  * @param {boolean} [generateRedlines] - Whether to create rPrChange
  * @returns {Element}
  */
-export function injectFormattingToRPr(xmlDoc, baseRPr, format, author, generateRedlines) {
-    const rPr = xmlDoc.createElement('w:rPr');
+export function injectFormattingToRPr(xmlDoc, baseRPr, format, author, generateRedlines) {
+    const rPr = createWordElement(xmlDoc, 'w:rPr');
 
     if (baseRPr) {
         Array.from(baseRPr.childNodes).forEach(child => {
@@ -150,8 +260,8 @@ export function injectFormattingToRPr(xmlDoc, baseRPr, format, author, generateR
         createRPrChange(xmlDoc, rPr, author, baseRPr);
     }
 
-    const syncElement = (tagName, isOn, valOn = null, valOff = '0') => {
-        const el = xmlDoc.createElement(tagName);
+    const syncElement = (tagName, isOn, valOn = null, valOff = '0') => {
+        const el = createWordElement(xmlDoc, tagName);
         if (isOn) {
             if (valOn) el.setAttribute('w:val', valOn);
         } else if (valOff) {
@@ -195,13 +305,14 @@ export function injectFormattingToRPr(xmlDoc, baseRPr, format, author, generateR
  * @param {Element} [sourceNode] - Optional source for previous state snapshot
  * @returns {Element}
  */
-export function snapshotAndAttachRPrChange(xmlDoc, rPr, author, dateStr, sourceNode) {
-    const rPrChange = xmlDoc.createElement('w:rPrChange');
-    rPrChange.setAttribute('w:id', String(createRevisionMetadata(author).id));
-    rPrChange.setAttribute('w:author', author);
-    rPrChange.setAttribute('w:date', dateStr);
-
-    const previousRPr = xmlDoc.createElement('w:rPr');
+export function snapshotAndAttachRPrChange(xmlDoc, rPr, author, dateStr, sourceNode) {
+    const rPrChange = createWordElement(xmlDoc, 'w:rPrChange');
+    const metadata = createRevisionMetadata(author);
+    rPrChange.setAttribute('w:id', String(metadata.id));
+    rPrChange.setAttribute('w:author', metadata.author);
+    rPrChange.setAttribute('w:date', dateStr || metadata.date);
+
+    const previousRPr = createWordElement(xmlDoc, 'w:rPr');
     const source = sourceNode || rPr;
 
     Array.from(source.childNodes).forEach(child => {
@@ -230,6 +341,6 @@ export function snapshotAndAttachRPrChange(xmlDoc, rPr, author, dateStr, sourceN
  * @param {Element} [previousRPrArg] - Optional explicit previous-state source
  * @returns {void}
  */
-function createRPrChange(xmlDoc, rPr, author, previousRPrArg) {
-    snapshotAndAttachRPrChange(xmlDoc, rPr, author, getRevisionTimestamp(), previousRPrArg || rPr);
-}
+function createRPrChange(xmlDoc, rPr, author, previousRPrArg) {
+    snapshotAndAttachRPrChange(xmlDoc, rPr, author, null, previousRPrArg || rPr);
+}