@ansonlai/docx-redline-js 0.5.2 → 0.5.4

package/node/docx-document.js

@@ -5,7 +5,8 @@ import { inspectDocumentParts } from '../services/document-inspection.js';
 import { applyOperationsToDocumentXml, preflightOperations } from '../services/standalone-operation-runner.js';
 import { createDynamicNumberingIdState, mergeNumberingXmlBySchemaOrder } from '../services/numbering-helpers.js';
 import { ensureCommentsArtifactsInZip, ensureCommentsExtendedArtifactsInZip, ensureNumberingArtifactsInZip, validateDocxPackage } from '../services/standalone-docx-plumbing.js';
-import { validateRedlineOoxml } from '../core/redline-validation.js';
+import { validateRedlineOoxml } from '../core/redline-validation.js';
+import { subtractValidationIssueMultiset, validationErrors } from '../core/validation-delta.js';
 import { acceptTrackedChangesInOoxml, rejectTrackedChangesInOoxml, deleteCommentsByAuthorInOoxml } from '../services/revision-comment-management.js';
 import { createSerializer, parseOoxmlSafe } from '../adapters/xml-adapter.js';
 import { createHash } from 'node:crypto';
@@ -176,19 +177,21 @@ export class DocxDocument {
             await ensureCommentsExtendedArtifactsInZip(zip, commentsExtendedXmlForPackaging, {
                 replaceExisting: result.commentsExtendedXmlMode === 'replace' || (!result.commentsExtendedXml && !!existingCommentsExtendedXml)
             });
-            if (options.validate !== false) {
-                const generated = validateRedlineOoxml(result.documentXml);
-                const baselineErrors = new Set(baseline.issues.filter(i => i.severity === 'error').map(i => `${i.code}:${i.message}`));
-                const introduced = generated.issues.filter(i => i.severity === 'error' && !baselineErrors.has(`${i.code}:${i.message}`));
-                if (introduced.length) {
-                    const codes = [...new Set(introduced.map(issue => issue.code))].join(', ');
-                    throw Object.assign(
-                        new Error(`Applied operations introduced invalid revision markup (${codes}); these are generated-output issues, not pre-existing input issues.`),
-                        { issues: introduced }
-                    );
-                }
-                await validateDocxPackage(zip);
-            }
+            if (options.validate !== false) {
+                const generated = validateRedlineOoxml(result.documentXml);
+                const outputIssues = generated.issues.map(issue => ({ source: 'word/document.xml', ...issue }));
+                try { await validateDocxPackage(zip); }
+                catch (error) { outputIssues.push({ source: 'package', code: 'PACKAGE_VALIDATION', severity: 'error', message: error.message }); }
+                const introduced = subtractValidationIssueMultiset(outputIssues, originalIssues);
+                const introducedErrors = validationErrors(introduced);
+                if (introducedErrors.length) {
+                    const codes = [...new Set(introducedErrors.map(issue => issue.code))].join(', ');
+                    throw Object.assign(
+                        new Error(`Applied operations introduced invalid revision markup (${codes}); these are generated-output issues, not pre-existing input issues.`),
+                        { issues: introducedErrors }
+                    );
+                }
+            }
             this.entries = working;
             const output = this.toBuffer();
             this.originalBuffer = Buffer.from(output);

package/package.json

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

package/pipeline/diff-engine.js

@@ -232,6 +232,21 @@ export function computeWordDiffs(originalText, newText, options = {}) {
     return decodeBmpDiffs(charDiffs, wordArray);
 }
 
+/**
+ * Computes a character-local diff without semantic cleanup. This is used to
+ * refine whitespace-only substitutions that a word-level token groups with
+ * adjacent unchanged content (for example, an NBSP beside a hyperlink).
+ *
+ * @param {string} originalText
+ * @param {string} newText
+ * @param {{ diffTimeoutSeconds?: number }} [options={}]
+ * @returns {Array<[number, string]>}
+ */
+export function computeCharacterDiffs(originalText, newText, options = {}) {
+    if (originalText === newText) return [[0, originalText]];
+    return createDiffEngine(options).diff_main(originalText, newText);
+}
+
 /**
  * Returns a character-local diff only when the modified string can be made
  * solely by inserting into the original. This prevents word-token cleanup

package/services/document-operation-applier.js

@@ -1,5 +1,5 @@
 import { getDefaultAuthor } from '../adapters/config.js';
-import {
+import {
     normalizeDocumentOperation,
     resolveDocumentOperationAuthor,
     validateDocumentOperation
@@ -14,8 +14,10 @@ import {
     applyCommentToParagraphByExactText,
     applyFormattingToParagraphByExactText,
     applyHighlightToParagraphByExactText,
-    applyParagraphFormatToParagraphByExactText,
-    applyToParagraphByExactText
+    applyParagraphFormatToParagraphByExactText,
+    insertIntoRejectedDeletedText,
+    restoreDeletedParagraphByExactText,
+    applyToParagraphByExactText
 } from './document-operation-mutations.js';
 import { applyCommentReplyToParts } from './comment-replies.js';
 import {
@@ -25,7 +27,9 @@ import {
 import {
     createEmptyReceipt,
     reconcileReceiptsAgainstOutput
-} from './receipt-collector.js';
+} from './receipt-collector.js';
+import { validateRedlineOoxml } from '../core/redline-validation.js';
+import { subtractValidationIssueMultiset, validationErrors } from '../core/validation-delta.js';
 
 export function normalizeOperationError(error) {
     return {
@@ -58,7 +62,15 @@ export async function applyOperationToDocumentXml(documentXml, op, author, runti
     const operation = validation.operation || normalizeDocumentOperation(op);
     const authorUsed = resolveDocumentOperationAuthor(operation, author, getDefaultAuthor());
 
-    if (operation.operationKind !== 'comment_reply' && operation.targetDescriptor?.revisionView === 'rejected') {
+    if (
+        operation.operationKind !== 'comment_reply'
+        && operation.operationKind !== 'rejected-insert'
+        && operation.operationKind !== 'restore'
+        && (
+            operation.targetDescriptor?.revisionView === 'rejected'
+            || operation.targetEndDescriptor?.revisionView === 'rejected'
+        )
+    ) {
         return {
             documentXml,
             hasChanges: false,
@@ -159,7 +171,8 @@ export async function applyOperationToDocumentXml(documentXml, op, author, runti
         pairReplacements: typeof operation.pairReplacements === 'boolean' ? operation.pairReplacements : (options.pairReplacements !== false),
         ...(operation.insertionAffinity ? { insertionAffinity: operation.insertionAffinity } : {}),
         ...(operation.formattingRevisionPolicy ? { formattingRevisionPolicy: operation.formattingRevisionPolicy } : {}),
-        targetDescriptor: operation.targetDescriptor,
+        targetDescriptor: operation.targetDescriptor,
+        targetEndDescriptor: operation.targetEndDescriptor,
         _resolutionCapture: resolutionCapture,
         _revisionIdAllocator: session.revisionIdAllocator,
         _documentOperationSession: session,
@@ -242,7 +255,29 @@ export async function applyOperationToDocumentXml(documentXml, op, author, runti
                 runtimeContext,
                 operationOptions
             );
-        } else {
+        } else if (operation.operationKind === 'rejected-insert') {
+            result = await insertIntoRejectedDeletedText(
+                documentXml,
+                operation.target,
+                operation.anchor,
+                operation.modified,
+                authorUsed,
+                operation.targetRef,
+                runtimeContext,
+                operationOptions
+            );
+        } else if (operation.operationKind === 'restore') {
+            result = await restoreDeletedParagraphByExactText(
+                documentXml,
+                operation.target,
+                operation.modified,
+                authorUsed,
+                operation.targetRef,
+                operation.targetEndRef,
+                runtimeContext,
+                operationOptions
+            );
+        } else {
             result = await applyToParagraphByExactText(
                 documentXml,
                 operation.target,
@@ -292,8 +327,37 @@ export async function applyOperationToDocumentXml(documentXml, op, author, runti
                     operationReceipt.warnings.push(String(w));
                 }
             }
-        } else {
-            session.markMutationCommitted(operation.operationKind !== 'comment_reply');
+        } else {
+            const beforeValidation = validateRedlineOoxml(savepoint.document);
+            const afterValidation = validateRedlineOoxml(session.document);
+            const generatedIssues = subtractValidationIssueMultiset(afterValidation.issues, beforeValidation.issues);
+            const generatedErrors = validationErrors(generatedIssues);
+            if (generatedErrors.length > 0) {
+                session.restoreSavepoint(savepoint);
+                operationReceipt = createEmptyReceipt(
+                    operationIndex,
+                    operation.operationId,
+                    authorUsed,
+                    'refused'
+                );
+                const codes = [...new Set(generatedErrors.map(issue => issue.code))].join(', ');
+                return {
+                    documentXml,
+                    hasChanges: false,
+                    status: 'error',
+                    error: {
+                        code: 'GENERATED_OOXML_INVALID',
+                        stage: 'validation',
+                        message: `Operation introduced invalid OOXML (${codes}).`,
+                        generatedIssues: generatedErrors
+                    },
+                    operationType: operation.operationKind,
+                    authorUsed,
+                    receipt: operationReceipt,
+                    ...resolutionCapture
+                };
+            }
+            session.markMutationCommitted(operation.operationKind !== 'comment_reply');
             if (operation.captureKey && session.captureTable) {
                 session.captureTable.set(
                     operation.captureKey,

package/services/document-operation-contract.js

@@ -14,6 +14,7 @@ const SUPPORTED_OPERATION_TYPES = new Set([
     'list-change',
     'table-reconciliation',
     'insert',
+    'restore',
     'delete',
     'comment',
     'comment_reply',
@@ -42,6 +43,8 @@ function nonEmptyString(value) {
 
 export function getCanonicalOperationType(operation) {
     const type = operation?.type;
+    if (type === 'insert' && operation?.target?.revisionView === 'rejected') return 'rejected-insert';
+    if (type === 'restore') return 'restore';
     if (type === 'comment' || type === 'comment_reply' || type === 'highlight') return type;
     if (type === 'paragraph-format') return 'paragraph-format';
     if (type === 'character-format' || (type === 'format' && (operation?.textToFormat != null || operation?.properties != null))) return 'format';
@@ -83,7 +86,7 @@ export function normalizeTargetDescriptor(target, legacyTargetRef = null) {
 export function normalizeDocumentOperation(operation) {
     const source = isRecord(operation) ? operation : {};
     const targetDescriptor = normalizeTargetDescriptor(source.target, source.targetRef);
-    const targetEndDescriptor = isRecord(source.targetEnd)
+    const targetEndDescriptor = source.targetEnd != null
         ? normalizeTargetDescriptor(source.targetEnd, source.targetEndRef)
         : null;
     const kind = getCanonicalOperationType(source);
@@ -93,7 +96,14 @@ export function normalizeDocumentOperation(operation) {
         operationId: nonEmptyString(source.operationId) ? source.operationId.trim() : null,
         captureKey: nonEmptyString(source.captureKey) ? source.captureKey.trim() : null,
         operationKind: kind,
+        anchor: isRecord(source.anchor) ? {
+            exactText: typeof source.anchor.exactText === 'string' ? source.anchor.exactText : '',
+            occurrence: Number.isInteger(source.anchor.occurrence) && source.anchor.occurrence > 0 ? source.anchor.occurrence : 1,
+            occurrenceExplicit: Number.isInteger(source.anchor.occurrence) && source.anchor.occurrence > 0,
+            offset: Number.isInteger(source.anchor.offset) ? source.anchor.offset : null
+        } : null,
         targetDescriptor,
+        targetEndDescriptor,
         target: targetDescriptor.text,
         targetRef: targetDescriptor.index,
         targetEndRef: targetEndDescriptor?.index ?? source.targetEndRef ?? null,
@@ -174,7 +184,14 @@ export function validateDocumentOperation(operation) {
     }
 
     const target = normalized.targetDescriptor;
-    if (normalized.operationKind !== 'comment_reply' && !nonEmptyString(target.text) && target.index == null && !target.paragraphId && !target.captureRef) {
+    if (
+        normalized.operationKind !== 'comment_reply'
+        && !nonEmptyString(target.text)
+        && target.index == null
+        && !target.paragraphId
+        && !target.fingerprint
+        && !target.captureRef
+    ) {
         return {
             valid: false,
             error: {
@@ -201,6 +218,64 @@ export function validateDocumentOperation(operation) {
         };
     }
 
+    if (normalized.operationKind === 'rejected-insert') {
+        if (!nonEmptyString(normalized.modified)) {
+            return {
+                valid: false,
+                error: { code: 'INVALID_OPERATION', message: 'Rejected-view insert operations require non-empty string "modified" text.' }
+            };
+        }
+        if (
+            !normalized.anchor
+            || !nonEmptyString(normalized.anchor.exactText)
+            || !Number.isInteger(normalized.anchor.offset)
+            || normalized.anchor.offset < 0
+            || normalized.anchor.offset > normalized.anchor.exactText.length
+        ) {
+            return {
+                valid: false,
+                error: {
+                    code: 'INVALID_OPERATION',
+                    message: 'Rejected-view insert operations require anchor.exactText, a positive occurrence, and an offset within the anchor text.'
+                }
+            };
+        }
+        if (normalized.existingRevisions !== 'slice-cross-author') {
+            return {
+                valid: false,
+                error: {
+                    code: 'INVALID_OPERATION',
+                    message: 'Rejected-view insert operations require existingRevisions: "slice-cross-author".'
+                }
+            };
+        }
+    }
+
+    if (normalized.operationKind === 'restore') {
+        const validSingle = nonEmptyString(normalized.modified);
+        const validRange = Array.isArray(normalized.modified)
+            && normalized.modified.length > 0
+            && normalized.modified.every(nonEmptyString);
+        if (!validSingle && !validRange) {
+            return {
+                valid: false,
+                error: {
+                    code: 'INVALID_OPERATION',
+                    message: 'Restore operations require a non-empty string or non-empty string array in "modified".'
+                }
+            };
+        }
+        if (normalized.generateRedlines === false) {
+            return {
+                valid: false,
+                error: {
+                    code: 'INVALID_OPERATION',
+                    message: 'Restore operations require tracked changes and cannot set generateRedlines to false.'
+                }
+            };
+        }
+    }
+
     if (normalized.structuredContent != null && typeof normalized.structuredContent !== 'boolean') {
         return {
             valid: false,