@beyondwork/docx-react-component 1.0.18 → 1.0.20

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

@@ -3,7 +3,12 @@ import type {
   FootnoteCollection,
   FootnoteDefinition,
   InlineNode,
+  ParagraphIndentation,
   ParagraphNode,
+  ParagraphSpacing,
+  TableCellNode,
+  TableNode,
+  TableRowNode,
   TextMark,
 } from "../../model/canonical-document.ts";
 
@@ -137,16 +142,24 @@ function parseNoteElement(
     if (name === "p") {
       blocks.push(parseParagraphElement(child));
     } else if (name === "tbl") {
-      blocks.push({
-        type: "opaque_block",
-        fragmentId: `fragment:note-tbl-${noteId}`,
-        warningId: `warning:note-opaque-table`,
-      });
+      // Simple tables (no revisions, fields, or nested tables) are promoted
+      // to supported-roundtrip; structurally risky tables stay opaque.
+      if (isSimpleSecondaryStoryTable(child)) {
+        blocks.push(parseSimpleTableElement(child));
+      } else {
+        blocks.push({
+          type: "opaque_block",
+          fragmentId: `fragment:note-tbl-${noteId}`,
+          warningId: `warning:note-opaque-table`,
+          rawXml: serializeElementToXml(child),
+        });
+      }
     } else {
       blocks.push({
         type: "opaque_block",
         fragmentId: `fragment:note-opaque-${noteId}`,
         warningId: `warning:note-opaque-block`,
+        rawXml: serializeElementToXml(child),
       });
     }
   }
