@ansonlai/docx-redline-js 0.5.0 → 0.5.1

package/engine/surgical-diff-application.js

@@ -12,7 +12,8 @@ import {
     getRunContentPieces,
     getRunTextLength,
     insertRunPiecesBefore,
-    sliceRunPieces
+    sliceRunPieces,
+    splitTrackChangeCarrier
 } from './surgical-run-splitting.js';
 import {
     findContainingSpan,
@@ -86,8 +87,7 @@ export function processDelete(xmlDoc, spanIndex, startPos, endPos, author, gener
         spansByRun.get(span.runElement).push(span);
     });
 
-    let changed = false;
-    let usedDelMetadata = false;
+    const records = [];
     spansByRun.forEach((runSpans, runElement) => {
         const parent = runElement.parentNode;
         if (!parent) return;
@@ -111,31 +111,104 @@ export function processDelete(xmlDoc, spanIndex, startPos, endPos, author, gener
 
         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);
+        records.push({
+            runElement,
+            parent,
+            rPr: runSpans[0].rPr,
+            beforePieces: sliceRunPieces(xmlDoc, pieces, 0, deleteStart, false),
+            deletedPieces: sliceRunPieces(xmlDoc, pieces, deleteStart, deleteEnd, true),
+            afterPieces: sliceRunPieces(xmlDoc, pieces, deleteEnd, getRunTextLength(pieces), false),
+            globalStart: Math.max(startPos, Math.min(...runSpans.map(span => span.charStart))),
+            globalEnd: Math.min(endPos, Math.max(...runSpans.map(span => span.charEnd))),
+            carrierGlobalStart: isWordElement(parent, 'ins') ? getCarrierGlobalStart(spanIndex, parent) : null
+        });
+    });
 
-        insertRunPiecesBefore(xmlDoc, parent, runElement, beforePieces, runSpans[0].rPr);
+    const groups = [];
+    for (const record of records) {
+        const previousGroup = groups[groups.length - 1];
+        const previousRecord = previousGroup?.[previousGroup.length - 1];
+        if (
+            previousRecord
+            && previousRecord.parent === record.parent
+            && nextElementSibling(previousRecord.runElement) === record.runElement
+        ) {
+            previousGroup.push(record);
+        } else {
+            groups.push([record]);
+        }
+    }
 
-        if (generateRedlines && deletedPieces.length > 0) {
-            const delRun = createRunFromPieces(xmlDoc, deletedPieces, runSpans[0].rPr);
+    let changed = false;
+    let usedDelMetadata = false;
+    for (const group of groups) {
+        const firstRecord = group[0];
+        let delWrapper = null;
+        if (generateRedlines && group.some(record => record.deletedPieces.length > 0)) {
             const metadata = revisionMetadata
-                ? (usedDelMetadata ? { ...revisionMetadata, id: createRevisionMetadata(author, xmlDoc).id } : revisionMetadata)
+                ? (usedDelMetadata ? { ...revisionMetadata, id: createRevisionMetadata(author, xmlDoc, 'del').id } : revisionMetadata)
                 : null;
             usedDelMetadata = true;
-            const delWrapper = createTrackChange(xmlDoc, 'del', delRun, author, metadata);
-            parent.insertBefore(delWrapper, runElement);
+            delWrapper = createTrackChange(xmlDoc, 'del', null, author, metadata);
         }
 
-        insertRunPiecesBefore(xmlDoc, parent, runElement, afterPieces, runSpans[0].rPr);
-        parent.removeChild(runElement);
-        changed = true;
-    });
+        for (const record of group) {
+            const { parent, runElement } = record;
+            insertRunPiecesBefore(xmlDoc, parent, runElement, record.beforePieces, record.rPr);
+            if (delWrapper && record === firstRecord) {
+                parent.insertBefore(delWrapper, runElement);
+            }
+            if (delWrapper && record.deletedPieces.length > 0) {
+                delWrapper.appendChild(createRunFromPieces(xmlDoc, record.deletedPieces, record.rPr));
+            }
+            insertRunPiecesBefore(xmlDoc, parent, runElement, record.afterPieces, record.rPr);
+            parent.removeChild(runElement);
+            changed = true;
+        }
+
+        const carrier = isWordElement(firstRecord.parent, 'ins') ? firstRecord.parent : null;
+        const groupEnd = Math.max(...group.map(record => record.globalEnd));
+        if (carrier && groupEnd === endPos) {
+            const carrierStart = firstRecord.carrierGlobalStart;
+            const deletedBeforeEnd = group
+                .filter(record => record.globalStart < endPos)
+                .reduce((sum, record) => sum + record.deletedPieces.reduce((n, piece) => n + (piece.textContent || '').length, 0), 0);
+            const currentOffset = Math.max(0, endPos - carrierStart - deletedBeforeEnd);
+            if (!spanIndex.revisionInsertionAnchors) spanIndex.revisionInsertionAnchors = new Map();
+            spanIndex.revisionInsertionAnchors.set(endPos, {
+                carrier,
+                splitOffset: currentOffset,
+                rPr: firstRecord.rPr
+            });
+        }
+    }
 
     return changed;
 }
 
