@ansonlai/docx-redline-js 0.9.0 → 0.10.0

package/services/inspection-comparison.js

@@ -0,0 +1,82 @@
+/**
+ * Compares two `inspectDocumentParts` results by what a reader and reviewer see:
+ * paragraph text, table position, list label, review segments and comments.
+ *
+ * A host that writes a prepared package uses this to verify what it committed
+ * against what was prepared. Revision ids, dates, rsids, paragraph ids and
+ * run boundaries are ignored, because hosts regenerate them on write.
+ */
+
+const commentIdentity = comment => [comment.author ?? null, comment.text ?? '', comment.anchoredText || ''];
+
+// Adjacent review segments of one kind and author are one change, however the
+// host split the runs.
+function reviewSegments(segments = []) {
+    return segments.filter(segment => segment.kind !== 'baseline').reduce((result, segment) => {
+        const next = {
+            kind: segment.kind, author: segment.author || null, text: segment.text,
+            acceptedStart: segment.acceptedStart ?? null, rejectedStart: segment.rejectedStart ?? null
+        };
+        const previous = result.at(-1);
+        const adjacent = key => (previous[key] == null && next[key] == null)
+            || (previous[key] != null && previous[key] + previous.text.length === next[key]);
+        if (previous && previous.kind === next.kind && previous.author === next.author
+            && adjacent('acceptedStart') && adjacent('rejectedStart')) previous.text += next.text;
+        else result.push(next);
+        return result;
+    }, []);
+}
+
+/**
+ * The host-independent shape of one inspection.
+ * @param {{ paragraphs: Array<object>, comments?: Array<object> }} inspection
+ */
+export function inspectionReviewShape(inspection) {
+    const comments = inspection?.comments || [];
+    return {
+        paragraphs: (inspection?.paragraphs || []).map(paragraph => ({
+            text: paragraph.exactText,
+            inTable: paragraph.inTable === true,
+            table: paragraph.table ? [paragraph.table.rowIndex, paragraph.table.cellIndex] : null,
+            list: paragraph.list ? [paragraph.list.format, paragraph.list.level, paragraph.list.label] : null,
+            review: {
+                present: paragraph.hasRevisions === true,
+                authors: [...(paragraph.revisionAuthors || [])].sort(),
+                segments: reviewSegments(paragraph.segments)
+            }
+        })),
+        comments: comments.map(comment => {
+            const parent = comment.parentCommentId != null
+                ? comments.find(item => String(item.id) === String(comment.parentCommentId))
+                : null;
+            return [...commentIdentity(comment), comment.done === true,
+                parent ? commentIdentity(parent)
+                    : (comment.parentCommentId != null || comment.parentParaId ? 'unresolved parent' : null)];
+        }).map(item => JSON.stringify(item)).sort()
+    };
+}
+
+/**
+ * @param {{ paragraphs: Array<object>, comments?: Array<object> }} expected - e.g. inspection of the prepared package
+ * @param {{ paragraphs: Array<object>, comments?: Array<object> }} actual - e.g. inspection of what the host committed
+ * @returns {{ matches: boolean, differences: Array<{ path: string, expected: any, actual: any }> }}
+ *   `differences` lists at most the first ten mismatches.
+ */
+export function compareDocumentInspections(expected, actual) {
+    const left = inspectionReviewShape(expected);
+    const right = inspectionReviewShape(actual);
+    const differences = [];
+    const note = (path, a, b) => {
+        if (differences.length < 10 && JSON.stringify(a) !== JSON.stringify(b)) differences.push({ path, expected: a, actual: b });
+    };
+    note('paragraphs.length', left.paragraphs.length, right.paragraphs.length);
+    const count = Math.max(left.paragraphs.length, right.paragraphs.length);
+    for (let index = 0; index < count; index++) {
+        const a = left.paragraphs[index] ?? null;
+        const b = right.paragraphs[index] ?? null;
+        if (!a || !b) { note(`paragraphs[${index}]`, a, b); continue; }
+        for (const key of ['text', 'inTable', 'table', 'list', 'review']) note(`paragraphs[${index}].${key}`, a[key], b[key]);
+    }
+    note('comments', left.comments, right.comments);
+    return { matches: differences.length === 0, differences };
+}

package/services/operation-preflight.js

@@ -4,7 +4,7 @@
 
 import { parseOoxmlSafe } from '../adapters/xml-adapter.js';
 import { getDefaultAuthor } from '../adapters/config.js';
