@ansonlai/docx-redline-js 0.5.2 → 0.5.4

package/services/operation-preflight.js

@@ -6,15 +6,20 @@ import { parseOoxmlSafe } from '../adapters/xml-adapter.js';
 import { getDefaultAuthor } from '../adapters/config.js';
 import { containsTrackedChanges, getTrackedChangeAuthors } from '../core/word-xml.js';
 import { NS_W } from '../core/types.js';
-import { extractCanonicalParagraphText } from '../core/paragraph-text.js';
+import { extractCanonicalParagraphText } from '../core/paragraph-text.js';
+import {
+    getParagraphRestorationRefusal,
+    inspectForeignDeletedParagraphTarget
+} from '../core/paragraph-revision-safety.js';
 import {
     buildParagraphMetadataIndex,
     createParagraphFingerprint,
     findContainingWordElement,
     getDocumentParagraphNodes,
     getParagraphId,
-    normalizeWhitespaceForTargeting,
-    resolveTargetParagraph,
+    normalizeWhitespaceForTargeting,
+    resolveParagraphRangeByRefs,
+    resolveTargetParagraph,
     validateParagraphBoundaryMutation
 } from '../core/paragraph-targeting.js';
 import { createParagraphTextIndex, resolveTextInParagraphIndex } from './comment-locator.js';
@@ -219,10 +224,69 @@ export function preflightOperations(documentXml, operations, author, options = {
                 || options.existingRevisions
                 || 'merge-same-author';
             const deletingWholeParagraph = operation.operationKind === 'redline' && operation.modified === '';
-            const commentIds = deletingWholeParagraph ? getCommentIdsInParagraph(paragraph) : [];
-
-            let error = null;
-            if (!anchorFound) {
+            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 replacements = Array.isArray(operation.modified) ? operation.modified : [operation.modified];
+                if (!restorationParagraphs || restorationParagraphs[0] !== paragraph || replacements.length !== restorationParagraphs.length) {
+                    error = {
+                        code: 'RESTORATION_COUNT_MISMATCH',
+                        message: 'Restoration requires one replacement for every paragraph in a contiguous resolved range.'
+                    };
+                } else {
+                    for (const restorationParagraph of restorationParagraphs) {
+                        const structuralRefusal = getParagraphRestorationRefusal(restorationParagraph);
+                        if (structuralRefusal?.code === 'UNSUPPORTED_MOVE_REVISION') {
+                            error = structuralRefusal;
+                            break;
+                        }
+                        const state = inspectForeignDeletedParagraphTarget(restorationParagraph, authorUsed);
+                        const refusal = state.matches
+                            ? (structuralRefusal || getParagraphRestorationRefusal(restorationParagraph))
+                            : null;
+                        if (!state.matches) {
+                            error = {
+                                code: 'RESTORATION_STATE_REQUIRED',
+                                message: 'Explicit restoration requires a foreign paragraph-mark deletion with every pre-existing content node deleted.',
+                                ...(state.ownerAuthor ? { ownerAuthor: state.ownerAuthor } : {})
+                            };
+                            break;
+                        }
+                        if (refusal) {
+                            error = refusal;
+                            break;
+                        }
+                    }
+                }
+            } else if (!anchorFound) {
                 error = anchorResolution?.error || {
                     code: 'ANCHOR_NOT_FOUND',
                     message: `Anchor text was not found in target paragraph: "${anchor}".`
@@ -354,7 +418,7 @@ export function preflightOperations(documentXml, operations, author, options = {
     }
 
     for (const [targetIndex, targetResults] of byTarget) {
-        const redlines = targetResults.filter(result => result.operationType === 'redline');
+        const redlines = targetResults.filter(result => ['redline', 'restore', 'rejected-insert'].includes(result.operationType));
         const highlights = targetResults.filter(result => result.operationType === 'highlight');
         const target = targetResults[0].resolvedTarget;
         if (redlines.length > 1) {

package/services/standalone-operation-runner.d.ts

@@ -23,6 +23,12 @@ export interface InsertionAffinity {
   comment?: 'inside' | 'outside';
 }
 
+export interface RejectedTextInsertionAnchor {
+  exactText: string;
+  occurrence?: number;
+  offset: number;
+}
+
 export interface DocumentOperationBase {
   operationId?: string;
   captureKey?: string;
@@ -41,6 +47,15 @@ export interface RedlineDocumentOperation extends DocumentOperationBase {
   structuredContent?: boolean;
   targetEnd?: ParagraphTargetDescriptor;
   targetEndRef?: number | string | null;
+  /** Required when type is insert and target.revisionView is rejected. */
+  anchor?: RejectedTextInsertionAnchor;
+}
+
+export interface RestoreDocumentOperation extends DocumentOperationBase {
+  type: 'restore';
+  modified: string | string[];
+  targetEnd?: ParagraphTargetDescriptor;
+  targetEndRef?: number | string | null;
 }
 
 export interface DeleteDocumentOperation extends DocumentOperationBase {
@@ -103,6 +118,7 @@ export interface ParagraphFormatDocumentOperation extends DocumentOperationBase
 
 export type DocumentOperation =
   | RedlineDocumentOperation
+  | RestoreDocumentOperation
   | DeleteDocumentOperation
   | CommentDocumentOperation
   | CommentReplyDocumentOperation
@@ -116,6 +132,16 @@ export interface ResolvedDocumentTarget {
   text: string;
   fingerprint?: string;
   inTable?: boolean;
+  targetTextMatch?: {
+    mode: 'exact' | 'space_equivalent' | 'normalized';
+    differences?: Array<{
+      offset: number;
+      sourceCodePoint: string;
+      requestedCodePoint: string;
+    }>;
+    sourceExcerpt?: string;
+    requestedExcerpt?: string;
+  };
 }
 
 export interface ResolvedCommentAnchor {