@ansonlai/docx-redline-js 0.8.4 → 0.10.0

package/engine/reconstruction-writer.js

@@ -7,14 +7,42 @@
 import { getApplicableFormatHints } from '../pipeline/markdown-processor.js';
 import {
     createTrackChange,
-    createFormattedRuns,
-    markParagraphMarkDeleted,
-    markParagraphMarkInserted
+    createFormattedRuns
 } from './run-builders.js';
+import { markParagraphDeleted, markParagraphInserted } from './paragraph-mark-revisions.js';
 import { getFirstElementByTagNSOrTag } from '../core/xml-query.js';
 import { NS_W, createReplacementRevisionEvent, createRevisionMetadata } from '../core/types.js';
 import { createWordElement, isWordElement } from '../core/word-xml.js';
 
+const NS_W14 = 'http://schemas.microsoft.com/office/word/2010/wordml';
+const IDENTITY_ATTRIBUTES = ['paraId', 'textId'];
+
+function hasMarkRevision(paragraph, kind) {
+    const pPr = Array.from(paragraph.childNodes).find(node => isWordElement(node, 'pPr'));
+    const rPr = pPr && Array.from(pPr.childNodes).find(node => isWordElement(node, 'rPr'));
+    return !!rPr && Array.from(rPr.childNodes).some(node => isWordElement(node, kind));
+}
+
+/**
+ * Carries the source paragraph identity (`w14:paraId`, `w14:textId`) onto the rebuilt paragraph that survives
+ * for it. Several rebuilt paragraphs can derive from one source paragraph (an inserted split), so the identity
+ * goes to exactly one: the paragraph whose mark is not tracked, else one whose mark is not tracked-deleted,
+ * else the first. Ids therefore stay unique; inserted paragraphs carry none, as on
+ * every other insertion path (Word assigns them on open).
+ */
+function carrySourceIdentity(claims) {
+    claims.forEach((rebuilt, source) => {
+        const survivor = rebuilt.find(p => !hasMarkRevision(p, 'ins') && !hasMarkRevision(p, 'del'))
+            || rebuilt.find(p => !hasMarkRevision(p, 'del'))
+            || rebuilt[0];
+        if (!survivor) return;
+        IDENTITY_ATTRIBUTES.forEach(name => {
+            const value = source.getAttributeNS?.(NS_W14, name) || source.getAttribute?.(`w14:${name}`);
+            if (value) survivor.setAttributeNS(NS_W14, `w14:${name}`, value);
+        });
+    });
+}
+
 /**
  * Applies diffs to reconstruction context and writes updated XML.
  *
@@ -40,8 +68,13 @@ export function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, aut
         isParagraphStart
     } = context;
 
-    const createNewParagraph = (pPr) => {
+    const identityClaims = new Map();
+    const createNewParagraph = (pPr, sourceParagraph = null) => {
         const newParagraph = createWordElement(xmlDoc, 'w:p');
+        if (sourceParagraph) {
+            if (!identityClaims.has(sourceParagraph)) identityClaims.set(sourceParagraph, []);
+            identityClaims.get(sourceParagraph).push(newParagraph);
+        }
         if (pPr) {
             const clonedPPr = pPr.cloneNode(true);
             // Safeguard: Never place w:sectPr on both paragraphs during split
@@ -55,7 +88,7 @@ export function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, aut
     };
 
     const startInfo = getParagraphInfo(0);
-    let currentParagraph = createNewParagraph(startInfo.pPr);
+    let currentParagraph = createNewParagraph(startInfo.pPr, startInfo.paragraph);
     const initialFragment = containerFragments.get(startInfo.container);
     if (initialFragment) {
         initialFragment.appendChild(currentParagraph);
@@ -83,7 +116,7 @@ export function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, aut
                     if (diffs[k][0] === 0) break;
                 }
                 if (pairReplacements && generateRedlines && hasInsert) {
-                    pendingReplacementEvent = createReplacementRevisionEvent(author, xmlDoc);
+                    pendingReplacementEvent = createReplacementRevisionEvent(author, xmlDoc, { deferReceipt: true });
                 }
             }
             let offset = 0;
@@ -189,7 +222,7 @@ export function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, aut
                     const hasVisibleText = Array.from(node.getElementsByTagNameNS(NS_W, 't')).length > 0;
                     const hasDeletedText = Array.from(node.getElementsByTagNameNS(NS_W, 'delText')).length > 0;
                     if (paragraphs.length === 1 && !hasVisibleText && (hasDeletedText || context.originalFullText.trim() !== '')) {
-                        markParagraphMarkDeleted(xmlDoc, node, author);
+                        markParagraphDeleted(node, { author, revisionIdAllocator: xmlDoc });
                     }
                 }
             });
@@ -215,6 +248,8 @@ export function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, aut
         }
     });
 
+    carrySourceIdentity(identityClaims);
+
     const paragraphSet = new Set(paragraphs);
     const insertionAnchors = new Map();
     paragraphs.forEach(paragraph => {
@@ -327,11 +362,11 @@ function appendTextToCurrent(
 
         if (part === '\n') {
             const info = getParagraphInfo(localBaseIndex + 1);
-            const nextParagraph = createNewParagraph(info.pPr);
+            const nextParagraph = createNewParagraph(info.pPr, info.paragraph);
             if (generateRedlines && type === 'insert') {
-                markParagraphMarkInserted(xmlDoc, localParagraph, author);
+                markParagraphInserted(localParagraph, { author, revisionIdAllocator: xmlDoc });
             } else if (generateRedlines && type === 'delete') {
-                markParagraphMarkDeleted(xmlDoc, localParagraph, author);
+                markParagraphDeleted(localParagraph, { author, revisionIdAllocator: xmlDoc });
             }
 
             const fragment = containerFragments.get(info.container);
@@ -370,6 +405,26 @@ function appendTextToCurrent(
         }
 
         if (referenceMap.has(part)) {
+            if (type === 'delete' && generateRedlines) {
+                // A deleted manual break, tab or inline object must be a tracked deletion so Reject All
+                // restores it; silently dropping the node loses it from the rejected view.
+                const refNode = referenceMap.get(part);
+                if (refNode) {
+                    const run = createWordElement(xmlDoc, 'w:r');
+                    if (rPr) run.appendChild(rPr.cloneNode(true));
+                    run.appendChild(refNode.cloneNode(true));
+                    let metadata = null;
+                    if (replacementEvent) {
+                        const id = replacementEvent.usedDeletionId
+                            ? createRevisionMetadata(author, xmlDoc, 'del').id
+                            : replacementEvent.deletionId;
+                        if (!replacementEvent.usedDeletionId) replacementEvent.recordUsed?.('del');
+                        replacementEvent.usedDeletionId = true;
+                        metadata = { id, author: replacementEvent.author, date: replacementEvent.date };
+                    }
+                    localParagraph.appendChild(createTrackChange(xmlDoc, 'del', run, author, metadata));
+                }
+            }
             if (type !== 'delete') {
                 const refNode = referenceMap.get(part);
                 if (refNode) {
@@ -408,6 +463,7 @@ function appendTextToCurrent(
                     const id = replacementEvent.usedDeletionId
                         ? createRevisionMetadata(author, xmlDoc, 'del').id
                         : replacementEvent.deletionId;
+                    if (!replacementEvent.usedDeletionId) replacementEvent.recordUsed?.('del');
                     replacementEvent.usedDeletionId = true;
                     metadata = {
                         id,
@@ -428,6 +484,7 @@ function appendTextToCurrent(
                     const id = replacementEvent.usedInsertionId
                         ? createRevisionMetadata(author, xmlDoc, 'ins').id
                         : replacementEvent.insertionId;
+                    if (!replacementEvent.usedInsertionId) replacementEvent.recordUsed?.('ins');
                     replacementEvent.usedInsertionId = true;
                     metadata = {
                         id,

package/engine/rpr-helpers.js

@@ -6,6 +6,7 @@
  */
 
 import { createWordElement } from '../core/word-xml.js';
