@ansonlai/docx-redline-js 0.1.0

package/pipeline/ingestion-table.js

@@ -0,0 +1,169 @@
+/**
+ * OOXML Reconciliation Pipeline - Table Ingestion
+ *
+ * Builds virtual-grid table models with merged-cell awareness.
+ */
+
+import { NS_W } from '../core/types.js';
+import { serializeXml } from '../adapters/xml-adapter.js';
+import {
+    getElementsByTagNS,
+    getElementsByTagNSOrTag,
+    getFirstElementByTag,
+    getFirstElementByTagNS
+} from '../core/xml-query.js';
+import { ingestParagraphElement } from './ingestion-paragraph.js';
+
+/**
+ * Ingests a table into a virtual grid model to handle merged cells.
+ *
+ * @param {Element} tableNode - w:tbl element
+ * @returns {Object}
+ */
+export function ingestTableToVirtualGrid(tableNode) {
+    const tblGrid = getFirstElementByTagNS(tableNode, NS_W, 'tblGrid');
+    const gridCols = tblGrid ? getElementsByTagNS(tblGrid, NS_W, 'gridCol') : [];
+    const colCount = gridCols.length;
+
+    const trElements = getElementsByTagNS(tableNode, NS_W, 'tr');
+    const rowCount = trElements.length;
+
+    const grid = Array.from({ length: rowCount }, () =>
+        Array.from({ length: colCount }, () => null)
+    );
+    const cellMap = new Map();
+    const vMergeOrigins = new Map();
+
+    for (let rowIdx = 0; rowIdx < trElements.length; rowIdx++) {
+        const tr = trElements[rowIdx];
+        const tcElements = getElementsByTagNS(tr, NS_W, 'tc');
+        let gridCol = 0;
+
+        for (let tcIdx = 0; tcIdx < tcElements.length; tcIdx++) {
+            const tc = tcElements[tcIdx];
+            const tcPr = getFirstElementByTagNS(tc, NS_W, 'tcPr');
+
+            while (gridCol < colCount && grid[rowIdx][gridCol] !== null) {
+                gridCol++;
+            }
+            if (gridCol >= colCount) break;
+
+            const gridSpanEl = tcPr ? (getFirstElementByTagNS(tcPr, NS_W, 'gridSpan') || getFirstElementByTag(tcPr, 'w:gridSpan')) : null;
+            const colSpan = parseInt(gridSpanEl?.getAttribute('w:val') || '1', 10);
+
+            const vMergeEl = tcPr ? (getFirstElementByTagNS(tcPr, NS_W, 'vMerge') || getFirstElementByTag(tcPr, 'w:vMerge')) : null;
+            const vMergeVal = vMergeEl?.getAttribute('w:val');
+            const hasVMerge = vMergeEl !== null;
+
+            let cell;
+            if (hasVMerge && vMergeVal !== 'restart') {
+                const origin = vMergeOrigins.get(gridCol);
+                if (origin) {
+                    origin.cell.rowSpan++;
+                    cell = {
+                        gridRow: rowIdx,
+                        gridCol,
+                        rowSpan: 0,
+                        colSpan,
+                        tcNode: tc,
+                        blocks: [],
+                        tcPrXml: serializeTcPr(tcPr),
+                        isMergeOrigin: false,
+                        isMergeContinuation: true,
+                        mergeOrigin: origin.cell
+                    };
+                } else {
+                    cell = createRegularCell(rowIdx, gridCol, colSpan, tc, tcPr);
+                }
+            } else {
+                const blocks = parseCellBlocks(tc);
+                cell = {
+                    gridRow: rowIdx,
+                    gridCol,
+                    rowSpan: 1,
+                    colSpan,
+                    tcNode: tc,
+                    blocks,
+                    tcPrXml: serializeTcPr(tcPr),
+                    isMergeOrigin: hasVMerge && vMergeVal === 'restart',
+                    isMergeContinuation: false,
+                    getText: () => blocks.map(block => block.acceptedText).join('\n')
+                };
+
+                if (hasVMerge && vMergeVal === 'restart') {
+                    for (let span = 0; span < colSpan; span++) {
+                        vMergeOrigins.set(gridCol + span, { originRow: rowIdx, cell });
+                    }
+                } else {
+                    for (let span = 0; span < colSpan; span++) {
+                        vMergeOrigins.delete(gridCol + span);
+                    }
+                }
+            }
+
+            for (let spanOffset = 0; spanOffset < colSpan; spanOffset++) {
+                const targetCol = gridCol + spanOffset;
+                if (targetCol < colCount) {
+                    grid[rowIdx][targetCol] = cell;
+                    cellMap.set(`${rowIdx},${targetCol}`, cell);
+                }
+            }
+
+            gridCol += colSpan;
+        }
+    }
+
+    return {
+        rowCount,
+        colCount,
+        grid,
+        cellMap,
+        tblPrXml: extractTblPr(tableNode),
+        tblGridXml: extractTblGrid(tableNode),
+        trPrList: Array.from(trElements).map(tr => extractTrPr(tr))
+    };
+}
+
+function createRegularCell(rowIdx, gridCol, colSpan, tc, tcPr) {
+    const blocks = parseCellBlocks(tc);
+    return {
+        gridRow: rowIdx,
+        gridCol,
+        rowSpan: 1,
+        colSpan,
+        tcNode: tc,
+        blocks,
+        tcPrXml: serializeTcPr(tcPr),
+        isMergeOrigin: false,
+        isMergeContinuation: false,
+        getText: () => blocks.map(block => block.acceptedText).join('\n')
+    };
+}
+
+function parseCellBlocks(tcNode) {
+    const paragraphs = getElementsByTagNSOrTag(tcNode, NS_W, 'p');
+    return paragraphs.map(paragraph => {
+        const { runModel, acceptedText, pPr } = ingestParagraphElement(paragraph);
+        return { runModel, acceptedText, pPr };
+    });
+}
+
+function serializeTcPr(tcPrNode) {
+    if (!tcPrNode) return '<w:tcPr/>';
+    return serializeXml(tcPrNode);
+}
+
+function extractTblPr(tableNode) {
+    const tblPr = getFirstElementByTagNS(tableNode, NS_W, 'tblPr');
+    return tblPr ? serializeXml(tblPr) : '<w:tblPr/>';
+}
+
+function extractTblGrid(tableNode) {
+    const tblGrid = getFirstElementByTagNS(tableNode, NS_W, 'tblGrid');
+    return tblGrid ? serializeXml(tblGrid) : '<w:tblGrid/>';
+}
+
+function extractTrPr(trNode) {
+    const trPr = getFirstElementByTagNS(trNode, NS_W, 'trPr');
+    return trPr ? serializeXml(trPr) : '<w:trPr/>';
+}

