@ansonlai/docx-redline-js 0.1.4 → 0.2.0

package/engine/surgical-run-splitting.js

@@ -0,0 +1,96 @@
+import { createWordElement, isWordElement } from '../core/word-xml.js';
+import { getRunChildText, isTextLikeRunChild } from './surgical-spans.js';
+
+export function getRunContentPieces(runElement) {
+    const pieces = [];
+    let offset = 0;
+
+    for (const child of Array.from(runElement.childNodes || [])) {
+        if (isWordElement(child, 'rPr')) continue;
+        if (!isTextLikeRunChild(child)) continue;
+
+        const text = getRunChildText(child);
+        if (text.length === 0) continue;
+
+        pieces.push({
+            node: child,
+            start: offset,
+            end: offset + text.length,
+            text
+        });
+        offset += text.length;
+    }
+
+    return pieces;
+}
+
+export function getRunTextLength(pieces) {
+    if (pieces.length === 0) return 0;
+    return pieces[pieces.length - 1].end;
+}
+
+export function sliceRunPieces(xmlDoc, pieces, start, end, asDeletedText) {
+    const sliced = [];
+    if (end <= start) return sliced;
+
+    pieces.forEach(piece => {
+        const overlapStart = Math.max(start, piece.start);
+        const overlapEnd = Math.min(end, piece.end);
+        if (overlapEnd <= overlapStart) return;
+
+        const localStart = overlapStart - piece.start;
+        const localEnd = overlapEnd - piece.start;
+        const text = piece.text.slice(localStart, localEnd);
+
+        sliced.push(cloneRunPiece(xmlDoc, piece.node, text, asDeletedText));
+    });
+
+    return sliced;
+}
+
+export function createRunFromPieces(xmlDoc, pieces, rPr) {
+    const run = createWordElement(xmlDoc, 'w:r');
+    if (rPr) run.appendChild(rPr.cloneNode(true));
+    pieces.forEach(piece => run.appendChild(piece));
+    return run;
+}
+
+export function insertRunPiecesBefore(xmlDoc, parent, referenceNode, pieces, rPr) {
+    if (pieces.length === 0) return null;
+    const run = createRunFromPieces(xmlDoc, pieces, rPr);
+    parent.insertBefore(run, referenceNode);
+    return run;
+}
+
+function cloneRunPiece(xmlDoc, sourceNode, text, asDeletedText) {
+    if (asDeletedText) {
+        const delText = createWordElement(xmlDoc, 'w:delText');
+        delText.setAttribute('xml:space', 'preserve');
+        delText.textContent = text;
+        return delText;
+    }
+
+    if (isWordElement(sourceNode, 't')) {
+        const textNode = sourceNode.cloneNode(false);
+        textNode.textContent = text;
+        if (/^\s|\s$/.test(text)) {
+            textNode.setAttribute('xml:space', 'preserve');
+        }
+        return textNode;
+    }
+
+    if (text === '\n' && (isWordElement(sourceNode, 'br') || isWordElement(sourceNode, 'cr'))) {
+        return sourceNode.cloneNode(true);
+    }
+    if (text === '\t' && isWordElement(sourceNode, 'tab')) {
+        return sourceNode.cloneNode(true);
+    }
+    if (text === '\u2011' && isWordElement(sourceNode, 'noBreakHyphen')) {
+        return sourceNode.cloneNode(true);
+    }
+
+    const textNode = createWordElement(xmlDoc, 'w:t');
+    textNode.setAttribute('xml:space', 'preserve');
+    textNode.textContent = text;
+    return textNode;
+}

package/engine/surgical-spans.js