-import { containsTrackedChanges, getTrackedChangeAuthors } from '../core/word-xml.js';
+import { containsTrackedChanges, getTrackedChangeAuthors, hasUnattributedTrackedChange, resolveExistingRevisionsPolicy } from '../core/word-xml.js';
 import { NS_W } from '../core/types.js';
 import { extractCanonicalParagraphText } from '../core/paragraph-text.js';
 import {
@@ -273,42 +273,49 @@ export function preflightOperations(documentXml, operations, author, options = {
                 : null;
             const anchorFound = anchor == null
                 || (anchorResolution ? anchorResolution.found : paragraphText.includes(anchor));
+            // The paragraphs from the target through targetEnd (just the target without one); null when the
+            // end does not resolve after the start.
+            const rangeParagraphs = opType => {
+                if (operation.targetEndRef) {
+                    return resolveParagraphRangeByRefs(xmlDoc, operation.targetRef, operation.targetEndRef, {
+                        opType,
+                        targetRefSnapshot: options.targetRefSnapshot || null,
+                        onInfo: options.onInfo,
+                        onWarn: options.onWarn
+                    });
+                }
+                if (!operation.targetEndDescriptor) return [paragraph];
+                const endResolved = resolveTargetParagraph(xmlDoc, {
+                    targetText: operation.targetEndDescriptor.text,
+                    targetRef: operation.targetEndDescriptor.index,
+                    targetDescriptor: operation.targetEndDescriptor,
+                    opType,
+                    strictAmbiguity: strictTargets,
+                    paragraphMetadataIndex: currentMetadataIndex,
+                    metadataIndices,
+                    onInfo: options.onInfo,
+                    onWarn: options.onWarn
+                });
+                const allParagraphs = getDocumentParagraphNodes(xmlDoc);
+                const startIndex = allParagraphs.indexOf(paragraph);
+                const endIndex = allParagraphs.indexOf(endResolved?.paragraph);
+                return startIndex >= 0 && endIndex >= startIndex
+                    ? allParagraphs.slice(startIndex, endIndex + 1)
+                    : null;
+            };
             const hasRevisions = containsTrackedChanges(paragraph);
-            const existingPolicy = operation.existingRevisions
-                || options.existingRevisions
-                || 'merge-same-author';
+            const requestedPolicy = operation.existingRevisions || options.existingRevisions || 'merge-same-author';
+            const existingPolicy = resolveExistingRevisionsPolicy(requestedPolicy,
+                requestedPolicy === 'auto' && operation.operationKind === 'redline' && (operation.targetEndRef || operation.targetEndDescriptor)
+                    ? (rangeParagraphs('redline') || paragraph)
+                    : paragraph,
+                authorUsed);
             const deletingWholeParagraph = operation.operationKind === 'redline' && operation.modified === '';
             const commentIds = deletingWholeParagraph ? getCommentIdsInParagraph(paragraph) : [];
 
             let error = null;
             if (operation.operationKind === 'restore') {
-                let restorationParagraphs = operation.targetEndRef
-                    ? resolveParagraphRangeByRefs(xmlDoc, operation.targetRef, operation.targetEndRef, {
-                        opType: 'restore',
-                        targetRefSnapshot: options.targetRefSnapshot || null,
-                        onInfo: options.onInfo,
-                        onWarn: options.onWarn
-                    })
-                    : [paragraph];
-                if (!operation.targetEndRef && operation.targetEndDescriptor) {
-                    const endResolved = resolveTargetParagraph(xmlDoc, {
-                        targetText: operation.targetEndDescriptor.text,
-                        targetRef: operation.targetEndDescriptor.index,
-                        targetDescriptor: operation.targetEndDescriptor,
-                        opType: 'restore',
-                        strictAmbiguity: strictTargets,
-                        paragraphMetadataIndex: currentMetadataIndex,
-                        metadataIndices,
-                        onInfo: options.onInfo,
-                        onWarn: options.onWarn
-                    });
-                    const allParagraphs = getDocumentParagraphNodes(xmlDoc);
-                    const startIndex = allParagraphs.indexOf(paragraph);
-                    const endIndex = allParagraphs.indexOf(endResolved?.paragraph);
-                    restorationParagraphs = startIndex >= 0 && endIndex >= startIndex
-                        ? allParagraphs.slice(startIndex, endIndex + 1)
-                        : null;
-                }
+                const restorationParagraphs = rangeParagraphs('restore');
                 const replacements = Array.isArray(operation.modified) ? operation.modified : [operation.modified];
                 if (!restorationParagraphs || restorationParagraphs[0] !== paragraph || replacements.length !== restorationParagraphs.length) {
                     error = {
@@ -364,11 +371,13 @@ export function preflightOperations(documentXml, operations, author, options = {
                 if (existingPolicy === 'merge-same-author' || existingPolicy === 'slice-cross-author') {
                     const authors = getTrackedChangeAuthors(paragraph);
                     const opAuthor = String(authorUsed || '').trim().toLowerCase();
-                    const allSame = authors.length > 0 && authors.every(a => a.trim().toLowerCase() === opAuthor);
+                    const allSame = authors.length > 0
+                        && !hasUnattributedTrackedChange(paragraph)
+                        && authors.every(a => a.trim().toLowerCase() === opAuthor);
                     if (!allSame && existingPolicy === 'merge-same-author') {
                         error = {
                             code: 'EXISTING_REVISIONS',
-                            message: `Target paragraph contains tracked changes from another author (${authors.length ? authors.join(', ') : 'unattributed'}). Use existingRevisions: "slice-cross-author" for a surgical edit that preserves reviewer history; accepting or rejecting revisions requires separate authorization.`,
+                            message: `Target paragraph contains tracked changes from another author (${[...authors, ...(hasUnattributedTrackedChange(paragraph) ? ['unattributed'] : [])].join(', ')}). Use existingRevisions: "slice-cross-author" for a surgical edit that preserves reviewer history; accepting or rejecting revisions requires separate authorization.`,
                             revisionAuthors: authors,
                             currentPolicy: existingPolicy
                         };

package/services/revision-fidelity-verifier.js

@@ -200,15 +200,15 @@ function parseNumberingDefinitions(text) {
     const cached = numberingDefinitionCache.get(text);
     if (cached) return cached;
     const abstractLevels = new Map();
-    for (const match of text.matchAll(/<(?:\w+:)?abstractNum([^>]*)>([\s\S]*?)<\/(?:\w+:)?abstractNum>/g)) {
+    for (const match of text.matchAll(/<(?:\w+:)?abstractNum\b([^>]*)>([\s\S]*?)<\/(?:\w+:)?abstractNum>/g)) {
         const id = /abstractNumId="([^"]*)"/.exec(match[1])?.[1];
         if (id == null) continue;
         const levels = abstractLevels.get(id) || new Set();
-        for (const lvl of match[2].matchAll(/<(?:\w+:)?lvl[^>]*?ilvl="([^"]*)"/g)) levels.add(lvl[1]);
+        for (const lvl of match[2].matchAll(/<(?:\w+:)?lvl\b[^>]*?ilvl="([^"]*)"/g)) levels.add(lvl[1]);
         abstractLevels.set(id, levels);
     }
     const numToAbstract = new Map();
-    for (const match of text.matchAll(/<(?:\w+:)?num([^>]*)>([\s\S]*?)<\/(?:\w+:)?num>/g)) {
+    for (const match of text.matchAll(/<(?:\w+:)?num\b([^>]*)>([\s\S]*?)<\/(?:\w+:)?num>/g)) {
         const id = /numId="([^"]*)"/.exec(match[1])?.[1];
         const abstractId = /abstractNumId[^>]*?val="([^"]*)"/.exec(match[2])?.[1];
         if (id != null && abstractId != null) numToAbstract.set(id, abstractId);
@@ -231,7 +231,7 @@ function parseNumberingDefinitions(text) {
  * @param {Document} input.after - post-mutation DOM
  * @param {Array<string|null|undefined>} input.numberingXmls - numbering part texts available at the seam
  */
-export function verifyNumberingReferences({ before, after, numberingXmls, beforeViews = null, afterViews = null }) {
+export function verifyNumberingReferences({ before, after, numberingXmls }) {
     const references = documentNode => {
         const found = new Map();
         for (const numIdNode of getAllReferencedNumIdElements(documentNode)) {
@@ -247,21 +247,7 @@ export function verifyNumberingReferences({ before, after, numberingXmls, before
     const used = references(after);
     if (used.size === 0) return { ok: true };
     const known = references(before);
-    const text = (numberingXmls || []).filter(Boolean).join('\n');
-    const abstractLevels = new Map();
-    for (const match of text.matchAll(/<(?:\w+:)?abstractNum\b([^>]*)>([\s\S]*?)<\/(?:\w+:)?abstractNum>/g)) {
-        const id = /abstractNumId="([^"]*)"/.exec(match[1])?.[1];
-        if (id == null) continue;
-        const levels = abstractLevels.get(id) || new Set();
-        for (const lvl of match[2].matchAll(/<(?:\w+:)?lvl\b[^>]*?ilvl="([^"]*)"/g)) levels.add(lvl[1]);
-        abstractLevels.set(id, levels);
-    }
-    const numToAbstract = new Map();
-    for (const match of text.matchAll(/<(?:\w+:)?num\b([^>]*)>([\s\S]*?)<\/(?:\w+:)?num>/g)) {
-        const id = /numId="([^"]*)"/.exec(match[1])?.[1];
-        const abstractId = /abstractNumId[^>]*?val="([^"]*)"/.exec(match[2])?.[1];
-        if (id != null && abstractId != null) numToAbstract.set(id, abstractId);
-    }
+    const { abstractLevels, numToAbstract } = parseNumberingDefinitions((numberingXmls || []).filter(Boolean).join('\n'));
     const violations = [];
     for (const [numId, levels] of used) {
         if (known.has(numId)) continue;