@ansonlai/docx-redline-js 0.8.4 → 0.10.0

package/core/word-revision-semantics.js

@@ -0,0 +1,256 @@
+import { NS_W } from './types.js';
+import { readCanonicalRunText } from './paragraph-text.js';
+
+/**
+ * Word-semantics Reject All / Accept All projection over a WordprocessingML DOM.
+ *
+ * The projection is a list of paragraph records describing what Word shows after
+ * rejecting or accepting every tracked revision. It never mutates the input and
+ * never serializes. Rules (Word behavior):
+ *   - a paragraph mark in w:pPr/w:rPr/w:ins (or moveTo) is removed on Reject; the
+ *     paragraph's remaining content merges into the FOLLOWING paragraph of the same
+ *     container, whose mark and properties survive. A deleted mark (w:del/moveFrom)
+ *     is removed on Accept with the same merge rule.
+ *   - at the end of a container: Reject keeps a table cell's last paragraph; otherwise a
+ *     trailing paragraph left empty by the removed mark disappears.
+ *   - w:ins/moveTo content is removed on Reject, w:del/moveFrom restored; Accept is
+ *     the converse. Rows whose w:trPr carries w:ins (Reject) or w:del (Accept) vanish.
+ *   - Reject restores the w:pPrChange snapshot as the paragraph's properties.
+ *   - a w:body whose last block is a table gets one untracked empty paragraph from Word on
+ *     open (a body must end with a paragraph). It is not a revision, so it survives Reject and
+ *     Accept alike: such a body counts one extra paragraph in both views even when Reject
+ *     removes the whole table (Word 16 COM evidence, R5).
+ *
+ * Shared by the post-apply fidelity verifier and the reject/accept tests.
+ */
+
+const CONTAINER_NAMES = new Set(['body', 'tc', 'txbxContent', 'footnote', 'endnote', 'comment', 'hdr', 'ftr']);
+const WRAPPER_NAMES = new Set(['hyperlink', 'fldSimple', 'sdt', 'smartTag', 'customXml']);
+const PROPERTY_SKIP = new Set(['rPr', 'pPrChange', 'sectPr']);
+
+const localName = node => {
+    const local = node?.localName;
+    if (local) return local.indexOf(':') < 0 ? local : local.replace(/^.*:/, '');
+    return String(node?.nodeName || '').replace(/^.*:/, '');
+};
+const isWordElement = node => node?.nodeType === 1 && (!node.namespaceURI || node.namespaceURI === NS_W);
+const attr = (node, name) => node?.getAttribute?.(`w:${name}`) || node?.getAttribute?.(name) || '';
+
+/** Document-order w:<name> descendants of `root`; a plain walk avoids the live node list's per-call cost. */
+function descendantWordElements(root, name) {
+    const found = [];
+    if (!root) return found;
+    const stack = [];
+    for (let child = root.lastChild; child; child = child.previousSibling) stack.push(child);
+    while (stack.length) {
+        const node = stack.pop();
+        if (node.nodeType !== 1) continue;
+        if (node.namespaceURI === NS_W && node.localName === name) found.push(node);
+        for (let child = node.lastChild; child; child = child.previousSibling) stack.push(child);
+    }
+    return found;
+}
+
+function directChild(node, name) {
+    for (let child = node?.firstChild; child; child = child.nextSibling) {
+        if (isWordElement(child) && localName(child) === name) return child;
+    }
+    return null;
+}
+
+/** Revision kind on the paragraph mark: 'ins' | 'del' | null (moveTo/moveFrom map to ins/del). */
+export function paragraphMarkRevision(paragraph) {
+    const rPr = directChild(directChild(paragraph, 'pPr'), 'rPr');
+    if (!rPr) return null;
+    for (let child = rPr.firstChild; child; child = child.nextSibling) {
+        if (!isWordElement(child)) continue;
+        const name = localName(child);
+        if (name === 'ins' || name === 'moveTo') return 'ins';
+        if (name === 'del' || name === 'moveFrom') return 'del';
+    }
+    return null;
+}
+
+function containerOf(paragraph) {
+    for (let cur = paragraph.parentNode; cur; cur = cur.parentNode) {
+        if (CONTAINER_NAMES.has(localName(cur))) return cur;
+    }
+    return null;
+}
+
+function hiddenByStructure(paragraph, view) {
+    const revisionName = view === 'rejected' ? 'ins' : 'del';
+    for (let cur = paragraph.parentNode; cur; cur = cur.parentNode) {
+        const name = localName(cur);
+        if (name === 'tr') {
+            if (directChild(directChild(cur, 'trPr'), revisionName)) return true;
+        } else if (name === 'tc') {
+            const cellRevision = view === 'rejected' ? 'cellIns' : 'cellDel';
+            if (directChild(directChild(cur, 'tcPr'), cellRevision)) return true;
+        } else if (name === 'body') {
+            break;
+        }
+    }
+    return false;
+}
+
+function canonicalElement(node) {
+    const attrs = Array.from(node.attributes || [])
+        .filter(a => !/^xmlns(:|$)/.test(a.name) && !/(^|:)(rsid\w*|paraId|textId)$/.test(a.name))
+        .map(a => `${a.name.replace(/^.*:/, '')}=${a.value}`)
+        .sort();
+    const children = Array.from(node.childNodes || [])
+        .filter(isWordElement)
+        .map(canonicalElement)
+        .sort();
+    return `${localName(node)}[${attrs.join(',')}]{${children.join('')}}`;
+}
+
+/** Properties a paragraph carries in a view (Reject restores the pPrChange snapshot). */
+function viewProperties(paragraph, view) {
+    const pPr = directChild(paragraph, 'pPr');
+    let source = pPr;
+    if (view === 'rejected') {
+        const change = directChild(pPr, 'pPrChange');
+        if (change) source = directChild(change, 'pPr');
+    }
+    let numPr = null;
+    const children = [];
+    for (const child of Array.from(source?.childNodes || [])) {
+        if (!isWordElement(child) || PROPERTY_SKIP.has(localName(child))) continue;
+        if (localName(child) === 'numPr') {
+            numPr = {
+                numId: attr(directChild(child, 'numId'), 'val') || null,
+                ilvl: attr(directChild(child, 'ilvl'), 'val') || '0'
+            };
+            continue;
+        }
+        children.push(canonicalElement(child));
+    }
+    return { props: children.sort().join(''), numPr };
+}
+
+function wrapperKey(node) {
+    const name = localName(node);
+    if (name === 'hyperlink') {
+        return `hyperlink:${node.getAttribute?.('r:id') || attr(node, 'anchor') || ''}`;
+    }
+    if (name === 'fldSimple') return `fldSimple:${attr(node, 'instr').trim()}`;
+    if (name === 'sdt') {
+        const sdtPr = directChild(node, 'sdtPr');
+        return `sdt:${attr(directChild(sdtPr, 'id'), 'val')}:${attr(directChild(sdtPr, 'tag'), 'val')}`;
+    }
+    return `${name}:${attr(node, 'element') || attr(node, 'uri')}`;
+}
+
+/** Visible text and inline wrapper spans of one paragraph in a view. */
+function paragraphContent(paragraph, view) {
+    let text = '';
+    const spans = [];
+    const walk = (node, wrappers) => {
+        for (let child = node.firstChild; child; child = child.nextSibling) {
+            if (!isWordElement(child)) continue;
+            const name = localName(child);
+            if (name === 'pPr') continue;
+            if (view === 'rejected' && (name === 'ins' || name === 'moveTo')) continue;
+            if (view === 'accepted' && (name === 'del' || name === 'moveFrom')) continue;
+            if (name === 'r') {
+                const start = text.length;
+                text += readCanonicalRunText(child, { revisionView: view, boundary: paragraph });
+                if (text.length > start) {
+                    for (const key of wrappers) spans.push({ key, start, end: text.length });
+                }
+                continue;
+            }
+            walk(child, WRAPPER_NAMES.has(name) ? [...wrappers, wrapperKey(child)] : wrappers);
+        }
+    };
+    walk(paragraph, []);
+    return { text, spans };
+}
+
+function mergeSpans(spans) {
+    const byKey = new Map();
+    for (const span of spans) {
+        const list = byKey.get(span.key) || [];
+        const last = list[list.length - 1];
+        if (last && last.end >= span.start) last.end = Math.max(last.end, span.end);
+        else list.push({ ...span });
+        byKey.set(span.key, list);
+    }
+    return [...byKey.values()].flat()
+        .sort((a, b) => a.start - b.start || a.end - b.end || (a.key < b.key ? -1 : 1))
+        .map(span => `${span.key}@${span.start}-${span.end}`);
+}
+
+/**
+ * Projects a document (or any element containing paragraphs) into the paragraph list Word
+ * shows after Reject All (`view: 'rejected'`) or Accept All (`view: 'accepted'`).
+ *
+ * @returns {Array<{ text: string, props: string, numPr: {numId: string|null, ilvl: string}|null,
+ *   wrappers: string[], container: string, sourceIndex: number }>}
+ */
+export function projectWordRevisionView(root, view = 'rejected') {
+    if (view !== 'rejected' && view !== 'accepted') throw new Error(`Unknown revision view '${view}'.`);
+    const paragraphs = descendantWordElements(root, 'p');
+    const removedMark = view === 'rejected' ? 'ins' : 'del';
+    const records = [];
+    const pending = new Map();
+    paragraphs.forEach((paragraph, sourceIndex) => {
+        if (hiddenByStructure(paragraph, view)) return;
+        const container = containerOf(paragraph);
+        const carried = pending.get(container) || null;
+        pending.delete(container);
+        const { text, spans } = paragraphContent(paragraph, view);
+        const offset = carried ? carried.text.length : 0;
+        const merged = {
+            text: (carried?.text || '') + text,
+            spans: [...(carried?.spans || []), ...spans.map(s => ({ ...s, start: s.start + offset, end: s.end + offset }))]
+        };
+        if (paragraphMarkRevision(paragraph) === removedMark) {
+            pending.set(container, { ...merged, paragraph, sourceIndex });
+            return;
+        }
+        records.push(finishRecord(paragraph, merged, view, container, sourceIndex));
+    });
+    // A removed mark on the last paragraph of a container (Word 16 COM evidence,
+    // tests/fixtures/word-revision-semantics/expectations.json): Reject keeps a cell's last
+    // paragraph; otherwise an emptied trailing paragraph disappears and the previous mark becomes
+    // the container's last. Non-empty trailing content is kept (not yet pinned by COM evidence).
+    for (const [container, carried] of pending) {
+        const keepCellParagraph = view === 'rejected' && localName(container) === 'tc';
+        if (!keepCellParagraph && carried.text.length === 0) continue;
+        records.push(finishRecord(carried.paragraph, carried, view, container, carried.sourceIndex));
+    }
+    records.sort((a, b) => a.sourceIndex - b.sourceIndex);
+    appendImplicitBodyParagraphs(root, paragraphs, records);
+    return records;
+}
+
+/** Word adds an untracked empty paragraph after a table that ends a body. */
+function appendImplicitBodyParagraphs(root, paragraphs, records) {
+    const bodies = localName(root) === 'body' ? [root] : descendantWordElements(root, 'body');
+    for (const body of bodies) {
+        const blocks = Array.from(body.childNodes || []).filter(node => isWordElement(node) && localName(node) !== 'sectPr');
+        const last = blocks[blocks.length - 1];
+        if (!last || localName(last) !== 'tbl') continue;
+        records.push({ text: '', props: '', numPr: null, wrappers: [], container: 'body', sourceIndex: paragraphs.length, implicit: true });
+    }
+}
+
+function finishRecord(paragraph, content, view, container, sourceIndex) {
+    const { props, numPr } = viewProperties(paragraph, view);
+    return {
+        text: content.text,
+        props,
+        numPr,
+        wrappers: mergeSpans(content.spans),
+        container: container ? localName(container) : 'root',
+        sourceIndex
+    };
+}
+
+/** Plain text per paragraph after Word Reject All / Accept All. */
+export function wordRevisionParagraphTexts(root, view = 'rejected') {
+    return projectWordRevisionView(root, view).map(record => record.text);
+}

