@ansonlai/docx-redline-js 0.1.4 → 0.2.0

package/engine/formatting-removal.js

@@ -7,6 +7,8 @@
 
 import { parseOoxml, serializeOoxml } from './oxml-engine.js';
 import { getDefaultAuthor } from '../adapters/config.js';
+import { createRevisionMetadata } from '../core/types.js';
+import { createWordElement } from '../core/word-xml.js';
 
 /**
  * Removes specific formatting properties from a run properties (w:rPr) element.
@@ -154,7 +156,7 @@ export function injectHighlightIntoRPr(doc, rPr, color = 'yellow', options = {})
     let rPrElement = rPr;
     if (!rPrElement) {
         // Create new rPr element
-        rPrElement = doc.createElementNS(NS_W, 'w:rPr');
+        rPrElement = createWordElement(doc, 'w:rPr');
     } else {
         rPrElement = rPr.cloneNode(true);
     }
@@ -163,7 +165,7 @@ export function injectHighlightIntoRPr(doc, rPr, color = 'yellow', options = {})
     // Clone the *original* rPr children before we touch them
     let previousRPrState = null;
     if (generateRedlines) {
-        previousRPrState = doc.createElementNS(NS_W, 'w:rPr');
+        previousRPrState = createWordElement(doc, 'w:rPr');
         Array.from(rPrElement.childNodes).forEach(child => {
             // Don't include existing rPrChange in the "previous" state wrapper usually, 
             // but for simplicity we clone children. Word generally handles nested track changes poorly,
@@ -180,18 +182,19 @@ export function injectHighlightIntoRPr(doc, rPr, color = 'yellow', options = {})
     Array.from(existingHighlight).forEach(el => el.remove());
 
     // Create and add new highlight element
-    const highlightEl = doc.createElementNS(NS_W, 'w:highlight');
+    const highlightEl = createWordElement(doc, 'w:highlight');
     highlightEl.setAttributeNS(NS_W, 'w:val', ooxmlColor);
     rPrElement.appendChild(highlightEl);
 
     // --- WRAP IN REDLINES IF ENABLED ---
     if (generateRedlines && previousRPrState) {
-        const rPrChange = doc.createElementNS(NS_W, 'w:rPrChange');
-
-        // Attributes
-        rPrChange.setAttributeNS(NS_W, 'w:id', Math.floor(Math.random() * 9999999).toString());
-        rPrChange.setAttributeNS(NS_W, 'w:author', author);
-        rPrChange.setAttributeNS(NS_W, 'w:date', new Date().toISOString());
+        const rPrChange = createWordElement(doc, 'w:rPrChange');
+
+        // Attributes
+        const metadata = createRevisionMetadata(author);
+        rPrChange.setAttribute('w:id', String(metadata.id));
+        rPrChange.setAttribute('w:author', metadata.author);
+        rPrChange.setAttribute('w:date', metadata.date);
 
         // Format: <w:rPrChange ...> <w:rPr>...previous...</w:rPr> </w:rPrChange>
         rPrChange.appendChild(previousRPrState);
@@ -272,7 +275,7 @@ export function applyHighlightToOoxml(ooxmlString, targetText, color = 'yellow',
             const tNodes = prefixRun.getElementsByTagNameNS(NS_W, 't');
             // Simply remove all t nodes and add one with new text to avoid complexity of multiple t nodes
             Array.from(tNodes).forEach(t => t.remove());
-            const newT = doc.createElementNS(NS_W, 'w:t');
+            const newT = createWordElement(doc, 'w:t');
             // Preserve xml:space="preserve" if it existed, or just add it usually
             newT.setAttribute('xml:space', 'preserve');
             newT.textContent = prefixText;
@@ -286,7 +289,7 @@ export function applyHighlightToOoxml(ooxmlString, targetText, color = 'yellow',
             // Update text content
             const tNodes = matchRun.getElementsByTagNameNS(NS_W, 't');
             Array.from(tNodes).forEach(t => t.remove());
-            const newT = doc.createElementNS(NS_W, 'w:t');
+            const newT = createWordElement(doc, 'w:t');
             newT.setAttribute('xml:space', 'preserve');
             newT.textContent = matchText;
             matchRun.appendChild(newT);
@@ -310,7 +313,7 @@ export function applyHighlightToOoxml(ooxmlString, targetText, color = 'yellow',
             // Update text content
             const tNodes = suffixRun.getElementsByTagNameNS(NS_W, 't');
             Array.from(tNodes).forEach(t => t.remove());
-            const newT = doc.createElementNS(NS_W, 'w:t');
+            const newT = createWordElement(doc, 'w:t');
             newT.setAttribute('xml:space', 'preserve');
             newT.textContent = suffixText;
             suffixRun.appendChild(newT);

package/engine/oxml-engine.js

@@ -7,11 +7,11 @@
 import { preprocessMarkdown } from '../pipeline/markdown-processor.js';
 import { isListTargetLoose } from '../pipeline/list-markers.js';
 import { ReconciliationPipeline } from '../pipeline/pipeline.js';
-import { wrapInDocumentFragment } from '../pipeline/serialization.js';
-import {
-    getElementsByTag,
-    getXmlParseError
-} from '../core/xml-query.js';
+import { wrapInDocumentFragment } from '../pipeline/serialization.js';
+import {
+    getElementsByTagNSOrTag,
+    getXmlParseError
+} from '../core/xml-query.js';
 import { createParser, createSerializer, parseXml, serializeXml } from '../adapters/xml-adapter.js';
 import { log, error } from '../adapters/logger.js';
 import { extractFormattingFromOoxml } from './format-extraction.js';
@@ -25,6 +25,9 @@ import { applySurgicalMode } from './surgical-mode.js';
 import { applyReconstructionMode } from './reconstruction-mode.js';
 import { applyTableReconciliation, applyTextToTableTransformation } from './table-mode.js';
 import { getDefaultAuthor } from '../adapters/config.js';
+import { containsTrackedChanges, withOoxmlSourceType } from '../core/word-xml.js';
+import { NS_W, seedRevisionIdsFromDocument } from '../core/types.js';
+import { acceptTrackedChangesInOoxml } from '../services/revision-comment-management.js';
 
 /**
  * Applies redline track changes to OOXML by modifying the DOM in-place.
@@ -32,33 +35,87 @@ import { getDefaultAuthor } from '../adapters/config.js';
  * @param {string} oxml - Original OOXML string
  * @param {string} originalText - Original plain text
  * @param {string} modifiedText - New text (may contain markdown)
- * @param {Object} [options={}] - Options
- * @param {string} [options.author='AI'] - Author for track changes
- * @param {string|null} [options.targetParagraphId=null] - Preferred paragraph identity for table wrappers
- * @returns {Promise<{ oxml: string, hasChanges: boolean }>}
- */
+ * @param {Object} [options={}] - Options
+ * @param {string} [options.author='AI'] - Author for track changes
+ * @param {string|null} [options.targetParagraphId=null] - Preferred paragraph identity for table wrappers
+ * @param {'reject-input'|'accept-all-first'} [options.existingRevisions='reject-input'] - Policy for source OOXML with tracked changes
+ * @returns {Promise<{ oxml: string, hasChanges: boolean, sourceType?: 'package'|'document'|'fragment', status?: 'ok'|'no-op'|'error', error?: { code: string, message: string } }>}
+ */
 export async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}) {
     const generateRedlines = options.generateRedlines ?? true;
     const author = options.author || getDefaultAuthor();
     const parser = createParser();
     const serializer = createSerializer();
-    const noChanges = () => ({ oxml, hasChanges: false });
+    const finalize = result => {
+        const withStatus = { ...result };
+        if (!withStatus.status) {
+            withStatus.status = withStatus.hasChanges ? 'ok' : 'no-op';
+        }
+        return withOoxmlSourceType(withStatus);
+    };
+    const noChanges = () => finalize({ oxml, hasChanges: false });
 
     let xmlDoc;
     try {
         xmlDoc = parser.parseFromString(oxml, 'text/xml');
-    } catch (e) {
-        error('[OxmlEngine] Failed to parse OXML:', e);
-        return noChanges();
-    }
-
-    const parseError = getXmlParseError(xmlDoc);
-    if (parseError) {
-        error('[OxmlEngine] XML parse error:', parseError.textContent);
-        return noChanges();
-    }
-
-    const initialTableCellContext = detectTableCellContext(xmlDoc, originalText, options);
+    } catch (e) {
+        error('[OxmlEngine] Failed to parse OXML:', e);
+        return finalize({
+            oxml,
+            hasChanges: false,
+            status: 'error',
+            error: { code: 'PARSE_ERROR', message: 'Could not parse OOXML input.' }
+        });
+    }
+
+    const parseError = getXmlParseError(xmlDoc);
+    if (parseError) {
+        error('[OxmlEngine] XML parse error:', parseError.textContent);
+        return finalize({
+            oxml,
+            hasChanges: false,
+            status: 'error',
+            error: { code: 'PARSE_ERROR', message: parseError.textContent || 'Could not parse OOXML input.' }
+        });
+    }
+    seedRevisionIdsFromDocument(xmlDoc);
+
+    if (containsTrackedChanges(xmlDoc)) {
+        const existingRevisionsPolicy = options.existingRevisions || 'reject-input';
+        if (existingRevisionsPolicy === 'accept-all-first') {
+            log('[OxmlEngine] Existing revisions detected; accepting all input revisions before redlining');
+            const accepted = acceptTrackedChangesInOoxml(oxml, { allAuthors: true });
+            oxml = accepted.oxml;
+            xmlDoc = parser.parseFromString(oxml, 'text/xml');
+            const acceptedParseError = getXmlParseError(xmlDoc);
+            if (acceptedParseError) {
+                error('[OxmlEngine] XML parse error after accepting existing revisions:', acceptedParseError.textContent);
+                return finalize({
+                    oxml,
+                    hasChanges: false,
+                    status: 'error',
+                    error: {
+                        code: 'PARSE_ERROR',
+                        message: 'Could not parse OOXML after accepting existing revisions.'
+                    }
+                });
+            }
+            seedRevisionIdsFromDocument(xmlDoc);
+        } else {
+            log('[OxmlEngine] Existing revisions detected; rejecting input per existingRevisions policy');
+            return finalize({
+                oxml,
+                hasChanges: false,
+                status: 'error',
+                error: {
+                    code: 'EXISTING_REVISIONS',
+                    message: 'Input OOXML contains existing tracked changes. Pass existingRevisions: "accept-all-first" to normalize before redlining.'
+                }
+            });
+        }
+    }
+
+    const initialTableCellContext = detectTableCellContext(xmlDoc, originalText, options);
     if (initialTableCellContext.hasTableWrapper && initialTableCellContext.targetParagraph && !options._isolatedTableCell) {
         log('[OxmlEngine] Isolating table-cell paragraph before diff');
         const isolatedOxml = serializeParagraphOnly(xmlDoc, initialTableCellContext.targetParagraph, serializer);
@@ -74,8 +131,29 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
     const hasTextChanges = cleanModifiedText.trim() !== originalText.trim();
     const hasFormatHints = formatHints.length > 0;
 
-    const { existingFormatHints, textSpans, paragraphs } = extractFormattingFromOoxml(xmlDoc);
+    const { existingFormatHints, textSpans, paragraphs } = extractFormattingFromOoxml(xmlDoc);
     const hasExistingFormatting = existingFormatHints.length > 0;
+    const visibleText = textSpans.map(span => textSpanVisibleText(span)).join('');
+    if (
+        hasTextChanges
+        && typeof originalText === 'string'
+        && originalText.trim()
+        && !originalText.includes('\n')
+        && !visibleText.includes(originalText.trim())
+        && !visibleText.replace(/[\t\n\u2011]/g, '').includes(originalText.trim().replace(/[\t\n\u2011]/g, ''))
+        && !normalizeTargetText(visibleText).includes(normalizeTargetText(originalText))
+    ) {
+        log('[OxmlEngine] Target text not found in OOXML');
+        return finalize({
+            oxml,
+            hasChanges: false,
+            status: 'error',
+            error: {
+                code: 'TARGET_NOT_FOUND',
+                message: 'Original text was not found in the supplied OOXML.'
+            }
+        });
+    }
     let paragraphInfos = null;
     const getParagraphInfos = () => {
         if (!paragraphInfos) {
@@ -149,13 +227,13 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
         );
 
         if (tableCellCtx.hasTableWrapper && targetParagraph) {
-            return {
-                oxml: serializeParagraphOnly(xmlDoc, targetParagraph, serializer),
-                hasChanges: removalResult.hasChanges
-            };
-        }
-
-        return removalResult;
+            return finalize({
+                oxml: serializeParagraphOnly(xmlDoc, targetParagraph, serializer),
+                hasChanges: removalResult.hasChanges
+            });
+        }
+
+        return finalize(removalResult);
     }
 
     if (!hasTextChanges && hasFormatHints) {
@@ -173,16 +251,16 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
             const formatResult = applyFormatOnlyWithOoxmlFallback(precomputedFormatContext);
 
             log('[OxmlEngine] Stripping table wrapper for table cell paragraph (format-only)');
-            return {
+            return finalize({
                 oxml: serializeParagraphOnly(xmlDoc, tableCellCtx.targetParagraph, serializer),
                 hasChanges: formatResult.hasChanges
-            };
+            });
         }
 
