@beyondwork/docx-react-component 1.0.57 → 1.0.59

package/src/io/ooxml/parse-revisions.ts

@@ -75,6 +75,8 @@ const SUPPORTED_CONTAINER_TYPES = new Set(["ins", "del"]);
 const PRESERVE_ONLY_CONTAINER_TYPES = new Set(["moveFrom", "moveTo"]);
 const PROPERTY_CHANGE_REVISION_TYPES = new Set(["rPrChange", "pPrChange"]);
 const STRUCTURAL_TABLE_REVISION_TYPES = new Set(["cellIns", "cellDel", "cellMerge"]);
+const MOVE_RANGE_START_TYPES = new Set(["moveFromRangeStart", "moveToRangeStart"]);
+const MOVE_RANGE_END_TYPES = new Set(["moveFromRangeEnd", "moveToRangeEnd"]);
 
 export function parseRevisionsFromDocumentXml(
   documentXml: string,
@@ -92,65 +94,118 @@ export function parseRevisionsFromDocumentXml(
     nextGeneratedIndex: 1,
   };
 
-  let paragraphIndex = -1;
-  let cursor = 0;
-  let previousWasParagraph = false;
+  const walkState = {
+    paragraphIndex: -1,
+    cursor: 0,
+    previousWasParagraph: false,
+    tableOrdinal: -1,
+  };
+
+  walkBodyChildren(bodyElement.children, walkState, state);
+
+  linkMoveRevisionPairs(state);
+
+  return {
+    revisions: state.revisions,
+    preservedMarkup: state.preservedMarkup.sort((left, right) => left.xmlStart - right.xmlStart),
+    diagnostics: state.diagnostics,
+    boundaries,
+  };
+}
 
