@beyondwork/docx-react-component 1.0.28 → 1.0.30

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

@@ -8,12 +8,35 @@
  */
 
 import type {
+  CellShading,
   CharacterStyleDefinition,
   LatentStyleDefinition,
   ParagraphStyleDefinition,
   StylesCatalog,
+  TableBorders,
+  TableCellBorders,
+  TableCellMargins,
+  TableLook,
+  TableStyleConditionalRegion,
   TableStyleDefinition,
+  TableStyleFormatting,
+  TableWidth,
 } from "../../model/canonical-document.ts";
+import {
+  readCellBorders,
+  readCellShading,
+  readCellVerticalAlign,
+  readCellWidth,
+  readRowHeight,
+  readRowHeightRule,
+  readRowIsHeader,
+  readTableAlignment,
+  readTableBorders,
+  readTableCellMargins,
+  readTableLook,
+  readTableWidth,
+} from "./parse-tables.ts";
+import { toCanonicalNumberingInstanceId } from "./parse-numbering.ts";
 
 // ---------------------------------------------------------------------------
 // Inline XML node types (same pattern as parse-numbering.ts)
@@ -24,11 +47,15 @@ interface XmlElementNode {
   name: string;
   attributes: Record<string, string>;
   children: XmlNode[];
+  start: number;
+  end: number;
 }
 
 interface XmlTextNode {
   type: "text";
   text: string;
+  start: number;
+  end: number;
 }
 
 type XmlNode = XmlElementNode | XmlTextNode;
