@ansonlai/docx-redline-js 0.8.2 → 0.8.3

package/dist/docx-redline.bundle.js

@@ -1,4 +1,4 @@
-// @ansonlai/docx-redline-js standalone bundle v0.8.2 — https://github.com/AnsonLai/docx-redline-js
+// @ansonlai/docx-redline-js standalone bundle v0.8.3 — https://github.com/AnsonLai/docx-redline-js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -10452,7 +10452,37 @@ async function executeListGeneration(options) {
       }];
     }
   }
-  if (generateRedlines && deletionRuns.length > 0) {
+  const sourceParagraphCount = (originalRunModel || []).filter((run) => run.kind === RunKind.PARAGRAPH_START).length;
+  if (generateRedlines && sourceParagraphCount > 0 && (sourceParagraphCount > 1 || deletionRuns.length === 0)) {
+    let segment = null;
+    const flushSegment = () => {
+      if (!segment) return;
+      results.push(serializeToOoxml(segment, null, [], {
+        author,
+        generateRedlines,
+        revisionIdAllocator
+      }));
+      segment = null;
+    };
+    for (const run of originalRunModel) {
+      if (run.kind === RunKind.PARAGRAPH_START) {
+        flushSegment();
+        segment = [{
+          ...run,
+          pPrElement: null,
+          pPrXml: addParagraphMarkRevision(
+            run.pPrElement || run.pPrXml || null,
+            "del",
+            author,
+            revisionIdAllocator
+          )
+        }];
+      } else if (segment && (run.kind === "text" || run.kind === "run")) {
+        segment.push({ ...run, kind: "deletion", author });
+      }
+    }
+    flushSegment();
+  } else if (generateRedlines && deletionRuns.length > 0) {
     const deletedPPr = addParagraphMarkRevision(sourcePPr, "del", author, revisionIdAllocator);
     const deletedParagraph = serializeToOoxml(deletionRuns, deletedPPr, [], {
       author,
@@ -16650,12 +16680,12 @@ function validateParagraphBoundaryMutation(targetParagraph, modifiedText, option
 }
 
 // core/list-targeting.js
-function getFirstDescendantByLocalName(node, localName2) {
-  if (!node || typeof node.getElementsByTagNameNS !== "function") return null;
-  const namespaced = node.getElementsByTagNameNS(WORD_MAIN_NS, localName2);
-  if (namespaced.length > 0) return namespaced[0];
-  const anyNs = node.getElementsByTagNameNS("*", localName2);
-  return anyNs.length > 0 ? anyNs[0] : null;
+function getDirectChildByLocalName(node, localName2) {
+  if (!node) return null;
+  for (const child of Array.from(node.childNodes || [])) {
+    if (child?.nodeType === 1 && child.localName === localName2) return child;
+  }
+  return null;
 }
 function readValAttribute(element) {
   if (!element) return null;
@@ -16772,15 +16802,15 @@ function buildListEntriesForInsertion(parsedItems, normalizedTargetText, anchorL
 }
 function getParagraphListInfo(paragraph) {
   if (!paragraph) return null;
-  const pPr = getFirstDescendantByLocalName(paragraph, "pPr");
+  const pPr = getDirectChildByLocalName(paragraph, "pPr");
   if (!pPr) return null;
-  const numPr = getFirstDescendantByLocalName(pPr, "numPr");
+  const numPr = getDirectChildByLocalName(pPr, "numPr");
   if (!numPr) return null;
-  const numIdEl = getFirstDescendantByLocalName(numPr, "numId");
+  const numIdEl = getDirectChildByLocalName(numPr, "numId");
   if (!numIdEl) return null;
   const numId = readValAttribute(numIdEl);
   if (!numId || numId === "0") return null;
-  const ilvlEl = getFirstDescendantByLocalName(numPr, "ilvl");
+  const ilvlEl = getDirectChildByLocalName(numPr, "ilvl");
   const ilvlRaw = readValAttribute(ilvlEl);
   const ilvl = Number.parseInt(ilvlRaw || "0", 10);
   return {
@@ -17190,8 +17220,13 @@ function enforceListBindingOnParagraphNodes(nodes, options = {}) {
   }
   return updated;
 }
+function parseOxmlFragment(oxml) {
+  const text2 = String(oxml || "");
+  const declared = /xmlns:w\s*=/.test(text2);
+  return parseOoxmlSafe(declared ? text2 : `<w:root xmlns:w="${NS_W}">${text2}</w:root>`, "application/xml").doc;
+}
 function getFirstParagraphFromOxml(oxml) {
-  const doc = parseOoxmlSafe(oxml, "application/xml").doc;
+  const doc = parseOxmlFragment(oxml);
   if (!doc) return null;
   const parseError = getXmlParseError(doc);
   if (parseError) return null;
@@ -17218,17 +17253,17 @@ function setElementVal(element, value) {
   element.setAttribute("w:val", String(value));
 }
 function extractFirstParagraphNumIdFromOxml(oxml) {
-  const doc = parseOoxmlSafe(oxml, "application/xml").doc;
+  const doc = parseOxmlFragment(oxml);
   if (!doc) return null;
   const parseError = getXmlParseError(doc);
   if (parseError) return null;
   const paragraphs = getDocumentParagraphNodes(doc);
-  const firstParagraph = paragraphs[0] || null;
-  if (!firstParagraph) return null;
-  const numIdNodes = Array.from(firstParagraph.getElementsByTagNameNS("*", "numId"));
-  for (const numIdNode of numIdNodes) {
-    const numId = getElementId(numIdNode, ["w:val", "val"]);
-    if (numId != null) return String(numId);
+  for (const paragraph of paragraphs) {
+    const numIdNodes = Array.from(paragraph.getElementsByTagNameNS("*", "numId"));
+    for (const numIdNode of numIdNodes) {
+      const numId = getElementId(numIdNode, ["w:val", "val"]);
+      if (numId != null) return String(numId);
+    }
   }
   return null;
 }
@@ -17724,6 +17759,8 @@ function createDynamicNumberingIdState(numberingXml, options = {}) {
   const baseNumId = Math.max(minId, maxUsedNumId + 1);
   const baseAbstractNumId = Math.max(minId, maxUsedAbstractNumId + 1);
   return {
+    // Kept so list edits can recognise which existing definition a source list uses and continue it.
+    sourceNumberingXml: String(numberingXml || ""),
     nextNumId: nextAvailableId(baseNumId, usedNumIds, maxPreferred),
     nextAbstractNumId: nextAvailableId(baseAbstractNumId, usedAbstractNumIds, maxPreferred),
     usedNumIds,
@@ -17864,6 +17901,82 @@ function buildExplicitDecimalMultilevelNumberingXml(numId, abstractNumId, startA
     </w:num>
 </w:numbering>`.trim();
 }
+function isTrackedDeletedParagraph(node) {
+  if (!node || node.nodeType !== 1 || node.localName !== "p") return false;
+  const pPr = Array.from(node.childNodes || []).find((child) => isDirectWordChild(child, "pPr"));
+  const rPr = pPr && Array.from(pPr.childNodes || []).find((child) => isDirectWordChild(child, "rPr"));
+  return !!rPr && Array.from(rPr.childNodes || []).some((child) => isDirectWordChild(child, "del"));
+}
+function paragraphNumIdNodes(node) {
+  return Array.from(node?.getElementsByTagNameNS?.("*", "numId") || []).filter((numIdNode) => numIdNode.parentNode?.localName === "numPr");
+}
+function levelFormats(abstractNum) {
+  const formats = /* @__PURE__ */ new Map();
+  for (const lvl of Array.from(abstractNum?.getElementsByTagNameNS?.("*", "lvl") || [])) {
+    const ilvl = getElementId2(lvl, ["w:ilvl", "ilvl"]);
+    const fmt = Array.from(lvl.getElementsByTagNameNS("*", "numFmt"))[0]?.getAttribute("w:val") || null;
+    if (ilvl != null && fmt) formats.set(ilvl, fmt);
+  }
+  return formats;
+}
+function normalizeListFormat(format) {
+  return format === "bullet" || format === "circle" || format === "square" ? "bullet" : format;
+}
+function abstractNumForNumId(numberingDoc, numId) {
+  const num = Array.from(numberingDoc.getElementsByTagNameNS("*", "num")).find((candidate) => getElementId2(candidate, ["w:numId", "numId"]) === numId);
+  const abstractId = num && getElementId2(Array.from(num.getElementsByTagNameNS("*", "abstractNumId"))[0], ["w:val", "val"]);
+  if (abstractId == null) return null;
+  return Array.from(numberingDoc.getElementsByTagNameNS("*", "abstractNum")).find((candidate) => getElementId2(candidate, ["w:abstractNumId", "abstractNumId"]) === abstractId) || null;
+}
+function reuseSourceListNumbering(numberingXml, replacementNodes, sourceParagraphs, numberingIdState) {
+  const sourceXml = numberingIdState?.sourceNumberingXml;
+  if (!numberingXml || !String(sourceXml || "").trim() || !Array.isArray(replacementNodes)) return null;
+  const sourceNumIds = /* @__PURE__ */ new Set();
+  for (const paragraph of sourceParagraphs || []) {
+    for (const numIdNode of paragraphNumIdNodes(paragraph)) {
+      const id = getElementId2(numIdNode, ["w:val", "val"]);
+      if (id != null && id !== 0) sourceNumIds.add(id);
+    }
+  }
+  if (sourceNumIds.size !== 1) return null;
+  const [sourceNumId] = sourceNumIds;
+  const sourceDoc = parseOoxml(sourceXml);
+  const payloadDoc = parseOoxml(numberingXml);
+  if (hasXmlParseError(sourceDoc) || hasXmlParseError(payloadDoc)) return null;
+  const sourceAbstract = abstractNumForNumId(sourceDoc, sourceNumId);
+  if (!sourceAbstract) return null;
+  const sourceFormats = levelFormats(sourceAbstract);
+  const newParagraphNumIds = [];
+  for (const node of replacementNodes) {
+    if (isTrackedDeletedParagraph(node)) continue;
+    for (const numIdNode of paragraphNumIdNodes(node)) {
+      const ilvlNode = Array.from(numIdNode.parentNode.childNodes || []).find((child) => child.localName === "ilvl");
+      newParagraphNumIds.push({
+        numId: getElementId2(numIdNode, ["w:val", "val"]),
+        ilvl: ilvlNode ? getElementId2(ilvlNode, ["w:val", "val"]) ?? 0 : 0
+      });
+    }
+  }
+  if (newParagraphNumIds.length === 0) return null;
+  const payloadFormats = /* @__PURE__ */ new Map();
+  for (const { numId, ilvl } of newParagraphNumIds) {
+    if (numId == null) return null;
+    if (!payloadFormats.has(numId)) {
+      const abstract = abstractNumForNumId(payloadDoc, numId);
+      if (!abstract) return null;
+      payloadFormats.set(numId, levelFormats(abstract));
+    }
+    const generated = payloadFormats.get(numId).get(ilvl);
+    const existing = sourceFormats.get(ilvl);
+    if (!generated || !existing || normalizeListFormat(generated) !== normalizeListFormat(existing)) return null;
+  }
+  const clonedNodes = replacementNodes.map((node) => node?.cloneNode ? node.cloneNode(true) : node);
+  for (const node of clonedNodes) {
+    if (isTrackedDeletedParagraph(node)) continue;
+    for (const numIdNode of paragraphNumIdNodes(node)) setElementVal2(numIdNode, sourceNumId);
+  }
+  return { numId: sourceNumId, replacementNodes: clonedNodes };
+}
 function remapNumberingPayloadForDocument(numberingXml, replacementNodes, numberingIdState) {
   const numberingDoc = parseOoxml(numberingXml);
   if (hasXmlParseError(numberingDoc)) {
@@ -17901,6 +18014,7 @@ function remapNumberingPayloadForDocument(numberingXml, replacementNodes, number
   }
   const clonedNodes = Array.isArray(replacementNodes) ? replacementNodes.map((node) => node?.cloneNode ? node.cloneNode(true) : node) : [];
   for (const node of clonedNodes) {
+    if (isTrackedDeletedParagraph(node)) continue;
     const numIdNodes = Array.from(node?.getElementsByTagNameNS?.("*", "numId") || []);
     for (const numIdNode of numIdNodes) {
       const oldNumRef = getElementId2(numIdNode, ["w:val", "val"]);
@@ -18721,6 +18835,8 @@ function areRevisionTokensEqual(a, b) {
 var attr2 = (node, name) => node?.getAttribute?.(`w:${name}`) || node?.getAttribute?.(name) || "";
 var descendants = (node, name) => Array.from(node?.getElementsByTagNameNS?.(NS_W, name) || []);
 var first = (node, name) => descendants(node, name)[0] || null;
+var directChild2 = (node, name) => Array.from(node?.childNodes || []).find((child) => child?.nodeType === 1 && child.localName === name && (!child.namespaceURI || child.namespaceURI === NS_W)) || null;
+var currentPPr = (paragraph) => directChild2(paragraph, "pPr");
 function hasAncestor(node, localName2) {
   let cursor = node?.parentNode;
   while (cursor) {
@@ -18736,11 +18852,11 @@ function parseXml2(xml, partName, required = false) {
   return { doc: parsed.doc, warnings: parsed.warnings || [] };
 }
 function paragraphListProperties(paragraph) {
-  const numPr = first(first(paragraph, "pPr"), "numPr");
+  const numPr = directChild2(currentPPr(paragraph), "numPr");
   if (!numPr) return null;
-  const numId = attr2(first(numPr, "numId"), "val");
+  const numId = attr2(directChild2(numPr, "numId"), "val");
   if (!numId || numId === "0") return null;
-  return { numId, level: Number.parseInt(attr2(first(numPr, "ilvl"), "val") || "0", 10) || 0 };
+  return { numId, level: Number.parseInt(attr2(directChild2(numPr, "ilvl"), "val") || "0", 10) || 0 };
 }
 function parseNumbering(numberingDoc) {
   const abstracts = /* @__PURE__ */ new Map();
@@ -18825,11 +18941,11 @@ function createNumberingResolver(numberingDoc) {
   };
 }
 function headingLevel(paragraph) {
-  const pPr = first(paragraph, "pPr");
-  const style = attr2(first(pPr, "pStyle"), "val");
+  const pPr = currentPPr(paragraph);
+  const style = attr2(directChild2(pPr, "pStyle"), "val");
   const match = style.match(/^heading\s*([1-9])$/i);
   if (match) return Math.min(Number(match[1]), 6);
-  const outline = Number.parseInt(attr2(first(pPr, "outlineLvl"), "val"), 10);
+  const outline = Number.parseInt(attr2(directChild2(pPr, "outlineLvl"), "val"), 10);
   return Number.isInteger(outline) ? Math.min(outline + 1, 6) : null;
 }
 function structuralContext(paragraph, text2) {
@@ -19008,7 +19124,7 @@ function inspectDocumentParts(parts, options = {}) {
     const ids = [...new Set([...descendants(paragraph, "commentRangeStart"), ...descendants(paragraph, "commentReference")].map((node) => attr2(node, "id")).filter(Boolean))];
     const authors = revisionAuthors(paragraph);
     const list = resolveNumbering(paragraphListProperties(paragraph));
-    const styleId = attr2(first(first(paragraph, "pPr"), "pStyle"), "val") || null;
+    const styleId = attr2(directChild2(currentPPr(paragraph), "pStyle"), "val") || null;
     const structure = structuralContext(paragraph, text2);
     const index = zeroIndex + 1;
     const provision = list?.label && list.format !== "bullet" ? list.label : null;
@@ -24409,7 +24525,9 @@ async function applyToParagraphByExactText(documentXml, targetText, modifiedText
         paragraphText,
         generateRedlines ? createRevisionMetadata(author, xmlDoc) : null,
         author,
-        { generateRedlines }
+        // A wholly inserted paragraph must track its own paragraph mark; otherwise Word's
+        // Reject All removes the text but leaves an empty paragraph behind.
+        { generateRedlines, trackParagraphMark: true }
       );
       const imported = xmlDoc.importNode(plainParagraph, true);
       ensureParagraphIdsOnImportedNode(imported, operationSession);
@@ -24540,6 +24658,14 @@ async function applyToParagraphByExactText(documentXml, targetText, modifiedText
   const extracted = extractReplacementNodes(result.oxml);
   let replacementNodes = removeListPackagingSentinel(extracted.replacementNodes, result.warnings);
   let numberingXml = extracted.numberingXml;
+  if (numberingXml && runtimeContext?.numberingIdState && !useTableScope) {
+    const sourceParagraphs = useListScope ? listScopeEdit.paragraphs : explicitRangeParagraphs || [targetParagraph];
+    const continued = reuseSourceListNumbering(numberingXml, replacementNodes, sourceParagraphs, runtimeContext.numberingIdState);
+    if (continued) {
+      replacementNodes = continued.replacementNodes;
+      numberingXml = null;
+    }
+  }
   if (numberingXml && runtimeContext?.numberingIdState) {
     const normalizedNumbering = remapNumberingPayloadForDocument(numberingXml, replacementNodes, runtimeContext.numberingIdState);
     replacementNodes = normalizedNumbering.replacementNodes;