-  for (const child of bodyElement.children) {
+interface BodyWalkState {
+  paragraphIndex: number;
+  cursor: number;
+  previousWasParagraph: boolean;
+  tableOrdinal: number;
+}
+
+function walkBodyChildren(
+  children: XmlNode[],
+  walkState: BodyWalkState,
+  state: ParseState,
+): void {
+  for (const child of children) {
     if (child.type !== "element") {
       continue;
     }
 
     const childType = localName(child.name);
 
-    if (childType !== "p") {
-      if (childType === "tbl") {
-        parseTblPropertyRevisions(child, cursor, state);
-        const nested = parseNestedParagraphContainers(
-          child.children,
-          paragraphIndex,
-          cursor,
-          previousWasParagraph,
-          state,
-        );
-        paragraphIndex = nested.paragraphIndex;
-        cursor = nested.cursor;
-        previousWasParagraph = nested.previousWasParagraph;
-      } else if (childType === "sectPr") {
-        parseSectPrRevisions(child, cursor, state);
-        cursor += 1;
-        previousWasParagraph = false;
-      } else {
-        cursor += 1;
-        previousWasParagraph = false;
+    if (childType === "p") {
+      if (walkState.previousWasParagraph) {
+        walkState.cursor += 1;
       }
+      walkState.paragraphIndex += 1;
+      const paragraphBoundary = state.boundaries[walkState.paragraphIndex];
+      if (!paragraphBoundary) {
+        continue;
+      }
+      parseParagraphMarkRevisions(child, paragraphBoundary, state);
+      walkParagraphContent(
+        child.children,
+        walkState.paragraphIndex,
+        state,
+        () => walkState.cursor,
+        (next) => {
+          walkState.cursor = next;
+        },
+      );
+      walkState.previousWasParagraph = true;
       continue;
     }
 
-    if (previousWasParagraph) {
-      cursor += 1;
+    if (childType === "tbl") {
+      walkState.tableOrdinal += 1;
+      parseTblPropertyRevisions(child, walkState.cursor, walkState.tableOrdinal, state);
+      const nested = parseNestedParagraphContainers(
+        child.children,
+        walkState.paragraphIndex,
+        walkState.cursor,
+        walkState.previousWasParagraph,
+        state,
+        [walkState.tableOrdinal],
+      );
+      walkState.paragraphIndex = nested.paragraphIndex;
+      walkState.cursor = nested.cursor;
+      walkState.previousWasParagraph = nested.previousWasParagraph;
+      continue;
     }
-    paragraphIndex += 1;
-    const paragraphBoundary = boundaries[paragraphIndex];
-    if (!paragraphBoundary) {
+
+    // Phase S: body-level SDT / customXml wrappers contribute their children
+    // to body scope. Tables inside them get flat body-level tableOrdinals
+    // (not nested paths) because the canonical-document projection preserves
+    // the SDT wrapper and `resolveCanonicalTableRow` descends into it to
+    // match ordinals.
+    if (
+      childType === "sdt" ||
+      childType === "sdtContent" ||
+      childType === "customXml" ||
+      childType === "smartTag"
+    ) {
+      walkBodyChildren(child.children, walkState, state);
       continue;
     }
 
-    parseParagraphMarkRevisions(child, paragraphBoundary, state);
-    walkParagraphContent(child.children, paragraphIndex, state, () => cursor, (next) => {
-      cursor = next;
-    });
-    previousWasParagraph = true;
-  }
+    if (childType === "sectPr") {
+      parseSectPrRevisions(child, walkState.cursor, state);
+      walkState.cursor += 1;
+      walkState.previousWasParagraph = false;
+      continue;
+    }
 
-  linkMoveRevisionPairs(state);
+    if (
+      MOVE_RANGE_START_TYPES.has(childType) ||
+      MOVE_RANGE_END_TYPES.has(childType)
+    ) {
+      parseMoveRangeMarker(child, childType, walkState.cursor, state);
+      walkState.previousWasParagraph = false;
+      continue;
+    }
 
-  return {
-    revisions: state.revisions,
-    preservedMarkup: state.preservedMarkup.sort((left, right) => left.xmlStart - right.xmlStart),
-    diagnostics: state.diagnostics,
-    boundaries,
-  };
+    walkState.cursor += 1;
+    walkState.previousWasParagraph = false;
+  }
 }
 
 function parseNestedParagraphContainers(
@@ -159,6 +214,8 @@ function parseNestedParagraphContainers(
   cursor: number,
   previousWasParagraph: boolean,
   state: ParseState,
+  parentPath?: readonly number[],
+  nestedTableCounter?: { value: number },
 ): {
   paragraphIndex: number;
   cursor: number;
@@ -167,6 +224,12 @@ function parseNestedParagraphContainers(
   let nextParagraphIndex = paragraphIndex;
   let nextCursor = cursor;
   let nextPreviousWasParagraph = previousWasParagraph;
+  // SHARED counter for nested <w:tbl> elements across the entire DFS walk of a
+  // single outer table. Created when first entering with parentPath (body
+  // loop or a new nested table); passed through recursive tr/tc/sdtContent
+  // calls so two sibling cells each containing a nested table get ordinals
+  // 0, 1 (matching `findNestedTableByOrdinal`'s DFS counter).
+  const counter = nestedTableCounter ?? { value: -1 };
 
   for (const node of nodes) {
     if (node.type !== "element") {
@@ -196,12 +259,30 @@ function parseNestedParagraphContainers(
       type === "customXml" ||
       type === "smartTag"
     ) {
+      let childParentPath = parentPath;
+      let childCounter = counter;
+
+      // For nested tables: call parseTblPropertyRevisions so that row/cell
+      // structural revisions inside the nested table get an ordinal path
+      // (tableOrdinalPath) instead of a body-level flat ordinal. (Phase Q)
+      if (type === "tbl" && parentPath !== undefined) {
+        counter.value += 1;
+        const myOrdinal = counter.value;
+        // parentPath (not nestedPath) because parseTableRowAndCellRevisions
+        // appends tableOrdinal itself to build the full tableOrdinalPath.
+        parseTblPropertyRevisions(node as XmlElementNode, nextCursor, myOrdinal, state, parentPath);
+        childParentPath = [...parentPath, myOrdinal];
+        // A new counter for THIS nested table's own direct-child tables.
+        childCounter = { value: -1 };
+      }
       const nested = parseNestedParagraphContainers(
         node.children,
         nextParagraphIndex,
         nextCursor,
         nextPreviousWasParagraph,
         state,
+        childParentPath,
+        childCounter,
       );
       nextParagraphIndex = nested.paragraphIndex;
       nextCursor = nested.cursor;
@@ -398,11 +479,7 @@ function walkContentNode(
     const length = measureStoryLength(node);
     const end = start + length;
     const hasNestedRevision = containsNestedRevision(node);
-    const metadata = readRevisionMetadata(
-      node,
-      state,
-      type === "moveFrom" || type === "moveTo" ? "move" : type,
-    );
+    const metadata = readRevisionMetadata(node, state, type);
 
     if (hasNestedRevision) {
       const nestedKind = type === "ins" ? "insertion" : type === "del" ? "deletion" : "move";
@@ -634,7 +711,9 @@ function parseRunFormattingRevisions(
 function parseTblPropertyRevisions(
   table: XmlElementNode,
   position: number,
+  tableOrdinal: number,
   state: ParseState,
+  parentPath?: readonly number[],
 ): void {
   const tblPr = findChildElement(table, "tblPr");
   if (tblPr) {
@@ -679,18 +758,87 @@ function parseTblPropertyRevisions(
     }
   }
 
-  parseTableRowAndCellRevisions(table, position, state);
+  parseTableRowAndCellRevisions(table, position, tableOrdinal, state, parentPath);
+}
+
+function parseMoveRangeMarker(
+  node: XmlElementNode,
+  markerType: string,
+  position: number,
+  state: ParseState,
+): void {
+  const direction: "from" | "to" = markerType.startsWith("moveFrom")
+    ? "from"
+    : "to";
+  const isStart =
+    markerType === "moveFromRangeStart" || markerType === "moveToRangeStart";
+
+  if (!isStart) {
+    // End markers serialize as-is; record only preservedMarkup so the
+    // serializer round-trips them losslessly. No revision record — the
+    // start marker owns the pairing.
+    state.preservedMarkup.push({
+      revisionId: `revision:${markerType}-${sanitizeRevisionToken(
+        node.attributes["w:id"] ?? node.attributes.id ?? `unknown-${state.nextGeneratedIndex++}`,
+      )}`,
+      rawXml: state.documentXml.slice(node.start, node.end),
+      xmlStart: node.start,
+      xmlEnd: node.end,
+      originalRevisionType: markerType,
+    });
+    return;
+  }
+
+  const metadata = readRevisionMetadata(node, state, markerType);
+  const moveData: MoveData = {
+    moveId: metadata.ooxmlRevisionId ?? `generated-${metadata.revisionId}`,
+    direction,
+  };
+
+  state.revisions.push(
+    createRevisionRecord({
+      revisionId: metadata.revisionId,
+      kind: "move",
+      anchor: createRevisionRangeAnchor(position, position),
+      authorId: metadata.authorId,
+      createdAt: metadata.createdAt,
+      metadata: {
+        source: "import",
+        originalRevisionType: markerType,
+        ooxmlRevisionId: metadata.ooxmlRevisionId,
+        preserveOnlyReason: "Imported preserve-only revision.",
+        moveData,
+      },
+    }),
+  );
+  state.preservedMarkup.push({
+    revisionId: metadata.revisionId,
+    rawXml: state.documentXml.slice(node.start, node.end),
+    xmlStart: node.start,
+    xmlEnd: node.end,
+    originalRevisionType: markerType,
+  });
+  state.diagnostics.push({
+    revisionId: metadata.revisionId,
+    code: "preserve_only_move_revision",
+    message: `Move range marker (${markerType}) parsed as preserve-only; pairing resolved in post-parse step.`,
+    featureClass: "preserve-only",
+  });
 }
 
 function parseTableRowAndCellRevisions(
   table: XmlElementNode,
   position: number,
+  tableOrdinal: number,
   state: ParseState,
+  parentPath?: readonly number[],
 ): void {
+  let rowIndex = -1;
   for (const child of table.children) {
     if (child.type !== "element" || localName(child.name) !== "tr") {
       continue;
     }
+    rowIndex += 1;
 
     const trPr = findChildElement(child, "trPr");
     if (trPr) {
@@ -728,12 +876,56 @@ function parseTableRowAndCellRevisions(
           beforeContainerXml: beforeXml,
         });
       }
+
+      // X4.a.3 — bare <w:ins>/<w:del> inside <w:trPr> mark the entire
+      // row as inserted/deleted. Distinct from cellIns/cellDel (which
+      // live inside tcPr) and from trPrChange (property diff).
+      for (const trChild of trPr.children) {
+        if (trChild.type !== "element") {
+          continue;
+        }
+        const trChildName = localName(trChild.name);
+        if (trChildName !== "ins" && trChildName !== "del") {
+          continue;
+        }
+        const markerType = trChildName === "ins" ? "row-ins" : "row-del";
+        const metadata = readRevisionMetadata(trChild, state, markerType);
+        state.revisions.push(
+          createRevisionRecord({
+            revisionId: metadata.revisionId,
+            kind: trChildName === "ins" ? "insertion" : "deletion",
+            anchor: createRevisionRangeAnchor(position, position),
+            authorId: metadata.authorId,
+            createdAt: metadata.createdAt,
+            metadata: {
+              source: "import",
+              originalRevisionType: markerType,
+              ooxmlRevisionId: metadata.ooxmlRevisionId,
+              semanticKind: "structural-change",
+              tableRevisionCoordinates: {
+                tableOrdinal,
+                rowIndex,
+                ...(parentPath ? { tableOrdinalPath: [...parentPath, tableOrdinal] } : {}),
+              },
+            },
+          }),
+        );
+        state.preservedMarkup.push({
+          revisionId: metadata.revisionId,
+          rawXml: state.documentXml.slice(trChild.start, trChild.end),
+          xmlStart: trChild.start,
+          xmlEnd: trChild.end,
+          originalRevisionType: markerType,
+        });
+      }
     }
 
+    let cellIndex = -1;
     for (const tcNode of child.children) {
       if (tcNode.type !== "element" || localName(tcNode.name) !== "tc") {
         continue;
       }
+      cellIndex += 1;
 
       const tcPr = findChildElement(tcNode, "tcPr");
       if (!tcPr) {
@@ -783,6 +975,44 @@ function parseTableRowAndCellRevisions(
         const tcChildName = localName(tcChild.name);
         if (STRUCTURAL_TABLE_REVISION_TYPES.has(tcChildName)) {
           const metadata = readRevisionMetadata(tcChild, state, tcChildName);
+          // Phase U: capture w:vMerge direction for cellMerge accept/reject.
+          const cellMergeDirection =
+            tcChildName === "cellMerge"
+              ? ((tcChild.attributes["w:vMerge"] ?? tcChild.attributes.vMerge ?? "rest") === "cont"
+                  ? "cont"
+                  : "rest")
+              : undefined;
+          const isActionable =
+            tcChildName === "cellIns" ||
+            tcChildName === "cellDel" ||
+            tcChildName === "cellMerge";
+          state.revisions.push(
+            createRevisionRecord({
+              revisionId: metadata.revisionId,
+              kind: "formatting",
+              anchor: createRevisionRangeAnchor(position, position),
+              authorId: metadata.authorId,
+              createdAt: metadata.createdAt,
+              metadata: {
+                source: "import",
+                originalRevisionType: tcChildName,
+                ooxmlRevisionId: metadata.ooxmlRevisionId,
+                semanticKind: "structural-change",
+                tableRevisionCoordinates: {
+                  tableOrdinal,
+                  rowIndex,
+                  cellIndex,
+                  ...(parentPath ? { tableOrdinalPath: [...parentPath, tableOrdinal] } : {}),
+                },
+                ...(cellMergeDirection ? { cellMergeData: { direction: cellMergeDirection } } : {}),
+                ...(isActionable
+                  ? {}
+                  : {
+                      preserveOnlyReason: `Structural table revision (${tcChildName}) preserved for round-trip.`,
+                    }),
+              },
+            }),
+          );
           state.preservedMarkup.push({
             revisionId: metadata.revisionId,
             rawXml: state.documentXml.slice(tcChild.start, tcChild.end),
@@ -792,9 +1022,13 @@ function parseTableRowAndCellRevisions(
           });
           state.diagnostics.push({
             revisionId: metadata.revisionId,
-            code: "table_structural_revision_preserve_only",
-            message: `Structural table revision (${tcChildName}) remains preserve-only; topology-altering changes cannot be safely applied.`,
-            featureClass: "preserve-only",
+            code: isActionable
+              ? "table_property_revision_parsed"
+              : "table_structural_revision_preserve_only",
+            message: isActionable
+              ? `Structural table revision (${tcChildName}) parsed as actionable structural-change.`
+              : `Structural table revision (${tcChildName}) remains preserve-only; topology-altering changes cannot be safely applied.`,
+            featureClass: isActionable ? "supported" : "preserve-only",
           });
         }
       }

package/src/io/ooxml/parse-settings.ts

@@ -5,14 +5,16 @@ import type {
   DocumentSettings,
   ThemeColorSlot,
 } from "../../model/canonical-document.ts";
+import { parseXml } from "./xml-parser.ts";
+import { localName } from "./xml-attr-helpers.ts";
 
-const CLRSCHEME_MAPPING_SLOTS = new Set<string>([
+const CLRSCHEME_MAPPING_SLOTS = new Set<ClrSchemeMappingSlot>([
   "bg1", "bg2", "t1", "t2",
   "accent1", "accent2", "accent3", "accent4", "accent5", "accent6",
   "hlink", "followedHyperlink",
 ]);
 
-const THEME_COLOR_SLOTS = new Set<string>([
+const THEME_COLOR_SLOTS = new Set<ThemeColorSlot>([
   "dk1", "lt1", "dk2", "lt2",
   "accent1", "accent2", "accent3", "accent4", "accent5", "accent6",
   "hlink", "folHlink",
@@ -161,8 +163,8 @@ function parseClrSchemeMapping(
   for (const [attr, value] of Object.entries(el.attributes)) {
     if (!value) continue;
     const local = localName(attr);
-    if (!CLRSCHEME_MAPPING_SLOTS.has(local)) continue;
-    if (!THEME_COLOR_SLOTS.has(value)) continue;
+    if (!CLRSCHEME_MAPPING_SLOTS.has(local as ClrSchemeMappingSlot)) continue;
+    if (!THEME_COLOR_SLOTS.has(value as ThemeColorSlot)) continue;
     mapping[local as ClrSchemeMappingSlot] = value as ThemeColorSlot;
   }
   return Object.keys(mapping).length > 0 ? mapping : undefined;
@@ -178,10 +180,6 @@ function findChildElementOptional(
   );
 }
 
-function localName(name: string): string {
-  const idx = name.indexOf(":");
-  return idx >= 0 ? name.slice(idx + 1) : name;
-}
 
 function readOnOffValue(
   element: XmlElementNode,
@@ -221,94 +219,3 @@ function readZoomLevel(
   return { zoomLevel: parsed };
 }
 
-function parseXml(xml: string): XmlElementNode {
-  const root: XmlElementNode = {
-    type: "element",
-    name: "__root__",
-    attributes: {},
-    children: [],
-  };
-  const stack: XmlElementNode[] = [root];
-  let cursor = 0;
-
-  while (cursor < xml.length) {
-    if (xml.startsWith("<!--", cursor)) {
-      const end = xml.indexOf("-->", cursor);
-      cursor = end >= 0 ? end + 3 : xml.length;
-      continue;
-    }
-
-    if (xml.startsWith("<?", cursor)) {
-      const end = xml.indexOf("?>", cursor);
-      cursor = end >= 0 ? end + 2 : xml.length;
-      continue;
-    }
-
-    const nextLt = xml.indexOf("<", cursor);
-    if (nextLt < 0) {
-      pushText(xml.slice(cursor));
-      break;
-    }
-
-    if (nextLt > cursor) {
-      pushText(xml.slice(cursor, nextLt));
-    }
-
-    if (xml.startsWith("</", nextLt)) {
-      const end = xml.indexOf(">", nextLt);
-      if (end < 0) break;
-      if (stack.length > 1) {
-        stack.pop();
-      }
-      cursor = end + 1;
-      continue;
-    }
-
-    const end = xml.indexOf(">", nextLt);
-    if (end < 0) {
-      break;
-    }
-
-    const rawTag = xml.slice(nextLt + 1, end).trim();
-    const selfClosing = rawTag.endsWith("/");
-    const tagBody = selfClosing ? rawTag.slice(0, -1).trim() : rawTag;
-    const spaceIndex = tagBody.search(/\s/u);
-    const name =
-      spaceIndex >= 0 ? tagBody.slice(0, spaceIndex) : tagBody;
-    const attrs = spaceIndex >= 0 ? tagBody.slice(spaceIndex + 1) : "";
-    const element: XmlElementNode = {
-      type: "element",
-      name,
-      attributes: parseAttributes(attrs),
-      children: [],
-    };
-    stack[stack.length - 1]?.children.push(element);
-    if (!selfClosing) {
-      stack.push(element);
-    }
-    cursor = end + 1;
-  }
-
-  return root;
-
-  function pushText(raw: string): void {
-    const normalized = raw.replace(/\r\n?/gu, "\n");
-    if (!normalized.trim()) {
-      return;
-    }
-    stack[stack.length - 1]?.children.push({
-      type: "text",
-      text: normalized,
-    });
-  }
-}
-
-function parseAttributes(raw: string): Record<string, string> {
-  const attributes: Record<string, string> = {};
-  const pattern = /([^\s=]+)\s*=\s*("([^"]*)"|'([^']*)')/gu;
-  for (const match of raw.matchAll(pattern)) {
-    const [, name, , dq, sq] = match;
-    attributes[name] = dq ?? sq ?? "";
-  }
-  return attributes;
-}