@ansonlai/docx-redline-js 0.1.0

package/engine/reconstruction-mapper.js

@@ -0,0 +1,270 @@
+/**
+ * Reconstruction mapper.
+ *
+ * Builds paragraph/property/sentinel mappings and indexed lookups used by reconstruction writing.
+ */
+
+import { appendParagraphBoundary } from '../core/paragraph-offset-policy.js';
+import { getDocumentParagraphs } from './format-extraction.js';
+import { getElementsByTag, getFirstElementByTag } from '../core/xml-query.js';
+
+function createRangeCursorLookup(ranges) {
+    let cursor = 0;
+    return {
+        at(index) {
+            while (cursor < ranges.length && ranges[cursor].end <= index) {
+                cursor++;
+            }
+            const match = ranges[cursor];
+            if (!match) return null;
+            if (match.start <= index && index < match.end) return match;
+            return null;
+        }
+    };
+}
+
+function indexSentinelsByStart(sentinelMap) {
+    const sentinelMapByStart = new Map();
+    sentinelMap.forEach(sentinel => {
+        if (!sentinelMapByStart.has(sentinel.start)) {
+            sentinelMapByStart.set(sentinel.start, []);
+        }
+        sentinelMapByStart.get(sentinel.start).push(sentinel);
+    });
+    return sentinelMapByStart;
+}
+
+/**
+ * Builds reconstruction mapping and cursor-based lookup helpers.
+ *
+ * @param {Document} xmlDoc - XML document
+ * @param {string} modifiedText - Modified text
+ * @returns {{
+ *   paragraphs: Element[],
+ *   body: Element|Document,
+ *   paragraphMap: Array<{start:number,end:number,pPr:Element|null,container:Node}>,
+ *   paragraphStarts: Set<number>,
+ *   propertyMap: Array<{start:number,end:number,rPr:Element|null,wrapper?:Element}>,
+ *   sentinelMap: Array<Object>,
+ *   sentinelMapByStart: Map<number, Object[]>,
+ *   referenceMap: Map<string, Node>,
+ *   tokenToCharMap: Map<string, string>,
+ *   containerFragments: Map<Node, DocumentFragment>,
+ *   replacementContainers: Map<Node, Node>,
+ *   originalFullText: string,
+ *   processedModifiedText: string,
+ *   getParagraphInfo: (index:number) => {start:number,end:number,pPr:Element|null,container:Node},
+ *   getRunProperties: (index:number) => {rPr:Element|null,wrapper?:Element},
+ *   getPropertySpanLength: (index:number,maxLength:number) => number,
+ *   isParagraphStart: (index:number) => boolean
+ * }}
+ */
+export function buildReconstructionMapping(xmlDoc, modifiedText) {
+    const rootElement = xmlDoc.documentElement;
+    const isBodyRoot = rootElement.nodeName === 'w:body' || rootElement.nodeName.endsWith(':package');
+    const paragraphs = getDocumentParagraphs(xmlDoc);
+
+    let body = getFirstElementByTag(xmlDoc, 'w:body');
+    if (!body && isBodyRoot) body = rootElement;
+
+    let originalFullText = '';
+    const propertyMap = [];
+    const paragraphMap = [];
+    const sentinelMap = [];
+    const referenceMap = new Map();
+    const tokenToCharMap = new Map();
+    let nextCharCode = 0xe000;
+    const uniqueContainers = new Set();
+
+    paragraphs.forEach((paragraph, paragraphIndex) => {
+        const paragraphStart = originalFullText.length;
+
+        Array.from(paragraph.childNodes).forEach(child => {
+            originalFullText = processChildNode(
+                child,
+                originalFullText,
+                propertyMap,
+                sentinelMap,
+                referenceMap,
+                tokenToCharMap,
+                nextCharCode
+            );
+            if (referenceMap.size > tokenToCharMap.size) {
+                nextCharCode++;
+            }
+        });
+
+        originalFullText = appendParagraphBoundary(originalFullText, paragraphIndex, paragraphs.length);
+
+        const paragraphEnd = originalFullText.length;
+        const pPr = getFirstElementByTag(paragraph, 'w:pPr');
+        const container = paragraph.parentNode;
+        if (container) uniqueContainers.add(container);
+
+        paragraphMap.push({
+            start: paragraphStart,
+            end: paragraphEnd,
+            pPr,
+            container: container || body
+        });
+    });
+
+    let processedModifiedText = modifiedText;
+    tokenToCharMap.forEach((char, tokenString) => {
+        const escapedToken = tokenString.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+        processedModifiedText = processedModifiedText.replace(new RegExp(escapedToken, 'g'), char);
+    });
+
+    const containerFragments = new Map();
+    uniqueContainers.forEach(container => {
+        containerFragments.set(container, xmlDoc.createDocumentFragment());
+    });
+    if (body && !containerFragments.has(body)) {
+        containerFragments.set(body, xmlDoc.createDocumentFragment());
+    }
+    if (!containerFragments.has(xmlDoc)) {
+        containerFragments.set(xmlDoc, xmlDoc.createDocumentFragment());
+    }
+
+    const replacementContainers = new Map();
+    const paragraphStarts = new Set(paragraphMap.map(paragraph => paragraph.start));
+    const paragraphLookup = createRangeCursorLookup(paragraphMap);
+    const propertyLookup = createRangeCursorLookup(propertyMap);
+    const sentinelMapByStart = indexSentinelsByStart(sentinelMap);
+
+    const getParagraphInfo = (index) => {
+        const match = paragraphLookup.at(index);
+        if (match) return match;
+        if (paragraphMap.length > 0) return paragraphMap[paragraphMap.length - 1];
+        return { start: 0, end: 0, pPr: null, container: body || xmlDoc };
+    };
+
+    const getRunProperties = (index) => {
+        const match = propertyLookup.at(index);
+        return match ? { rPr: match.rPr, wrapper: match.wrapper } : { rPr: null };
+    };
+
+    const getPropertySpanLength = (index, maxLength) => {
+        const match = propertyLookup.at(index);
+        if (!match) return 1;
+        return Math.min(match.end - index, maxLength);
+    };
+
+    return {
+        paragraphs,
+        body: body || xmlDoc,
+        paragraphMap,
+        paragraphStarts,
+        propertyMap,
+        sentinelMap,
+        sentinelMapByStart,
+        referenceMap,
+        tokenToCharMap,
+        containerFragments,
+        replacementContainers,
+        originalFullText,
+        processedModifiedText,
+        getParagraphInfo,
+        getRunProperties,
+        getPropertySpanLength,
+        isParagraphStart: index => paragraphStarts.has(index)
+    };
+}
+
+function processChildNode(child, originalFullText, propertyMap, sentinelMap, referenceMap, tokenToCharMap, nextCharCode) {
+    if (child.nodeName === 'w:r') {
+        return processRunForReconstruction(child, originalFullText, propertyMap, sentinelMap, referenceMap, tokenToCharMap, nextCharCode);
+    }
+    if (child.nodeName === 'w:hyperlink') {
+        return processHyperlinkForReconstruction(child, originalFullText, propertyMap);
+    }
+    if (['w:sdt', 'w:oMath', 'm:oMath', 'w:bookmarkStart', 'w:bookmarkEnd'].includes(child.nodeName)) {
+        sentinelMap.push({ start: originalFullText.length, node: child });
+        return originalFullText + '\uFFFC';
+    }
+    if (['w:commentRangeStart', 'w:commentRangeEnd'].includes(child.nodeName)) {
+        sentinelMap.push({ start: originalFullText.length, node: child, isCommentMarker: true });
+        return originalFullText;
+    }
+    return originalFullText;
+}
+
+function processRunForReconstruction(runElement, originalFullText, propertyMap, sentinelMap, referenceMap, tokenToCharMap, nextCharCode) {
+    let fullText = originalFullText;
+    const rPr = getFirstElementByTag(runElement, 'w:rPr');
+
+    Array.from(runElement.childNodes).forEach(runChild => {
+        if (runChild.nodeName === 'w:t') {
+            const textContent = runChild.textContent || '';
+            if (textContent.length > 0) {
+                propertyMap.push({
+                    start: fullText.length,
+                    end: fullText.length + textContent.length,
+                    rPr
+                });
+                fullText += textContent;
+            }
+        } else if (runChild.nodeName === 'w:br' || runChild.nodeName === 'w:cr') {
+            fullText += '\n';
+            propertyMap.push({ start: fullText.length - 1, end: fullText.length, rPr });
+        } else if (runChild.nodeName === 'w:tab') {
+            fullText += '\t';
+            propertyMap.push({ start: fullText.length - 1, end: fullText.length, rPr });
+        } else if (runChild.nodeName === 'w:noBreakHyphen') {
+            fullText += '\u2011';
+            propertyMap.push({ start: fullText.length - 1, end: fullText.length, rPr });
+        } else if (['w:drawing', 'w:pict', 'w:object', 'w:fldChar', 'w:instrText', 'w:sym'].includes(runChild.nodeName)) {
+            const textBoxContent = getFirstElementByTag(runChild, 'w:txbxContent');
+            const hasTextBox = runChild.nodeName === 'w:pict' && !!textBoxContent;
+
+            sentinelMap.push({
+                start: fullText.length,
+                node: runChild,
+                isTextBox: hasTextBox,
+                originalContainer: hasTextBox ? textBoxContent : undefined
+            });
+            fullText += '\uFFFC';
+            propertyMap.push({ start: fullText.length - 1, end: fullText.length, rPr });
+        } else if (runChild.nodeName === 'w:footnoteReference' || runChild.nodeName === 'w:endnoteReference') {
+            const id = runChild.getAttribute('w:id');
+            if (id) {
+                const type = runChild.nodeName === 'w:footnoteReference' ? 'FN' : 'EN';
+                const tokenString = `{{__${type}_${id}__}}`;
+                const char = String.fromCharCode(nextCharCode);
+                referenceMap.set(char, runChild);
+                tokenToCharMap.set(tokenString, char);
+                fullText += char;
+                propertyMap.push({ start: fullText.length - 1, end: fullText.length, rPr });
+            }
+        } else if (runChild.nodeName === 'w:commentReference') {
+            sentinelMap.push({ start: fullText.length, node: runChild, isCommentMarker: true });
+        }
+    });
+
+    return fullText;
+}
+
+function processHyperlinkForReconstruction(hyperlinkElement, originalFullText, propertyMap) {
+    let fullText = originalFullText;
+
+    Array.from(hyperlinkElement.childNodes).forEach(hyperlinkChild => {
+        if (hyperlinkChild.nodeName !== 'w:r') return;
+
+        const rPr = getFirstElementByTag(hyperlinkChild, 'w:rPr');
+        const texts = getElementsByTag(hyperlinkChild, 'w:t');
+        texts.forEach(textNode => {
+            const textContent = textNode.textContent || '';
+            if (textContent.length === 0) return;
+
+            propertyMap.push({
+                start: fullText.length,
+                end: fullText.length + textContent.length,
+                rPr,
+                wrapper: hyperlinkElement
+            });
+            fullText += textContent;
+        });
+    });
+
+    return fullText;
+}