package/core/word-xml.js

@@ -1,118 +1,160 @@
-import { NS_W } from './types.js';
-
-/**
- * Returns true when a node is a WordprocessingML element with the given local name.
- *
- * @param {Node|null|undefined} node - Candidate node
- * @param {string} localName - Word local name, for example `r` or `tbl`
- * @returns {boolean}
- */
-export function isWordElement(node, localName) {
-    if (!node || node.nodeType !== 1) return false;
-    if (node.namespaceURI === NS_W && node.localName === localName) return true;
-    const nodeName = String(node.nodeName || '');
-    return nodeName === `w:${localName}` || nodeName === localName;
-}
-
-/**
- * Creates a WordprocessingML element using namespace-aware DOM APIs when available.
- *
- * @param {Document} xmlDoc - Target document
- * @param {string} qualifiedName - Qualified name, for example `w:r`
- * @returns {Element}
- */
-export function createWordElement(xmlDoc, qualifiedName) {
-    return typeof xmlDoc.createElementNS === 'function'
-        ? xmlDoc.createElementNS(NS_W, qualifiedName)
-        : xmlDoc.createElement(qualifiedName);
-}
-
-function wordElementsByLocalName(xmlDoc, localName) {
-    const namespaced = Array.from(xmlDoc?.getElementsByTagNameNS?.(NS_W, localName) || []);
-    if (namespaced.length > 0) return namespaced;
-    return Array.from(xmlDoc?.getElementsByTagName?.('*') || []).filter(node => isWordElement(node, localName));
-}
-
-// Keep revision discovery and author discovery on the same taxonomy. Cell
-// markers are included for fail-closed detection even though selective
-// acceptance/rejection of those structural revisions is not yet supported.
-const TRACKED_CHANGE_NAMES = [
-    'ins',
-    'del',
-    'moveFrom',
-    'moveTo',
-    'moveFromRangeStart',
-    'moveFromRangeEnd',
-    'moveToRangeStart',
-    'moveToRangeEnd',
-    'rPrChange',
-    'pPrChange',
-    'tblPrChange',
-    'trPrChange',
-    'tcPrChange',
-    'cellIns',
-    'cellDel'
-];
-
-/**
- * Returns true if a document or fragment contains Word tracked-change markup.
- *
- * @param {Document|Element} xmlDoc - Parsed OOXML document or element
- * @returns {boolean}
- */
-export function containsTrackedChanges(xmlDoc) {
-    return TRACKED_CHANGE_NAMES.some(localName => wordElementsByLocalName(xmlDoc, localName).length > 0);
-}
-
-/**
- * Collects all distinct author names from tracked changes in the given XML document or element.
- *
- * @param {Document|Element|null|undefined} xmlDocOrElement
- * @returns {string[]} Sorted unique list of author names.
- */
-export function getTrackedChangeAuthors(xmlDocOrElement) {
-    if (!xmlDocOrElement) return [];
-    const authors = new Set();
-    for (const localName of TRACKED_CHANGE_NAMES) {
-        for (const node of wordElementsByLocalName(xmlDocOrElement, localName)) {
-            const author = node.getAttribute?.('w:author')
-                || node.getAttribute?.('author')
-                || (typeof node.getAttributeNS === 'function' ? node.getAttributeNS(NS_W, 'author') : null);
-            if (author && typeof author === 'string' && author.trim()) {
-                authors.add(author.trim());
-            }
-        }
-    }
-    return [...authors].sort();
-}
-
-/**
- * Classifies the shape of an OOXML payload.
- *
- * @param {string} oxml - OOXML payload
- * @returns {'package'|'document'|'fragment'}
- */
-export function classifyOoxmlSourceType(oxml) {
-    const trimmed = String(oxml || '').trim();
-    if (/^<\?xml\b[^>]*>\s*<pkg:package\b/i.test(trimmed) || /^<pkg:package\b/i.test(trimmed)) {
-        return 'package';
-    }
-    if (/^<\?xml\b[^>]*>\s*<(?:w:)?document\b/i.test(trimmed) || /^<(?:w:)?document\b/i.test(trimmed)) {
-        return 'document';
-    }
-    return 'fragment';
-}
-
-/**
- * Adds `sourceType` metadata to OOXML result objects without changing payloads.
- *
- * @template T
- * @param {T & { oxml?: string, sourceType?: 'package'|'document'|'fragment' }} result - Result object
- * @returns {T & { sourceType?: 'package'|'document'|'fragment' }}
- */
-export function withOoxmlSourceType(result) {
-    if (!result || typeof result !== 'object' || result.sourceType || typeof result.oxml !== 'string') {
-        return result;
-    }
-    return { ...result, sourceType: classifyOoxmlSourceType(result.oxml) };
-}
+import { NS_W } from './types.js';
+
+/**
+ * Returns true when a node is a WordprocessingML element with the given local name.
+ *
+ * @param {Node|null|undefined} node - Candidate node
+ * @param {string} localName - Word local name, for example `r` or `tbl`
+ * @returns {boolean}
+ */
+export function isWordElement(node, localName) {
+    if (!node || node.nodeType !== 1) return false;
+    if (node.namespaceURI === NS_W && node.localName === localName) return true;
+    const nodeName = String(node.nodeName || '');
+    return nodeName === `w:${localName}` || nodeName === localName;
+}
+
+/**
+ * Creates a WordprocessingML element using namespace-aware DOM APIs when available.
+ *
+ * @param {Document} xmlDoc - Target document
+ * @param {string} qualifiedName - Qualified name, for example `w:r`
+ * @returns {Element}
+ */
+export function createWordElement(xmlDoc, qualifiedName) {
+    return typeof xmlDoc.createElementNS === 'function'
+        ? xmlDoc.createElementNS(NS_W, qualifiedName)
+        : xmlDoc.createElement(qualifiedName);
+}
+
+function wordElementsByLocalName(xmlDoc, localName) {
+    const namespaced = Array.from(xmlDoc?.getElementsByTagNameNS?.(NS_W, localName) || []);
+    if (namespaced.length > 0) return namespaced;
+    return Array.from(xmlDoc?.getElementsByTagName?.('*') || []).filter(node => isWordElement(node, localName));
+}
+
+// Keep revision discovery and author discovery on the same taxonomy. Cell
+// markers are included for fail-closed detection even though selective
+// acceptance/rejection of those structural revisions is not yet supported.
+const TRACKED_CHANGE_NAMES = [
+    'ins',
+    'del',
+    'moveFrom',
+    'moveTo',
+    'moveFromRangeStart',
+    'moveFromRangeEnd',
+    'moveToRangeStart',
+    'moveToRangeEnd',
+    'rPrChange',
+    'pPrChange',
+    'tblPrChange',
+    'trPrChange',
+    'tcPrChange',
+    'cellIns',
+    'cellDel'
+];
+
+/**
+ * Returns true if a document or fragment contains Word tracked-change markup.
+ *
+ * @param {Document|Element} xmlDoc - Parsed OOXML document or element
+ * @returns {boolean}
+ */
+export function containsTrackedChanges(xmlDoc) {
+    return TRACKED_CHANGE_NAMES.some(localName => wordElementsByLocalName(xmlDoc, localName).length > 0);
+}
+
+/**
+ * Collects all distinct author names from tracked changes in the given XML document or element.
+ *
+ * @param {Document|Element|null|undefined} xmlDocOrElement
+ * @returns {string[]} Sorted unique list of author names.
+ */
+export function getTrackedChangeAuthors(xmlDocOrElement) {
+    if (!xmlDocOrElement) return [];
+    const authors = new Set();
+    for (const localName of TRACKED_CHANGE_NAMES) {
+        for (const node of wordElementsByLocalName(xmlDocOrElement, localName)) {
+            const author = node.getAttribute?.('w:author')
+                || node.getAttribute?.('author')
+                || (typeof node.getAttributeNS === 'function' ? node.getAttributeNS(NS_W, 'author') : null);
+            if (author && typeof author === 'string' && author.trim()) {
+                authors.add(author.trim());
+            }
+        }
+    }
+    return [...authors].sort();
+}
+
+/**
+ * Classifies the shape of an OOXML payload.
+ *
+ * @param {string} oxml - OOXML payload
+ * @returns {'package'|'document'|'fragment'}
+ */
+export function classifyOoxmlSourceType(oxml) {
+    const trimmed = String(oxml || '').trim();
+    if (/^<\?xml\b[^>]*>\s*<pkg:package\b/i.test(trimmed) || /^<pkg:package\b/i.test(trimmed)) {
+        return 'package';
+    }
+    if (/^<\?xml\b[^>]*>\s*<(?:w:)?document\b/i.test(trimmed) || /^<(?:w:)?document\b/i.test(trimmed)) {
+        return 'document';
+    }
+    return 'fragment';
+}
+
+/**
+ * Adds `sourceType` metadata to OOXML result objects without changing payloads.
+ *
+ * @template T
+ * @param {T & { oxml?: string, sourceType?: 'package'|'document'|'fragment' }} result - Result object
+ * @returns {T & { sourceType?: 'package'|'document'|'fragment' }}
+ */
+export function withOoxmlSourceType(result) {
+    if (!result || typeof result !== 'object' || result.sourceType || typeof result.oxml !== 'string') {
+        return result;
+    }
+    return { ...result, sourceType: classifyOoxmlSourceType(result.oxml) };
+}
+
+/**
+ * Returns true if any tracked change in the node lacks a non-blank author.
+ * Same-author checks treat such a revision as another reviewer's, because
+ * `getTrackedChangeAuthors` omits it.
+ *
+ * @param {Document|Element|null|undefined} node
+ * @returns {boolean}
+ */
+export function hasUnattributedTrackedChange(node) {
+    if (!node) return false;
+    for (const localName of TRACKED_CHANGE_NAMES) {
+        for (const change of wordElementsByLocalName(node, localName)) {
+            const author = change.getAttribute?.('w:author')
+                || change.getAttribute?.('author')
+                || (typeof change.getAttributeNS === 'function' ? change.getAttributeNS(NS_W, 'author') : null);
+            if (!author || !String(author).trim()) return true;
+        }
+    }
+    return false;
+}
+
+/**
+ * Resolves `existingRevisions: 'auto'` for one target. A target without tracked
+ * changes, or whose changes are all by `author`, merges same-author history;
+ * any other or unattributed reviewer's change selects 'slice-cross-author',
+ * which preserves that history. Other policies are returned unchanged.
+ * @param {string|null|undefined} policy
+ * @param {Node|Array<Node>} node - target paragraph, scope element or document, or every paragraph of a range
+ * @param {string} author
+ * @returns {string|null|undefined}
+ */
+export function resolveExistingRevisionsPolicy(policy, node, author) {
+    if (policy !== 'auto') return policy;
+    const nodes = (Array.isArray(node) ? node : [node]).filter(Boolean);
+    const own = String(author || '').trim().toLowerCase();
+    const foreign = nodes.some(item => containsTrackedChanges(item) && (
+        hasUnattributedTrackedChange(item)
+        || getTrackedChangeAuthors(item).some(name => name.trim().toLowerCase() !== own)
+    ));
+    return foreign ? 'slice-cross-author' : 'merge-same-author';
+}