@ansonlai/docx-redline-js 0.5.4 → 0.6.1

package/dist/docx-redline-js.esm.js

@@ -1,4 +1,4 @@
-// @ansonlai/docx-redline-js v0.5.4 — https://github.com/AnsonLai/docx-redline-js
+// @ansonlai/docx-redline-js v0.6.1 — https://github.com/AnsonLai/docx-redline-js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -4890,6 +4890,47 @@ function extractFormattingFromOoxml(xmlDoc) {
   return { existingFormatHints, textSpans, paragraphs };
 }
 
+// core/revision-cloning.js
+var REVISION_HISTORY_ELEMENTS = /* @__PURE__ */ new Set([
+  "ins",
+  "del",
+  "moveFrom",
+  "moveTo",
+  "pPrChange",
+  "rPrChange",
+  "tblPrChange",
+  "trPrChange",
+  "tcPrChange",
+  "sectPrChange"
+]);
+function clonePropertiesWithoutRevisionHistory(root) {
+  if (!root) return null;
+  const clone = root.cloneNode(true);
+  const candidates = [clone, ...Array.from(clone.getElementsByTagName?.("*") || [])];
+  for (const node of candidates.reverse()) {
+    if (!REVISION_HISTORY_ELEMENTS.has(String(node.localName || node.nodeName || "").replace(/^.*:/, ""))) continue;
+    node.parentNode?.removeChild(node);
+  }
+  return clone;
+}
+function refreshRunPropertyChangeIds(root, allocator = null) {
+  if (!root) return root;
+  const xmlDoc = root.nodeType === 9 ? root : root.ownerDocument;
+  const resolvedAllocator = allocator instanceof RevisionIdAllocator ? allocator : getRevisionIdAllocatorForDocument(xmlDoc) || createRevisionIdAllocator(xmlDoc);
+  const candidates = [root, ...Array.from(root.getElementsByTagName?.("*") || [])];
+  for (const node of candidates) {
+    if (!isWordElement(node, "rPrChange")) continue;
+    const nextId = String(resolvedAllocator.next());
+    if (typeof node.setAttributeNS === "function") {
+      node.setAttributeNS(NS_W, "w:id", nextId);
+    } else {
+      node.setAttribute("w:id", nextId);
+    }
+    resolvedAllocator._receiptCollector?.recordRevision(Number(nextId), "rPrChange");
+  }
+  return root;
+}
+
 // engine/run-builders.js
 function createTrackChange(xmlDoc, type, run, author, revisionMetadata = null) {
   const wrapper = createWordElement(xmlDoc, type === "ins" ? "w:ins" : "w:del");
@@ -5078,13 +5119,8 @@ function snapshotAndAttachRPrChange(xmlDoc, rPr, author, dateStr, sourceNode) {
   rPrChange.setAttribute("w:id", String(metadata.id));
   rPrChange.setAttribute("w:author", metadata.author);
   rPrChange.setAttribute("w:date", dateStr || metadata.date);
-  const previousRPr = createWordElement(xmlDoc, "w:rPr");
   const source = sourceNode || rPr;
-  Array.from(source.childNodes).forEach((child) => {
-    if (child.nodeName !== "w:rPrChange") {
-      previousRPr.appendChild(child.cloneNode(true));
-    }
-  });
+  const previousRPr = clonePropertiesWithoutRevisionHistory(source) || createWordElement(xmlDoc, "w:rPr");
   rPrChange.appendChild(previousRPr);
   const existing = getFirstElementByTag(rPr, "w:rPrChange");
   if (existing) {
@@ -5894,25 +5930,6 @@ function describeInsertionBoundary(spanIndex, pos, fallbackParagraph = null) {
   };
 }
 
-// core/revision-cloning.js
-function refreshRunPropertyChangeIds(root, allocator = null) {
-  if (!root) return root;
-  const xmlDoc = root.nodeType === 9 ? root : root.ownerDocument;
-  const resolvedAllocator = allocator instanceof RevisionIdAllocator ? allocator : getRevisionIdAllocatorForDocument(xmlDoc) || createRevisionIdAllocator(xmlDoc);
-  const candidates = [root, ...Array.from(root.getElementsByTagName?.("*") || [])];
-  for (const node of candidates) {
-    if (!isWordElement(node, "rPrChange")) continue;
-    const nextId = String(resolvedAllocator.next());
-    if (typeof node.setAttributeNS === "function") {
-      node.setAttributeNS(NS_W, "w:id", nextId);
-    } else {
-      node.setAttribute("w:id", nextId);
-    }
-    resolvedAllocator._receiptCollector?.recordRevision(Number(nextId), "rPrChange");
-  }
-  return root;
-}
-
 // engine/surgical-run-splitting.js
 var TRACK_CHANGE_CARRIERS = /* @__PURE__ */ new Set(["ins", "del"]);
 function getRunContentPieces(runElement) {
@@ -8415,6 +8432,51 @@ function getCommentIdsInOoxml(node) {
   }
   return [...ids].sort((a, b) => Number(a) - Number(b) || a.localeCompare(b));
 }
+function directWordChild(node, localName2) {
+  return Array.from(node?.childNodes || []).find((child) => child?.nodeType === 1 && child.namespaceURI === NS_W && child.localName === localName2) || null;
+}
+function insertedParagraphMarkMetadata(paragraph, author) {
+  const marker = directWordChild(directWordChild(directWordChild(paragraph, "pPr"), "rPr"), "ins");
+  if (!marker) return null;
+  const markerAuthor = marker.getAttribute("w:author") || marker.getAttributeNS(NS_W, "author") || "";
+  if (markerAuthor.trim().toLowerCase() !== String(author || "").trim().toLowerCase()) return null;
+  return {
+    id: marker.getAttribute("w:id") || marker.getAttributeNS(NS_W, "id") || "",
+    author: markerAuthor,
+    date: marker.getAttribute("w:date") || marker.getAttributeNS(NS_W, "date") || ""
+  };
+}
+function emptyParagraphBaseline(paragraph, serializer) {
+  const clone = paragraph.cloneNode(false);
+  const pPr = directWordChild(paragraph, "pPr");
+  if (pPr) clone.appendChild(clonePropertiesWithoutRevisionHistory(pPr));
+  return serializer.serializeToString(clone);
+}
+function restoreInsertedParagraphMark(oxml, metadata) {
+  if (!metadata || typeof oxml !== "string" || !oxml.trim()) return oxml;
+  const parsed = parseOoxmlSafe(oxml, "text/xml");
+  if (!parsed.doc || parsed.error) return oxml;
+  const paragraph = parsed.doc.documentElement?.localName === "p" ? parsed.doc.documentElement : getDocumentParagraphs(parsed.doc)[0];
+  if (!paragraph) return oxml;
+  let pPr = directWordChild(paragraph, "pPr");
+  if (!pPr) {
+    pPr = createWordElement(parsed.doc, "w:pPr");
+    paragraph.insertBefore(pPr, paragraph.firstChild);
+  }
+  let rPr = directWordChild(pPr, "rPr");
+  if (!rPr) {
+    rPr = createWordElement(parsed.doc, "w:rPr");
+    pPr.appendChild(rPr);
+  }
+  if (!directWordChild(rPr, "ins")) {
+    const marker = createWordElement(parsed.doc, "w:ins");
+    if (metadata.id) marker.setAttribute("w:id", metadata.id);
+    marker.setAttribute("w:author", metadata.author);
+    if (metadata.date) marker.setAttribute("w:date", metadata.date);
+    rPr.appendChild(marker);
+  }
+  return serializeXml(parsed.doc);
+}
 async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}) {
   const inputOoxml = oxml;
   let workingOoxml = oxml;
@@ -8426,6 +8488,7 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
   let parseWarnings = [];
   const operationWarnings = [];
   let normalizedExistingRevisions = false;
+  let preservedInsertedParagraphMark = null;
   const existingRevisionsPolicy = options.existingRevisions || "merge-same-author";
   const keepNormalizedNoOp = existingRevisionsPolicy === "accept-all-first-keep-normalized";
   const finalize = (result) => {
@@ -8456,6 +8519,9 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
     if (!withStatus.status) {
       withStatus.status = withStatus.hasChanges ? "ok" : "no-op";
     }
+    if (preservedInsertedParagraphMark && withStatus.hasChanges && typeof withStatus.oxml === "string") {
+      withStatus.oxml = restoreInsertedParagraphMark(withStatus.oxml, preservedInsertedParagraphMark);
+    }
     return withOoxmlSourceType(withStatus);
   };
   const finalizeUnchanged = () => {
@@ -8521,9 +8587,11 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
           });
         }
         log("[OxmlEngine] Existing revisions from same author detected; rejecting previous changes to merge against baseline");