-export function processInsert(xmlDoc, spanIndex, pos, text, author, formatHints = [], insertOffset = 0, generateRedlines = true, fallbackParagraph = null, revisionMetadata = null, affinity = null) {
+export function processInsert(xmlDoc, spanIndex, pos, text, author, formatHints = [], insertOffset = 0, generateRedlines = true, fallbackParagraph = null, revisionMetadata = null, affinity = null, existingRevisions = 'merge-same-author') {
+    const mutationAnchor = spanIndex.revisionInsertionAnchors?.get(pos) || null;
+    if (
+        mutationAnchor
+        && existingRevisions === 'slice-cross-author'
+        && isConnected(mutationAnchor.carrier)
+        && isForeignInsertion(mutationAnchor.carrier, author)
+    ) {
+        spanIndex.revisionInsertionAnchors.delete(pos);
+        return spliceInsertionAtCarrierOffset(
+            xmlDoc,
+            mutationAnchor.carrier,
+            mutationAnchor.splitOffset,
+            text,
+            mutationAnchor.rPr,
+            author,
+            formatHints,
+            insertOffset,
+            generateRedlines,
+            revisionMetadata
+        );
+    }
+
     if (!affinity) {
         let targetSpan = findContainingSpan(spanIndex, pos);
 
@@ -164,6 +237,25 @@ export function processInsert(xmlDoc, spanIndex, pos, text, author, formatHints
             return true;
         }
 
+        if (
+            generateRedlines
+            && existingRevisions === 'slice-cross-author'
+            && isForeignInsertion(parent, author)
+        ) {
+            return spliceInsertionAtCarrierOffset(
+                xmlDoc,
+                parent,
+                getCarrierSplitOffset(spanIndex, parent, pos),
+                text,
+                targetSpan.rPr,
+                author,
+                formatHints,
+                insertOffset,
+                generateRedlines,
+                revisionMetadata
+            );
+        }
+
         const pieces = getRunContentPieces(targetSpan.runElement);
         const targetPiece = pieces.find(piece => piece.node === targetSpan.textElement);
         const localInsertPos = targetPiece
@@ -357,10 +449,90 @@ export function processInsert(xmlDoc, spanIndex, pos, text, author, formatHints
         }
     }
 
+    if (
+        generateRedlines
+        && existingRevisions === 'slice-cross-author'
+        && isForeignInsertion(parent, author)
+    ) {
+        return spliceInsertionAtCarrierOffset(
+            xmlDoc,
+            parent,
+            getCarrierSplitOffset(spanIndex, parent, pos),
+            text,
+            baseRPr,
+            author,
+            formatHints,
+            insertOffset,
+            generateRedlines,
+            revisionMetadata
+        );
+    }
+
     insertTextRuns(xmlDoc, parent, referenceNode, text, baseRPr, author, formatHints, insertOffset, generateRedlines, revisionMetadata);
     return true;
 }
 
+function spliceInsertionAtCarrierOffset(xmlDoc, carrier, splitOffset, text, baseRPr, author, formatHints, insertOffset, generateRedlines, revisionMetadata) {
+    const parent = carrier.parentNode;
+    if (!parent) return false;
+
+    const { leftCarrier, rightCarrier } = splitTrackChangeCarrier(xmlDoc, carrier, splitOffset);
+    if (leftCarrier) parent.insertBefore(leftCarrier, carrier);
+    insertTextRuns(
+        xmlDoc,
+        parent,
+        carrier,
+        text,
+        withoutRunPropertyChanges(baseRPr),
+        author,
+        formatHints,
+        insertOffset,
+        generateRedlines,
+        revisionMetadata
+    );
+    if (rightCarrier) parent.insertBefore(rightCarrier, carrier);
+    parent.removeChild(carrier);
+    return true;
+}
+
+function withoutRunPropertyChanges(rPr) {
+    if (!rPr) return null;
+    const clone = rPr.cloneNode(true);
+    const changes = Array.from(clone.getElementsByTagName?.('*') || [])
+        .filter(node => isWordElement(node, 'rPrChange'));
+    changes.forEach(node => node.parentNode?.removeChild(node));
+    return clone;
+}
+
+function getCarrierSplitOffset(spanIndex, carrier, pos) {
+    const carrierStart = getCarrierGlobalStart(spanIndex, carrier);
+    const carrierLength = spanIndex.spans
+        .filter(span => span.runElement?.parentNode === carrier)
+        .reduce((length, span) => length + (span.charEnd - span.charStart), 0);
+    return Math.max(0, Math.min(pos - carrierStart, carrierLength));
+}
+
+function getCarrierGlobalStart(spanIndex, carrier) {
+    const carrierSpans = spanIndex.spans.filter(span => span.runElement?.parentNode === carrier);
+    return carrierSpans.length > 0 ? Math.min(...carrierSpans.map(span => span.charStart)) : 0;
+}
+
+function isForeignInsertion(node, author) {
+    if (!isWordElement(node, 'ins')) return false;
+    const carrierAuthor = node.getAttribute('w:author') || node.getAttributeNS?.(NS_W, 'author') || '';
+    return carrierAuthor.trim().toLowerCase() !== String(author || '').trim().toLowerCase();
+}
+
+function nextElementSibling(node) {
+    let sibling = node?.nextSibling || null;
+    while (sibling && sibling.nodeType !== 1) sibling = sibling.nextSibling;
+    return sibling;
+}
+
+function isConnected(node) {
+    return !!node?.parentNode;
+}
+
 function insertTextRuns(xmlDoc, parent, referenceNode, text, baseRPr, author, formatHints, insertOffset, generateRedlines, revisionMetadata = null) {
     const applicableHints = getApplicableFormatHints(formatHints, insertOffset, insertOffset + text.length);
 

package/engine/surgical-mode.js

@@ -17,7 +17,7 @@ import {
 import { withOoxmlSourceType } from '../core/word-xml.js';
 import { createReplacementRevisionEvent } from '../core/types.js';
 
-function checkSafeAdjacencyForPairing(spanIndex, startPos, endPos) {
+function checkSafeAdjacencyForPairing(spanIndex, startPos, endPos, allowInsertionCarrier = false) {
     const spans = [];
     forEachOverlappingSpan(spanIndex, startPos, endPos, span => spans.push(span));
     if (spans.length === 0) return { safe: false };
@@ -32,7 +32,10 @@ function checkSafeAdjacencyForPairing(spanIndex, startPos, endPos) {
 
     // Parent container itself cannot be an existing revision or unsupported container
     const parentLocal = (parent.localName || parent.nodeName.replace(/^.*:/, ''));
-    if (['hyperlink', 'sdt', 'ins', 'del', 'moveFrom', 'moveTo'].includes(parentLocal)) {
+    if (
+        ['hyperlink', 'sdt', 'del', 'moveFrom', 'moveTo'].includes(parentLocal)
+        || (parentLocal === 'ins' && !allowInsertionCarrier)
+    ) {
         return { safe: false, structuralBoundary: true };
     }
 
@@ -149,7 +152,12 @@ export function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer
                 const nextText = diffs[i + 1][1];
                 const textWithoutNewlines = nextText.replace(/\n/g, ' ');
                 if (textWithoutNewlines.trim().length > 0) {
-                    const checkResult = checkSafeAdjacencyForPairing(spanIndex, originalPos, originalPos + text.length);
+                    const checkResult = checkSafeAdjacencyForPairing(
+                        spanIndex,
+                        originalPos,
+                        originalPos + text.length,
+                        options?.existingRevisions === 'slice-cross-author'
+                    );
                     if (checkResult.safe) {
                         const event = createReplacementRevisionEvent(author, xmlDoc);
                         delMetadata = { id: event.deletionId, author: event.author, date: event.date };
@@ -171,7 +179,7 @@ export function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer
                 const [, nextText] = diffs[i];
                 const textWithoutNewlines = nextText.replace(/\n/g, ' ');
                 if (textWithoutNewlines.trim().length > 0) {
-                    const insertResult = processInsert(xmlDoc, spanIndex, originalPos, textWithoutNewlines, author, formatHints, newPos, generateRedlines, allParagraphs[0] || null, insMetadata, options?.insertionAffinity || null);
+                    const insertResult = processInsert(xmlDoc, spanIndex, originalPos, textWithoutNewlines, author, formatHints, newPos, generateRedlines, allParagraphs[0] || null, insMetadata, options?.insertionAffinity || null, options?.existingRevisions || 'merge-same-author');
                     if (insertResult && typeof insertResult === 'object' && insertResult.error) {
                         return withOoxmlSourceType({
                             oxml: serializer.serializeToString(xmlDoc),
@@ -189,7 +197,7 @@ export function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer
         } else if (op === 1) {
             const textWithoutNewlines = text.replace(/\n/g, ' ');
             if (textWithoutNewlines.trim().length > 0) {
-                const insertResult = processInsert(xmlDoc, spanIndex, originalPos, textWithoutNewlines, author, formatHints, newPos, generateRedlines, allParagraphs[0] || null, null, options?.insertionAffinity || null);
+                const insertResult = processInsert(xmlDoc, spanIndex, originalPos, textWithoutNewlines, author, formatHints, newPos, generateRedlines, allParagraphs[0] || null, null, options?.insertionAffinity || null, options?.existingRevisions || 'merge-same-author');
                 if (insertResult && typeof insertResult === 'object' && insertResult.error) {
                     return withOoxmlSourceType({
                         oxml: serializer.serializeToString(xmlDoc),

package/engine/surgical-run-splitting.js

@@ -1,6 +1,15 @@
 import { createWordElement, isWordElement } from '../core/word-xml.js';
+import {
+    NS_W,
+    RevisionIdAllocator,
+    createRevisionIdAllocator,
+    getRevisionIdAllocatorForDocument
+} from '../core/types.js';
+import { refreshRunPropertyChangeIds } from '../core/revision-cloning.js';
 import { getRunChildText, isTextLikeRunChild } from './surgical-spans.js';
 
+const TRACK_CHANGE_CARRIERS = new Set(['ins']);
+
 export function getRunContentPieces(runElement) {
     const pieces = [];
     let offset = 0;
@@ -62,6 +71,100 @@ export function insertRunPiecesBefore(xmlDoc, parent, referenceNode, pieces, rPr
     return run;
 }
 
+/**
+ * Splits a run-level tracked-change carrier at an accepted-view character
+ * offset without mutating the source carrier. The original revision ID stays
+ * with the leading fragment; an interior trailing fragment receives a fresh,
+ * document-scoped ID while all other carrier metadata remains unchanged.
+ *
+ * @param {Document} xmlDoc
+ * @param {Element} carrierElement
+ * @param {number} splitOffset
+ * @param {RevisionIdAllocator|null} [allocator=null]
+ * @returns {{ leftCarrier: Element|null, rightCarrier: Element|null }}
+ */
+export function splitTrackChangeCarrier(xmlDoc, carrierElement, splitOffset, allocator = null) {
+    const carrierName = getLocalName(carrierElement);
+    if (!TRACK_CHANGE_CARRIERS.has(carrierName)) {
+        throw new TypeError('splitTrackChangeCarrier requires a w:ins carrier.');
+    }
+    if (!Number.isInteger(splitOffset) || splitOffset < 0) {
+        throw new RangeError('splitOffset must be a non-negative integer.');
+    }
+
+    const children = Array.from(carrierElement.childNodes || []);
+    const totalLength = children.reduce((length, child) => {
+        return length + (isWordElement(child, 'r') ? getRunTextLength(getRunContentPieces(child)) : 0);
+    }, 0);
+    if (splitOffset > totalLength) {
+        throw new RangeError(`splitOffset ${splitOffset} exceeds carrier text length ${totalLength}.`);
+    }
+
+    if (splitOffset === 0) {
+        return { leftCarrier: null, rightCarrier: carrierElement.cloneNode(true) };
+    }
+    if (splitOffset === totalLength) {
+        return { leftCarrier: carrierElement.cloneNode(true), rightCarrier: null };
+    }
+
+    const leftCarrier = carrierElement.cloneNode(false);
+    const rightCarrier = carrierElement.cloneNode(false);
+    let offset = 0;
+
+    for (const child of children) {
+        if (!isWordElement(child, 'r')) {
+            const destination = offset <= splitOffset ? leftCarrier : rightCarrier;
+            destination.appendChild(child.cloneNode(true));
+            continue;
+        }
+
+        const pieces = getRunContentPieces(child);
+        const runLength = getRunTextLength(pieces);
+        const runEnd = offset + runLength;
+
+        if (runEnd <= splitOffset) {
+            leftCarrier.appendChild(child.cloneNode(true));
+        } else if (offset >= splitOffset) {
+            rightCarrier.appendChild(child.cloneNode(true));
+        } else {
+            const localOffset = splitOffset - offset;
+            const rPr = Array.from(child.childNodes || []).find(node => isWordElement(node, 'rPr')) || null;
+            const leftPieces = sliceRunPieces(xmlDoc, pieces, 0, localOffset, false);
+            const rightPieces = sliceRunPieces(xmlDoc, pieces, localOffset, runLength, false);
+            leftCarrier.appendChild(createRunFromPieces(xmlDoc, leftPieces, rPr));
+            const rightRun = createRunFromPieces(xmlDoc, rightPieces, rPr);
+            refreshRunPropertyChangeIds(rightRun, resolveAllocator(xmlDoc, allocator));
+            rightCarrier.appendChild(rightRun);
+        }
+        offset = runEnd;
+    }
+
+    const resolvedAllocator = resolveAllocator(xmlDoc, allocator);
+    const nextId = resolvedAllocator.next();
+    setWordAttribute(rightCarrier, 'id', String(nextId));
+    resolvedAllocator._receiptCollector?.recordRevision(nextId, carrierName);
+
+    return { leftCarrier, rightCarrier };
+}
+
+function resolveAllocator(xmlDoc, allocator) {
+    return allocator instanceof RevisionIdAllocator
+        ? allocator
+        : (getRevisionIdAllocatorForDocument(xmlDoc) || createRevisionIdAllocator(xmlDoc));
+}
+
+function setWordAttribute(element, localName, value) {
+    if (typeof element.setAttributeNS === 'function') {
+        element.setAttributeNS(NS_W, `w:${localName}`, value);
+    } else {
+        element.setAttribute(`w:${localName}`, value);
+    }
+}
+
+function getLocalName(element) {
+    return String(element?.localName || element?.nodeName || '').replace(/^.*:/, '');
+}
+
 function cloneRunPiece(xmlDoc, sourceNode, text, asDeletedText) {
     if (asDeletedText) {
         const delText = createWordElement(xmlDoc, 'w:delText');

package/index.d.ts

@@ -1,6 +1,6 @@
 export type OoxmlSourceType = 'package' | 'document' | 'fragment';
 export type RedlineStatus = 'ok' | 'no-op' | 'error';
-export type ExistingRevisionsPolicy = 'merge-same-author' | 'reject-input' | 'accept-all-first' | 'accept-all-first-keep-normalized';
+export type ExistingRevisionsPolicy = 'merge-same-author' | 'slice-cross-author' | 'reject-input' | 'accept-all-first' | 'accept-all-first-keep-normalized';
 export type RevisionView = 'accepted' | 'rejected';
 
 export interface RevisionTextSegment {

package/node/cli.js

@@ -4,14 +4,16 @@ import { openDocx } from './docx-document.js';
 import { MemoryZip, unzipDocx } from './zip-archive.js';
 import { validateDocxPackage } from '../services/standalone-docx-plumbing.js';
 import { validateRedlineOoxml } from '../core/redline-validation.js';
-import { configureLogger } from '../adapters/logger.js';
+import { configureLogger } from '../adapters/logger.js';
+import { isExistingRevisionsPolicy } from '../services/document-operation-contract.js';
 
 const suffixes = { apply: 'redlined', accept: 'accepted', reject: 'rejected', 'delete-comments': 'comments-removed' };
 const CLI_CONTRACT_VERSION = 2;
-const CLI_CAPABILITIES = [
-    'atomic-batch-results-on-package-failure',
-    'baseline-aware-validation',
-    'document-scoped-list-revision-ids'
+const CLI_CAPABILITIES = [
+    'atomic-batch-results-on-package-failure',
+    'baseline-aware-validation',
+    'cross-author-revision-slicing',
+    'document-scoped-list-revision-ids'
 ];
 const commandOptions = {
     version: new Set(['help']),
@@ -214,8 +216,11 @@ export async function executeCli(argv) {
         };
     }
     if (!rawInput) return cliError('INPUT_REQUIRED', 'An input .docx path is required.');
-    const optionError = validateCommandOptions(command, flags, extraPositionals);
-    if (optionError) return optionError;
+    const optionError = validateCommandOptions(command, flags, extraPositionals);
+    if (optionError) return optionError;
+    if (flags.existingRevisions != null && !isExistingRevisionsPolicy(flags.existingRevisions)) {
+        return cliError('INVALID_OPERATION', `Unsupported existing-revisions policy: "${String(flags.existingRevisions)}".`);
+    }
     let inspectOptions = null;
     if (command === 'inspect' || command === 'extract') {
         try { inspectOptions = inspectionOptions(flags); }