@ansonlai/docx-redline-js 0.8.2 → 0.8.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ansonlai/docx-redline-js",
-  "version": "0.8.2",
+  "version": "0.8.3",
   "description": "Host-independent OOXML reconciliation engine for .docx manipulation with track changes",
   "license": "MIT",
   "type": "module",

package/pipeline/list-generation.js

@@ -1,44 +1,44 @@
-/**
- * List generation flow extracted from ReconciliationPipeline.
- */
-
-import { preprocessMarkdown } from './markdown-processor.js';
+/**
+ * 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 { serializeToOoxml } from './serialization.js';
+import { generateTableOoxml } from '../services/table-reconciliation.js';
 import { parseTable } from './content-analysis.js';
 import { log } from '../adapters/logger.js';
 import { createRevisionMetadata, NS_W, RunKind } from '../core/types.js';
 import { parseOoxmlSafe, serializeXml } from '../adapters/xml-adapter.js';
 import { createWordElement } from '../core/word-xml.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>}
- */
+
+/**
+ * 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,
+    const {
+        cleanText,
+        numberingContext,
+        originalRunModel = [],
+        originalText = '',
+        generateRedlines = true,
         author = 'AI',
         font = null,
         revisionIdAllocator = null,
         numberingService
-    } = options;
-
+    } = options;
+
     const normalizedListText = normalizeCompositeListMarkers(cleanText);
     const lineMetadata = buildLineMetadata(normalizedListText);
     const rawLines = lineMetadata.map(line => line.raw);
@@ -50,26 +50,61 @@ export async function executeListGeneration(options) {
         sourcePPr,
         ['rFonts', 'kern', 'position', 'rtl', 'cs', 'lang']
     );
-
-    let deletionRuns = [];
+
+    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
-            }];
+        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
+            }];
         }
     }
 
-    if (generateRedlines && deletionRuns.length > 0) {
+    const sourceParagraphCount = (originalRunModel || [])
+        .filter(run => run.kind === RunKind.PARAGRAPH_START).length;
+    if (generateRedlines && sourceParagraphCount > 0 && (sourceParagraphCount > 1 || deletionRuns.length === 0)) {
+        // Each source paragraph keeps its own deleted paragraph (content and tracked-deleted mark), so
+        // Reject All restores every original paragraph boundary instead of merging them into one.
+        // Serialize each source paragraph on its own so empty paragraphs are emitted too (an empty
+        // paragraph carrying only its tracked-deleted mark).
+        let segment = null;
+        const flushSegment = () => {
+            if (!segment) return;
+            results.push(serializeToOoxml(segment, null, [], {
+                author,
+                generateRedlines,
+                revisionIdAllocator
+            }));
+            segment = null;
+        };
+        for (const run of originalRunModel) {
+            if (run.kind === RunKind.PARAGRAPH_START) {
+                flushSegment();
+                segment = [{
+                    ...run,
+                    pPrElement: null,
+                    pPrXml: addParagraphMarkRevision(
+                        run.pPrElement || run.pPrXml || null,
+                        'del',
+                        author,
+                        revisionIdAllocator
+                    )
+                }];
+            } else if (segment && (run.kind === 'text' || run.kind === 'run')) {
+                segment.push({ ...run, kind: 'deletion', author });
+            }
+        }
+        flushSegment();
+    } else if (generateRedlines && deletionRuns.length > 0) {
         const deletedPPr = addParagraphMarkRevision(sourcePPr, 'del', author, revisionIdAllocator);
         const deletedParagraph = serializeToOoxml(deletionRuns, deletedPPr, [], {
             author,
@@ -78,102 +113,102 @@ export async function executeListGeneration(options) {
         });
         results.push(deletedParagraph);
     }
-
-    const indentStep = detectIndentationStep(rawLines);
-    log(`[ListGen] Detected indentation step: ${indentStep} spaces/chars`);
-
+
+    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) {
+    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) {
                 results.push(generateTableOoxml(tableData, {
                     generateRedlines,
                     author,
                     revisionIdAllocator,
                     trackAsBlock: true
                 }));
-                i = tableBlock.endIndex;
-                continue;
-            }
-        }
-
-        const line = lineMetadata[i];
+                i = tableBlock.endIndex;
+                continue;
+            }
+        }
+
+        const line = lineMetadata[i];
         const entry = buildListEntry(
             line,
             indentStep,
-            numberingContext,
-            numberingService,
-            generateRedlines,
+            numberingContext,
+            numberingService,
+            generateRedlines,
             author,
             font,
             revisionIdAllocator,
             inheritedTypographyRPrXml,
             inheritedHeadingRPrXml
         );
-        results.push(entry.ooxml);
-    }
-
-    const numberingXml = numberingService.generateNumberingXml();
-    const finalOoxml = results.join('');
+        results.push(entry.ooxml);
+    }
+
+    const numberingXml = numberingService.generateNumberingXml();
+    const finalOoxml = results.join('');
 
     log(`[ListGen] ✅ Generated OOXML for ${results.length} paragraphs, total length: ${finalOoxml.length}`);
     log(`[ListGen] First 200 chars: ${finalOoxml.substring(0, 200)}...`);
-
-    return {
+
+    return {
         ooxml: finalOoxml,
-        isValid: true,
-        warnings: ['Paragraph expanded to list fragment'],
-        type: 'fragment',
-        includeNumbering: true,
-        numberingXml
-    };
+        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;
-}
-
+
+/**
+ * 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)
-            };
+    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)
+            };
         });
 }
 
@@ -214,34 +249,34 @@ function normalizeCompositeListMarkers(text) {
     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 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,
     indentStep,
-    numberingContext,
-    numberingService,
-    generateRedlines,
+    numberingContext,
+    numberingService,
+    generateRedlines,
     author,
     font,
     revisionIdAllocator,
@@ -251,11 +286,11 @@ function buildListEntry(
     let pPrXml = '';
     let segmentText = '';
     let insertedRPrXml = inheritedTypographyRPrXml;
-
-    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];
+
+    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>`;
@@ -263,17 +298,17 @@ function buildListEntry(
             inheritedHeadingRPrXml,
             `<w:rPr><w:b/><w:sz w:val="${headingSize}"/><w:szCs w:val="${headingSize}"/></w:rPr>`
         );
-    } 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 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;
     }
@@ -294,13 +329,13 @@ function buildListEntry(
         kind: generateRedlines ? 'insertion' : 'run',
         text: cleanText,
         rPrXml: insertedRPrXml,
-        author,
-        startOffset: 0,
-        endOffset: cleanText.length
-    });
-
-    return {
-        ooxml: serializeToOoxml(runModel, pPrXml, formatHints, {
+        author,
+        startOffset: 0,
+        endOffset: cleanText.length
+    });
+
+    return {
+        ooxml: serializeToOoxml(runModel, pPrXml, formatHints, {
             author,
             generateRedlines,
             font,

package/services/document-inspection.js

@@ -8,6 +8,9 @@ import { extractDocumentPartsEntries, computeRevisionTokenSync } from './revisio
 const attr = (node, name) => node?.getAttribute?.(`w:${name}`) || node?.getAttribute?.(name) || '';
 const descendants = (node, name) => Array.from(node?.getElementsByTagNameNS?.(NS_W, name) || []);
 const first = (node, name) => descendants(node, name)[0] || null;
+const directChild = (node, name) => Array.from(node?.childNodes || []).find(child => child?.nodeType === 1 && child.localName === name && (!child.namespaceURI || child.namespaceURI === NS_W)) || null;
+/** Current paragraph properties: the paragraph's direct w:pPr only (never the historical w:pPrChange/w:pPr). */
+const currentPPr = paragraph => directChild(paragraph, 'pPr');
 function hasAncestor(node, localName) { let cursor = node?.parentNode; while (cursor) { if (cursor.localName === localName && (!cursor.namespaceURI || cursor.namespaceURI === NS_W)) return true; cursor = cursor.parentNode; } return false; }
 
 function parseXml(xml, partName, required = false) {
@@ -18,11 +21,11 @@ function parseXml(xml, partName, required = false) {
 }
 
 function paragraphListProperties(paragraph) {
-    const numPr = first(first(paragraph, 'pPr'), 'numPr');
+    const numPr = directChild(currentPPr(paragraph), 'numPr');
     if (!numPr) return null;
-    const numId = attr(first(numPr, 'numId'), 'val');
+    const numId = attr(directChild(numPr, 'numId'), 'val');
     if (!numId || numId === '0') return null;
-    return { numId, level: Number.parseInt(attr(first(numPr, 'ilvl'), 'val') || '0', 10) || 0 };
+    return { numId, level: Number.parseInt(attr(directChild(numPr, 'ilvl'), 'val') || '0', 10) || 0 };
 }
 
 function parseNumbering(numberingDoc) {
@@ -100,11 +103,11 @@ function createNumberingResolver(numberingDoc) {
 }
 
 function headingLevel(paragraph) {
-    const pPr = first(paragraph, 'pPr');
-    const style = attr(first(pPr, 'pStyle'), 'val');
+    const pPr = currentPPr(paragraph);
+    const style = attr(directChild(pPr, 'pStyle'), 'val');
     const match = style.match(/^heading\s*([1-9])$/i);
     if (match) return Math.min(Number(match[1]), 6);
-    const outline = Number.parseInt(attr(first(pPr, 'outlineLvl'), 'val'), 10);
+    const outline = Number.parseInt(attr(directChild(pPr, 'outlineLvl'), 'val'), 10);
     return Number.isInteger(outline) ? Math.min(outline + 1, 6) : null;
 }
 
@@ -283,7 +286,7 @@ export function inspectDocumentParts(parts, options = {}) {
         const ids = [...new Set([...descendants(paragraph, 'commentRangeStart'), ...descendants(paragraph, 'commentReference')].map(node => attr(node, 'id')).filter(Boolean))];
         const authors = revisionAuthors(paragraph);
         const list = resolveNumbering(paragraphListProperties(paragraph));
-        const styleId = attr(first(first(paragraph, 'pPr'), 'pStyle'), 'val') || null;
+        const styleId = attr(directChild(currentPPr(paragraph), 'pStyle'), 'val') || null;
         const structure = structuralContext(paragraph, text);
         const index = zeroIndex + 1;
         const provision = list?.label && list.format !== 'bullet' ? list.label : null;