package/pipeline/ingestion-xml.js

@@ -0,0 +1,39 @@
+/**
+ * Shared XML helpers for ingestion flows.
+ */
+
+/**
+ * Returns all children as an array.
+ *
+ * @param {Node} node - Parent node
+ * @returns {Node[]}
+ */
+export function childNodesToArray(node) {
+    return Array.from(node?.childNodes || []);
+}
+
+/**
+ * Serializes all attributes into a plain string.
+ *
+ * @param {Element} element - Element with attributes
+ * @returns {string}
+ */
+export function serializeAttributes(element) {
+    return Array.from(element.attributes)
+        .map(attr => `${attr.name}="${attr.value}"`)
+        .join(' ');
+}
+
+/**
+ * Returns true when a node belongs to the target namespace and optional local name.
+ *
+ * @param {Node} node - Candidate node
+ * @param {string} namespaceUri - Namespace URI
+ * @param {string} [localName] - Optional local name
+ * @returns {boolean}
+ */
+export function isNamespacedNode(node, namespaceUri, localName = '') {
+    if (!node || node.namespaceURI !== namespaceUri) return false;
+    if (!localName) return true;
+    return node.localName === localName;
+}

package/pipeline/ingestion.js

@@ -0,0 +1,8 @@
+/**
+ * OOXML Reconciliation Pipeline - Ingestion Facade
+ *
+ * Backward-compatible exports for paragraph and table ingestion.
+ */
+
+export { ingestOoxml, ingestParagraphElement, detectNumberingContext } from './ingestion-paragraph.js';
+export { ingestTableToVirtualGrid } from './ingestion-table.js';

package/pipeline/list-generation.js