@@ -156,7 +169,15 @@ function parseNoteElement(
 
 function parseParagraphElement(pElement: XmlElementNode): ParagraphNode {
   let styleId: string | undefined;
+  let alignment: ParagraphNode["alignment"];
+  let spacing: ParagraphNode["spacing"];
+  let indentation: ParagraphNode["indentation"];
   const children: InlineNode[] = [];
+  let activeComplexField: {
+    instruction: string;
+    children: InlineNode[];
+    mode: "instruction" | "result";
+  } | null = null;
 
   for (const child of pElement.children) {
     if (child.type !== "element") {
@@ -168,24 +189,141 @@ function parseParagraphElement(pElement: XmlElementNode): ParagraphNode {
     if (name === "pPr") {
       const pStyle = findChildElementOptional(child, "pStyle");
       styleId = pStyle?.attributes["w:val"] ?? pStyle?.attributes.val;
+      const jc = findChildElementOptional(child, "jc");
+      const jcVal = jc?.attributes["w:val"] ?? jc?.attributes.val;
+      if (jcVal === "left" || jcVal === "center" || jcVal === "right" || jcVal === "both" || jcVal === "distribute") {
+        alignment = jcVal;
+      }
+      spacing = readParagraphSpacing(child);
+      indentation = readParagraphIndentation(child);
     } else if (name === "r") {
-      children.push(...parseRunElement(child));
+      activeComplexField = appendRunNodes(child, children, activeComplexField);
     } else if (name === "hyperlink") {
+      if (activeComplexField && activeComplexField.instruction.trim().length > 0) {
+        children.push({
+          type: "field",
+          fieldType: "complex",
+          instruction: activeComplexField.instruction,
+          children: activeComplexField.children,
+        });
+        activeComplexField = null;
+      }
       children.push(parseHyperlinkElement(child));
     } else if (name === "bookmarkStart" || name === "bookmarkEnd") {
-      children.push(parseBookmarkElement(child));
+      const bookmarkNode = parseBookmarkElement(child);
+      if (activeComplexField?.mode === "result") {
+        activeComplexField.children.push(bookmarkNode);
+      } else {
+        if (activeComplexField && activeComplexField.instruction.trim().length > 0) {
+          children.push({
+            type: "field",
+            fieldType: "complex",
+            instruction: activeComplexField.instruction,
+            children: activeComplexField.children,
+          });
+          activeComplexField = null;
+        }
+        children.push(bookmarkNode);
+      }
     } else if (name === "fldSimple") {
-      children.push(parseFieldElement(child));
+      if (activeComplexField && activeComplexField.instruction.trim().length > 0) {
+        children.push({
+          type: "field",
+          fieldType: "complex",
+          instruction: activeComplexField.instruction,
+          children: activeComplexField.children,
+        });
+        activeComplexField = null;
+      }
+      pushFieldNode(children, child, "simple");
     }
   }
 
+  if (activeComplexField && activeComplexField.instruction.trim().length > 0) {
+    children.push({
+      type: "field",
+      fieldType: "complex",
+      instruction: activeComplexField.instruction,
+      children: activeComplexField.children,
+    });
+  }
+
   return {
     type: "paragraph",
     ...(styleId ? { styleId } : {}),
+    ...(alignment ? { alignment } : {}),
+    ...(spacing ? { spacing } : {}),
+    ...(indentation ? { indentation } : {}),
     children,
   };
 }
 
+function appendRunNodes(
+  rElement: XmlElementNode,
+  nodes: InlineNode[],
+  activeComplexField: {
+    instruction: string;
+    children: InlineNode[];
+    mode: "instruction" | "result";
+  } | null,
+): {
+  instruction: string;
+  children: InlineNode[];
+  mode: "instruction" | "result";
+} | null {
+  const marks: TextMark[] = parseRunProperties(rElement);
+
+  for (const child of rElement.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+
+    const name = localName(child.name);
+    if (name === "fldChar") {
+      const fldType = child.attributes["w:fldCharType"] ?? child.attributes.fldCharType;
+      if (fldType === "begin") {
+        activeComplexField = { instruction: "", children: [], mode: "instruction" };
+      } else if (fldType === "separate" && activeComplexField) {
+        activeComplexField.mode = "result";
+      } else if (fldType === "end" && activeComplexField) {
+        if (activeComplexField.instruction.trim().length > 0) {
+          nodes.push({
+            type: "field",
+            fieldType: "complex",
+            instruction: activeComplexField.instruction,
+            children: activeComplexField.children,
+          });
+        }
+        activeComplexField = null;
+      }
+      continue;
+    }
+
+    if (name === "instrText") {
+      if (activeComplexField) {
+        activeComplexField.instruction += extractTextContent(child);
+      } else {
+        pushFieldNode(nodes, child, "complex");
+      }
+      continue;
+    }
+
+    const inlineNode = parseRunChildNode(child, marks);
+    if (!inlineNode) {
+      continue;
+    }
+
+    if (activeComplexField?.mode === "result") {
+      activeComplexField.children.push(inlineNode);
+      continue;
+    }
+
+    nodes.push(inlineNode);
+  }
+
+  return activeComplexField;
+}
+
 function parseRunElement(rElement: XmlElementNode): InlineNode[] {
   const nodes: InlineNode[] = [];
   const marks: TextMark[] = parseRunProperties(rElement);
@@ -226,14 +364,60 @@ function parseRunElement(rElement: XmlElementNode): InlineNode[] {
       }
     } else if (name === "bookmarkStart" || name === "bookmarkEnd") {
       nodes.push(parseBookmarkElement(child));
-    } else if (name === "fldChar" || name === "instrText") {
-      nodes.push(parseFieldElement(child));
+    } else if (name === "instrText") {
+      pushFieldNode(nodes, child, "complex");
     }
   }
 
   return nodes;
 }
 
+function parseRunChildNode(
+  child: XmlElementNode,
+  marks: TextMark[],
+): InlineNode | null {
+  const name = localName(child.name);
+
+  if (name === "t") {
+    const text = extractTextContent(child);
+    if (text.length > 0) {
+      return {
+        type: "text",
+        text,
+        ...(marks.length > 0 ? { marks } : {}),
+      };
+    }
+    return null;
+  }
+  if (name === "br") {
+    return { type: "hard_break" };
+  }
+  if (name === "tab") {
+    return { type: "tab" };
+  }
+  if (name === "footnoteReference") {
+    const noteId =
+      child.attributes["w:id"] ?? child.attributes.id ?? "";
+    if (noteId) {
+      return { type: "footnote_ref", noteId, noteKind: "footnote" };
+    }
+    return null;
+  }
+  if (name === "endnoteReference") {
+    const noteId =
+      child.attributes["w:id"] ?? child.attributes.id ?? "";
+    if (noteId) {
+      return { type: "footnote_ref", noteId, noteKind: "endnote" };
+    }
+    return null;
+  }
+  if (name === "bookmarkStart" || name === "bookmarkEnd") {
+    return parseBookmarkElement(child);
+  }
+
+  return null;
+}
+
 function parseHyperlinkElement(element: XmlElementNode): Extract<InlineNode, { type: "hyperlink" }> {
   const href = element.attributes["w:anchor"]
     ? `#${element.attributes["w:anchor"]}`
@@ -275,22 +459,30 @@ function parseBookmarkElement(
   };
 }
 
-function parseFieldElement(element: XmlElementNode): Extract<InlineNode, { type: "field" }> {
-  const rawFieldType =
-    element.attributes["w:fldCharType"] ??
-    element.attributes.fldCharType ??
-    localName(element.name);
-  const fieldType: "simple" | "complex" = rawFieldType === "complex" ? "complex" : "simple";
-  const instruction =
-    element.attributes["w:instr"] ??
-    element.attributes.instr ??
-    extractTextContent(element);
-  return {
+function pushFieldNode(
+  nodes: InlineNode[],
+  element: XmlElementNode,
+  fieldType: "simple" | "complex",
+): void {
+  const instruction = readFieldInstruction(element);
+  if (!instruction) {
+    return;
+  }
+
+  nodes.push({
     type: "field",
     fieldType,
     instruction,
     children: [],
-  };
+  });
+}
+
+function readFieldInstruction(element: XmlElementNode): string | undefined {
+  const instruction =
+    element.attributes["w:instr"] ??
+    element.attributes.instr ??
+    extractTextContent(element);
+  return instruction.trim().length > 0 ? instruction : undefined;
 }
 
 function parseRunProperties(rElement: XmlElementNode): TextMark[] {
@@ -322,12 +514,75 @@ function parseRunProperties(rElement: XmlElementNode): TextMark[] {
       case "strike":
         if (val !== "0" && val !== "false") marks.push({ type: "strikethrough" });
         break;
+      case "dstrike":
+        if (val !== "0" && val !== "false") marks.push({ type: "doubleStrikethrough" });
+        break;
+      case "rFonts": {
+        const family =
+          child.attributes["w:ascii"] ??
+          child.attributes["w:hAnsi"] ??
+          child.attributes.ascii ??
+          child.attributes.hAnsi;
+        if (family) marks.push({ type: "fontFamily", val: family });
+        break;
+      }
+      case "sz": {
+        const szVal = child.attributes["w:val"] ?? child.attributes.val;
+        if (szVal) {
+          const size = Number.parseInt(szVal, 10);
+          if (Number.isFinite(size) && size > 0) marks.push({ type: "fontSize", val: size });
+        }
+        break;
+      }
+      case "color": {
+        const colorVal = child.attributes["w:val"] ?? child.attributes.val;
+        if (colorVal && colorVal !== "auto") marks.push({ type: "textColor", color: colorVal });
+        break;
+      }
+      case "smallCaps":
+        if (val !== "0" && val !== "false") marks.push({ type: "smallCaps" });
+        break;
+      case "caps":
+        if (val !== "0" && val !== "false") marks.push({ type: "allCaps" });
+        break;
     }
   }
 
   return marks;
 }
 
+function readParagraphSpacing(pPr: XmlElementNode): ParagraphSpacing | undefined {
+  const spacingNode = findChildElementOptional(pPr, "spacing");
+  if (!spacingNode) return undefined;
+  const result: ParagraphSpacing = {};
+  const before = spacingNode.attributes["w:before"] ?? spacingNode.attributes.before;
+  if (before) result.before = Number.parseInt(before, 10);
+  const after = spacingNode.attributes["w:after"] ?? spacingNode.attributes.after;
+  if (after) result.after = Number.parseInt(after, 10);
+  const line = spacingNode.attributes["w:line"] ?? spacingNode.attributes.line;
+  if (line) result.line = Number.parseInt(line, 10);
+  const lineRule = spacingNode.attributes["w:lineRule"] ?? spacingNode.attributes.lineRule;
+  if (lineRule === "auto" || lineRule === "exact" || lineRule === "atLeast") {
+    result.lineRule = lineRule;
+  }
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
+function readParagraphIndentation(pPr: XmlElementNode): ParagraphIndentation | undefined {
+  const indNode = findChildElementOptional(pPr, "ind");
+  if (!indNode) return undefined;
+  const result: ParagraphIndentation = {};
+  const left = indNode.attributes["w:left"] ?? indNode.attributes.left;
+  if (left) result.left = Number.parseInt(left, 10);
+  const right = indNode.attributes["w:right"] ?? indNode.attributes.right;
+  if (right) result.right = Number.parseInt(right, 10);
+  const firstLine = indNode.attributes["w:firstLine"] ?? indNode.attributes.firstLine;
+  if (firstLine) result.firstLine = Number.parseInt(firstLine, 10);
+  const hanging = indNode.attributes["w:hanging"] ?? indNode.attributes.hanging;
+  if (hanging) result.hanging = Number.parseInt(hanging, 10);
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
 function extractTextContent(tElement: XmlElementNode): string {
   let text = "";
   for (const child of tElement.children) {
@@ -353,6 +608,181 @@ function localName(name: string): string {
   return idx >= 0 ? name.slice(idx + 1) : name;
 }
 
+// ---- Simple secondary-story table support ----
+
+const RISKY_TABLE_ELEMENT_NAMES = new Set([
+  "ins",
+  "del",
+  "moveFrom",
+  "moveTo",
+  "tblPrChange",
+  "trPrChange",
+  "tcPrChange",
+  "rPrChange",
+  "pPrChange",
+  "sectPrChange",
+  "fldSimple",
+  "fldChar",
+  "instrText",
+  "sdt",
+  "customXml",
+]);
+
+function isSimpleSecondaryStoryTable(tblElement: XmlElementNode): boolean {
+  return !containsRiskyElement(tblElement);
+}
+
+function containsRiskyElement(element: XmlElementNode): boolean {
+  for (const child of element.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+    const name = localName(child.name);
+    if (RISKY_TABLE_ELEMENT_NAMES.has(name)) {
+      return true;
+    }
+    if (name === "tbl") {
+      return true;
+    }
+    if (containsRiskyElement(child)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function parseSimpleTableElement(tblElement: XmlElementNode): TableNode {
+  let gridColumns: number[] = [];
+  const rows: TableRowNode[] = [];
+  let propertiesXml: string | undefined;
+  let styleId: string | undefined;
+
+  for (const child of tblElement.children) {
+    if (child.type !== "element") continue;
+    const name = localName(child.name);
+
+    if (name === "tblPr") {
+      propertiesXml = serializeElementToXml(child);
+      const pStyle = findChildElementOptional(child, "tblStyle");
+      styleId = pStyle?.attributes["w:val"] ?? pStyle?.attributes.val;
+    } else if (name === "tblGrid") {
+      gridColumns = readGridColumns(child);
+    } else if (name === "tr") {
+      rows.push(parseSimpleTableRow(child));
+    }
+  }
+
+  return {
+    type: "table",
+    ...(styleId ? { styleId } : {}),
+    ...(propertiesXml ? { propertiesXml } : {}),
+    gridColumns,
+    rows,
+  };
+}
+
+function readGridColumns(tblGrid: XmlElementNode): number[] {
+  const columns: number[] = [];
+  for (const child of tblGrid.children) {
+    if (child.type !== "element") continue;
+    if (localName(child.name) === "gridCol") {
+      const w = child.attributes["w:w"] ?? child.attributes.w ?? "0";
+      columns.push(Number.parseInt(w, 10) || 0);
+    }
+  }
+  return columns;
+}
+
+function parseSimpleTableRow(trElement: XmlElementNode): TableRowNode {
+  const cells: TableCellNode[] = [];
+  let propertiesXml: string | undefined;
+
+  for (const child of trElement.children) {
+    if (child.type !== "element") continue;
+    const name = localName(child.name);
+
+    if (name === "trPr") {
+      propertiesXml = serializeElementToXml(child);
+    } else if (name === "tc") {
+      cells.push(parseSimpleTableCell(child));
+    }
+  }
+
+  return {
+    type: "table_row",
+    ...(propertiesXml ? { propertiesXml } : {}),
+    cells,
+  };
+}
+
+function parseSimpleTableCell(tcElement: XmlElementNode): TableCellNode {
+  const children: BlockNode[] = [];
+  let propertiesXml: string | undefined;
+  let gridSpan: number | undefined;
+  let verticalMerge: "restart" | "continue" | undefined;
+
+  for (const child of tcElement.children) {
+    if (child.type !== "element") continue;
+    const name = localName(child.name);
+
+    if (name === "tcPr") {
+      propertiesXml = serializeElementToXml(child);
+      const gsEl = findChildElementOptional(child, "gridSpan");
+      const gsVal = gsEl?.attributes["w:val"] ?? gsEl?.attributes.val;
+      if (gsVal) gridSpan = Number.parseInt(gsVal, 10) || undefined;
+
+      const vmEl = findChildElementOptional(child, "vMerge");
+      if (vmEl) {
+        const vmVal = vmEl.attributes["w:val"] ?? vmEl.attributes.val ?? "continue";
+        verticalMerge = vmVal === "restart" ? "restart" : "continue";
+      }
+    } else if (name === "p") {
+      children.push(parseParagraphElement(child));
+    }
+  }
+
+  return {
+    type: "table_cell",
+    ...(propertiesXml ? { propertiesXml } : {}),
+    ...(gridSpan ? { gridSpan } : {}),
+    ...(verticalMerge ? { verticalMerge } : {}),
+    children: children.length > 0 ? children : [{ type: "paragraph", children: [] }],
+  };
+}
+
+function serializeElementToXml(element: XmlElementNode): string {
+  const attrs = Object.entries(element.attributes)
+    .map(([key, value]) => ` ${key}="${escapeXmlAttribute(value)}"`)
+    .join("");
+  const children = element.children
+    .map((child) => {
+      if (child.type === "text") {
+        return escapeXmlText(child.text);
+      }
+      return serializeElementToXml(child);
+    })
+    .join("");
+  if (children.length === 0) {
+    return `<${element.name}${attrs}/>`;
+  }
+  return `<${element.name}${attrs}>${children}</${element.name}>`;
+}
+
+function escapeXmlAttribute(text: string): string {
+  return text
+    .replace(/&/g, "&amp;")
+    .replace(/"/g, "&quot;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+}
+
+function escapeXmlText(text: string): string {
+  return text
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+}
+
 // ---- Minimal XML parser (same pattern as parse-numbering.ts) ----
 
 function parseXml(xml: string): XmlElementNode {