package/engine/reconstruction-mode.js

@@ -0,0 +1,38 @@
+/**
+ * Reconstruction reconciliation mode orchestration.
+ */
+
+import { computeWordDiffs } from '../pipeline/diff-engine.js';
+import { buildReconstructionMapping } from './reconstruction-mapper.js';
+import { applyReconstructionDiffs } from './reconstruction-writer.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
+ * @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 diffs = computeWordDiffs(mapping.originalFullText, mapping.processedModifiedText);
+
+    return applyReconstructionDiffs(
+        xmlDoc,
+        diffs,
+        mapping,
+        serializer,
+        author,
+        formatHints,
+        generateRedlines
+    );
+}

package/engine/reconstruction-writer.js

@@ -0,0 +1,276 @@
+/**
+ * Reconstruction writer.
+ *
+ * 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';
+
+/**
+ * Applies diffs to reconstruction context and writes updated XML.
+ *
+ * @param {Document} xmlDoc - XML document
+ * @param {Array<[number, string]>} diffs - Diff tuples from diff-match-patch
+ * @param {ReturnType<import('./reconstruction-mapper.js').buildReconstructionMapping>} context - Reconstruction mapping
+ * @param {XMLSerializer} serializer - Serializer instance
+ * @param {string} author - Author name
+ * @param {Array} formatHints - Format hints
+ * @param {boolean} [generateRedlines=true] - Track change toggle
+ * @returns {{ oxml: string, hasChanges: boolean }}
+ */
+export function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, author, formatHints, generateRedlines = true) {
+    const {
+        paragraphs,
+        paragraphMap,
+        containerFragments,
+        sentinelMapByStart,
+        referenceMap,
+        replacementContainers,
+        getParagraphInfo,
+        getRunProperties,
+        getPropertySpanLength,
+        isParagraphStart
+    } = context;
+
+    const createNewParagraph = (pPr) => {
+        const newParagraph = xmlDoc.createElement('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;
+
+    for (const [op, text] of diffs) {
+        if (op === 0 || op === -1) {
+            const type = op === 0 ? 'equal' : 'delete';
+            let offset = 0;
+
+            while (offset < text.length) {
+                const chunkStart = currentOriginalIndex + offset;
+                const properties = getRunProperties(chunkStart);
+                const chunkLength = getPropertySpanLength(chunkStart, text.length - offset);
+                const chunk = text.substring(offset, offset + chunkLength);
+
+                appendTextToCurrent(
+                    xmlDoc,
+                    chunk,
+                    type,
+                    properties.rPr,
+                    properties.wrapper,
+                    chunkStart,
+                    currentParagraph,
+                    containerFragments,
+                    sentinelMapByStart,
+                    referenceMap,
+                    replacementContainers,
+                    getParagraphInfo,
+                    createNewParagraph,
+                    author,
+                    formatHints,
+                    currentInsertOffset,
+                    generateRedlines
+                );
+
+                if (op === 0) {
+                    currentInsertOffset += chunkLength;
+                }
+                offset += chunkLength;
+            }
+
+            currentOriginalIndex += text.length;
+            continue;
+        }
+
+        if (op === 1) {
+            const properties = currentOriginalIndex > 0 && !isParagraphStart(currentOriginalIndex)
+                ? getRunProperties(currentOriginalIndex - 1)
+                : getRunProperties(currentOriginalIndex);
+
+            appendTextToCurrent(
+                xmlDoc,
+                text,
+                'insert',
+                properties.rPr,
+                properties.wrapper,
+                currentOriginalIndex,
+                currentParagraph,
+                containerFragments,
+                sentinelMapByStart,
+                referenceMap,
+                replacementContainers,
+                getParagraphInfo,
+                createNewParagraph,
+                author,
+                formatHints,
+                currentInsertOffset,
+                generateRedlines
+            );
+            currentInsertOffset += text.length;
+        }
+    }
+
+    paragraphs.forEach(paragraph => {
+        if (paragraph.parentNode) {
+            paragraph.parentNode.removeChild(paragraph);
+        }
+    });
+
+    containerFragments.forEach((fragment, container) => {
+        const replacement = replacementContainers.get(container);
+        const target = replacement || container;
+
+        if (target.nodeType === 9) {
+            const firstChild = fragment.firstChild;
+            if (firstChild) {
+                target.appendChild(firstChild);
+                while (fragment.firstChild) {
+                    target.documentElement.appendChild(fragment.firstChild);
+                }
+            }
+            return;
+        }
+
+        target.appendChild(fragment);
+    });
+
+    return { oxml: serializer.serializeToString(xmlDoc), hasChanges: true };
+}
+
+function appendTextToCurrent(
+    xmlDoc,
+    text,
+    type,
+    rPr,
+    wrapper,
+    baseIndex,
+    currentParagraphRef,
+    containerFragments,
+    sentinelMapByStart,
+    referenceMap,
+    replacementContainers,
+    getParagraphInfo,
+    createNewParagraph,
+    author,
+    formatHints = [],
+    insertOffset = 0,
+    generateRedlines = true
+) {
+    let localBaseIndex = baseIndex;
+    let localInsertOffset = insertOffset;
+    let localParagraph = currentParagraphRef;
+
+    const parts = text.split(/([\n\uFFFC]|[\uE000-\uF8FF])/);
+
+    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 {
+                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++;
+            return;
+        }
+
+        if (part === '\uFFFC') {
+            const sentinel = sentinelsAtOffset.find(entry => !entry.isCommentMarker) || sentinelsAtOffset[0];
+            if (sentinel) {
+                const clone = sentinel.node.cloneNode(true);
+                if (sentinel.isTextBox && sentinel.originalContainer) {
+                    const newContainer = getFirstElementByTag(clone, 'w:txbxContent');
+                    if (newContainer) {
+                        while (newContainer.firstChild) newContainer.removeChild(newContainer.firstChild);
+                        replacementContainers.set(sentinel.originalContainer, newContainer);
+                    }
+                }
+                localParagraph.appendChild(clone);
+            }
+            localBaseIndex++;
+            if (type !== 'delete') localInsertOffset++;
+            return;
+        }
+
+        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);
+                }
+            }
+            localBaseIndex++;
+            if (type !== 'delete') localInsertOffset++;
+            return;
+        }
+
+        if (part.length === 0) return;
+
+        let parent = localParagraph;
+        if (wrapper) {
+            const wrapperClone = wrapper.cloneNode(false);
+            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 (generateRedlines) {
+                const del = createTrackChange(xmlDoc, 'del', run, author);
+                parent.appendChild(del);
+            }
+        } else {
+            const applicableHints = getApplicableFormatHints(formatHints, localInsertOffset, localInsertOffset + part.length);
+            const runs = createFormattedRuns(xmlDoc, part, rPr, applicableHints, localInsertOffset, author, generateRedlines);
+
+            if (type === 'insert' && generateRedlines) {
+                const ins = createTrackChange(xmlDoc, 'ins', null, author);
+                runs.forEach(run => ins.appendChild(run));
+                parent.appendChild(ins);
+            } else {
+                runs.forEach(run => parent.appendChild(run));
+            }
+        }
+
+        if (type !== 'delete') {
+            localInsertOffset += part.length;
+        }
+        localBaseIndex += part.length;
+    });
+}