@@ -107,6 +134,7 @@ export function parseStylesXml(xml: string): ParseStylesResult {
         case "paragraph": {
           const nextStyle = readLinkedStyleId(child, "next");
           const outlineLevel = readParagraphStyleOutlineLevel(child);
+          const numbering = readParagraphStyleNumbering(child);
           paragraphs[styleId] = {
             styleId,
             displayName,
@@ -115,6 +143,7 @@ export function parseStylesXml(xml: string): ParseStylesResult {
             ...(basedOn ? { basedOn } : {}),
             ...(nextStyle ? { nextStyle } : {}),
             ...(outlineLevel !== undefined ? { outlineLevel } : {}),
+            ...(numbering ? { numbering } : {}),
           };
           break;
         }
@@ -129,12 +158,16 @@ export function parseStylesXml(xml: string): ParseStylesResult {
           break;
         }
         case "table": {
+          const formatting = readTableStyleFormatting(child);
+          const conditionalFormatting = readTableConditionalFormatting(child);
           tables[styleId] = {
             styleId,
             displayName,
             kind: "table",
             isDefault,
             ...(basedOn ? { basedOn } : {}),
+            ...(formatting ? { formatting } : {}),
+            ...(conditionalFormatting ? { conditionalFormatting } : {}),
           };
           break;
         }
@@ -204,6 +237,140 @@ function readParagraphStyleOutlineLevel(
   return Number.isInteger(parsed) && parsed >= 0 ? parsed : undefined;
 }
 
+function readParagraphStyleNumbering(
+  styleNode: XmlElementNode,
+): ParagraphStyleDefinition["numbering"] | undefined {
+  const paragraphProperties = findChildElementOptional(styleNode, "pPr");
+  if (!paragraphProperties) {
+    return undefined;
+  }
+
+  const numberingProperties = findChildElementOptional(paragraphProperties, "numPr");
+  if (!numberingProperties) {
+    return undefined;
+  }
+
+  const levelNode = findChildElementOptional(numberingProperties, "ilvl");
+  const instanceNode = findChildElementOptional(numberingProperties, "numId");
+  const rawInstanceId = instanceNode?.attributes["w:val"] ?? instanceNode?.attributes.val;
+  if (!rawInstanceId) {
+    return undefined;
+  }
+  if (rawInstanceId === "0") {
+    return undefined;
+  }
+
+  const rawLevel = levelNode?.attributes["w:val"] ?? levelNode?.attributes.val;
+  const parsedLevel =
+    rawLevel !== undefined ? Number.parseInt(rawLevel, 10) : Number.NaN;
+
+  return {
+    numberingInstanceId: toCanonicalNumberingInstanceId(rawInstanceId),
+    ...(Number.isInteger(parsedLevel) && parsedLevel >= 0 ? { level: parsedLevel } : {}),
+  };
+}
+function readTableStyleFormatting(styleNode: XmlElementNode): TableStyleFormatting | undefined {
+  const tableProperties = findChildElementOptional(styleNode, "tblPr");
+  const rowProperties = findChildElementOptional(styleNode, "trPr");
+  const cellProperties = findChildElementOptional(styleNode, "tcPr");
+  const formatting: TableStyleFormatting = {};
+
+  if (tableProperties) {
+    const table: NonNullable<TableStyleFormatting["table"]> = {};
+    const width = readTableWidth(tableProperties);
+    const alignment = readTableAlignment(tableProperties);
+    const borders = readTableBorders(tableProperties);
+    const cellMargins = readTableCellMargins(tableProperties);
+    const tblLook = readTableLook(tableProperties);
+
+    if (width) table.width = width as TableWidth;
+    if (alignment) table.alignment = alignment;
+    if (borders) table.borders = borders as TableBorders;
+    if (cellMargins) table.cellMargins = cellMargins as TableCellMargins;
+    if (tblLook) table.tblLook = tblLook as TableLook;
+
+    if (Object.keys(table).length > 0) {
+      formatting.table = table;
+    }
+  }
+
+  if (rowProperties) {
+    const row: NonNullable<TableStyleFormatting["row"]> = {};
+    const height = readRowHeight(rowProperties);
+    const heightRule = readRowHeightRule(rowProperties);
+    const isHeader = readRowIsHeader(rowProperties);
+
+    if (height !== undefined) row.height = height;
+    if (heightRule) row.heightRule = heightRule;
+    if (isHeader !== undefined) row.isHeader = isHeader;
+
+    if (Object.keys(row).length > 0) {
+      formatting.row = row;
+    }
+  }
+
+  if (cellProperties) {
+    const cell: NonNullable<TableStyleFormatting["cell"]> = {};
+    const width = readCellWidth(cellProperties);
+    const borders = readCellBorders(cellProperties);
+    const shading = readCellShading(cellProperties);
+    const verticalAlign = readCellVerticalAlign(cellProperties);
+
+    if (width) cell.width = width as TableWidth;
+    if (borders) cell.borders = borders as TableCellBorders;
+    if (shading) cell.shading = shading as CellShading;
+    if (verticalAlign) cell.verticalAlign = verticalAlign;
+
+    if (Object.keys(cell).length > 0) {
+      formatting.cell = cell;
+    }
+  }
+
+  return Object.keys(formatting).length > 0 ? formatting : undefined;
+}
+
+function readTableConditionalFormatting(
+  styleNode: XmlElementNode,
+): Partial<Record<TableStyleConditionalRegion, TableStyleFormatting>> | undefined {
+  const conditionalFormatting: Partial<Record<TableStyleConditionalRegion, TableStyleFormatting>> = {};
+
+  for (const child of styleNode.children) {
+    if (child.type !== "element" || localName(child.name) !== "tblStylePr") {
+      continue;
+    }
+
+    const region = mapTableConditionalRegion(child.attributes["w:type"] ?? child.attributes.type);
+    if (!region) {
+      continue;
+    }
+
+    const formatting = readTableStyleFormatting(child);
+    if (formatting) {
+      conditionalFormatting[region] = formatting;
+    }
+  }
+
+  return Object.keys(conditionalFormatting).length > 0 ? conditionalFormatting : undefined;
+}
+
+function mapTableConditionalRegion(value: string | undefined): TableStyleConditionalRegion | undefined {
+  switch (value) {
+    case "firstRow":
+    case "lastRow":
+    case "band1Horz":
+    case "band2Horz":
+    case "band1Vert":
+    case "band2Vert":
+      return value;
+    case "firstCol":
+      return "firstColumn";
+    case "lastCol":
+      return "lastColumn";
+    default:
+      return undefined;
+  }
+}
+
 function readLatentStyles(
   latentNode: XmlElementNode,
   out: Record<string, LatentStyleDefinition>,
@@ -263,6 +430,8 @@ function parseXml(xml: string): XmlElementNode {
     name: "__root__",
     attributes: {},
     children: [],
+    start: 0,
+    end: xml.length,
   };
   const stack: XmlElementNode[] = [root];
   let cursor = 0;
@@ -286,6 +455,8 @@ function parseXml(xml: string): XmlElementNode {
       stack[stack.length - 1]?.children.push({
         type: "text",
         text: xml.slice(cursor + 9, textEnd),
+        start: cursor,
+        end: end >= 0 ? end + 3 : xml.length,
       });
       cursor = end >= 0 ? end + 3 : xml.length;
       continue;
@@ -299,6 +470,8 @@ function parseXml(xml: string): XmlElementNode {
         stack[stack.length - 1]?.children.push({
           type: "text",
           text,
+          start: cursor,
+          end,
         });
       }
       cursor = end;
@@ -316,6 +489,7 @@ function parseXml(xml: string): XmlElementNode {
       if (!current || localName(current.name) !== localName(name)) {
         throw new Error(`Malformed XML: unexpected closing tag </${name}>.`);
       }
+      current.end = end + 1;
 
       cursor = end + 1;
       continue;
@@ -330,6 +504,8 @@ function parseXml(xml: string): XmlElementNode {
       name,
       attributes,
       children: [],
+      start: cursor,
+      end: tagEnd + 1,
     };
     stack[stack.length - 1]?.children.push(element);
 

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

@@ -1,4 +1,4 @@
-interface XmlElementNode {
+export interface XmlElementNode {
   type: "element";
   name: string;
   attributes: Record<string, string>;
@@ -7,14 +7,14 @@ interface XmlElementNode {
   end: number;
 }
 
-interface XmlTextNode {
+export interface XmlTextNode {
   type: "text";
   text: string;
   start: number;
   end: number;
 }
 
-type XmlNode = XmlElementNode | XmlTextNode;
+export type XmlNode = XmlElementNode | XmlTextNode;
 
 export interface ParsedBorderSpec {
   value?: string;
@@ -163,7 +163,7 @@ function parseRow(node: XmlElementNode, sourceXml: string): ParsedTableRow {
     rawXml: sourceXml.slice(node.start, node.end),
     ...(height !== undefined ? { height } : {}),
     ...(heightRule ? { heightRule } : {}),
-    ...(isHeader ? { isHeader } : {}),
+    ...(isHeader !== undefined ? { isHeader } : {}),
   };
 }
 
@@ -193,7 +193,7 @@ function parseCell(node: XmlElementNode, sourceXml: string): ParsedTableCell {
   };
 }
 
-function readGridColumns(node: XmlElementNode): number[] {
+export function readGridColumns(node: XmlElementNode): number[] {
   return node.children
     .filter((child): child is XmlElementNode => child.type === "element" && localName(child.name) === "gridCol")
     .map((child) => parsePositiveInteger(child.attributes["w:w"] ?? child.attributes.w ?? "0"));
@@ -443,7 +443,7 @@ function decodeXmlEntities(value: string): string {
 
 // Cell property readers
 
-function readCellWidth(propertiesNode: XmlElementNode): ParsedTableWidth | undefined {
+export function readCellWidth(propertiesNode: XmlElementNode): ParsedTableWidth | undefined {
   const widthNode = findFirstChild(propertiesNode, "tcW");
   if (!widthNode) return undefined;
   const value = parsePositiveInteger(widthNode.attributes["w:w"] ?? widthNode.attributes.w);
@@ -453,7 +453,7 @@ function readCellWidth(propertiesNode: XmlElementNode): ParsedTableWidth | undef
   return { value, type };
 }
 
-function readCellBorders(propertiesNode: XmlElementNode): ParsedTableCellBorders | undefined {
+export function readCellBorders(propertiesNode: XmlElementNode): ParsedTableCellBorders | undefined {
   const bordersNode = findFirstChild(propertiesNode, "tcBorders");
   if (!bordersNode) return undefined;
   const borders: ParsedTableCellBorders = {};
@@ -467,7 +467,7 @@ function readCellBorders(propertiesNode: XmlElementNode): ParsedTableCellBorders
   return Object.keys(borders).length > 0 ? borders : undefined;
 }
 
-function readCellShading(propertiesNode: XmlElementNode): ParsedCellShading | undefined {
+export function readCellShading(propertiesNode: XmlElementNode): ParsedCellShading | undefined {
   const shdNode = findFirstChild(propertiesNode, "shd");
   if (!shdNode) return undefined;
   const fill = shdNode.attributes["w:fill"] ?? shdNode.attributes.fill;
@@ -481,7 +481,7 @@ function readCellShading(propertiesNode: XmlElementNode): ParsedCellShading | un
   return result;
 }
 
-function readCellVerticalAlign(propertiesNode: XmlElementNode): "top" | "center" | "bottom" | undefined {
+export function readCellVerticalAlign(propertiesNode: XmlElementNode): "top" | "center" | "bottom" | undefined {
   const vAlignNode = findFirstChild(propertiesNode, "vAlign");
   if (!vAlignNode) return undefined;
   const val = vAlignNode.attributes["w:val"] ?? vAlignNode.attributes.val;
@@ -491,7 +491,7 @@ function readCellVerticalAlign(propertiesNode: XmlElementNode): "top" | "center"
 
 // Table property readers
 
-function readTableWidth(propertiesNode: XmlElementNode): ParsedTableWidth | undefined {
+export function readTableWidth(propertiesNode: XmlElementNode): ParsedTableWidth | undefined {
   const widthNode = findFirstChild(propertiesNode, "tblW");
   if (!widthNode) return undefined;
   const value = parsePositiveInteger(widthNode.attributes["w:w"] ?? widthNode.attributes.w);
@@ -501,7 +501,7 @@ function readTableWidth(propertiesNode: XmlElementNode): ParsedTableWidth | unde
   return { value, type };
 }
 
-function readTableAlignment(propertiesNode: XmlElementNode): "left" | "center" | "right" | undefined {
+export function readTableAlignment(propertiesNode: XmlElementNode): "left" | "center" | "right" | undefined {
   const jcNode = findFirstChild(propertiesNode, "jc");
   if (!jcNode) return undefined;
   const val = jcNode.attributes["w:val"] ?? jcNode.attributes.val;
@@ -509,13 +509,13 @@ function readTableAlignment(propertiesNode: XmlElementNode): "left" | "center" |
   return undefined;
 }
 
-function readTableStyleId(propertiesNode: XmlElementNode): string | undefined {
+export function readTableStyleId(propertiesNode: XmlElementNode): string | undefined {
   const styleNode = findFirstChild(propertiesNode, "tblStyle");
   if (!styleNode) return undefined;
   return styleNode.attributes["w:val"] ?? styleNode.attributes.val;
 }
 
-function readTableLook(propertiesNode: XmlElementNode): ParsedTableLook | undefined {
+export function readTableLook(propertiesNode: XmlElementNode): ParsedTableLook | undefined {
   const tblLookNode = findFirstChild(propertiesNode, "tblLook");
   if (!tblLookNode) return undefined;
 
@@ -543,7 +543,7 @@ function readTableLook(propertiesNode: XmlElementNode): ParsedTableLook | undefi
   return Object.keys(tableLook).length > 0 ? tableLook : undefined;
 }
 
-function readTableBorders(propertiesNode: XmlElementNode): ParsedTableBorders | undefined {
+export function readTableBorders(propertiesNode: XmlElementNode): ParsedTableBorders | undefined {
   const bordersNode = findFirstChild(propertiesNode, "tblBorders");
   if (!bordersNode) return undefined;
   const borders: ParsedTableBorders = {};
@@ -557,30 +557,39 @@ function readTableBorders(propertiesNode: XmlElementNode): ParsedTableBorders |
   return Object.keys(borders).length > 0 ? borders : undefined;
 }
 
-function readTableCellMargins(propertiesNode: XmlElementNode): ParsedCellMargins | undefined {
+export function readTableCellMargins(propertiesNode: XmlElementNode): ParsedCellMargins | undefined {
   const marginsNode = findFirstChild(propertiesNode, "tblCellMar");
   if (!marginsNode) return undefined;
-  const readSide = (name: string): number => {
-    const n = findFirstChild(marginsNode, name);
-    return n ? parsePositiveInteger(n.attributes["w:w"] ?? n.attributes.w) : 0;
+  const readSide = (name: string): number | undefined => {
+    const node = findFirstChild(marginsNode, name);
+    if (!node) return undefined;
+    return parsePositiveInteger(node.attributes["w:w"] ?? node.attributes.w);
   };
   const top = readSide("top");
   const bottom = readSide("bottom");
-  const left = readSide("start") || readSide("left");
-  const right = readSide("end") || readSide("right");
-  if (top === 0 && bottom === 0 && left === 0 && right === 0) return undefined;
-  return { top, bottom, left, right };
+  const left = readSide("start") ?? readSide("left");
+  const right = readSide("end") ?? readSide("right");
+  if (top === undefined && bottom === undefined && left === undefined && right === undefined) {
+    return undefined;
+  }
+
+  return {
+    ...(top !== undefined ? { top } : {}),
+    ...(bottom !== undefined ? { bottom } : {}),
+    ...(left !== undefined ? { left } : {}),
+    ...(right !== undefined ? { right } : {}),
+  };
 }
 
 // Row property readers
 
-function readRowHeight(propertiesNode: XmlElementNode): number | undefined {
+export function readRowHeight(propertiesNode: XmlElementNode): number | undefined {
   const heightNode = findFirstChild(propertiesNode, "trHeight");
   if (!heightNode) return undefined;
   return parsePositiveInteger(heightNode.attributes["w:val"] ?? heightNode.attributes.val);
 }
 
-function readRowHeightRule(propertiesNode: XmlElementNode): "auto" | "atLeast" | "exact" | undefined {
+export function readRowHeightRule(propertiesNode: XmlElementNode): "auto" | "atLeast" | "exact" | undefined {
   const heightNode = findFirstChild(propertiesNode, "trHeight");
   if (!heightNode) return undefined;
   const raw = (heightNode.attributes["w:hRule"] ?? heightNode.attributes.hRule ?? "").toLowerCase();
@@ -590,7 +599,7 @@ function readRowHeightRule(propertiesNode: XmlElementNode): "auto" | "atLeast" |
   return undefined;
 }
 
-function readRowIsHeader(propertiesNode: XmlElementNode): boolean | undefined {
+export function readRowIsHeader(propertiesNode: XmlElementNode): boolean | undefined {
   const headerNode = findFirstChild(propertiesNode, "tblHeader");
   if (!headerNode) return undefined;
   const val = headerNode.attributes["w:val"] ?? headerNode.attributes.val;

package/src/io/ooxml/revision-boundaries.ts

@@ -50,8 +50,21 @@ export function mapRevisionBoundaries(
     }
 
     if (localName(child.name) !== "p") {
-      cursor += 1;
-      previousWasParagraph = false;
+      if (localName(child.name) === "tbl") {
+        const nested = collectNestedParagraphBoundaries(
+          child.children,
+          paragraphIndex,
+          cursor,
+          previousWasParagraph,
+        );
+        paragraphIndex = nested.paragraphIndex;
+        cursor = nested.cursor;
+        previousWasParagraph = nested.previousWasParagraph;
+        paragraphs.push(...nested.paragraphs);
+      } else {
+        cursor += 1;
+        previousWasParagraph = false;
+      }
       continue;
     }
 
@@ -105,6 +118,117 @@ export function mapRevisionBoundaries(
   return paragraphs;
 }
 
+function collectNestedParagraphBoundaries(
+  nodes: XmlNode[],
+  paragraphIndex: number,
+  cursor: number,
+  previousWasParagraph: boolean,
+): {
+  paragraphs: RevisionParagraphBoundary[];
+  paragraphIndex: number;
+  cursor: number;
+  previousWasParagraph: boolean;
+} {
+  const paragraphs: RevisionParagraphBoundary[] = [];
+  let nextParagraphIndex = paragraphIndex;
+  let nextCursor = cursor;
+  let nextPreviousWasParagraph = previousWasParagraph;
+
+  for (const node of nodes) {
+    if (node.type !== "element") {
+      continue;
+    }
+    const type = localName(node.name);
+
+    if (type === "p") {
+      nextParagraphIndex += 1;
+      const boundaries = new Map<number, number>();
+      boundaries.set(nextCursor, node.openingTagEnd);
+
+      const paragraphProperties = findChildElement(node, "pPr");
+      const paragraphRunProperties = paragraphProperties
+        ? findChildElement(paragraphProperties, "rPr")
+        : undefined;
+
+      walkStoryNodesForBoundaries(
+        node.children,
+        boundaries,
+        () => nextCursor,
+        (next) => {
+          nextCursor = next;
+        },
+      );
+
+      boundaries.set(nextCursor, node.closingTagStart);
+      paragraphs.push({
+        paragraphIndex: nextParagraphIndex,
+        start: Math.min(...boundaries.keys()),
+        end: Math.max(...boundaries.keys()),
+        boundaries,
+        paragraphStart: node.start,
+        paragraphStartTagEnd: node.openingTagEnd,
+        paragraphEndTagStart: node.closingTagStart,
+        paragraphEnd: node.end,
+        ...(paragraphProperties
+          ? {
+              paragraphPropertiesStart: paragraphProperties.start,
+              paragraphPropertiesEnd: paragraphProperties.end,
+            }
+          : {}),
+        ...(paragraphRunProperties
+          ? {
+              paragraphRunPropertiesStart: paragraphRunProperties.start,
+              paragraphRunPropertiesEnd: paragraphRunProperties.end,
+            }
+          : {}),
+      });
+      nextPreviousWasParagraph = false;
+      continue;
+    }
+
+    if (
+      type === "tbl" ||
+      type === "tr" ||
+      type === "tc" ||
+      type === "sdtContent" ||
+      type === "customXml" ||
+      type === "smartTag"
+    ) {
+      const nested = collectNestedParagraphBoundaries(
+        node.children,
+        nextParagraphIndex,
+        nextCursor,
+        nextPreviousWasParagraph,
+      );
+      nextParagraphIndex = nested.paragraphIndex;
+      nextCursor = nested.cursor;
+      nextPreviousWasParagraph = nested.previousWasParagraph;
+      paragraphs.push(...nested.paragraphs);
+      continue;
+    }
+
+    if (
+      type === "tblPr" ||
+      type === "tblGrid" ||
+      type === "gridCol" ||
+      type === "trPr" ||
+      type === "tcPr"
+    ) {
+      continue;
+    }
+
+    nextCursor += 1;
+    nextPreviousWasParagraph = false;
+  }
+
+  return {
+    paragraphs,
+    paragraphIndex: nextParagraphIndex,
+    cursor: nextCursor,
+    previousWasParagraph: nextPreviousWasParagraph,
+  };
+}
+
 function walkStoryNodesForBoundaries(
   nodes: XmlNode[],
   boundaries: Map<number, number>,
@@ -163,7 +287,7 @@ function walkStoryNodeForBoundaries(
       if (!boundaries.has(getCursor())) {
         boundaries.set(getCursor(), node.start);
       }
-      setCursor(getCursor() + text.length);
+      setCursor(getCursor() + Array.from(text).length);
       boundaries.set(getCursor(), node.end);
       return;
     }