@@ -0,0 +1,169 @@
+import { appendParagraphBoundary } from '../core/paragraph-offset-policy.js';
+import { getFirstElementByTag } from '../core/xml-query.js';
+import { isWordElement } from '../core/word-xml.js';
+
+export function getRunChildText(child) {
+    if (isWordElement(child, 't')) return child.textContent || '';
+    if (isWordElement(child, 'br') || isWordElement(child, 'cr')) return '\n';
+    if (isWordElement(child, 'tab')) return '\t';
+    if (isWordElement(child, 'noBreakHyphen')) return '\u2011';
+    return '';
+}
+
+export function isTextLikeRunChild(child) {
+    return isWordElement(child, 't')
+        || isWordElement(child, 'br')
+        || isWordElement(child, 'cr')
+        || isWordElement(child, 'tab')
+        || isWordElement(child, 'noBreakHyphen');
+}
+
+export function buildSurgicalTextSpans(paragraphs) {
+    let fullText = '';
+    const textSpans = [];
+
+    paragraphs.forEach((paragraph, paragraphIndex) => {
+        const container = paragraph.parentNode;
+
+        for (let child = paragraph.firstChild; child; child = child.nextSibling) {
+            if (isWordElement(child, 'r')) {
+                fullText += processRunElement(child, paragraph, container, fullText.length, textSpans).text;
+            } else if (isWordElement(child, 'hyperlink')) {
+                for (let hc = child.firstChild; hc; hc = hc.nextSibling) {
+                    if (isWordElement(hc, 'r')) {
+                        fullText += processRunElement(hc, paragraph, container, fullText.length, textSpans).text;
+                    }
+                }
+            }
+        }
+
+        fullText = appendParagraphBoundary(fullText, paragraphIndex, paragraphs.length);
+    });
+
+    return { fullText, textSpans };
+}
+
+function processRunElement(run, paragraph, container, currentOffset, textSpans) {
+    const rPr = getFirstElementByTag(run, 'w:rPr');
+    let localOffset = currentOffset;
+    const textParts = [];
+
+    for (let child = run.firstChild; child; child = child.nextSibling) {
+        if (isWordElement(child, 't')) {
+            const text = child.textContent || '';
+            if (text.length === 0) continue;
+
+            textSpans.push({
+                charStart: localOffset,
+                charEnd: localOffset + text.length,
+                textElement: child,
+                runElement: run,
+                paragraph,
+                container,
+                rPr
+            });
+            localOffset += text.length;
+            textParts.push(text);
+        } else if (isTextLikeRunChild(child)) {
+            const text = getRunChildText(child);
+            textSpans.push({
+                charStart: localOffset,
+                charEnd: localOffset + 1,
+                textElement: child,
+                runElement: run,
+                paragraph,
+                container,
+                rPr
+            });
+            localOffset += 1;
+            textParts.push(text);
+        }
+    }
+
+    return { text: textParts.join('') };
+}
+
+export function buildSpanIndex(textSpans) {
+    const spans = textSpans
+        .slice()
+        .sort((a, b) => a.charStart - b.charStart || a.charEnd - b.charEnd);
+
+    const starts = spans.map(span => span.charStart);
+    const ends = spans.map(span => span.charEnd);
+
+    return { spans, starts, ends };
+}
+
+export function forEachOverlappingSpan(spanIndex, startPos, endPos, callback) {
+    if (endPos <= startPos || spanIndex.spans.length === 0) {
+        return;
+    }
+
+    let index = upperBound(spanIndex.ends, startPos);
+    while (index < spanIndex.spans.length) {
+        const span = spanIndex.spans[index];
+        if (span.charStart >= endPos) {
+            break;
+        }
+        callback(span);
+        index++;
+    }
+}
+
+export function findContainingSpan(spanIndex, pos) {
+    if (spanIndex.spans.length === 0) return null;
+
+    const index = upperBound(spanIndex.starts, pos) - 1;
+    if (index < 0) return null;
+
+    const span = spanIndex.spans[index];
+    return pos >= span.charStart && pos < span.charEnd ? span : null;
+}
+
+export function findFirstSpanEndingAt(spanIndex, pos) {
+    const index = lowerBound(spanIndex.ends, pos);
+    if (index < spanIndex.spans.length && spanIndex.ends[index] === pos) {
+        return spanIndex.spans[index];
+    }
+    return null;
+}
+
+export function findLastSpanEndingBeforeOrAt(spanIndex, pos) {
+    const index = upperBound(spanIndex.ends, pos) - 1;
+    if (index >= 0) {
+        return spanIndex.spans[index];
+    }
+    return null;
+}
+
+function upperBound(values, target) {
+    let left = 0;
+    let right = values.length;
+
+    while (left < right) {
+        const middle = (left + right) >> 1;
+        if (values[middle] <= target) {
+            left = middle + 1;
+        } else {
+            right = middle;
+        }
+    }
+
+    return left;
+}
+
+function lowerBound(values, target) {
+    let left = 0;
+    let right = values.length;
+
+    while (left < right) {
+        const middle = (left + right) >> 1;
+        if (values[middle] < target) {
+            left = middle + 1;
+        } else {
+            right = middle;
+        }
+    }
+
+    return left;
+}

