@ansonlai/docx-redline-js 0.1.0

package/pipeline/ingestion-export.js

@@ -0,0 +1,255 @@
+/**
+ * Word OOXML ingestion helpers for plain-text/markdown export.
+ *
+ * These helpers are intentionally conservative and only map obvious signals:
+ * - Paragraph structure
+ * - Heading styles
+ * - List paragraph properties
+ * - Run-level bold/italic formatting
+ */
+
+import { createParser } from '../adapters/xml-adapter.js';
+import { NS_W } from '../core/types.js';
+import { getXmlParseError } from '../core/xml-query.js';
+
+function hasParserError(doc) {
+    if (!doc || !doc.documentElement) return true;
+    if (doc.documentElement.localName === 'parsererror') return true;
+    return !!getXmlParseError(doc);
+}
+
+function parseWordOoxml(ooxml) {
+    const source = typeof ooxml === 'string' ? ooxml : String(ooxml || '');
+    if (!source.trim()) {
+        return null;
+    }
+
+    try {
+        const parser = createParser();
+        const doc = parser.parseFromString(source, 'application/xml');
+        if (hasParserError(doc)) {
+            return null;
+        }
+        return doc;
+    } catch {
+        return null;
+    }
+}
+
+function getWordParagraphs(doc) {
+    if (!doc) return [];
+    const namespaced = Array.from(doc.getElementsByTagNameNS(NS_W, 'p'));
+    if (namespaced.length > 0) return namespaced;
+    return Array.from(doc.getElementsByTagNameNS('*', 'p')).filter(node => node?.localName === 'p');
+}
+
+function getDirectWordChild(node, localName) {
+    const children = Array.from(node?.childNodes || []);
+    for (const child of children) {
+        if (child?.nodeType !== 1) continue;
+        if (child.namespaceURI !== NS_W) continue;
+        if (child.localName === localName) return child;
+    }
+    return null;
+}
+
+function getWordDescendants(node, localName) {
+    return Array.from(node?.getElementsByTagNameNS?.(NS_W, localName) || []);
+}
+
+function getWordAttribute(element, names) {
+    if (!element) return '';
+    for (const name of names) {
+        const value = element.getAttribute(name);
+        if (value != null && value !== '') return value;
+    }
+    return '';
+}
+
+function hasWordAncestorWithin(node, localName, boundary) {
+    let cursor = node?.parentNode || null;
+    while (cursor && cursor !== boundary) {
+        if (cursor.nodeType === 1 && cursor.namespaceURI === NS_W && cursor.localName === localName) {
+            return true;
+        }
+        cursor = cursor.parentNode;
+    }
+    return false;
+}
+
+function readRunText(run) {
+    let text = '';
+    for (const child of Array.from(run?.childNodes || [])) {
+        if (!child || child.nodeType !== 1 || child.namespaceURI !== NS_W) continue;
+        if (child.localName === 't') {
+            text += child.textContent || '';
+        } else if (child.localName === 'tab') {
+            text += '\t';
+        } else if (child.localName === 'br' || child.localName === 'cr') {
+            text += '\n';
+        } else if (child.localName === 'noBreakHyphen') {
+            text += '\u2011';
+        }
+    }
+    return text;
+}
+
+function getRunFormatting(run) {
+    const rPr = getDirectWordChild(run, 'rPr');
+    if (!rPr) return { bold: false, italic: false };
+    const rStyle = getWordDescendants(rPr, 'rStyle')[0] || null;
+    const rStyleValue = getWordAttribute(rStyle, ['w:val', 'val']).toLowerCase();
+    const styleImpliesBold = rStyleValue.includes('strong') || rStyleValue.includes('bold');
+    const styleImpliesItalic = rStyleValue.includes('italic') || rStyleValue.includes('emphasis');
+    return {
+        bold: getWordDescendants(rPr, 'b').length > 0 || styleImpliesBold,
+        italic: getWordDescendants(rPr, 'i').length > 0 || styleImpliesItalic
+    };
+}
+
+function collectParagraphSegments(paragraph) {
+    const segments = [];
+    const runs = Array.from(paragraph?.getElementsByTagNameNS?.(NS_W, 'r') || []);
+    for (const run of runs) {
+        if (hasWordAncestorWithin(run, 'del', paragraph)) continue;
+        const text = readRunText(run);
+        if (!text) continue;
+        segments.push({
+            text,
+            ...getRunFormatting(run)
+        });
+    }
+    return segments;
+}
+
+function normalizeInlineWhitespace(text) {
+    const normalizedLines = String(text || '')
+        .replace(/\r/g, '')
+        .split('\n')
+        .map(line => line.replace(/[ \t]+/g, ' ').trim());
+    return normalizedLines.join('\n').trim();
+}
+
+function wrapRunMarkdown(text, format) {
+    const raw = String(text || '');
+    if (!raw) return '';
+    if (!format?.bold && !format?.italic) return raw;
+
+    const match = raw.match(/^(\s*)([\s\S]*?)(\s*)$/);
+    if (!match) return raw;
+    const leading = match[1] || '';
+    const core = match[2] || '';
+    const trailing = match[3] || '';
+    if (!core.trim()) return raw;
+
+    let wrapped = core;
+    if (format.bold && format.italic) wrapped = `***${core}***`;
+    else if (format.bold) wrapped = `**${core}**`;
+    else if (format.italic) wrapped = `*${core}*`;
+    return `${leading}${wrapped}${trailing}`;
+}
+
+function parseHeadingLevel(paragraph) {
+    const pPr = getDirectWordChild(paragraph, 'pPr');
+    if (!pPr) return null;
+
+    const pStyle = getWordDescendants(pPr, 'pStyle')[0] || null;
+    const styleVal = getWordAttribute(pStyle, ['w:val', 'val']);
+    if (styleVal) {
+        const match = styleVal.match(/^heading\s*([1-9])$/i);
+        if (match) {
+            const level = Number.parseInt(match[1], 10);
+            if (Number.isInteger(level)) return Math.min(Math.max(level, 1), 6);
+        }
+    }
+
+    const outlineLvl = getWordDescendants(pPr, 'outlineLvl')[0] || null;
+    const outlineRaw = getWordAttribute(outlineLvl, ['w:val', 'val']);
+    const outline = Number.parseInt(outlineRaw, 10);
+    if (Number.isInteger(outline) && outline >= 0) {
+        return Math.min(outline + 1, 6);
+    }
+
+    return null;
+}
+
+function parseListInfo(paragraph) {
+    const pPr = getDirectWordChild(paragraph, 'pPr');
+    if (!pPr) return null;
+
+    const numPr = getWordDescendants(pPr, 'numPr')[0] || null;
+    if (!numPr) return null;
+
+    const ilvlEl = getWordDescendants(numPr, 'ilvl')[0] || null;
+    const numIdEl = getWordDescendants(numPr, 'numId')[0] || null;
+    const ilvl = Number.parseInt(getWordAttribute(ilvlEl, ['w:val', 'val']), 10);
+    const numId = getWordAttribute(numIdEl, ['w:val', 'val']);
+
+    const safeLevel = Number.isInteger(ilvl) && ilvl >= 0 ? ilvl : 0;
+    const marker = numId === '1' ? '-' : '1.';
+    return { level: safeLevel, marker };
+}
+
+function paragraphToPlainText(paragraph) {
+    const text = collectParagraphSegments(paragraph).map(segment => segment.text).join('');
+    return normalizeInlineWhitespace(text);
+}
+
+function paragraphToMarkdown(paragraph) {
+    const segments = collectParagraphSegments(paragraph);
+    const inline = segments.map(segment => wrapRunMarkdown(segment.text, segment)).join('');
+    const normalizedInline = normalizeInlineWhitespace(inline);
+    if (!normalizedInline) return '';
+
+    const headingLevel = parseHeadingLevel(paragraph);
+    if (headingLevel != null) {
+        return `${'#'.repeat(headingLevel)} ${normalizedInline}`;
+    }
+
+    const list = parseListInfo(paragraph);
+    if (list) {
+        const indent = '  '.repeat(list.level);
+        return `${indent}${list.marker} ${normalizedInline}`;
+    }
+
+    return normalizedInline;
+}
+
+/**
+ * Ingests Word OOXML and returns readable plain text.
+ *
+ * @param {string} ooxml
+ * @returns {string}
+ */
+export function ingestWordOoxmlToPlainText(ooxml) {
+    const doc = parseWordOoxml(ooxml);
+    if (!doc) return '';
+
+    const paragraphs = getWordParagraphs(doc);
+    if (paragraphs.length === 0) {
+        const fallback = normalizeInlineWhitespace(doc.documentElement?.textContent || '');
+        return fallback;
+    }
+
+    const lines = paragraphs.map(paragraphToPlainText);
+    return lines.join('\n\n').trim();
+}
+
+/**
+ * Ingests Word OOXML and returns basic markdown.
+ *
+ * @param {string} ooxml
+ * @returns {string}
+ */
+export function ingestWordOoxmlToMarkdown(ooxml) {
+    const doc = parseWordOoxml(ooxml);
+    if (!doc) return '';
+
+    const paragraphs = getWordParagraphs(doc);
+    if (paragraphs.length === 0) {
+        return '';
+    }
+
+    const lines = paragraphs.map(paragraphToMarkdown);
+    return lines.join('\n\n').trim();
+}