-        return applyFormatOnlyWithOoxmlFallback(precomputedFormatContext);
+        return finalize(applyFormatOnlyWithOoxmlFallback(precomputedFormatContext));
     }
 
-    const tables = getElementsByTag(xmlDoc, 'w:tbl');
+    const tables = getElementsByTagNSOrTag(xmlDoc, NS_W, 'tbl');
     const hasTables = tables.length > 0;
     const isMarkdownTable = /^\|.+\|/.test(cleanModifiedText.trim()) && cleanModifiedText.includes('\n');
     const isTargetList = isListTargetLoose(cleanModifiedText);
@@ -192,12 +270,12 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
 
     if (isMarkdownTable && !hasTables) {
         log('[OxmlEngine] Text-to-table transformation: generating new table from Markdown');
-        return applyTextToTableTransformation(xmlDoc, cleanModifiedText, serializer, parser, author, generateRedlines);
-    }
-
-    if (hasTables && isMarkdownTable) {
-        return applyTableReconciliation(xmlDoc, cleanModifiedText, serializer, parser, author, generateRedlines);
-    }
+        return finalize(applyTextToTableTransformation(xmlDoc, cleanModifiedText, serializer, parser, author, generateRedlines));
+    }
+
+    if (hasTables && isMarkdownTable) {
+        return finalize(applyTableReconciliation(xmlDoc, cleanModifiedText, serializer, parser, author, generateRedlines));
+    }
     if (hasTables) {
         const surgicalTarget = tableCellContext.hasTableWrapper && tableCellContext.targetParagraph
             ? tableCellContext.targetParagraph
@@ -217,11 +295,11 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
             surgicalTarget
         );
 