package/engine/table-cell-context.js

@@ -6,11 +6,13 @@
  */
 
 import { getDocumentParagraphs } from './format-extraction.js';
-import { log } from '../adapters/logger.js';
-import { buildParagraphOnlyPackage } from '../services/package-builder.js';
-import { getElementsByTag } from '../core/xml-query.js';
-
-const W14_NS = 'http://schemas.microsoft.com/office/word/2010/wordml';
+import { log } from '../adapters/logger.js';
+import { buildParagraphOnlyPackage } from '../services/package-builder.js';
+import { getElementsByTagNSOrTag } from '../core/xml-query.js';
+import { NS_W } from '../core/types.js';
+import { isWordElement } from '../core/word-xml.js';
+
+const W14_NS = 'http://schemas.microsoft.com/office/word/2010/wordml';
 
 /**
  * Detects whether the current XML is table-wrapped and resolves target paragraph context.
@@ -30,19 +32,19 @@ const W14_NS = 'http://schemas.microsoft.com/office/word/2010/wordml';
  */
 export function detectTableCellContext(xmlDoc, originalText, options = {}) {
     const { targetParagraphId = null } = options;
-    const tables = getElementsByTag(xmlDoc, 'w:tbl');
+    const tables = getElementsByTagNSOrTag(xmlDoc, NS_W, 'tbl');
     if (tables.length === 0) {
         return { hasTableWrapper: false, isTableCellParagraph: false, paragraphs: [], paragraph: null, tableElement: null };
     }
 
     const allParagraphs = getDocumentParagraphs(xmlDoc);
     const paragraphsInCells = allParagraphs.filter(p => {
-        let parent = p.parentNode;
-        while (parent) {
-            if (parent.nodeName === 'w:tc') return true;
-            parent = parent.parentNode;
-        }
-        return false;
+        let parent = p.parentNode;
+        while (parent) {
+            if (isWordElement(parent, 'tc')) return true;
+            parent = parent.parentNode;
+        }
+        return false;
     });
 
     log(`[OxmlEngine] Table wrapper detected: ${tables.length} tables, ${paragraphsInCells.length} paragraphs in cells`);
@@ -68,7 +70,7 @@ export function detectTableCellContext(xmlDoc, originalText, options = {}) {
         const normalizedTarget = originalText.trim();
         if (!targetParagraph) {
             for (const p of paragraphsInCells) {
-                const textNodes = getElementsByTag(p, 'w:t');
+                const textNodes = getElementsByTagNSOrTag(p, NS_W, 't');
                 let paragraphText = '';
                 for (const t of textNodes) {
                     paragraphText += t.textContent || '';

package/engine/table-mode.js

@@ -2,23 +2,26 @@
  * Table-specific reconciliation and transformation flows.
  */
 
-import { NS_W, getNextRevisionId, getRevisionTimestamp } from '../core/types.js';
-import {
-    getElementsByTag,
-    getElementsByTagNS,
-    getFirstElementByTag,
-    getFirstElementByTagNS,
-    getXmlParseError
-} from '../core/xml-query.js';
+import { NS_W, createRevisionMetadata } from '../core/types.js';
+import {
+    getElementsByTagNS,
+    getElementsByTagNSOrTag,
+    getFirstElementByTag,
+    getFirstElementByTagNS,
+    getFirstElementByTagNSOrTag,
+    getXmlParseError
+} from '../core/xml-query.js';
 import { createParser } from '../adapters/xml-adapter.js';
-import { log, error } from '../adapters/logger.js';
-import { diffTablesWithVirtualGrid, serializeVirtualGridToOoxml, generateTableOoxml } from '../services/table-reconciliation.js';
-import { parseTable } from '../pipeline/pipeline.js';
-import { ingestTableToVirtualGrid } from '../pipeline/ingestion.js';
-
-function noChanges(serializer, xmlDoc) {
-    return { oxml: serializer.serializeToString(xmlDoc), hasChanges: false };
-}
+import { log, error } from '../adapters/logger.js';
+import { diffTablesWithVirtualGrid, serializeVirtualGridToOoxml, generateTableOoxml } from '../services/table-reconciliation.js';
+import { parseTable } from '../pipeline/pipeline.js';
+import { ingestTableToVirtualGrid } from '../pipeline/ingestion.js';
+import { createWordElement, withOoxmlSourceType } from '../core/word-xml.js';
+import { markParagraphMarkDeleted } from './run-builders.js';
+
+function noChanges(serializer, xmlDoc) {
+    return withOoxmlSourceType({ oxml: serializer.serializeToString(xmlDoc), hasChanges: false });
+}
 
 /**
  * Applies structural reconciliation to tables using Virtual Grid.
@@ -31,8 +34,8 @@ function noChanges(serializer, xmlDoc) {
  * @param {boolean} [generateRedlines=true] - Track change toggle
  * @returns {{ oxml: string, hasChanges: boolean }}
  */
-export function applyTableReconciliation(xmlDoc, modifiedText, serializer, parser, author, generateRedlines = true) {
-    const tableNodes = getElementsByTag(xmlDoc, 'w:tbl');
+export function applyTableReconciliation(xmlDoc, modifiedText, serializer, parser, author, generateRedlines = true) {
+    const tableNodes = getElementsByTagNSOrTag(xmlDoc, NS_W, 'tbl');
     const newTableData = parseTable(modifiedText);
     const hasNewContent = newTableData.rows.length > 0 || newTableData.headers.length > 0;
 
@@ -60,7 +63,7 @@ export function applyTableReconciliation(xmlDoc, modifiedText, serializer, parse
         return noChanges(serializer, xmlDoc);
     }
 
-    const newTableNode = getFirstElementByTag(reconciledDoc, 'w:tbl');
+    const newTableNode = getFirstElementByTagNSOrTag(reconciledDoc, NS_W, 'tbl');
     if (!newTableNode) {
         error('[OxmlEngine] No table found in reconciled OOXML');
         return noChanges(serializer, xmlDoc);
@@ -69,7 +72,7 @@ export function applyTableReconciliation(xmlDoc, modifiedText, serializer, parse
     const importedTable = xmlDoc.importNode(newTableNode, true);
     targetTable.parentNode.replaceChild(importedTable, targetTable);
 
-    return { oxml: serializer.serializeToString(xmlDoc), hasChanges: true };
+    return withOoxmlSourceType({ oxml: serializer.serializeToString(xmlDoc), hasChanges: true });
 }
 
 /**
@@ -135,25 +138,26 @@ export function applyTextToTableTransformation(xmlDoc, modifiedText, serializer,
 
     const importedTable = workingDoc.importNode(newTableElement, true);
 
-    if (generateRedlines) {
-        const date = getRevisionTimestamp();
-        paragraphs.forEach(p => {
-            const runs = getElementsByTagNS(p, NS_W, 'r');
-            runs.forEach(run => {
+    if (generateRedlines) {
+        paragraphs.forEach(p => {
+            markParagraphMarkDeleted(workingDoc, p, author);
+            const runs = getElementsByTagNS(p, NS_W, 'r');
+            runs.forEach(run => {
                 const textNodes = getElementsByTagNS(run, NS_W, 't');
                 textNodes.forEach(t => {
                     const text = t.textContent || '';
                     if (text.trim()) {
-                        const delText = workingDoc.createElementNS(NS_W, 'w:delText');
-                        delText.textContent = text;
-                        t.parentNode.replaceChild(delText, t);
+                        const delText = createWordElement(workingDoc, 'w:delText');
+                        delText.textContent = text;
+                        t.parentNode.replaceChild(delText, t);
                     }
                 });
-
-                const del = workingDoc.createElementNS(NS_W, 'w:del');
-                del.setAttribute('w:id', String(getNextRevisionId()));
-                del.setAttribute('w:author', author);
-                del.setAttribute('w:date', date);
+
+                const del = createWordElement(workingDoc, 'w:del');
+                const metadata = createRevisionMetadata(author);
+                del.setAttribute('w:id', String(metadata.id));
+                del.setAttribute('w:author', metadata.author);
+                del.setAttribute('w:date', metadata.date);
                 run.parentNode.insertBefore(del, run);
                 del.appendChild(run);
             });
@@ -168,5 +172,5 @@ export function applyTextToTableTransformation(xmlDoc, modifiedText, serializer,
     }
 
     log('[OxmlEngine] Text-to-table transformation complete');
-    return { oxml: serializer.serializeToString(workingDoc), hasChanges: true };
-}
+    return withOoxmlSourceType({ oxml: serializer.serializeToString(workingDoc), hasChanges: true });
+}

package/index.d.ts

@@ -0,0 +1,172 @@
+export type OoxmlSourceType = 'package' | 'document' | 'fragment';
+export type RedlineStatus = 'ok' | 'no-op' | 'error';
+export type ExistingRevisionsPolicy = 'reject-input' | 'accept-all-first';
+
+export interface RedlineError {
+  code: 'PARSE_ERROR' | 'TARGET_NOT_FOUND' | 'EXISTING_REVISIONS' | string;
+  message: string;
+}
+
+export interface RedlineOptions {
+  generateRedlines?: boolean;
+  author?: string;
+  targetParagraphId?: string | null;
+  existingRevisions?: ExistingRevisionsPolicy;
+  [key: string]: unknown;
+}
+
+export interface RedlineResult {
+  oxml: string;
+  hasChanges: boolean;
+  sourceType?: OoxmlSourceType;
+  status?: RedlineStatus;
+  error?: RedlineError;
+  warnings?: string[];
+  numberingXml?: string;
+  useNativeApi?: boolean;
+  [key: string]: unknown;
+}
+
+export interface TableReconciliationResult extends RedlineResult {
+  isMarkdownTable: boolean;
+  tableData?: {
+    headers?: string[];
+    rows?: string[][];
+    [key: string]: unknown;
+  };
+}
+
+export interface RevisionFilterOptions {
+  author?: string;
+  allAuthors?: boolean;
+}
+
+export interface AcceptTrackedChangesResult {
+  oxml: string;
+  hasChanges: boolean;
+  acceptedCount: number;
+  warnings: string[];
+}
+
+export interface RejectTrackedChangesResult {
+  oxml: string;
+  hasChanges: boolean;
+  rejectedCount: number;
+  warnings: string[];
+}
+
+export interface DeleteCommentsResult {
+  oxml: string;
+  hasChanges: boolean;
+  commentsRemoved: number;
+  referencesRemoved: number;
+  warnings: string[];
+}
+
+export interface XmlProvider {
+  DOMParser: typeof DOMParser;
+  XMLSerializer: typeof XMLSerializer;
+}
+
+export interface LoggerConfig {
+  log?: (...args: unknown[]) => void;
+  warn?: (...args: unknown[]) => void;
+  error?: (...args: unknown[]) => void;
+}
+
+export interface DocumentOperationResult {
+  documentXml: string;
+  hasChanges: boolean;
+  numberingXml?: string | null;
+  commentsXml?: string | null;
+  warnings?: string[];
+  status?: RedlineStatus;
+  error?: RedlineError;
+}
+
+export function configureXmlProvider(provider: XmlProvider): void;
+export function configureLogger(logger: LoggerConfig): void;
+export function setDefaultAuthor(name: string): void;
+export function getDefaultAuthor(): string;
+export function setPlatform(label: string): void;
+export function getPlatform(): string;
+
+export function applyRedlineToOxml(
+  oxml: string,
+  originalText: string,
+  modifiedText: string,
+  options?: RedlineOptions
+): Promise<RedlineResult>;
+
+export function applyRedlineToOxmlWithListFallback(
+  oxml: string,
+  originalText: string,
+  modifiedText: string,
+  options?: RedlineOptions
+): Promise<RedlineResult>;
+
+export function reconcileMarkdownTableOoxml(
+  oxml: string,
+  originalText: string,
+  markdownTable: string,
+  options?: RedlineOptions
+): Promise<TableReconciliationResult>;
+
+export function ingestWordOoxmlToPlainText(oxml: string): string;
+export function ingestWordOoxmlToMarkdown(oxml: string): string;
+export function ingestOoxml(oxml: string): unknown;
+export function preprocessMarkdown(text: string): { cleanText: string; formatHints: unknown[] };
+export function serializeToOoxml(runModel: unknown[], pPrXml?: string | null, formatHints?: unknown[], options?: Record<string, unknown>): string;
+export function wrapInDocumentFragment(rawOoxml: string, options?: Record<string, unknown>): string;
+
+export function injectCommentsIntoOoxml(oxml: string, comments: unknown[], options?: Record<string, unknown>): unknown;
+export function injectCommentsIntoPackage(packageXml: string, comments: unknown[], options?: Record<string, unknown>): unknown;
+export function acceptTrackedChangesInOoxml(oxml: string, options?: RevisionFilterOptions): AcceptTrackedChangesResult;
+export function rejectTrackedChangesInOoxml(oxml: string, options?: RevisionFilterOptions): RejectTrackedChangesResult;
+export function deleteCommentsByAuthorInOoxml(oxml: string, options?: RevisionFilterOptions): DeleteCommentsResult;
+export function containsTrackedChanges(xmlDoc: Document | Element): boolean;
+
+export type RedlineValidationSeverity = 'error' | 'warning';
+
+export interface RedlineValidationIssue {
+  code:
+    | 'PARSE_ERROR'
+    | 'NESTED_REVISION'
+    | 'DEL_CONTAINS_T'
+    | 'MISSING_REVISION_METADATA'
+    | 'DUPLICATE_REVISION_ID'
+    | 'MISSING_SPACE_PRESERVE'
+    | 'EMPTY_TEXT_ELEMENT'
+    | 'EMPTY_REVISION_WRAPPER'
+    | string;
+  severity: RedlineValidationSeverity;
+  message: string;
+}
+
+export interface RedlineValidationResult {
+  valid: boolean;
+  issues: RedlineValidationIssue[];
+}
+
+export function validateRedlineOoxml(oxml: string): RedlineValidationResult;
+
+export function applyHighlightToOoxml(oxml: string, targetText: string, color: string, options?: Record<string, unknown>): string;
+export function generateTableOoxml(headersOrData: unknown, rowsOrOptions?: unknown, options?: Record<string, unknown>): string;
+export function extractReplacementNodesFromOoxml(oxml: string): unknown;
+export function validateDocxPackage(zip: unknown): Promise<unknown> | unknown;
+export function ensureNumberingArtifactsInZip(zip: unknown, numberingXml: string): Promise<unknown> | unknown;
+export function ensureCommentsArtifactsInZip(zip: unknown, commentsXml: string): Promise<unknown> | unknown;
+export function createDynamicNumberingIdState(numberingXml?: string): unknown;
+
+export function parseOoxml(ooxml: string): Document;
+export function serializeOoxml(node: Node): string;
+export function sanitizeAiResponse(text: string): string;
+
+export class ReconciliationPipeline {
+  constructor(options?: Record<string, unknown>);
+  execute(oxml: string, modifiedText: string, options?: Record<string, unknown>): Promise<unknown>;
+}
+
+export class NumberingService {
+  constructor(...args: unknown[]);
+}