+import { getCurrentChild } from '../core/current-properties.js';
 
 /**
  * Canonical OOXML run-property schema ordering.
@@ -419,9 +420,34 @@ export function checkParagraphPropertiesChanged(pPr, properties) {
         if (currentVal !== properties.style) return true;
     }
 
+    if (properties.numbering !== undefined) {
+        const current = readDirectNumbering(pPr);
+        const desired = properties.numbering;
+        if (desired === null) return current != null;
+        if (!current) return true;
+        if (current.numId !== String(Number(desired.numId))) return true;
+        if (current.level !== (Number(desired.level) || 0)) return true;
+    }
+
     return false;
 }
 
+/**
+ * Reads the paragraph's own (direct, non-snapshot) numbering binding.
+ *
+ * @param {Element|null} pPr
+ * @returns {{ numId: string, level: number }|null}
+ */
+function readDirectNumbering(pPr) {
+    const numPr = getCurrentChild(pPr, 'numPr');
+    if (!numPr) return null;
+    const read = (name) => {
+        const el = getCurrentChild(numPr, name);
+        return el ? (el.getAttribute('w:val') ?? el.getAttribute('val')) : null;
+    };
+    return { numId: String(Number(read('numId'))), level: Number(read('ilvl')) || 0 };
+}
+
 /**
  * Applies explicit paragraph formatting to a pPr in schema order.
  *
@@ -492,4 +518,20 @@ export function applyParagraphPropertiesToPPr(xmlDoc, pPr, properties) {
             insertPPrChildInOrder(pPr, pStyle);
         }
     }
+
+    if (properties.numbering !== undefined) {
+        removeTags(['w:numPr']);
+        if (properties.numbering) {
+            // CT_PPr sequence: numPr follows widowControl and precedes suppressLineNumbers ... ind; inside
+            // CT_NumPr the order is ilvl, numId.
+            const numPr = createWordElement(xmlDoc, 'w:numPr');
+            const ilvl = createWordElement(xmlDoc, 'w:ilvl');
+            ilvl.setAttribute('w:val', String(Number(properties.numbering.level) || 0));
+            const numId = createWordElement(xmlDoc, 'w:numId');
+            numId.setAttribute('w:val', String(Number(properties.numbering.numId)));
+            numPr.appendChild(ilvl);
+            numPr.appendChild(numId);
+            insertPPrChildInOrder(pPr, numPr);
+        }
+    }
 }

package/engine/run-builders.js

@@ -33,79 +33,6 @@ export function createTrackChange(xmlDoc, type, run, author, revisionMetadata =
     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, revisionMetadata = null) {
-    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 = revisionMetadata || createRevisionMetadata(author, xmlDoc, type === 'ins' ? 'ins' : 'del');
-    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
- * @param {Object|null} [revisionMetadata=null] - Optional explicit revision metadata
- * @returns {Element}
- */
-export function markParagraphMarkInserted(xmlDoc, paragraph, author, revisionMetadata = null) {
-    return markParagraphMark(xmlDoc, paragraph, author, 'ins', revisionMetadata);
-}
-
-/**
- * Marks a paragraph mark as deleted.
- *
- * @param {Document} xmlDoc - XML document
- * @param {Element} paragraph - Paragraph to mark
- * @param {string} author - Change author
- * @param {Object|null} [revisionMetadata=null] - Optional explicit revision metadata
- * @returns {Element}
- */
-export function markParagraphMarkDeleted(xmlDoc, paragraph, author, revisionMetadata = null) {
-    return markParagraphMark(xmlDoc, paragraph, author, 'del', revisionMetadata);
-}
-
 /**
  * Creates a text run with optional formatting.
  *