-        if (tableCellContext.hasTableWrapper && result.hasChanges && tableCellContext.targetParagraph) {
-            log('[OxmlEngine] Stripping table wrapper for table cell paragraph (surgical mode)');
-            return { oxml: serializeParagraphOnly(xmlDoc, tableCellContext.targetParagraph, serializer), hasChanges: true };
-        }
-        return result;
+        if (tableCellContext.hasTableWrapper && result.hasChanges && tableCellContext.targetParagraph) {
+            log('[OxmlEngine] Stripping table wrapper for table cell paragraph (surgical mode)');
+            return finalize({ oxml: serializeParagraphOnly(xmlDoc, tableCellContext.targetParagraph, serializer), hasChanges: true });
+        }
+        return finalize(result);
     }
     if (isTargetList) {
         log('[OxmlEngine] 🎯 Using reconciliation pipeline for list generation');
@@ -235,15 +313,28 @@ export async function applyRedlineToOxml(oxml, originalText, modifiedText, optio
                 numberingXml: result.numberingXml
             });
             log(`[OxmlEngine] ✅ Wrapped OOXML length: ${wrapped.length}`);
-            return { oxml: wrapped, hasChanges: true };
-        }
-        return noChanges();
-    }
-
-    return applyReconstructionMode(xmlDoc, originalText, cleanModifiedText, serializer, author, formatHints, generateRedlines);
-}
-
-/**
+            return finalize({ oxml: wrapped, hasChanges: true });
+        }
+        return noChanges();
+    }
+
+    return finalize(applyReconstructionMode(xmlDoc, originalText, cleanModifiedText, serializer, author, formatHints, generateRedlines));
+}
+
+function normalizeTargetText(text) {
+    return String(text || '').replace(/[\t\n\u2011]/g, ' ').replace(/\s+/g, ' ').trim();
+}
+
+function textSpanVisibleText(span) {
+    const node = span?.textElement;
+    const localName = String(node?.localName || node?.nodeName || '').replace(/^.*:/, '');
+    if (localName === 'tab') return '\t';
+    if (localName === 'br' || localName === 'cr') return '\n';
+    if (localName === 'noBreakHyphen') return '\u2011';
+    return node?.textContent || '';
+}
+
+/**
  * Sanitizes AI response text by removing common prefixes.
  *
  * @param {string} text - AI response text

package/engine/reconstruction-mapper.js

@@ -109,11 +109,12 @@ export function buildReconstructionMapping(xmlDoc, modifiedText) {
         });
     });
 
-    let processedModifiedText = modifiedText;
-    tokenToCharMap.forEach((char, tokenString) => {
-        const escapedToken = tokenString.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
-        processedModifiedText = processedModifiedText.replace(new RegExp(escapedToken, 'g'), char);
-    });
+    let processedModifiedText = modifiedText;
+    tokenToCharMap.forEach((char, tokenString) => {
+        const escapedToken = tokenString.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+        processedModifiedText = processedModifiedText.replace(new RegExp(escapedToken, 'g'), char);
+    });
+    processedModifiedText = preserveReferencePlaceholders(originalFullText, processedModifiedText, referenceMap);
 
     const containerFragments = new Map();
     uniqueContainers.forEach(container => {
@@ -169,9 +170,35 @@ export function buildReconstructionMapping(xmlDoc, modifiedText) {
         getPropertySpanLength,
         isParagraphStart: index => paragraphStarts.has(index)
     };
-}
-
-function processChildNode(child, originalFullText, propertyMap, sentinelMap, referenceMap, tokenToCharMap, nextCharCode) {
+}
+
+function preserveReferencePlaceholders(originalFullText, modifiedText, referenceMap) {
+    let result = modifiedText;
+
+    for (const referenceChar of referenceMap.keys()) {
+        if (result.includes(referenceChar)) continue;
+
+        const originalIndex = originalFullText.indexOf(referenceChar);
+        if (originalIndex < 0) continue;
+
+        const prefix = originalFullText.slice(0, originalIndex);
+        const suffix = originalFullText.slice(originalIndex + referenceChar.length);
+
+        if (prefix && result.startsWith(prefix)) {
+            result = `${result.slice(0, prefix.length)}${referenceChar}${result.slice(prefix.length)}`;
+            continue;
+        }
+
+        if (suffix && result.endsWith(suffix)) {
+            const insertAt = result.length - suffix.length;
+            result = `${result.slice(0, insertAt)}${referenceChar}${result.slice(insertAt)}`;
+        }
+    }
+
+    return result;
+}
+
+function processChildNode(child, originalFullText, propertyMap, sentinelMap, referenceMap, tokenToCharMap, nextCharCode) {
     if (child.nodeName === 'w:r') {
         return processRunForReconstruction(child, originalFullText, propertyMap, sentinelMap, referenceMap, tokenToCharMap, nextCharCode);
     }

package/engine/reconstruction-mode.js

@@ -5,6 +5,7 @@
 import { computeWordDiffs } from '../pipeline/diff-engine.js';
 import { buildReconstructionMapping } from './reconstruction-mapper.js';
 import { applyReconstructionDiffs } from './reconstruction-writer.js';
+import { withOoxmlSourceType } from '../core/word-xml.js';
 
 /**
  * Applies reconstruction mode reconciliation.
@@ -19,20 +20,20 @@ import { applyReconstructionDiffs } from './reconstruction-writer.js';
  * @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 mapping = buildReconstructionMapping(xmlDoc, modifiedText);
+    if (mapping.paragraphs.length === 0) {
+        return withOoxmlSourceType({ oxml: serializer.serializeToString(xmlDoc), hasChanges: false });
+    }
 
     const diffs = computeWordDiffs(mapping.originalFullText, mapping.processedModifiedText);
 
-    return applyReconstructionDiffs(
+    return withOoxmlSourceType(applyReconstructionDiffs(
         xmlDoc,
-        diffs,
-        mapping,
-        serializer,
-        author,
-        formatHints,
-        generateRedlines
-    );
-}
+        diffs,
+        mapping,
+        serializer,
+        author,
+        formatHints,
+        generateRedlines
+    ));
+}