@ansonlai/docx-redline-js 0.1.3 → 0.1.6

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

package/engine/surgical-diff-application.js

@@ -0,0 +1,216 @@
+import { getApplicableFormatHints } from '../pipeline/markdown-processor.js';
+import { isWordElement } from '../core/word-xml.js';
+import {
+    createTrackChange,
+    createTextRun,
+    createFormattedRuns,
+    createTextRunWithRPrElement,
+    injectFormattingToRPr
+} from './run-builders.js';
+import {
+    createRunFromPieces,
+    getRunContentPieces,
+    getRunTextLength,
+    insertRunPiecesBefore,
+    sliceRunPieces
+} from './surgical-run-splitting.js';
+import {
+    findContainingSpan,
+    findFirstSpanEndingAt,
+    findLastSpanEndingBeforeOrAt,
+    forEachOverlappingSpan
+} from './surgical-spans.js';
+
+export function reconcileFormattingForTextSpan(xmlDoc, span, start, end, applicableHints, author, generateRedlines) {
+    const desiredFormat = {};
+    if (applicableHints.length > 0) {
+        applicableHints.forEach(h => Object.assign(desiredFormat, h.format));
+    }
+
+    const rPr = span.rPr;
+    const hasElement = (localName) => {
+        if (!rPr) return false;
+        for (let node = rPr.firstChild; node; node = node.nextSibling) {
+            if (isWordElement(node, localName)) {
+                return true;
+            }
+        }
+        return false;
+    };
+
+    const existingFormat = {
+        bold: hasElement('b'),
+        italic: hasElement('i'),
+        underline: hasElement('u'),
+        strikethrough: hasElement('strike')
+    };
+
+    const formatsToCheck = ['bold', 'italic', 'underline', 'strikethrough'];
+    const changesNeeded = formatsToCheck.some(f => !!desiredFormat[f] !== existingFormat[f]);
+
+    if (!changesNeeded) return false;
+
+    const parent = span.runElement.parentNode;
+    if (!parent) return false;
+
+    const fullText = span.textElement.textContent || '';
+    const runStart = span.charStart;
+
+    const localStart = start - runStart;
+    const localEnd = end - runStart;
+
+    const beforeText = fullText.substring(0, localStart);
+    const affectedText = fullText.substring(localStart, localEnd);
+    const afterText = fullText.substring(localEnd);
+
+    if (beforeText.length > 0) {
+        const beforeRun = createTextRun(xmlDoc, beforeText, rPr, false);
+        parent.insertBefore(beforeRun, span.runElement);
+    }
+
+    const newRPr = injectFormattingToRPr(xmlDoc, rPr, desiredFormat, author, generateRedlines);
+    const newRun = createTextRunWithRPrElement(xmlDoc, affectedText, newRPr, false);
+    parent.insertBefore(newRun, span.runElement);
+
+    if (afterText.length > 0) {
+        const afterRun = createTextRun(xmlDoc, afterText, rPr, false);
+        parent.insertBefore(afterRun, span.runElement);
+    }
+
+    parent.removeChild(span.runElement);
+    return true;
+}
+
+export function processDelete(xmlDoc, spanIndex, startPos, endPos, author, generateRedlines) {
+    const spans = [];
+    forEachOverlappingSpan(spanIndex, startPos, endPos, span => {
+        spans.push(span);
+    });
+
+    if (spans.length === 0) return false;
+
+    const spansByRun = new Map();
+    spans.forEach(span => {
+        if (!span.runElement?.parentNode) return;
+        if (!spansByRun.has(span.runElement)) spansByRun.set(span.runElement, []);
+        spansByRun.get(span.runElement).push(span);
+    });
+
+    let changed = false;
+    spansByRun.forEach((runSpans, runElement) => {
+        const parent = runElement.parentNode;
+        if (!parent) return;
+
+        const pieces = getRunContentPieces(runElement);
+        if (pieces.length === 0) return;
+
+        let deleteStart = Infinity;
+        let deleteEnd = -Infinity;
+        runSpans.forEach(span => {
+            const piece = pieces.find(candidate => candidate.node === span.textElement);
+            if (!piece) return;
+
+            const spanDeleteStart = Math.max(0, startPos - span.charStart);
+            const spanDeleteEnd = Math.min(span.charEnd - span.charStart, endPos - span.charStart);
+            if (spanDeleteEnd <= spanDeleteStart) return;
+
+            deleteStart = Math.min(deleteStart, piece.start + spanDeleteStart);
+            deleteEnd = Math.max(deleteEnd, piece.start + spanDeleteEnd);
+        });
+
+        if (!Number.isFinite(deleteStart) || deleteEnd <= deleteStart) return;
+
+        const beforePieces = sliceRunPieces(xmlDoc, pieces, 0, deleteStart, false);
+        const deletedPieces = sliceRunPieces(xmlDoc, pieces, deleteStart, deleteEnd, true);
+        const afterPieces = sliceRunPieces(xmlDoc, pieces, deleteEnd, getRunTextLength(pieces), false);
+
+        insertRunPiecesBefore(xmlDoc, parent, runElement, beforePieces, runSpans[0].rPr);
+
+        if (generateRedlines && deletedPieces.length > 0) {
+            const delRun = createRunFromPieces(xmlDoc, deletedPieces, runSpans[0].rPr);
+            const delWrapper = createTrackChange(xmlDoc, 'del', delRun, author);
+            parent.insertBefore(delWrapper, runElement);
+        }
+
+        insertRunPiecesBefore(xmlDoc, parent, runElement, afterPieces, runSpans[0].rPr);
+        parent.removeChild(runElement);
+        changed = true;
+    });
+
+    return changed;
+}
+
+export function processInsert(xmlDoc, spanIndex, pos, text, author, formatHints = [], insertOffset = 0, generateRedlines = true, fallbackParagraph = null) {
+    let targetSpan = findContainingSpan(spanIndex, pos);
+
+    if (!targetSpan && pos > 0) {
+        targetSpan = findFirstSpanEndingAt(spanIndex, pos);
+    }
+
+    if (!targetSpan && pos > 0) {
+        targetSpan = findLastSpanEndingBeforeOrAt(spanIndex, pos);
+    }
+
+    if (!targetSpan && spanIndex.spans.length > 0) {
+        targetSpan = spanIndex.spans[spanIndex.spans.length - 1];
+    }
+
+    if (!targetSpan) {
+        if (!fallbackParagraph) return false;
+        insertTextRuns(xmlDoc, fallbackParagraph, null, text, null, author, formatHints, insertOffset, generateRedlines);
+        return true;
+    }
+
+    const parent = targetSpan.runElement.parentNode;
+    if (!parent) {
+        if (!fallbackParagraph) return false;
+        insertTextRuns(xmlDoc, fallbackParagraph, null, text, targetSpan.rPr, author, formatHints, insertOffset, generateRedlines);
+        return true;
+    }
+
+    const pieces = getRunContentPieces(targetSpan.runElement);
+    const targetPiece = pieces.find(piece => piece.node === targetSpan.textElement);
+    const localInsertPos = targetPiece
+        ? targetPiece.start + Math.max(0, Math.min(pos - targetSpan.charStart, targetSpan.charEnd - targetSpan.charStart))
+        : (pos <= targetSpan.charStart ? 0 : getRunTextLength(pieces));
+
+    if (localInsertPos > 0 && localInsertPos < getRunTextLength(pieces)) {
+        const beforePieces = sliceRunPieces(xmlDoc, pieces, 0, localInsertPos, false);
+        const afterPieces = sliceRunPieces(xmlDoc, pieces, localInsertPos, getRunTextLength(pieces), false);
+
+        insertRunPiecesBefore(xmlDoc, parent, targetSpan.runElement, beforePieces, targetSpan.rPr);
+        insertTextRuns(xmlDoc, parent, targetSpan.runElement, text, targetSpan.rPr, author, formatHints, insertOffset, generateRedlines);
+        insertRunPiecesBefore(xmlDoc, parent, targetSpan.runElement, afterPieces, targetSpan.rPr);
+        parent.removeChild(targetSpan.runElement);
+        return true;
+    }
+
+    const referenceNode = pos <= targetSpan.charStart ? targetSpan.runElement : targetSpan.runElement.nextSibling;
+    insertTextRuns(xmlDoc, parent, referenceNode, text, targetSpan.rPr, author, formatHints, insertOffset, generateRedlines);
+    return true;
+}
+
+function insertTextRuns(xmlDoc, parent, referenceNode, text, baseRPr, author, formatHints, insertOffset, generateRedlines) {
+    const applicableHints = getApplicableFormatHints(formatHints, insertOffset, insertOffset + text.length);
+
+    if (applicableHints.length === 0) {
+        const insRun = createTextRun(xmlDoc, text, baseRPr, false);
+        if (generateRedlines) {
+            const insWrapper = createTrackChange(xmlDoc, 'ins', insRun, author);
+            parent.insertBefore(insWrapper, referenceNode);
+        } else {
+            parent.insertBefore(insRun, referenceNode);
+        }
+        return;
+    }
+
+    const runs = createFormattedRuns(xmlDoc, text, baseRPr, applicableHints, insertOffset, author, generateRedlines);
+
+    if (generateRedlines) {
+        const insWrapper = createTrackChange(xmlDoc, 'ins', null, author);
+        runs.forEach(run => insWrapper.appendChild(run));
+        parent.insertBefore(insWrapper, referenceNode);
+    } else {
+        runs.forEach(run => parent.insertBefore(run, referenceNode));
+    }
+}