@beyondwork/docx-react-component 1.0.36 → 1.0.38

package/src/io/ooxml/parse-headers-footers.ts

@@ -16,16 +16,31 @@ import { resolveHighlightColor } from "./highlight-colors.ts";
 import { classifyFieldInstruction } from "./parse-fields.ts";
 import {
   readCellBorders,
+  readCellCnfStyle,
+  readCellFitText,
+  readCellMargins,
+  readCellNoWrap,
   readCellShading,
+  readCellTextDirection,
   readCellVerticalAlign,
   readCellWidth,
   readGridColumns as readSharedGridColumns,
+  readRowCantSplit,
+  readRowCnfStyle,
   readRowHeight,
   readRowHeightRule,
+  readRowHorizontalAlignment,
   readRowIsHeader,
   readTableAlignment,
+  readTableBidiVisual,
   readTableBorders,
+  readTableCaption,
   readTableCellMargins,
+  readTableCellSpacing,
+  readTableDescription,
+  readTableFloating,
+  readTableIndent,
+  readTableLayoutMode,
   readTableLook,
   readTableStyleId,
   readTableWidth,
@@ -689,7 +704,8 @@ function parseRunProperties(rElement: XmlElementNode): TextMark[] {
       }
       case "color": {
         const colorVal = child.attributes["w:val"] ?? child.attributes.val;
-        if (colorVal && colorVal !== "auto") {
+        // A.9: preserve "auto" verbatim for round-trip.
+        if (colorVal) {
           marks.push({ type: "textColor", color: colorVal });
         }
         break;
@@ -926,6 +942,13 @@ function parseSimpleTableElement(tblElement: XmlElementNode): TableNode {
   let borders: TableNode["borders"];
   let cellMargins: TableNode["cellMargins"];
   let tblLook: TableNode["tblLook"];
+  let indent: TableNode["indent"];
+  let layoutMode: TableNode["layoutMode"];
+  let cellSpacing: TableNode["cellSpacing"];
+  let caption: TableNode["caption"];
+  let description: TableNode["description"];
+  let bidiVisual: TableNode["bidiVisual"];
+  let floating: TableNode["floating"];
 
   for (const child of tblElement.children) {
     if (child.type !== "element") continue;
@@ -939,6 +962,13 @@ function parseSimpleTableElement(tblElement: XmlElementNode): TableNode {
       borders = readTableBorders(child);
       cellMargins = readTableCellMargins(child);
       tblLook = readTableLook(child);
+      indent = readTableIndent(child);
+      layoutMode = readTableLayoutMode(child);
+      cellSpacing = readTableCellSpacing(child);
+      caption = readTableCaption(child);
+      description = readTableDescription(child);
+      bidiVisual = readTableBidiVisual(child);
+      floating = readTableFloating(child);
     } else if (name === "tblGrid") {
       gridColumns = readGridColumns(child);
     } else if (name === "tr") {
@@ -957,6 +987,13 @@ function parseSimpleTableElement(tblElement: XmlElementNode): TableNode {
     ...(borders ? { borders } : {}),
     ...(cellMargins ? { cellMargins } : {}),
     ...(tblLook ? { tblLook } : {}),
+    ...(indent ? { indent } : {}),
+    ...(layoutMode ? { layoutMode } : {}),
+    ...(cellSpacing ? { cellSpacing } : {}),
+    ...(caption !== undefined ? { caption } : {}),
+    ...(description !== undefined ? { description } : {}),
+    ...(bidiVisual !== undefined ? { bidiVisual } : {}),
+    ...(floating ? { floating } : {}),
   };
 }
 
@@ -970,6 +1007,9 @@ function parseSimpleTableRow(trElement: XmlElementNode): TableRowNode {
   let height: TableRowNode["height"];
   let heightRule: TableRowNode["heightRule"];
   let isHeader: TableRowNode["isHeader"];
+  let cantSplit: TableRowNode["cantSplit"];
+  let horizontalAlignment: TableRowNode["horizontalAlignment"];
+  let cnfStyle: TableRowNode["cnfStyle"];
 
   for (const child of trElement.children) {
     if (child.type !== "element") continue;
@@ -980,6 +1020,9 @@ function parseSimpleTableRow(trElement: XmlElementNode): TableRowNode {
       height = readRowHeight(child);
       heightRule = readRowHeightRule(child);
       isHeader = readRowIsHeader(child);
+      cantSplit = readRowCantSplit(child);
+      horizontalAlignment = readRowHorizontalAlignment(child);
+      cnfStyle = readRowCnfStyle(child);
     } else if (name === "tc") {
       cells.push(parseSimpleTableCell(child));
     }
@@ -991,6 +1034,9 @@ function parseSimpleTableRow(trElement: XmlElementNode): TableRowNode {
     ...(height !== undefined ? { height } : {}),
     ...(heightRule ? { heightRule } : {}),
     ...(isHeader !== undefined ? { isHeader } : {}),
+    ...(cantSplit !== undefined ? { cantSplit } : {}),
+    ...(horizontalAlignment ? { horizontalAlignment } : {}),
+    ...(cnfStyle ? { cnfStyle } : {}),
     cells,
   };
 }
@@ -1004,6 +1050,11 @@ function parseSimpleTableCell(tcElement: XmlElementNode): TableCellNode {
   let borders: TableCellNode["borders"];
   let shading: TableCellNode["shading"];
   let verticalAlign: TableCellNode["verticalAlign"];
+  let textDirection: TableCellNode["textDirection"];
+  let noWrap: TableCellNode["noWrap"];
+  let fitText: TableCellNode["fitText"];
+  let margins: TableCellNode["margins"];
+  let cnfStyle: TableCellNode["cnfStyle"];
 
   for (const child of tcElement.children) {
     if (child.type !== "element") continue;
@@ -1024,6 +1075,11 @@ function parseSimpleTableCell(tcElement: XmlElementNode): TableCellNode {
       borders = readCellBorders(child);
       shading = readCellShading(child);
       verticalAlign = readCellVerticalAlign(child);
+      textDirection = readCellTextDirection(child);
+      noWrap = readCellNoWrap(child);
+      fitText = readCellFitText(child);
+      margins = readCellMargins(child);
+      cnfStyle = readCellCnfStyle(child);
     } else if (name === "p") {
       children.push(parseParagraphElement(child));
     }
@@ -1038,6 +1094,11 @@ function parseSimpleTableCell(tcElement: XmlElementNode): TableCellNode {
     ...(borders ? { borders } : {}),
     ...(shading ? { shading } : {}),
     ...(verticalAlign ? { verticalAlign } : {}),
+    ...(textDirection ? { textDirection } : {}),
+    ...(noWrap !== undefined ? { noWrap } : {}),
+    ...(fitText !== undefined ? { fitText } : {}),
+    ...(margins ? { margins } : {}),
+    ...(cnfStyle ? { cnfStyle } : {}),
     children: children.length > 0 ? children : [{ type: "paragraph", children: [] }],
   };
 }

package/src/io/ooxml/parse-main-document.ts

@@ -10,6 +10,8 @@ import type {
   TableBorders,
   TableCellBorders,
   TableCellMargins,
+  TableFloatingProperties,
+  TableIndent,
   TableLook,
   TableWidth,
   SectionProperties,
@@ -35,16 +37,31 @@ import { classifyFieldInstruction } from "./parse-fields.ts";
 import { resolveHighlightColor } from "./highlight-colors.ts";
 import {
   readCellBorders as readSharedCellBorders,
+  readCellCnfStyle as readSharedCellCnfStyle,
+  readCellFitText as readSharedCellFitText,
+  readCellMargins as readSharedCellMargins,
+  readCellNoWrap as readSharedCellNoWrap,
   readCellShading as readSharedCellShading,
+  readCellTextDirection as readSharedCellTextDirection,
   readCellVerticalAlign as readSharedCellVerticalAlign,
   readCellWidth as readSharedCellWidth,
   readGridColumns as readSharedGridColumns,
+  readRowCantSplit as readSharedRowCantSplit,
+  readRowCnfStyle as readSharedRowCnfStyle,
   readRowHeight as readSharedRowHeight,
   readRowHeightRule as readSharedRowHeightRule,
+  readRowHorizontalAlignment as readSharedRowHorizontalAlignment,
   readRowIsHeader as readSharedRowIsHeader,
   readTableAlignment as readSharedTableAlignment,
+  readTableBidiVisual as readSharedTableBidiVisual,
   readTableBorders as readSharedTableBorders,
+  readTableCaption as readSharedTableCaption,
   readTableCellMargins as readSharedTableCellMargins,
+  readTableCellSpacing as readSharedTableCellSpacing,
+  readTableDescription as readSharedTableDescription,
+  readTableFloating as readSharedTableFloating,
+  readTableIndent as readSharedTableIndent,
+  readTableLayoutMode as readSharedTableLayoutMode,
   readTableLook as readSharedTableLook,
   readTableStyleId as readSharedTableStyleId,
   readTableWidth as readSharedTableWidth,
@@ -92,6 +109,11 @@ export interface ParsedParagraphNode {
   bidi?: boolean;
   suppressLineNumbers?: boolean;
   cnfStyle?: string;
+  /** A.7: preserved w14 extension ids (paraId/textId). */
+  wordExtensionIds?: {
+    paraId?: string;
+    textId?: string;
+  };
   sectionProperties?: SectionProperties;
   sectionPropertiesXml?: string;
   children: ParsedInlineNode[];
@@ -327,6 +349,13 @@ export interface ParsedTableBlockNode {
   alignment?: "left" | "center" | "right";
   borders?: TableBorders;
   cellMargins?: TableCellMargins;
+  indent?: TableIndent;
+  layoutMode?: "fixed" | "autofit";
+  cellSpacing?: TableWidth;
+  caption?: string;
+  description?: string;
+  bidiVisual?: boolean;
+  floating?: TableFloatingProperties;
   rawXml: string;
 }
 
@@ -341,6 +370,9 @@ export interface ParsedTableRowNode {
   height?: number;
   heightRule?: "auto" | "atLeast" | "exact";
   isHeader?: boolean;
+  cantSplit?: boolean;
+  horizontalAlignment?: "left" | "center" | "right";
+  cnfStyle?: string;
   rawXml: string;
 }
 
@@ -354,6 +386,11 @@ export interface ParsedTableCellNode {
   borders?: TableCellBorders;
   shading?: CellShading;
   verticalAlign?: "top" | "center" | "bottom";
+  textDirection?: "lrTb" | "tbRl" | "btLr";
+  noWrap?: boolean;
+  fitText?: boolean;
+  margins?: TableCellMargins;
+  cnfStyle?: string;
   rawXml: string;
 }
 
@@ -493,6 +530,17 @@ function parseBodyChild(
   let sectionProperties: SectionProperties | undefined;
   let sectionPropertiesXml: string | undefined;
   let paragraphSupported = true;
+  // A.7: capture w14:paraId / w14:textId from the <w:p> element attributes
+  // so round-trip export can re-emit them unchanged.
+  const paraId = node.attributes["w14:paraId"] ?? node.attributes.paraId;
+  const textId = node.attributes["w14:textId"] ?? node.attributes.textId;
+  const wordExtensionIds: ParsedParagraphNode["wordExtensionIds"] | undefined =
+    paraId || textId
+      ? {
+          ...(paraId ? { paraId: paraId.toUpperCase() } : {}),
+          ...(textId ? { textId: textId.toUpperCase() } : {}),
+        }
+      : undefined;
   const children: ParsedInlineNode[] = [];
   let activeComplexField: {
     instruction: string;
@@ -709,6 +757,7 @@ function parseBodyChild(
     ...(bidi ? { bidi } : {}),
     ...(suppressLineNumbers ? { suppressLineNumbers } : {}),
     ...(cnfStyle ? { cnfStyle } : {}),
+    ...(wordExtensionIds ? { wordExtensionIds } : {}),
     ...(sectionProperties ? { sectionProperties } : {}),
     ...(sectionPropertiesXml ? { sectionPropertiesXml } : {}),
     children,
@@ -840,6 +889,13 @@ function parseTableElement(
   let alignment: ParsedTableBlockNode["alignment"];
   let borders: TableBorders | undefined;
   let cellMargins: TableCellMargins | undefined;
+  let indent: TableIndent | undefined;
+  let layoutMode: ParsedTableBlockNode["layoutMode"];
+  let cellSpacing: TableWidth | undefined;
+  let caption: string | undefined;
+  let description: string | undefined;
+  let bidiVisual: boolean | undefined;
+  let floating: TableFloatingProperties | undefined;
   const rows: ParsedTableRowNode[] = [];
 
   for (const child of node.children) {
@@ -854,6 +910,13 @@ function parseTableElement(
         alignment = readTableAlignment(child);
         borders = readTableBorders(child);
         cellMargins = readTableCellMargins(child);
+        indent = readTableIndent(child);
+        layoutMode = readTableLayoutMode(child);
+        cellSpacing = readTableCellSpacing(child);
+        caption = readTableCaption(child);
+        description = readTableDescription(child);
+        bidiVisual = readTableBidiVisual(child);
+        floating = readTableFloating(child);
         break;
       }
       case "tblGrid": {
@@ -878,6 +941,13 @@ function parseTableElement(
     ...(alignment ? { alignment } : {}),
     ...(borders ? { borders } : {}),
     ...(cellMargins ? { cellMargins } : {}),
+    ...(indent ? { indent } : {}),
+    ...(layoutMode ? { layoutMode } : {}),
+    ...(cellSpacing ? { cellSpacing } : {}),
+    ...(caption !== undefined ? { caption } : {}),
+    ...(description !== undefined ? { description } : {}),
+    ...(bidiVisual !== undefined ? { bidiVisual } : {}),
+    ...(floating ? { floating } : {}),
     rawXml: sourceXml.slice(node.start, node.end),
   };
 }
@@ -898,6 +968,9 @@ function parseTableRowElement(
   let height: number | undefined;
   let heightRule: ParsedTableRowNode["heightRule"];
   let isHeader: boolean | undefined;
+  let cantSplit: boolean | undefined;
+  let horizontalAlignment: ParsedTableRowNode["horizontalAlignment"];
+  let cnfStyle: string | undefined;
   const cells: ParsedTableCellNode[] = [];
 
   for (const child of node.children) {
@@ -913,6 +986,9 @@ function parseTableRowElement(
         height = readRowHeight(child);
         heightRule = readRowHeightRule(child);
         isHeader = readRowIsHeader(child);
+        cantSplit = readRowCantSplit(child);
+        horizontalAlignment = readRowHorizontalAlignment(child);
+        cnfStyle = readRowCnfStyle(child);
         break;
       case "tc":
         cells.push(parseTableCellElement(child, sourceXml, relationshipMap, relationships, mediaParts, sourcePartPath));
@@ -930,6 +1006,9 @@ function parseTableRowElement(
     ...(height !== undefined ? { height } : {}),
     ...(heightRule ? { heightRule } : {}),
     ...(isHeader !== undefined ? { isHeader } : {}),
+    ...(cantSplit !== undefined ? { cantSplit } : {}),
+    ...(horizontalAlignment ? { horizontalAlignment } : {}),
+    ...(cnfStyle ? { cnfStyle } : {}),
     cells,
     rawXml: sourceXml.slice(node.start, node.end),
   };
@@ -950,6 +1029,11 @@ function parseTableCellElement(
   let borders: TableCellBorders | undefined;
   let shading: CellShading | undefined;
   let verticalAlign: ParsedTableCellNode["verticalAlign"];
+  let textDirection: ParsedTableCellNode["textDirection"];
+  let noWrap: boolean | undefined;
+  let fitText: boolean | undefined;
+  let margins: TableCellMargins | undefined;
+  let cnfStyle: string | undefined;
   const children: ParsedBlockNode[] = [];
 
   for (const child of node.children) {
@@ -964,6 +1048,11 @@ function parseTableCellElement(
         borders = readCellBorders(child);
         shading = readCellShading(child);
         verticalAlign = readCellVerticalAlign(child);
+        textDirection = readCellTextDirection(child);
+        noWrap = readCellNoWrap(child);
+        fitText = readCellFitText(child);
+        margins = readCellMargins(child);
+        cnfStyle = readCellCnfStyle(child);
         break;
       }
       default: {
@@ -984,6 +1073,11 @@ function parseTableCellElement(
     ...(borders ? { borders } : {}),
     ...(shading ? { shading } : {}),
     ...(verticalAlign ? { verticalAlign } : {}),
+    ...(textDirection ? { textDirection } : {}),
+    ...(noWrap !== undefined ? { noWrap } : {}),
+    ...(fitText !== undefined ? { fitText } : {}),
+    ...(margins ? { margins } : {}),
+    ...(cnfStyle ? { cnfStyle } : {}),
     rawXml: sourceXml.slice(node.start, node.end),
   };
 }
@@ -1257,6 +1351,66 @@ function readCellVerticalAlign(node: XmlElementNode): ParsedTableCellNode["verti
   return readSharedCellVerticalAlign(node);
 }
 
+function readTableIndent(node: XmlElementNode): TableIndent | undefined {
+  return readSharedTableIndent(node);
+}
+
+function readTableLayoutMode(node: XmlElementNode): ParsedTableBlockNode["layoutMode"] {
+  return readSharedTableLayoutMode(node);
+}
+
+function readTableCellSpacing(node: XmlElementNode): TableWidth | undefined {
+  return readSharedTableCellSpacing(node);
+}
+
+function readTableCaption(node: XmlElementNode): string | undefined {
+  return readSharedTableCaption(node);
+}
+
+function readTableDescription(node: XmlElementNode): string | undefined {
+  return readSharedTableDescription(node);
+}
+
+function readTableBidiVisual(node: XmlElementNode): boolean | undefined {
+  return readSharedTableBidiVisual(node);
+}
+
+function readTableFloating(node: XmlElementNode): TableFloatingProperties | undefined {
+  return readSharedTableFloating(node);
+}
+
+function readRowCantSplit(node: XmlElementNode): boolean | undefined {
+  return readSharedRowCantSplit(node);
+}
+
+function readRowHorizontalAlignment(node: XmlElementNode): ParsedTableRowNode["horizontalAlignment"] {
+  return readSharedRowHorizontalAlignment(node);
+}
+
+function readRowCnfStyle(node: XmlElementNode): string | undefined {
+  return readSharedRowCnfStyle(node);
+}
+
+function readCellTextDirection(node: XmlElementNode): ParsedTableCellNode["textDirection"] {
+  return readSharedCellTextDirection(node);
+}
+
+function readCellNoWrap(node: XmlElementNode): boolean | undefined {
+  return readSharedCellNoWrap(node);
+}
+
+function readCellFitText(node: XmlElementNode): boolean | undefined {
+  return readSharedCellFitText(node);
+}
+
+function readCellMargins(node: XmlElementNode): TableCellMargins | undefined {
+  return readSharedCellMargins(node);
+}
+
+function readCellCnfStyle(node: XmlElementNode): string | undefined {
+  return readSharedCellCnfStyle(node);
+}
+
 /**
  * Check if a table's raw XML contains content that cannot safely round-trip
  * through the parsed table path yet. This includes:
@@ -2242,7 +2396,10 @@ function readRunMarks(node: XmlElementNode, sourceXml: string): MarksParseResult
   );
   if (colorNode) {
     const colorVal = colorNode.attributes["w:val"] ?? colorNode.attributes.val;
-    if (colorVal && colorVal !== "auto") {
+    // A.9: preserve the literal "auto" marker so the serializer can round-trip
+    // it back. The canonical colour string is free-form; downstream paint
+    // paths treat "auto" as "inherit from theme/style".
+    if (colorVal) {
       marks.push({ type: "textColor", color: colorVal });
     }
   }