package/pipeline/ingestion-paragraph.js

@@ -0,0 +1,351 @@
+/**
+ * OOXML Reconciliation Pipeline - Paragraph Ingestion
+ *
+ * Parses paragraph content into run models and accepted text offsets.
+ */
+
+import { NS_W, RunKind, ContainerKind } from '../core/types.js';
+import { appendParagraphBoundary, advanceOffsetForParagraphBoundary } from '../core/paragraph-offset-policy.js';
+import { createParser, serializeXml } from '../adapters/xml-adapter.js';
+import { warn, error as logError } from '../adapters/logger.js';
+import {
+    getElementsByTagNS,
+    getFirstElementByTagNS,
+    getFirstElementByTagNSOrTag,
+    getXmlParseError
+} from '../core/xml-query.js';
+import { childNodesToArray, isNamespacedNode, serializeAttributes } from './ingestion-xml.js';
+
+let containerIdCounter = 0;
+
+/**
+ * Ingests OOXML paragraph content and builds a run-aware text model.
+ *
+ * @param {string} ooxmlString - OOXML input
+ * @param {{ xmlDoc?: Document|null }} [options={}] - Optional pre-parsed XML document
+ * @returns {import('../core/types.js').IngestionResult}
+ */
+export function ingestOoxml(ooxmlString, options = {}) {
+    const runModel = [];
+    let acceptedText = '';
+    const preParsedDoc = options.xmlDoc || null;
+
+    if (!ooxmlString && !preParsedDoc) {
+        return { runModel, acceptedText, pPr: null };
+    }
+
+    try {
+        const doc = preParsedDoc || (() => {
+            const parser = createParser();
+            return parser.parseFromString(ooxmlString, 'application/xml');
+        })();
+
+        const parseError = getXmlParseError(doc);
+        if (parseError) {
+            logError('OOXML parse error:', parseError.textContent);
+            return { runModel, acceptedText, pPr: null };
+        }
+
+        const paragraphs = getElementsByTagNS(doc, NS_W, 'p');
+        if (paragraphs.length === 0) {
+            warn('No paragraphs found in OOXML');
+            return { runModel, acceptedText, pPr: null };
+        }
+
+        return ingestParagraphElements(paragraphs, { includeParagraphBoundaries: true });
+    } catch (error) {
+        logError('Error ingesting OOXML:', error);
+        return { runModel, acceptedText, pPr: null };
+    }
+}
+
+/**
+ * Ingests a single paragraph element directly, avoiding serialize+reparse cycles.
+ *
+ * @param {Element} paragraphElement - Paragraph element
+ * @returns {import('../core/types.js').IngestionResult}
+ */
+export function ingestParagraphElement(paragraphElement) {
+    if (!paragraphElement) {
+        return { runModel: [], acceptedText: '', pPr: null };
+    }
+    return ingestParagraphElements([paragraphElement], { includeParagraphBoundaries: false });
+}
+
+/**
+ * Extracts numbering metadata from a paragraph.
+ *
+ * @param {Element} pElement - w:p element
+ * @returns {Object|null}
+ */
+export function detectNumberingContext(pElement) {
+    const pPr = getFirstElementByTagNS(pElement, NS_W, 'pPr');
+    if (!pPr) return null;
+
+    const numPr = getFirstElementByTagNS(pPr, NS_W, 'numPr');
+    if (!numPr) return null;
+
+    const numIdEl = getFirstElementByTagNS(numPr, NS_W, 'numId');
+    const ilvlEl = getFirstElementByTagNS(numPr, NS_W, 'ilvl');
+    if (!numIdEl) return null;
+
+    const numId = numIdEl.getAttribute('w:val');
+    const type = numId === '1' ? 'bullet' : (numId === '2' ? 'numbered' : 'unknown');
+
+    return {
+        numId,
+        ilvl: parseInt(ilvlEl?.getAttribute('w:val') || '0', 10),
+        type
+    };
+}
+
+function ingestParagraphElements(paragraphs, options = {}) {
+    const includeParagraphBoundaries = options.includeParagraphBoundaries ?? true;
+    const runModel = [];
+    let acceptedText = '';
+    let currentOffset = 0;
+    let firstPPr = null;
+
+    for (let pIndex = 0; pIndex < paragraphs.length; pIndex++) {
+        const pElement = paragraphs[pIndex];
+        const pPr = getFirstElementByTagNS(pElement, NS_W, 'pPr');
+
+        if (pIndex === 0) {
+            firstPPr = pPr;
+        }
+
+        runModel.push({
+            kind: RunKind.PARAGRAPH_START,
+            // Keep pPr as a DOM reference; serialize only when downstream actually needs string XML.
+            pPrElement: pPr || null,
+            startOffset: currentOffset,
+            endOffset: currentOffset,
+            text: ''
+        });
+
+        const result = processNodeRecursive(pElement, currentOffset, runModel);
+        acceptedText += result.text;
+        currentOffset = acceptedText.length;
+
+        if (includeParagraphBoundaries) {
+            acceptedText = appendParagraphBoundary(acceptedText, pIndex, paragraphs.length);
+            currentOffset = advanceOffsetForParagraphBoundary(currentOffset, pIndex, paragraphs.length);
+        }
+    }
+
+    return { runModel, acceptedText, pPr: firstPPr };
+}
+
+function processNodeRecursive(node, currentOffset, runModel) {
+    let localOffset = currentOffset;
+    let text = '';
+
+    const handlers = getNodeHandlers(runModel);
+    for (const child of childNodesToArray(node)) {
+        if (isNamespacedNode(child, NS_W, 'pPr') || isNamespacedNode(child, NS_W, 'proofErr')) {
+            continue;
+        }
+
+        const handler = handlers.get(child.localName);
+        if (!handler) continue;
+
+        const result = handler(child, localOffset);
+        localOffset = result.offset;
+        text += result.text;
+    }
+
+    return { offset: localOffset, text };
+}
+
+function getNodeHandlers(runModel) {
+    /** @type {Map<string, (child: Node, offset: number) => { offset: number, text: string }>} */
+    const handlers = new Map();
+
+    handlers.set('sdt', (child, offset) => {
+        const containerId = `sdt_${containerIdCounter++}`;
+        const sdtPr = getFirstElementByTagNS(child, NS_W, 'sdtPr');
+        const sdtContent = getFirstElementByTagNS(child, NS_W, 'sdtContent');
+
+        runModel.push({
+            kind: RunKind.CONTAINER_START,
+            containerKind: ContainerKind.SDT,
+            containerId,
+            propertiesXml: sdtPr ? serializeXml(sdtPr) : '',
+            startOffset: offset,
+            endOffset: offset,
+            text: ''
+        });
+
+        const contentResult = sdtContent
+            ? processNodeRecursive(sdtContent, offset, runModel)
+            : { offset, text: '' };
+
+        runModel.push({
+            kind: RunKind.CONTAINER_END,
+            containerKind: ContainerKind.SDT,
+            containerId,
+            startOffset: contentResult.offset,
+            endOffset: contentResult.offset,
+            text: ''
+        });
+
+        return contentResult;
+    });
+
+    handlers.set('smartTag', (child, offset) => {
+        const containerId = `smartTag_${containerIdCounter++}`;
+        runModel.push({
+            kind: RunKind.CONTAINER_START,
+            containerKind: ContainerKind.SMART_TAG,
+            containerId,
+            propertiesXml: serializeAttributes(child),
+            startOffset: offset,
+            endOffset: offset,
+            text: ''
+        });
+
+        const contentResult = processNodeRecursive(child, offset, runModel);
+        runModel.push({
+            kind: RunKind.CONTAINER_END,
+            containerKind: ContainerKind.SMART_TAG,
+            containerId,
+            startOffset: contentResult.offset,
+            endOffset: contentResult.offset,
+            text: ''
+        });
+
+        return contentResult;
+    });
+
+    handlers.set('del', (child, offset) => {
+        const deletionEntry = processDeletion(child, offset);
+        if (deletionEntry) {
+            runModel.push(deletionEntry);
+        }
+        return { offset, text: '' };
+    });
+
+    handlers.set('bookmarkStart', (child, offset) => {
+        runModel.push({
+            kind: RunKind.BOOKMARK,
+            nodeXml: serializeXml(child),
+            startOffset: offset,
+            endOffset: offset,
+            text: ''
+        });
+        return { offset, text: '' };
+    });
+
+    handlers.set('bookmarkEnd', (child, offset) => {
+        runModel.push({
+            kind: RunKind.BOOKMARK,
+            nodeXml: serializeXml(child),
+            startOffset: offset,
+            endOffset: offset,
+            text: ''
+        });
+        return { offset, text: '' };
+    });
+
+    handlers.set('ins', (child, offset) => processNodeRecursive(child, offset, runModel));
+
+    handlers.set('hyperlink', (child, offset) => {
+        const containerId = `hyperlink_${containerIdCounter++}`;
+        const rId = child.getAttribute('r:id') || '';
+        const anchor = child.getAttribute('w:anchor') || '';
+
+        runModel.push({
+            kind: RunKind.CONTAINER_START,
+            containerKind: 'hyperlink',
+            containerId,
+            propertiesXml: JSON.stringify({ rId, anchor }),
+            startOffset: offset,
+            endOffset: offset,
+            text: ''
+        });
+
+        const contentResult = processNodeRecursive(child, offset, runModel);
+        runModel.push({
+            kind: RunKind.CONTAINER_END,
+            containerKind: 'hyperlink',
+            containerId,
+            startOffset: contentResult.offset,
+            endOffset: contentResult.offset,
+            text: ''
+        });
+
+        return contentResult;
+    });
+
+    handlers.set('r', (child, offset) => {
+        const runEntry = processRun(child, offset);
+        if (!runEntry || !runEntry.text) {
+            return { offset, text: '' };
+        }
+
+        runModel.push(runEntry);
+        const nextOffset = offset + runEntry.text.length;
+        return { offset: nextOffset, text: runEntry.text };
+    });
+
+    return handlers;
+}
+
+function processRun(runElement, startOffset) {
+    const rPr = getFirstElementByTagNSOrTag(runElement, NS_W, 'rPr');
+    const rPrXml = rPr ? serializeXml(rPr) : '';
+
+    let text = '';
+    for (const child of childNodesToArray(runElement)) {
+        const nodeName = child.nodeName;
+        if (nodeName.endsWith(':t') || nodeName === 't') {
+            text += child.textContent || '';
+        } else if (nodeName.endsWith(':br') || nodeName === 'br' || nodeName.endsWith(':cr') || nodeName === 'cr') {
+            text += '\n';
+        } else if (nodeName.endsWith(':tab') || nodeName === 'tab') {
+            text += '\t';
+        } else if (nodeName.endsWith(':noBreakHyphen') || nodeName === 'noBreakHyphen') {
+            text += '\u2011';
+        }
+    }
+
+    if (!text) return null;
+
+    return {
+        kind: RunKind.TEXT,
+        text,
+        rPrXml,
+        startOffset,
+        endOffset: startOffset + text.length
+    };
+}
+
+function processDeletion(delElement, offset) {
+    const author = delElement.getAttribute('w:author') || '';
+
+    let text = '';
+    const delTexts = getElementsByTagNS(delElement, NS_W, 'delText');
+    for (const delText of delTexts) {
+        text += delText.textContent || '';
+    }
+
+    const runs = getElementsByTagNS(delElement, NS_W, 'r');
+    for (const run of runs) {
+        const innerDelTexts = getElementsByTagNS(run, NS_W, 'delText');
+        for (const delText of innerDelTexts) {
+            text += delText.textContent || '';
+        }
+    }
+
+    if (!text) return null;
+
+    return {
+        kind: RunKind.DELETION,
+        text,
+        rPrXml: '',
+        startOffset: offset,
+        endOffset: offset,
+        author,
+        nodeXml: serializeXml(delElement)
+    };
+}