@beyondwork/docx-react-component 1.0.18 → 1.0.20

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

@@ -147,6 +147,11 @@ function readLevels(abstractNode: XmlElementNode): NumberingLevelDefinition[] {
     const text = textNode?.attributes["w:val"] ?? textNode?.attributes.val ?? `%${level + 1}.`;
     const paragraphStyleId =
       paragraphStyleNode?.attributes["w:val"] ?? paragraphStyleNode?.attributes.val;
+    const isLegalNode = findChildElementOptional(child, "isLgl");
+    const isLegalNumbering = isLegalNode !== undefined;
+    const suffixNode = findChildElementOptional(child, "suff");
+    const suffixVal = suffixNode?.attributes["w:val"] ?? suffixNode?.attributes.val;
+    const suffix = suffixVal === "space" || suffixVal === "nothing" ? suffixVal : suffixVal === "tab" ? "tab" : undefined;
 
     levels.push({
       level,
@@ -154,6 +159,8 @@ function readLevels(abstractNode: XmlElementNode): NumberingLevelDefinition[] {
       text,
       ...(startAt !== undefined ? { startAt } : {}),
       ...(paragraphStyleId ? { paragraphStyleId } : {}),
+      ...(isLegalNumbering ? { isLegalNumbering } : {}),
+      ...(suffix ? { suffix } : {}),
     });
   }
 

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

@@ -38,9 +38,14 @@ export interface RevisionImportDiagnostic {
     | "preserve_only_move_revision"
     | "preserve_only_formatting_revision"
     | "nested_revision_preserve_only"
-    | "ambiguous_revision_anchor";
+    | "shallow_nested_revision_promoted"
+    | "linked_move_pair"
+    | "unlinked_move_revision"
+    | "ambiguous_revision_anchor"
+    | "table_structural_revision_preserve_only"
+    | "table_property_revision_parsed";
   message: string;
-  featureClass: "preserve-only";
+  featureClass: "preserve-only" | "supported" | "informational";
 }
 
 export interface ParsedRevisionsResult {
@@ -69,6 +74,7 @@ interface RevisionMetadata {
 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"]);
 
 export function parseRevisionsFromDocumentXml(
   documentXml: string,
@@ -124,6 +130,8 @@ export function parseRevisionsFromDocumentXml(
     previousWasParagraph = true;
   }
 
+  linkMoveRevisionPairs(state);
+
   return {
     revisions: state.revisions,
     preservedMarkup: state.preservedMarkup.sort((left, right) => left.xmlStart - right.xmlStart),
@@ -284,6 +292,46 @@ function walkContentNode(
 
     if (hasNestedRevision) {
       const nestedKind = type === "ins" ? "insertion" : type === "del" ? "deletion" : "move";
+      const isShallowNesting = isShallowPropertyChangeNesting(node);
+
+      if (isShallowNesting && SUPPORTED_CONTAINER_TYPES.has(type)) {
+        state.revisions.push(
+          createRevisionRecord({
+            revisionId: metadata.revisionId,
+            kind: nestedKind as "insertion" | "deletion",
+            anchor:
+              length > 0
+                ? createRevisionRangeAnchor(start, end)
+                : createDetachedAnchor({ from: start, to: end }, "importAmbiguity"),
+            authorId: metadata.authorId,
+            createdAt: metadata.createdAt,
+            metadata: {
+              source: "import",
+              importedRevisionForm:
+                type === "ins" ? "run-insertion" : "run-deletion",
+              originalRevisionType: type,
+              ooxmlRevisionId: metadata.ooxmlRevisionId,
+            },
+          }),
+        );
+        state.preservedMarkup.push({
+          revisionId: metadata.revisionId,
+          rawXml: state.documentXml.slice(node.start, node.end),
+          xmlStart: node.start,
+          xmlEnd: node.end,
+          originalRevisionType: type,
+        });
+        state.diagnostics.push({
+          revisionId: metadata.revisionId,
+          code: "shallow_nested_revision_promoted",
+          message: "Shallow nested revision (property changes inside ins/del) promoted to supported rendering.",
+          featureClass: "supported",
+        });
+        parseNestedPropertyChangeRevisions(node, paragraphIndex, state, start);
+        advanceCursor(node, setCursor, getCursor);
+        return;
+      }
+
       state.revisions.push(
         createRevisionRecord({
           revisionId: metadata.revisionId,
@@ -353,7 +401,7 @@ function walkContentNode(
       state.diagnostics.push({
         revisionId: metadata.revisionId,
         code: "preserve_only_move_revision",
-        message: "Tracked move revisions are preserve-only. Content is preserved for round-trip but cannot be accepted or rejected.",
+        message: "Move revision parsed as preserve-only. Content is preserved for round-trip; linking resolved in post-parse step.",
         featureClass: "preserve-only",
       });
       advanceCursor(node, setCursor, getCursor);
@@ -475,45 +523,169 @@ function parseTblPropertyRevisions(
   state: ParseState,
 ): void {
   const tblPr = findChildElement(table, "tblPr");
-  if (!tblPr) {
-    return;
-  }
+  if (tblPr) {
+    const tblPrChange = findChildElement(tblPr, "tblPrChange");
+    if (tblPrChange) {
+      const metadata = readRevisionMetadata(tblPrChange, state, "property-change");
+      const innerTblPr = findChildElement(tblPrChange, "tblPr");
+      const beforeXml = innerTblPr ? state.documentXml.slice(innerTblPr.start, innerTblPr.end) : "";
+      const propertyChangeData: PropertyChangeData = { xmlTag: "tblPrChange", beforeXml };
 
-  const tblPrChange = findChildElement(tblPr, "tblPrChange");
-  if (!tblPrChange) {
-    return;
+      state.revisions.push(
+        createRevisionRecord({
+          revisionId: metadata.revisionId,
+          kind: "property-change",
+          anchor: createRevisionRangeAnchor(position, position),
+          authorId: metadata.authorId,
+          createdAt: metadata.createdAt,
+          metadata: {
+            source: "import",
+            originalRevisionType: "tblPrChange",
+            ooxmlRevisionId: metadata.ooxmlRevisionId,
+            propertyChangeData,
+          },
+        }),
+      );
+      state.preservedMarkup.push({
+        revisionId: metadata.revisionId,
+        rawXml: state.documentXml.slice(tblPrChange.start, tblPrChange.end),
+        xmlStart: tblPrChange.start,
+        xmlEnd: tblPrChange.end,
+        originalRevisionType: "tblPrChange",
+        containerXmlStart: tblPr.start,
+        containerXmlEnd: tblPr.end,
+        beforeContainerXml: beforeXml,
+      });
+      state.diagnostics.push({
+        revisionId: metadata.revisionId,
+        code: "table_property_revision_parsed",
+        message: "Table property change (tblPrChange) parsed as actionable property-change revision.",
+        featureClass: "supported",
+      });
+    }
   }
 
-  const metadata = readRevisionMetadata(tblPrChange, state, "property-change");
-  const innerTblPr = findChildElement(tblPrChange, "tblPr");
-  const beforeXml = innerTblPr ? state.documentXml.slice(innerTblPr.start, innerTblPr.end) : "";
-  const propertyChangeData: PropertyChangeData = { xmlTag: "tblPrChange", beforeXml };
+  parseTableRowAndCellRevisions(table, position, state);
+}
 
-  state.revisions.push(
-    createRevisionRecord({
-      revisionId: metadata.revisionId,
-      kind: "property-change",
-      anchor: createRevisionRangeAnchor(position, position),
-      authorId: metadata.authorId,
-      createdAt: metadata.createdAt,
-      metadata: {
-        source: "import",
-        originalRevisionType: "tblPrChange",
-        ooxmlRevisionId: metadata.ooxmlRevisionId,
-        propertyChangeData,
-      },
-    }),
-  );
-  state.preservedMarkup.push({
-    revisionId: metadata.revisionId,
-    rawXml: state.documentXml.slice(tblPrChange.start, tblPrChange.end),
-    xmlStart: tblPrChange.start,
-    xmlEnd: tblPrChange.end,
-    originalRevisionType: "tblPrChange",
-    containerXmlStart: tblPr.start,
-    containerXmlEnd: tblPr.end,
-    beforeContainerXml: beforeXml,
-  });
+function parseTableRowAndCellRevisions(
+  table: XmlElementNode,
+  position: number,
+  state: ParseState,
+): void {
+  for (const child of table.children) {
+    if (child.type !== "element" || localName(child.name) !== "tr") {
+      continue;
+    }
+
+    const trPr = findChildElement(child, "trPr");
+    if (trPr) {
+      const trPrChange = findChildElement(trPr, "trPrChange");
+      if (trPrChange) {
+        const metadata = readRevisionMetadata(trPrChange, state, "property-change");
+        const innerTrPr = findChildElement(trPrChange, "trPr");
+        const beforeXml = innerTrPr ? state.documentXml.slice(innerTrPr.start, innerTrPr.end) : "";
+        const propertyChangeData: PropertyChangeData = { xmlTag: "tblPrChange", beforeXml };
+
+        state.revisions.push(
+          createRevisionRecord({
+            revisionId: metadata.revisionId,
+            kind: "property-change",
+            anchor: createRevisionRangeAnchor(position, position),
+            authorId: metadata.authorId,
+            createdAt: metadata.createdAt,
+            metadata: {
+              source: "import",
+              originalRevisionType: "trPrChange",
+              ooxmlRevisionId: metadata.ooxmlRevisionId,
+              propertyChangeData,
+              preserveOnlyReason: "Row property changes remain preserve-only for export safety.",
+            },
+          }),
+        );
+        state.preservedMarkup.push({
+          revisionId: metadata.revisionId,
+          rawXml: state.documentXml.slice(trPrChange.start, trPrChange.end),
+          xmlStart: trPrChange.start,
+          xmlEnd: trPrChange.end,
+          originalRevisionType: "trPrChange",
+          containerXmlStart: trPr.start,
+          containerXmlEnd: trPr.end,
+          beforeContainerXml: beforeXml,
+        });
+      }
+    }
+
+    for (const tcNode of child.children) {
+      if (tcNode.type !== "element" || localName(tcNode.name) !== "tc") {
+        continue;
+      }
+
+      const tcPr = findChildElement(tcNode, "tcPr");
+      if (!tcPr) {
+        continue;
+      }
+
+      const tcPrChange = findChildElement(tcPr, "tcPrChange");
+      if (tcPrChange) {
+        const metadata = readRevisionMetadata(tcPrChange, state, "property-change");
+        const innerTcPr = findChildElement(tcPrChange, "tcPr");
+        const beforeXml = innerTcPr ? state.documentXml.slice(innerTcPr.start, innerTcPr.end) : "";
+        const propertyChangeData: PropertyChangeData = { xmlTag: "tblPrChange", beforeXml };
+
+        state.revisions.push(
+          createRevisionRecord({
+            revisionId: metadata.revisionId,
+            kind: "property-change",
+            anchor: createRevisionRangeAnchor(position, position),
+            authorId: metadata.authorId,
+            createdAt: metadata.createdAt,
+            metadata: {
+              source: "import",
+              originalRevisionType: "tcPrChange",
+              ooxmlRevisionId: metadata.ooxmlRevisionId,
+              propertyChangeData,
+              preserveOnlyReason: "Cell property changes remain preserve-only for export safety.",
+            },
+          }),
+        );
+        state.preservedMarkup.push({
+          revisionId: metadata.revisionId,
+          rawXml: state.documentXml.slice(tcPrChange.start, tcPrChange.end),
+          xmlStart: tcPrChange.start,
+          xmlEnd: tcPrChange.end,
+          originalRevisionType: "tcPrChange",
+          containerXmlStart: tcPr.start,
+          containerXmlEnd: tcPr.end,
+          beforeContainerXml: beforeXml,
+        });
+      }
+
+      for (const tcChild of tcPr.children) {
+        if (tcChild.type !== "element") {
+          continue;
+        }
+
+        const tcChildName = localName(tcChild.name);
+        if (STRUCTURAL_TABLE_REVISION_TYPES.has(tcChildName)) {
+          const metadata = readRevisionMetadata(tcChild, state, tcChildName);
+          state.preservedMarkup.push({
+            revisionId: metadata.revisionId,
+            rawXml: state.documentXml.slice(tcChild.start, tcChild.end),
+            xmlStart: tcChild.start,
+            xmlEnd: tcChild.end,
+            originalRevisionType: tcChildName,
+          });
+          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",
+          });
+        }
+      }
+    }
+  }
 }
 
 function parseSectPrRevisions(
@@ -604,6 +776,113 @@ function sanitizeRevisionToken(value: string): string {
   return sanitized.length > 0 ? sanitized : "unknown";
 }
 
+function linkMoveRevisionPairs(state: ParseState): void {
+  const moveRevisions = state.revisions.filter(
+    (r) => r.kind === "move" && r.metadata.moveData,
+  );
+
+  const byMoveId = new Map<string, typeof moveRevisions>();
+  for (const revision of moveRevisions) {
+    const moveId = revision.metadata.moveData!.moveId;
+    const group = byMoveId.get(moveId) ?? [];
+    group.push(revision);
+    byMoveId.set(moveId, group);
+  }
+
+  for (const [moveId, group] of byMoveId) {
+    const fromRevision = group.find(
+      (r) => r.metadata.moveData!.direction === "from",
+    );
+    const toRevision = group.find(
+      (r) => r.metadata.moveData!.direction === "to",
+    );
+
+    if (fromRevision && toRevision) {
+      fromRevision.metadata.moveData!.linkedRevisionId = toRevision.revisionId;
+      toRevision.metadata.moveData!.linkedRevisionId = fromRevision.revisionId;
+
+      state.diagnostics.push({
+        revisionId: fromRevision.revisionId,
+        code: "linked_move_pair",
+        message: `Move-from revision linked to move-to revision ${toRevision.revisionId} via moveId ${moveId}.`,
+        featureClass: "informational",
+      });
+      state.diagnostics.push({
+        revisionId: toRevision.revisionId,
+        code: "linked_move_pair",
+        message: `Move-to revision linked to move-from revision ${fromRevision.revisionId} via moveId ${moveId}.`,
+        featureClass: "informational",
+      });
+    } else {
+      for (const revision of group) {
+        state.diagnostics.push({
+          revisionId: revision.revisionId,
+          code: "unlinked_move_revision",
+          message: `Move revision has no matching counterpart for moveId ${moveId}. Remains preserve-only.`,
+          featureClass: "preserve-only",
+        });
+      }
+    }
+  }
+}
+
+function isShallowPropertyChangeNesting(node: XmlElementNode): boolean {
+  for (const child of node.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+
+    const name = localName(child.name);
+
+    if (SUPPORTED_CONTAINER_TYPES.has(name) || PRESERVE_ONLY_CONTAINER_TYPES.has(name)) {
+      return false;
+    }
+
+    if (name === "r") {
+      const runProperties = findChildElement(child, "rPr");
+      if (runProperties) {
+        for (const rpChild of runProperties.children) {
+          if (rpChild.type !== "element") {
+            continue;
+          }
+
+          const rpChildName = localName(rpChild.name);
+          if (
+            SUPPORTED_CONTAINER_TYPES.has(rpChildName) ||
+            PRESERVE_ONLY_CONTAINER_TYPES.has(rpChildName)
+          ) {
+            return false;
+          }
+        }
+      }
+      continue;
+    }
+
+    if (!isShallowPropertyChangeNesting(child)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function parseNestedPropertyChangeRevisions(
+  container: XmlElementNode,
+  paragraphIndex: number,
+  state: ParseState,
+  containerStart: number,
+): void {
+  for (const child of container.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+
+    if (localName(child.name) === "r") {
+      parseRunFormattingRevisions(child, paragraphIndex, state, containerStart);
+    }
+  }
+}
+
 function containsNestedRevision(node: XmlElementNode): boolean {
   return node.children.some(
     (child) =>

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

@@ -0,0 +1,184 @@
+import type { DocumentSettings } from "../../model/canonical-document.ts";
+
+interface XmlElementNode {
+  type: "element";
+  name: string;
+  attributes: Record<string, string>;
+  children: XmlNode[];
+}
+
+interface XmlTextNode {
+  type: "text";
+  text: string;
+}
+
+type XmlNode = XmlElementNode | XmlTextNode;
+
+export function parseSettingsXml(xml: string): DocumentSettings {
+  if (!xml.trim()) {
+    return {};
+  }
+
+  const root = parseXml(xml);
+  const settingsElement = findChildElementOptional(root, "settings");
+  if (!settingsElement) {
+    return {};
+  }
+
+  const evenAndOddHeaders = findChildElementOptional(settingsElement, "evenAndOddHeaders");
+  const zoom = findChildElementOptional(settingsElement, "zoom");
+
+  return {
+    ...(evenAndOddHeaders
+      ? {
+          evenAndOddHeaders: readOnOffValue(evenAndOddHeaders, true),
+        }
+      : {}),
+    ...(zoom ? readZoomLevel(zoom) : {}),
+  };
+}
+
+function findChildElementOptional(
+  node: XmlElementNode,
+  childLocalName: string,
+): XmlElementNode | undefined {
+  return node.children.find(
+    (entry): entry is XmlElementNode =>
+      entry.type === "element" && localName(entry.name) === childLocalName,
+  );
+}
+
+function localName(name: string): string {
+  const idx = name.indexOf(":");
+  return idx >= 0 ? name.slice(idx + 1) : name;
+}
+
+function readOnOffValue(
+  element: XmlElementNode,
+  defaultValue: boolean,
+): boolean {
+  const value =
+    element.attributes["w:val"] ??
+    element.attributes.val ??
+    (defaultValue ? "true" : "false");
+  return value !== "0" && value !== "false";
+}
+
+function readZoomLevel(
+  element: XmlElementNode,
+): Pick<DocumentSettings, "zoomLevel"> {
+  const rawValue = element.attributes["w:val"] ?? element.attributes.val;
+  if (rawValue === "bestFit") {
+    return { zoomLevel: "pageWidth" };
+  }
+  if (rawValue === "fullPage") {
+    return { zoomLevel: "onePage" };
+  }
+
+  const rawPercent =
+    element.attributes["w:percent"] ??
+    element.attributes.percent;
+  if (!rawPercent) {
+    return {};
+  }
+
+  const normalizedPercent = rawPercent.trim().replace(/%$/u, "");
+  const parsed = Number.parseInt(normalizedPercent, 10);
+  if (!Number.isFinite(parsed)) {
+    return {};
+  }
+
+  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;
+}

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

@@ -15,8 +15,12 @@ const WPS_SHAPE_GRAPHIC_URI =
 
 export interface ParsedWpsShape {
   type: "shape";
+  /** True if this shape is a text box (geometry=rect with txbx content). */
+  isTextBox?: boolean;
   /** Extracted text content from wps:txbx for display. */
   text?: string;
+  /** Raw txbxContent XML for structured re-rendering. */
+  txbxContentXml?: string;
   /** DrawML geometry preset, e.g. "rect", "roundRect". */
   geometry?: string;
   /** Original drawing XML for lossless round-trip export. */
@@ -81,9 +85,17 @@ export function parseShapeXml(drawingXml: string): ParsedWpsShape | ParsedWordAr
     };
   }
 
+  // Text box detection: rect or no geometry with text content
+  const isTextBox = Boolean(txbxContent && (!prst || prst === "rect"));
+
+  // Extract raw txbxContent XML for structured re-rendering of text boxes
+  const txbxContentXml = txbxContent ? extractRawXml(txbxContent, drawingXml) : undefined;
+
   return {
     type: "shape",
+    ...(isTextBox ? { isTextBox: true } : {}),
     ...(text ? { text } : {}),
+    ...(txbxContentXml ? { txbxContentXml } : {}),
     ...(prst ? { geometry: prst } : {}),
     rawXml: drawingXml,
   };
@@ -131,6 +143,19 @@ export function parseVmlXml(pictXml: string): ParsedVmlShape | null {
   };
 }
 
+// ---- Raw XML extraction helpers ----
+
+function extractRawXml(node: XmlElementNode, sourceXml: string): string | undefined {
+  // Find the txbxContent element boundaries in the source XML by tag name
+  const tagName = node.name;
+  const openIdx = sourceXml.indexOf(`<${tagName}`);
+  if (openIdx < 0) return undefined;
+  const closeTag = `</${tagName}>`;
+  const closeIdx = sourceXml.indexOf(closeTag, openIdx);
+  if (closeIdx < 0) return undefined;
+  return sourceXml.slice(openIdx, closeIdx + closeTag.length);
+}
+
 // ---- Text extraction helpers ----
 
 function extractAllText(node: XmlElementNode): string {