@ansonlai/docx-redline-js 0.7.0 → 0.7.2

package/services/document-operation-mutations.js

@@ -223,7 +223,37 @@ function describeTargetTextMatch(actualText, requestedText) {
         requestedExcerpt: escapeInvisibleText(requested)
     };
 }
-
+
+function resolvedTargetDiagnostics(xmlDoc, paragraph, metadata, targetText, options) {
+    const revisionView = options?.targetDescriptor?.revisionView === 'rejected'
+        ? 'rejected'
+        : 'accepted';
+    const viewMetadata = metadata?.revisionView === revisionView ? metadata : null;
+    const index = viewMetadata?.index ?? getDocumentParagraphNodes(xmlDoc).indexOf(paragraph) + 1;
+    const paragraphId = viewMetadata?.paragraphId ?? getParagraphId(paragraph);
+    const inTable = viewMetadata?.inTable ?? !!findContainingWordElement(paragraph, 'tbl');
+    const text = viewMetadata?.text ?? extractCanonicalParagraphText(paragraph, { revisionView });
+    const fingerprint = viewMetadata?.fingerprint ?? createParagraphFingerprint(paragraph, {
+        text,
+        index,
+        paragraphId,
+        inTable,
+        revisionView
+    });
+    return {
+        index,
+        paragraphId,
+        text,
+        fingerprint,
+        revisionView,
+        inTable,
+        targetTextMatch: describeTargetTextMatch(
+            text,
+            options?.targetDescriptor?.text ?? options?.targetDescriptor?.exactText ?? targetText
+        )
+    };
+}
+
 function resolveTargetParagraph(xmlDoc, targetText, targetRef, opType, runtimeContext = null, options = {}) {
     const onInfo = typeof options?.onInfo === 'function' ? options.onInfo : () => { };
     const onWarn = typeof options?.onWarn === 'function' ? options.onWarn : () => { };
@@ -239,17 +269,7 @@ function resolveTargetParagraph(xmlDoc, targetText, targetRef, opType, runtimeCo
             const metadata = paragraphMetadataIndex?.byParagraph?.get(paragraph) || null;
             Object.assign(options._resolutionCapture, {
                 resolvedBy: resolved.resolvedBy,
-                resolvedTarget: {
-                    index: metadata?.index ?? getDocumentParagraphNodes(xmlDoc).indexOf(paragraph) + 1,
-                    paragraphId: metadata?.paragraphId ?? getParagraphId(paragraph),
-                    text: metadata?.text ?? getParagraphText(paragraph),
-                    fingerprint: metadata?.fingerprint ?? createParagraphFingerprint(paragraph),
-                    inTable: metadata?.inTable ?? !!findContainingWordElement(paragraph, 'tbl'),
-                    targetTextMatch: describeTargetTextMatch(
-                        metadata?.text ?? getParagraphText(paragraph),
-                        options?.targetDescriptor?.exactText ?? targetText
-                    )
-                }
+                resolvedTarget: resolvedTargetDiagnostics(xmlDoc, paragraph, metadata, targetText, options)
             });
         }
         return resolved;
@@ -263,17 +283,7 @@ function resolveTargetParagraph(xmlDoc, targetText, targetRef, opType, runtimeCo
                 const metadata = paragraphMetadataIndex?.byParagraph?.get(paragraph) || null;
                 Object.assign(options._resolutionCapture, {
                     resolvedBy: resolved.resolvedBy,
-                    resolvedTarget: {
-                        index: metadata?.index ?? Array.from(xmlDoc.getElementsByTagNameNS(NS_W, 'p')).indexOf(paragraph) + 1,
-                        paragraphId: metadata?.paragraphId ?? getParagraphId(paragraph),
-                        text: metadata?.text ?? getParagraphText(paragraph),
-                        fingerprint: metadata?.fingerprint ?? createParagraphFingerprint(paragraph),
-                        inTable: metadata?.inTable ?? !!findContainingWordElement(paragraph, 'tbl'),
-                        targetTextMatch: describeTargetTextMatch(
-                            metadata?.text ?? getParagraphText(paragraph),
-                            options?.targetDescriptor?.exactText ?? targetText
-                        )
-                    }
+                    resolvedTarget: resolvedTargetDiagnostics(xmlDoc, paragraph, metadata, targetText, options)
                 });
             }
             return resolved;
@@ -301,19 +311,9 @@ function resolveTargetParagraph(xmlDoc, targetText, targetRef, opType, runtimeCo
     if (options?._resolutionCapture && resolved?.paragraph) {
         const paragraph = resolved.paragraph;
         const metadata = paragraphMetadataIndex?.byParagraph?.get(paragraph) || null;
-        Object.assign(options._resolutionCapture, {
-            resolvedBy: resolved.resolvedBy,
-            resolvedTarget: {
-                index: metadata?.index ?? Array.from(xmlDoc.getElementsByTagNameNS(NS_W, 'p')).indexOf(paragraph) + 1,
-                paragraphId: metadata?.paragraphId ?? getParagraphId(paragraph),
-                text: metadata?.text ?? getParagraphText(paragraph),
-                fingerprint: metadata?.fingerprint ?? createParagraphFingerprint(paragraph),
-                inTable: metadata?.inTable ?? !!findContainingWordElement(paragraph, 'tbl'),
-                targetTextMatch: describeTargetTextMatch(
-                    metadata?.text ?? getParagraphText(paragraph),
-                    options?.targetDescriptor?.exactText ?? targetText
-                )
-            }
+        Object.assign(options._resolutionCapture, {
+            resolvedBy: resolved.resolvedBy,
+            resolvedTarget: resolvedTargetDiagnostics(xmlDoc, paragraph, metadata, targetText, options)
         });
     }
     return resolved;

package/services/localized-replacement-compiler.js

@@ -41,6 +41,65 @@ function occurrenceOffsets(sourceText, find) {
     return offsets;
 }
 
+function equivalentSpace(left, right) {
+    return (left === ' ' || left === '\u00a0')
+        && (right === ' ' || right === '\u00a0');
+}
+
+function spaceEquivalentOffsets(sourceText, find) {
+    const offsets = [];
+    for (let start = 0; start <= sourceText.length - find.length; start += 1) {
+        let matches = true;
+        for (let offset = 0; offset < find.length; offset += 1) {
+            const sourceCharacter = sourceText[start + offset];
+            const findCharacter = find[offset];
+            if (sourceCharacter !== findCharacter && !equivalentSpace(sourceCharacter, findCharacter)) {
+                matches = false;
+                break;
+            }
+        }
+        if (matches) offsets.push(start);
+    }
+    return offsets;
+}
+
+/** Resolve exact offsets first, then the narrow ASCII-space/NBSP equivalent fallback. */
+export function localizedReplacementOffsets(sourceText, find) {
+    const exact = occurrenceOffsets(sourceText, find);
+    if (exact.length > 0) return { offsets: exact, matchMode: 'exact' };
+    return { offsets: spaceEquivalentOffsets(sourceText, find), matchMode: 'space_equivalent' };
+}
+
+function preserveEquivalentBoundarySpaces(sourceSlice, find, replace) {
+    const effective = replace.split('');
+    let prefix = 0;
+    while (
+        prefix < find.length
+        && prefix < replace.length
+        && (find[prefix] === replace[prefix] || equivalentSpace(find[prefix], replace[prefix]))
+    ) {
+        if (equivalentSpace(sourceSlice[prefix], replace[prefix])) effective[prefix] = sourceSlice[prefix];
+        prefix += 1;
+    }
+    let sourceOffset = find.length - 1;
+    let replacementOffset = replace.length - 1;
+    while (
+        sourceOffset >= prefix
+        && replacementOffset >= prefix
+        && (
+            find[sourceOffset] === replace[replacementOffset]
+            || equivalentSpace(find[sourceOffset], replace[replacementOffset])
+        )
+    ) {
+        if (equivalentSpace(sourceSlice[sourceOffset], replace[replacementOffset])) {
+            effective[replacementOffset] = sourceSlice[sourceOffset];
+        }
+        sourceOffset -= 1;
+        replacementOffset -= 1;
+    }
+    return effective.join('');
+}
+
 function offsetCandidate(sourceText, start, length) {
     const excerptStart = Math.max(0, start - 40);
     const excerptEnd = Math.min(sourceText.length, start + length + 40);
@@ -168,15 +227,15 @@ export function compileExactReplacements(
         const replacement = validation.replacements[index];
         const itemField = `${field}[${index}]`;
         const occurrence = replacement.occurrence ?? null;
-        const offsets = occurrenceOffsets(sourceText, replacement.find);
+        const { offsets, matchMode } = localizedReplacementOffsets(sourceText, replacement.find);
         if (offsets.length === 0 || (occurrence != null && occurrence > offsets.length)) {
             return {
                 ok: false,
                 error: patchError(
                     'PATCH_SOURCE_NOT_FOUND',
                     occurrence == null
-                        ? `Exact patch source was not found: "${replacement.find}".`
-                        : `Occurrence ${occurrence} of exact patch source was not found: "${replacement.find}".`,
+                        ? `Patch source was not found: "${replacement.find}".`
+                        : `Occurrence ${occurrence} of patch source was not found: "${replacement.find}".`,
                     itemField,
                     'change_patch',
                     { matchCount: offsets.length }
@@ -188,7 +247,7 @@ export function compileExactReplacements(
                 ok: false,
                 error: patchError(
                     'AMBIGUOUS_PATCH_SOURCE',
-                    `Exact patch source matched ${offsets.length} locations; provide occurrence.`,
+                    `Patch source matched ${offsets.length} locations; provide occurrence.`,
                     itemField,
                     'choose_occurrence',
                     { candidates: offsets.map(start => offsetCandidate(sourceText, start, replacement.find.length)) }
@@ -197,12 +256,17 @@ export function compileExactReplacements(
         }
 
         const start = offsets[(occurrence || 1) - 1];
+        const sourceSlice = sourceText.slice(start, start + replacement.find.length);
         resolved.push({
             requestIndex: index,
             start,
             end: start + replacement.find.length,
             find: replacement.find,
             replace: replacement.replace,
+            effectiveReplace: matchMode === 'space_equivalent'
+                ? preserveEquivalentBoundarySpaces(sourceSlice, replacement.find, replacement.replace)
+                : replacement.replace,
+            matchMode,
             occurrence: occurrence || 1
         });
     }
@@ -212,7 +276,7 @@ export function compileExactReplacements(
     for (const replacement of resolved) {
         const previous = unique.at(-1);
         if (previous && replacement.start === previous.start && replacement.end === previous.end) {
-            if (replacement.replace !== previous.replace) {
+            if (replacement.effectiveReplace !== previous.effectiveReplace) {
                 return {
                     ok: false,
                     error: patchError(
@@ -245,7 +309,7 @@ export function compileExactReplacements(
     let desiredText = '';
     for (const replacement of unique) {
         desiredText += sourceText.slice(cursor, replacement.start);
-        desiredText += replacement.replace;
+        desiredText += replacement.effectiveReplace;
         cursor = replacement.end;
     }
     desiredText += sourceText.slice(cursor);
@@ -259,9 +323,10 @@ export function compileExactReplacements(
             end: replacement.end,
             find: replacement.find,
             replace: replacement.replace,
+            matchMode: replacement.matchMode,
             occurrence: replacement.occurrence,
             removedLength: replacement.end - replacement.start,
-            insertedLength: replacement.replace.length
+            insertedLength: replacement.effectiveReplace.length
         }))
     };
 }
@@ -280,6 +345,7 @@ export function buildLocalizedReplacementChange(compilation, outputText, target
         return {
             find: replacement.find,
             replace: replacement.replace,
+            ...(replacement.matchMode === 'space_equivalent' ? { matchMode: replacement.matchMode } : {}),
             occurrence: replacement.occurrence,
             beforeExcerpt: boundedExcerpt(sourceText, replacement.start, replacement.end),
             afterExcerpt: boundedExcerpt(desiredText, afterStart, afterEnd)

package/services/operation-batch-compiler.js

@@ -296,6 +296,15 @@ export function compileOperationBatch(xmlDoc, operations = [], options = {}) {
                             canonicalValidation.error
                         );
                     }
+                } else if (operation.operationKind === 'restore' && sourceOperation.modified === undefined) {
+                    compiled.modified = start.metadata.text;
+                    const canonicalValidation = validateDocumentOperation(compiled);
+                    if (!canonicalValidation.valid) {
+                        throw Object.assign(
+                            new Error(canonicalValidation.error.message),
+                            canonicalValidation.error
+                        );
+                    }
                 }
 
                 const targetEndDescriptor = operation.targetEndDescriptor

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

@@ -75,13 +75,32 @@ export type RedlineDocumentOperation =
       replacements?: never;
     });
 
-export interface RestoreDocumentOperation extends DocumentOperationBase {
+interface RestoreDocumentOperationCommon extends DocumentOperationBase {
   type: 'restore';
-  modified: string | string[];
-  targetEnd?: ParagraphTargetDescriptor;
-  targetEndRef?: number | string | null;
 }
 
+export type RestoreDocumentOperation =
+  | (RestoreDocumentOperationCommon & {
+      modified: string | string[];
+      replacements?: never;
+      targetEnd?: ParagraphTargetDescriptor;
+      targetEndRef?: number | string | null;
+    })
+  | (RestoreDocumentOperationCommon & {
+      modified?: never;
+      /** Exact, case-sensitive replacements in one strong rejected-view paragraph. */
+      replacements: LocalizedReplacement[];
+      targetEnd?: never;
+      targetEndRef?: never;
+    })
+  | (RestoreDocumentOperationCommon & {
+      /** Omit modified to restore one strong rejected-view paragraph verbatim. */
+      modified?: never;
+      replacements?: never;
+      targetEnd?: never;
+      targetEndRef?: never;
+    });
+
 export interface DeleteDocumentOperation extends DocumentOperationBase {
   type: 'delete';
   modified?: '';
@@ -155,6 +174,7 @@ export interface ResolvedDocumentTarget {
   paragraphId: string | null;
   text: string;
   fingerprint?: string;
+  revisionView?: 'accepted' | 'rejected';
   inTable?: boolean;
   targetTextMatch?: {
     mode: 'exact' | 'space_equivalent' | 'normalized';
@@ -232,6 +252,7 @@ export interface LocalizedReplacementChange {
     find: string;
     replace: string;
     occurrence?: number;
+    matchMode?: 'space_equivalent';
     beforeExcerpt: string;
     afterExcerpt: string;
   }>;