+        const soleParagraph = inputParagraphs.length === 1 ? inputParagraphs[0] : null;
+        preservedInsertedParagraphMark = insertedParagraphMarkMetadata(soleParagraph, author);
         const rejected = rejectTrackedChangesInOoxml(inputOoxml, { author });
         if (rejected.status === "error") return finalize(rejected);
-        workingOoxml = rejected.oxml;
+        workingOoxml = preservedInsertedParagraphMark && !String(rejected.oxml || "").trim() ? emptyParagraphBaseline(soleParagraph, serializer) : rejected.oxml;
         normalizedExistingRevisions = true;
         const rejectedParsed = parseOoxmlSafe(workingOoxml, "text/xml");
         parseWarnings.push(...rejectedParsed.warnings);
@@ -8565,7 +8633,9 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
           status: "error",
           error: {
             code: "EXISTING_REVISIONS",
-            message: `Input OOXML contains tracked changes from another author (${authors.length ? authors.join(", ") : "unattributed"}). Pass existingRevisions: "accept-all-first" or resolve revisions first.`
+            message: `Input OOXML 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.`,
+            revisionAuthors: authors,
+            currentPolicy: existingRevisionsPolicy
           }
         });
       } else {
@@ -9173,9 +9243,12 @@ function resolveTargetParagraph(xmlDoc, options = {}) {
       );
     }
     if (descriptor.fingerprint && descriptor.fingerprint !== actualFingerprint) {
+      const alternateView = revisionView === "rejected" ? "accepted" : "rejected";
+      const alternateFingerprint = createParagraphFingerprint(byId, { revisionView: alternateView });
+      const viewHint = descriptor.fingerprint === alternateFingerprint ? ` The supplied fingerprint matches the ${alternateView} view; set target.revisionView to "${alternateView}" or use a fingerprint extracted from the ${revisionView} view.` : "";
       throw createTargetError(
         "TARGET_FINGERPRINT_MISMATCH",
-        `Target paragraphId "${descriptor.paragraphId}" no longer matches its source fingerprint.`,
+        `Target paragraphId "${descriptor.paragraphId}" no longer matches its source fingerprint.${viewHint}`,
         cachedEntry ? [serializeTargetCandidate(cachedEntry)] : null
       );
     }