@@ -0,0 +1,280 @@
+/**
+ * List generation flow extracted from ReconciliationPipeline.
+ */
+
+import { preprocessMarkdown } from './markdown-processor.js';
+import { matchListMarker, stripListMarker } from './list-markers.js';
+import { serializeToOoxml } from './serialization.js';
+import { generateTableOoxml } from '../services/table-reconciliation.js';
+import { parseTable } from './content-analysis.js';
+import { log } from '../adapters/logger.js';
+
+/**
+ * Executes list generation when paragraph content expands into list/table blocks.
+ *
+ * @param {Object} options - Generation options
+ * @param {string} options.cleanText - Preprocessed target text
+ * @param {Object|null} options.numberingContext - Existing numbering context
+ * @param {Array} [options.originalRunModel=[]] - Original run model
+ * @param {string} [options.originalText=''] - Original text fallback
+ * @param {boolean} [options.generateRedlines=true] - Track-change toggle
+ * @param {string} [options.author='AI'] - Author metadata
+ * @param {string|null} [options.font=null] - Optional font
+ * @param {import('../services/numbering-service.js').NumberingService} options.numberingService - Numbering service
+ * @returns {Promise<import('../core/types.js').ReconciliationResult>}
+ */
+export async function executeListGeneration(options) {
+    const {
+        cleanText,
+        numberingContext,
+        originalRunModel = [],
+        originalText = '',
+        generateRedlines = true,
+        author = 'AI',
+        font = null,
+        numberingService
+    } = options;
+
+    const normalizedListText = normalizeCompositeListMarkers(cleanText);
+    const lineMetadata = buildLineMetadata(normalizedListText);
+    const rawLines = lineMetadata.map(line => line.raw);
+    const results = [];
+
+    let deletionRuns = [];
+    if (generateRedlines) {
+        if (originalRunModel && originalRunModel.length > 0) {
+            deletionRuns = originalRunModel
+                .filter(run => run.kind === 'text' || run.kind === 'run')
+                .map(run => ({ ...run, kind: 'deletion', author }));
+        } else if (originalText && originalText.trim().length > 0) {
+            const trimmed = originalText.trim();
+            deletionRuns = [{
+                kind: 'deletion',
+                text: trimmed,
+                author,
+                startOffset: 0,
+                endOffset: trimmed.length
+            }];
+        }
+    }
+
+    const indentStep = detectIndentationStep(rawLines);
+    log(`[ListGen] Detected indentation step: ${indentStep} spaces/chars`);
+
+    const firstMarker = lineMetadata.find(line => line.marker)?.marker || '';
+    const { format: defaultFormat } = numberingService.detectNumberingFormat(firstMarker);
+    log(`[ListGen] Detected primary marker: "${firstMarker}", format: ${defaultFormat}`);
+
+    for (let i = 0; i < lineMetadata.length; i++) {
+        const tableBlock = collectMarkdownTableBlock(lineMetadata, i);
+        if (tableBlock) {
+            const tableData = parseTable(tableBlock.tableText);
+            if (tableData.headers.length > 0 || tableData.rows.length > 0) {
+                if (generateRedlines && results.length === 0 && deletionRuns.length > 0) {
+                    results.push(serializeToOoxml(deletionRuns, null, [], {
+                        author,
+                        generateRedlines,
+                        font
+                    }));
+                }
+
+                results.push(generateTableOoxml(tableData, { generateRedlines, author }));
+                i = tableBlock.endIndex;
+                continue;
+            }
+        }
+
+        const line = lineMetadata[i];
+        const entry = buildListEntry(
+            line,
+            i,
+            indentStep,
+            numberingContext,
+            numberingService,
+            generateRedlines,
+            author,
+            font,
+            deletionRuns
+        );
+        results.push(entry.ooxml);
+    }
+
+    const numberingXml = numberingService.generateNumberingXml();
+    const finalOoxml = results.join('');
+    const blankParagraph = '<w:p><w:pPr></w:pPr></w:p>';
+    const oxmlWithSpacing = finalOoxml + blankParagraph;
+
+    log(`[ListGen] ✅ Generated OOXML for ${results.length} list items, total length: ${oxmlWithSpacing.length}`);
+    log(`[ListGen] First 200 chars: ${oxmlWithSpacing.substring(0, 200)}...`);
+
+    return {
+        ooxml: oxmlWithSpacing,
+        isValid: true,
+        warnings: ['Paragraph expanded to list fragment'],
+        type: 'fragment',
+        includeNumbering: true,
+        numberingXml
+    };
+}
+
+/**
+ * Heuristically detects indentation step (spaces/tabs per level).
+ *
+ * @param {string[]} lines - Raw lines
+ * @returns {number}
+ */
+export function detectIndentationStep(lines) {
+    const indentations = lines
+        .map(line => line.match(/^(\s*)/)[0].length)
+        .filter(length => length > 0)
+        .sort((a, b) => a - b);
+
+    if (indentations.length === 0) return 2;
+
+    let minJump = indentations[0];
+    for (let i = 1; i < indentations.length; i++) {
+        const jump = indentations[i] - indentations[i - 1];
+        if (jump > 0 && jump < minJump) {
+            minJump = jump;
+        }
+    }
+
+    return minJump || 2;
+}
+
+function buildLineMetadata(cleanText) {
+    return cleanText
+        .split('\n')
+        .filter(line => line.trim().length > 0)
+        .map(raw => {
+            const markerMatch = matchListMarker(raw);
+            const headerMatch = raw.match(/^\s*(#{1,9})\s+(.*)/);
+            return {
+                raw,
+                marker: markerMatch ? markerMatch[2].trim() : '',
+                headerMatch,
+                indentSize: (raw.match(/^(\s*)/)?.[1].length) || 0,
+                isTableLine: /^\s*\|/.test(raw),
+                isTableSeparator: /^\s*\|?[\s:-]*-[-\s|:]*\|?\s*$/.test(raw)
+            };
+        });
+}
+
+function normalizeCompositeListMarkers(text) {
+    const lines = String(text || '').split('\n');
+    const nonEmptyIndexes = lines
+        .map((line, index) => ({ line, index }))
+        .filter(entry => entry.line.trim().length > 0);
+    if (nonEmptyIndexes.length < 2) return text;
+
+    const rewrites = [];
+    let rewrittenCount = 0;
+
+    for (const { line, index } of nonEmptyIndexes) {
+        const outerMarkerMatch = matchListMarker(line);
+        if (!outerMarkerMatch) return text;
+
+        const stripped = stripListMarker(line);
+        const innerMarkerMatch = matchListMarker(stripped);
+        if (!innerMarkerMatch) return text;
+
+        const outerMarker = (outerMarkerMatch[2] || '').trim();
+        const innerMarker = (innerMarkerMatch[2] || '').trim();
+        if (!outerMarker || !innerMarker || outerMarker === innerMarker) return text;
+
+        const indent = outerMarkerMatch[1] || '';
+        const rewritten = `${indent}${stripped.trimStart()}`;
+        rewrites.push({ index, rewritten });
+        rewrittenCount++;
+    }
+
+    if (rewrittenCount < 2) return text;
+
+    const updated = lines.slice();
+    for (const rewrite of rewrites) {
+        updated[rewrite.index] = rewrite.rewritten;
+    }
+    log(`[ListGen] Normalized ${rewrittenCount} composite list markers (e.g., "- A." -> "A.").`);
+    return updated.join('\n');
+}
+
+function collectMarkdownTableBlock(lineMetadata, index) {
+    const current = lineMetadata[index];
+    const next = lineMetadata[index + 1];
+
+    if (!current?.isTableLine || !next?.isTableLine || !next?.isTableSeparator) {
+        return null;
+    }
+
+    const tableLines = [];
+    let cursor = index;
+    while (cursor < lineMetadata.length && lineMetadata[cursor].isTableLine) {
+        tableLines.push(lineMetadata[cursor].raw);
+        cursor++;
+    }
+
+    return {
+        tableText: tableLines.join('\n'),
+        endIndex: cursor - 1
+    };
+}
+
+function buildListEntry(
+    line,
+    lineIndex,
+    indentStep,
+    numberingContext,
+    numberingService,
+    generateRedlines,
+    author,
+    font,
+    deletionRuns
+) {
+    let pPrXml = '';
+    let segmentText = '';
+
+    if (line.headerMatch) {
+        const level = Math.min(line.headerMatch[1].length, 9);
+        const outlineLevel = Math.min(level - 1, 8);
+        const headingSizes = [32, 28, 26, 24, 22, 20, 20, 20, 20];
+        const headingSize = headingSizes[level - 1] || headingSizes[headingSizes.length - 1];
+        segmentText = line.headerMatch[2].trim();
+        pPrXml = `<w:pPr><w:pStyle w:val="Heading${level}"/><w:outlineLvl w:val="${outlineLevel}"/><w:rPr><w:b/><w:sz w:val="${headingSize}"/><w:szCs w:val="${headingSize}"/></w:rPr></w:pPr>`;
+    } else if (line.marker) {
+        const lineFormat = numberingService.detectNumberingFormat(line.marker);
+        const indentLevel = indentStep > 0 ? Math.floor(line.indentSize / indentStep) : 0;
+        const contextLevel = numberingContext?.ilvl || 0;
+        const ilvl = lineFormat.format === 'outline'
+            ? Math.min(8, lineFormat.depth)
+            : Math.min(8, indentLevel + contextLevel);
+
+        segmentText = stripListMarker(line.raw);
+        const numId = numberingService.getOrCreateNumId({ type: lineFormat.format }, numberingContext);
+        pPrXml = numberingService.buildListPPr(numId, ilvl);
+    } else {
+        segmentText = line.raw;
+    }
+
+    const { cleanText, formatHints } = preprocessMarkdown(segmentText);
+    const runModel = [];
+
+    if (lineIndex === 0 && deletionRuns.length > 0) {
+        runModel.push(...deletionRuns);
+    }
+
+    runModel.push({
+        kind: generateRedlines ? 'insertion' : 'run',
+        text: cleanText,
+        author,
+        startOffset: 0,
+        endOffset: cleanText.length
+    });
+
+    return {
+        ooxml: serializeToOoxml(runModel, pPrXml, formatHints, {
+            author,
+            generateRedlines,
+            font
+        })
+    };
+}

package/pipeline/list-markers.js

@@ -0,0 +1,77 @@
+/**
+ * Shared list-marker detection/parsing helpers.
+ *
+ * Keeps marker parsing consistent across router, pipeline, and patching flows.
+ */
+
+const LIST_MARKER_CORE = String.raw`(?:\d+(?:\.\d+)*\.?|\((?:\d+|[a-zA-Z]|[ivxlcIVXLC]+)\)|[a-zA-Z]\.|\d+\.|[ivxlcIVXLC]+\.|[-*\u2022])`;
+
+const LINE_REGEX_STRICT = new RegExp(`^(\\s*)((?:${LIST_MARKER_CORE})\\s+)`);
+const LINE_REGEX_LOOSE = new RegExp(`^(\\s*)((?:${LIST_MARKER_CORE})\\s*)`);
+const MULTILINE_REGEX_STRICT = new RegExp(`^(\\s*)((?:${LIST_MARKER_CORE})\\s+)`, 'm');
+const MULTILINE_REGEX_LOOSE = new RegExp(`^(\\s*)((?:${LIST_MARKER_CORE})\\s*)`, 'm');
+
+/**
+ * Determines whether text should be treated as list-target content.
+ * Strict mode requires at least one whitespace after the marker.
+ *
+ * @param {string} text - Candidate text
+ * @returns {boolean}
+ */
+export function isListTargetStrict(text) {
+    if (typeof text !== 'string') return false;
+    return text.includes('\n') && MULTILINE_REGEX_STRICT.test(text);
+}
+
+/**
+ * Determines whether text should be treated as list-target content.
+ * Loose mode allows markers with optional trailing whitespace.
+ *
+ * @param {string} text - Candidate text
+ * @returns {boolean}
+ */
+export function isListTargetLoose(text) {
+    if (typeof text !== 'string') return false;
+    return text.includes('\n') && MULTILINE_REGEX_LOOSE.test(text.trim());
+}
+
+/**
+ * Matches a list marker at the start of a line.
+ *
+ * @param {string} line - Input line
+ * @param {Object} [options={}] - Match options
+ * @param {boolean} [options.allowZeroSpaceAfterMarker=false] - Allow zero spaces after marker
+ * @returns {RegExpMatchArray|null}
+ */
+export function matchListMarker(line, options = {}) {
+    const { allowZeroSpaceAfterMarker = false } = options;
+    const regex = allowZeroSpaceAfterMarker ? LINE_REGEX_LOOSE : LINE_REGEX_STRICT;
+    return line.match(regex);
+}
+
+/**
+ * Extracts the marker text from a line.
+ *
+ * @param {string} line - Input line
+ * @param {Object} [options={}] - Match options
+ * @param {boolean} [options.allowZeroSpaceAfterMarker=false] - Allow zero spaces after marker
+ * @returns {string}
+ */
+export function extractListMarker(line, options = {}) {
+    const match = matchListMarker(line, options);
+    return match ? match[2].trim() : '';
+}
+
+/**
+ * Strips the marker (and its immediate trailing spacing) from a line.
+ *
+ * @param {string} line - Input line
+ * @param {Object} [options={}] - Strip options
+ * @param {boolean} [options.allowZeroSpaceAfterMarker=false] - Allow zero spaces after marker
+ * @returns {string}
+ */
+export function stripListMarker(line, options = {}) {
+    const { allowZeroSpaceAfterMarker = false } = options;
+    const regex = allowZeroSpaceAfterMarker ? LINE_REGEX_LOOSE : LINE_REGEX_STRICT;
+    return line.replace(regex, '');
+}