@@ -9187,9 +9260,14 @@ function resolveTargetParagraph(xmlDoc, options = {}) {
       );
     }
     if (cleanTargetText && actualText !== normalizeWhitespaceForTargeting(cleanTargetText)) {
+      const alternateView = revisionView === "rejected" ? "accepted" : "rejected";
+      const alternateText = normalizeWhitespaceForTargeting(
+        extractCanonicalParagraphText(byId, { revisionView: alternateView })
+      );
+      const viewHint = alternateText === normalizeWhitespaceForTargeting(cleanTargetText) ? ` The supplied text matches the ${alternateView} view; set target.revisionView to "${alternateView}".` : "";
       throw createTargetError(
         "TARGET_TEXT_MISMATCH",
-        `Target paragraphId "${descriptor.paragraphId}" no longer matches the supplied text.`,
+        `Target paragraphId "${descriptor.paragraphId}" no longer matches the supplied text.${viewHint}`,
         cachedEntry ? [serializeTargetCandidate(cachedEntry)] : null
       );
     }
@@ -11388,6 +11466,70 @@ function collectDocumentCommentAnchors(paragraphNodes, revisionView) {
   });
   return anchors;
 }
+function selectInspectionParagraphs(allParagraphs, options) {
+  let matches = allParagraphs;
+  if (options.revisedOnly) matches = matches.filter((item) => item.hasRevisions);
+  if (options.inTable != null) matches = matches.filter((item) => item.inTable === !!options.inTable);
+  if (options.skipEmpty) matches = matches.filter((item) => item.text.length > 0);
+  if (options.search) {
+    const needle = String(options.search).toLowerCase();
+    matches = matches.filter((item) => item.text.toLowerCase().includes(needle));
+  }
+  if (Array.isArray(options.indexes)) {
+    const indexes = new Set(options.indexes);
+    matches = matches.filter((item) => indexes.has(item.index));
+  }
+  let rangeStart = 1;
+  let rangeEnd = allParagraphs.length;
+  if (options.range) {
+    rangeStart = Number(options.range.start ?? options.range[0]);
+    rangeEnd = Number(options.range.end ?? options.range[1]);
+    matches = matches.filter((item) => item.index >= rangeStart && item.index <= rangeEnd);
+  }
+  const totalMatches = matches.length;
+  const after = Number.isInteger(options.after) && options.after > 0 ? options.after : null;
+  const remaining = after == null ? matches : matches.filter((item) => item.index > after);
+  const limit = Number.isInteger(options.limit) && options.limit > 0 ? options.limit : null;
+  const selectedMatches = limit == null ? remaining : remaining.slice(0, limit);
+  const truncated = selectedMatches.length < remaining.length;
+  const around = Number.isInteger(options.around) && options.around > 0 ? options.around : 0;
+  const exposeSelection = !!options.search || around > 0 || limit != null || after != null;
+  let paragraphs = selectedMatches;
+  if (around > 0 && options.search) {
+    const directIndexes = new Set(selectedMatches.map((item) => item.index));
+    const contextFor = /* @__PURE__ */ new Map();
+    for (const match of selectedMatches) {
+      const start = Math.max(rangeStart, match.index - around);
+      const end = Math.min(rangeEnd, match.index + around);
+      for (let index = start; index <= end; index++) {
+        if (directIndexes.has(index)) continue;
+        const owners = contextFor.get(index) || [];
+        owners.push(match.index);
+        contextFor.set(index, owners);
+      }
+    }
+    const returnedIndexes = /* @__PURE__ */ new Set([...directIndexes, ...contextFor.keys()]);
+    paragraphs = allParagraphs.filter((item) => returnedIndexes.has(item.index)).map((item) => directIndexes.has(item.index) ? { ...item, selectionRole: "match" } : { ...item, selectionRole: "context", contextFor: contextFor.get(item.index) || [] });
+  } else if (exposeSelection) {
+    paragraphs = selectedMatches.map((item) => ({ ...item, selectionRole: "match" }));
+  }
+  return {
+    paragraphs,
+    ...exposeSelection ? {
+      selection: {
+        ...options.search ? { search: String(options.search), caseSensitive: false } : {},
+        totalMatches,
+        returnedMatches: selectedMatches.length,
+        returnedParagraphs: paragraphs.length,
+        truncated,
+        nextAfter: truncated && selectedMatches.length > 0 ? selectedMatches[selectedMatches.length - 1].index : null,
+        ...limit != null ? { limit } : {},
+        ...after != null ? { after } : {},
+        ...around > 0 ? { around } : {}
+      }
+    } : {}
+  };
+}
 function inspectDocumentParts(parts, options = {}) {
   const documentPart = parseXml2(parts?.documentXml, "word/document.xml", true);
   if (documentPart.error) return { status: "error", error: documentPart.error, paragraphs: [], comments: [], warnings: [] };
@@ -11403,9 +11545,10 @@ function inspectDocumentParts(parts, options = {}) {
   const resolveNumbering = createNumberingResolver(numberingPart.doc);
   let nearestHeading = null;
   const paragraphNodes = getDocumentParagraphNodes(documentPart.doc);
-  const commentAnchors = collectDocumentCommentAnchors(paragraphNodes, options.revisionView || "accepted");
+  const revisionView = options.revisionView === "rejected" ? "rejected" : "accepted";
+  const commentAnchors = collectDocumentCommentAnchors(paragraphNodes, revisionView);
   let paragraphs = paragraphNodes.map((paragraph, zeroIndex) => {
-    const text = extractCanonicalParagraphText(paragraph, { revisionView: options.revisionView || "accepted" });
+    const text = extractCanonicalParagraphText(paragraph, { revisionView });
     const level = headingLevel(paragraph);
     if (level) nearestHeading = { level, text };
     const ids = [...new Set([...descendants(paragraph, "commentRangeStart"), ...descendants(paragraph, "commentReference")].map((node) => attr2(node, "id")).filter(Boolean))];
@@ -11416,17 +11559,20 @@ function inspectDocumentParts(parts, options = {}) {
     const index = zeroIndex + 1;
     const provision = list?.label && list.format !== "bullet" ? list.label : null;
     const headingText = nearestHeading?.text || null;
-    const humanReference = [provision, headingText, text.slice(0, options.excerptLength || 120)].filter(Boolean).join(" \u2014 ");
+    const excerpt = text.slice(0, options.excerptLength || 120);
+    const humanReference = level ? text : provision ? [provision, headingText].filter(Boolean).join(" \u2014 ") : headingText ? [headingText, excerpt].filter(Boolean).join(" \u2014 ") : excerpt;
     const segments = extractParagraphRevisionSegments(paragraph);
     return {
       index,
       ref: `P${index}`,
       paragraphId: getParagraphId2(paragraph),
-      fingerprint: createParagraphFingerprint(paragraph),
+      fingerprint: createParagraphFingerprint(paragraph, { text, index, revisionView }),
+      revisionView,
       text,
       exactText: text,
-      excerpt: text.slice(0, options.excerptLength || 120),
+      excerpt,
       humanReference,
+      provision,
       inTable: hasAncestor(paragraph, "tc"),
       table: structure.table,
       styleId,
@@ -11447,22 +11593,8 @@ function inspectDocumentParts(parts, options = {}) {
     definition.anchoredText ?? (definition.anchoredText = commentAnchors.get(id) || paragraph.text);
     comments.set(id, definition);
   }
-  if (options.revisedOnly) paragraphs = paragraphs.filter((item) => item.hasRevisions);
-  if (options.inTable != null) paragraphs = paragraphs.filter((item) => item.inTable === !!options.inTable);
-  if (options.skipEmpty) paragraphs = paragraphs.filter((item) => item.text.length > 0);
-  if (options.search) {
-    const needle = String(options.search).toLowerCase();
-    paragraphs = paragraphs.filter((item) => item.text.toLowerCase().includes(needle));
-  }
-  if (Array.isArray(options.indexes)) {
-    const indexes = new Set(options.indexes);
-    paragraphs = paragraphs.filter((item) => indexes.has(item.index));
-  }
-  if (options.range) {
-    const start = Number(options.range.start ?? options.range[0]);
-    const end = Number(options.range.end ?? options.range[1]);
-    paragraphs = paragraphs.filter((item) => item.index >= start && item.index <= end);
-  }
+  const selected = selectInspectionParagraphs(paragraphs, options);
+  paragraphs = selected.paragraphs;
   const allRevisionAuthors = [...new Set(paragraphs.flatMap((item) => item.revisionAuthors))].sort();
   const coveredEntries = extractDocumentPartsEntries(parts);
   const coveredParts = coveredEntries.map((e) => e.name).sort();
@@ -11479,6 +11611,7 @@ function inspectDocumentParts(parts, options = {}) {
     revisionToken,
     coveredParts,
     paragraphs,
+    ...selected.selection ? { selection: selected.selection } : {},
     comments: [...comments.values()],
     revisionAuthors: allRevisionAuthors,
     commentAuthors: [...new Set([...comments.values()].map((item) => item.author).filter(Boolean))].sort(),