@beyondwork/docx-react-component 1.0.1 → 1.0.3

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

@@ -0,0 +1,568 @@
+interface XmlElementNode {
+  type: "element";
+  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;
+
+export interface ParsedBorderSpec {
+  value?: string;
+  size?: number;
+  space?: number;
+  color?: string;
+}
+
+export interface ParsedTableBorders {
+  top?: ParsedBorderSpec;
+  left?: ParsedBorderSpec;
+  bottom?: ParsedBorderSpec;
+  right?: ParsedBorderSpec;
+  insideH?: ParsedBorderSpec;
+  insideV?: ParsedBorderSpec;
+}
+
+export interface ParsedTableCellBorders {
+  top?: ParsedBorderSpec;
+  left?: ParsedBorderSpec;
+  bottom?: ParsedBorderSpec;
+  right?: ParsedBorderSpec;
+  insideH?: ParsedBorderSpec;
+  insideV?: ParsedBorderSpec;
+}
+
+export interface ParsedTableWidth {
+  value: number;
+  type: "dxa" | "auto" | "pct" | "nil";
+}
+
+export interface ParsedCellShading {
+  fill?: string;
+  color?: string;
+  val?: string;
+}
+
+export interface ParsedCellMargins {
+  top?: number;
+  left?: number;
+  bottom?: number;
+  right?: number;
+}
+
+export interface ParsedTableDocument {
+  tables: ParsedTable[];
+}
+
+export interface ParsedTable {
+  type: "table";
+  propertiesXml?: string;
+  gridColumns: number[];
+  rows: ParsedTableRow[];
+  rawXml: string;
+  width?: ParsedTableWidth;
+  alignment?: "left" | "center" | "right";
+  borders?: ParsedTableBorders;
+  cellMargins?: ParsedCellMargins;
+}
+
+export interface ParsedTableRow {
+  propertiesXml?: string;
+  cells: ParsedTableCell[];
+  rawXml: string;
+  height?: number;
+  heightRule?: "auto" | "atLeast" | "exact";
+  isHeader?: boolean;
+}
+
+export interface ParsedTableCell {
+  propertiesXml?: string;
+  gridSpan?: number;
+  verticalMerge?: "restart" | "continue";
+  blocksXml: string[];
+  rawXml: string;
+  width?: ParsedTableWidth;
+  borders?: ParsedTableCellBorders;
+  shading?: ParsedCellShading;
+  verticalAlign?: "top" | "center" | "bottom";
+}
+
+export function parseTablesFromDocumentXml(xml: string): ParsedTableDocument {
+  const root = parseXml(xml);
+  const documentElement = findChildElement(root, "document");
+  const bodyElement = findChildElement(documentElement, "body");
+
+  return {
+    tables: bodyElement.children
+      .filter((node): node is XmlElementNode => node.type === "element" && localName(node.name) === "tbl")
+      .map((node) => parseTable(node, xml)),
+  };
+}
+
+function parseTable(node: XmlElementNode, sourceXml: string): ParsedTable {
+  const propertiesNode = findFirstChild(node, "tblPr");
+  const gridNode = findFirstChild(node, "tblGrid");
+  const rows = node.children
+    .filter((child): child is XmlElementNode => child.type === "element" && localName(child.name) === "tr")
+    .map((rowNode) => parseRow(rowNode, sourceXml));
+
+  const width = propertiesNode ? readTableWidth(propertiesNode) : undefined;
+  const alignment = propertiesNode ? readTableAlignment(propertiesNode) : undefined;
+  const borders = propertiesNode ? readTableBorders(propertiesNode) : undefined;
+  const cellMargins = propertiesNode ? readTableCellMargins(propertiesNode) : undefined;
+
+  return {
+    type: "table",
+    ...(propertiesNode ? { propertiesXml: sourceXml.slice(propertiesNode.start, propertiesNode.end) } : {}),
+    gridColumns: gridNode ? readGridColumns(gridNode) : [],
+    rows,
+    rawXml: sourceXml.slice(node.start, node.end),
+    ...(width ? { width } : {}),
+    ...(alignment ? { alignment } : {}),
+    ...(borders ? { borders } : {}),
+    ...(cellMargins ? { cellMargins } : {}),
+  };
+}
+
+function parseRow(node: XmlElementNode, sourceXml: string): ParsedTableRow {
+  const propertiesNode = findFirstChild(node, "trPr");
+  const height = propertiesNode ? readRowHeight(propertiesNode) : undefined;
+  const heightRule = propertiesNode ? readRowHeightRule(propertiesNode) : undefined;
+  const isHeader = propertiesNode ? readRowIsHeader(propertiesNode) : undefined;
+
+  return {
+    ...(propertiesNode ? { propertiesXml: sourceXml.slice(propertiesNode.start, propertiesNode.end) } : {}),
+    cells: node.children
+      .filter((child): child is XmlElementNode => child.type === "element" && localName(child.name) === "tc")
+      .map((cellNode) => parseCell(cellNode, sourceXml)),
+    rawXml: sourceXml.slice(node.start, node.end),
+    ...(height !== undefined ? { height } : {}),
+    ...(heightRule ? { heightRule } : {}),
+    ...(isHeader ? { isHeader } : {}),
+  };
+}
+
+function parseCell(node: XmlElementNode, sourceXml: string): ParsedTableCell {
+  const propertiesNode = findFirstChild(node, "tcPr");
+  const gridSpanNode = propertiesNode ? findFirstChild(propertiesNode, "gridSpan") : undefined;
+  const verticalMergeNode = propertiesNode ? findFirstChild(propertiesNode, "vMerge") : undefined;
+  const blocksXml = node.children
+    .filter((child): child is XmlElementNode => child.type === "element" && localName(child.name) !== "tcPr")
+    .map((child) => sourceXml.slice(child.start, child.end));
+
+  const cellWidth = propertiesNode ? readCellWidth(propertiesNode) : undefined;
+  const borders = propertiesNode ? readCellBorders(propertiesNode) : undefined;
+  const shading = propertiesNode ? readCellShading(propertiesNode) : undefined;
+  const verticalAlign = propertiesNode ? readCellVerticalAlign(propertiesNode) : undefined;
+
+  return {
+    ...(propertiesNode ? { propertiesXml: sourceXml.slice(propertiesNode.start, propertiesNode.end) } : {}),
+    ...(gridSpanNode ? { gridSpan: parsePositiveInteger(gridSpanNode.attributes["w:val"] ?? gridSpanNode.attributes.val) } : {}),
+    ...(verticalMergeNode ? { verticalMerge: readVerticalMerge(verticalMergeNode) } : {}),
+    blocksXml,
+    rawXml: sourceXml.slice(node.start, node.end),
+    ...(cellWidth ? { width: cellWidth } : {}),
+    ...(borders ? { borders } : {}),
+    ...(shading ? { shading } : {}),
+    ...(verticalAlign ? { verticalAlign } : {}),
+  };
+}
+
+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"));
+}
+
+function readVerticalMerge(node: XmlElementNode): "restart" | "continue" {
+  const value = (node.attributes["w:val"] ?? node.attributes.val ?? "continue").toLowerCase();
+  return value === "restart" ? "restart" : "continue";
+}
+
+function parsePositiveInteger(value: string | undefined): number {
+  const parsed = Number.parseInt(value ?? "0", 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+}
+
+function findChildElement(node: XmlElementNode, childLocalName: string): XmlElementNode {
+  const child = findFirstChild(node, childLocalName);
+  if (!child) {
+    throw new Error(`Expected <${childLocalName}> element.`);
+  }
+
+  return child;
+}
+
+function findFirstChild(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 separatorIndex = name.indexOf(":");
+  return separatorIndex >= 0 ? name.slice(separatorIndex + 1) : name;
+}
+
+function parseXml(xml: string): XmlElementNode {
+  const root: XmlElementNode = {
+    type: "element",
+    name: "__root__",
+    attributes: {},
+    children: [],
+    start: 0,
+    end: xml.length,
+  };
+  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;
+    }
+
+    if (xml.startsWith("<![CDATA[", cursor)) {
+      const end = xml.indexOf("]]>", cursor);
+      const textEnd = end >= 0 ? end : xml.length;
+      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;
+    }
+
+    if (xml[cursor] !== "<") {
+      const nextTag = xml.indexOf("<", cursor);
+      const end = nextTag >= 0 ? nextTag : xml.length;
+      const text = decodeXmlEntities(xml.slice(cursor, end));
+      if (text.length > 0) {
+        stack[stack.length - 1]?.children.push({
+          type: "text",
+          text,
+          start: cursor,
+          end,
+        });
+      }
+      cursor = end;
+      continue;
+    }
+
+    if (xml[cursor + 1] === "/") {
+      const end = xml.indexOf(">", cursor);
+      if (end < 0) {
+        throw new Error("Malformed XML: missing closing >.");
+      }
+
+      const name = xml.slice(cursor + 2, end).trim();
+      const current = stack.pop();
+      if (!current || localName(current.name) !== localName(name)) {
+        throw new Error(`Malformed XML: unexpected closing tag </${name}>.`);
+      }
+      current.end = end + 1;
+      cursor = end + 1;
+      continue;
+    }
+
+    const tagEnd = findTagEnd(xml, cursor);
+    const tagBody = xml.slice(cursor + 1, tagEnd);
+    const selfClosing = /\/\s*$/.test(tagBody);
+    const { name, attributes } = parseTag(tagBody.replace(/\/\s*$/, "").trim());
+    const element: XmlElementNode = {
+      type: "element",
+      name,
+      attributes,
+      children: [],
+      start: cursor,
+      end: tagEnd + 1,
+    };
+    stack[stack.length - 1]?.children.push(element);
+
+    if (!selfClosing) {
+      stack.push(element);
+    }
+
+    cursor = tagEnd + 1;
+  }
+
+  if (stack.length !== 1) {
+    throw new Error("Malformed XML: unclosed element.");
+  }
+
+  return root;
+}
+
+function parseTag(tagBody: string): { name: string; attributes: Record<string, string> } {
+  let cursor = 0;
+  while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
+    cursor += 1;
+  }
+
+  const nameStart = cursor;
+  while (cursor < tagBody.length && !/\s/.test(tagBody[cursor] ?? "")) {
+    cursor += 1;
+  }
+  const name = tagBody.slice(nameStart, cursor);
+  const attributes: Record<string, string> = {};
+
+  while (cursor < tagBody.length) {
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
+      cursor += 1;
+    }
+    if (cursor >= tagBody.length) {
+      break;
+    }
+
+    const keyStart = cursor;
+    while (cursor < tagBody.length && !/[\s=]/.test(tagBody[cursor] ?? "")) {
+      cursor += 1;
+    }
+    const key = tagBody.slice(keyStart, cursor);
+
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
+      cursor += 1;
+    }
+
+    if (tagBody[cursor] !== "=") {
+      attributes[key] = "";
+      continue;
+    }
+    cursor += 1;
+
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
+      cursor += 1;
+    }
+
+    const quote = tagBody[cursor];
+    if (quote !== `"` && quote !== `'`) {
+      throw new Error(`Malformed XML attribute ${key}.`);
+    }
+    cursor += 1;
+
+    const valueStart = cursor;
+    while (cursor < tagBody.length && tagBody[cursor] !== quote) {
+      cursor += 1;
+    }
+    attributes[key] = decodeXmlEntities(tagBody.slice(valueStart, cursor));
+    cursor += 1;
+  }
+
+  return { name, attributes };
+}
+
+function findTagEnd(xml: string, start: number): number {
+  let cursor = start + 1;
+  let quote: string | null = null;
+
+  while (cursor < xml.length) {
+    const current = xml[cursor];
+    if (quote) {
+      if (current === quote) {
+        quote = null;
+      }
+      cursor += 1;
+      continue;
+    }
+
+    if (current === `"` || current === `'`) {
+      quote = current;
+      cursor += 1;
+      continue;
+    }
+
+    if (current === ">") {
+      return cursor;
+    }
+
+    cursor += 1;
+  }
+
+  throw new Error("Malformed XML: missing >.");
+}
+
+function decodeXmlEntities(value: string): string {
+  return value.replace(/&(#x[0-9a-fA-F]+|#\d+|amp|lt|gt|quot|apos);/g, (match, entity) => {
+    switch (entity) {
+      case "amp":
+        return "&";
+      case "lt":
+        return "<";
+      case "gt":
+        return ">";
+      case "quot":
+        return `"`;
+      case "apos":
+        return "'";
+      default:
+        if (entity.startsWith("#x")) {
+          return String.fromCodePoint(Number.parseInt(entity.slice(2), 16));
+        }
+        if (entity.startsWith("#")) {
+          return String.fromCodePoint(Number.parseInt(entity.slice(1), 10));
+        }
+        return match;
+    }
+  });
+}
+
+// Cell property readers
+
+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);
+  const rawType = (widthNode.attributes["w:type"] ?? widthNode.attributes.type ?? "dxa").toLowerCase();
+  const type: ParsedTableWidth["type"] =
+    rawType === "auto" ? "auto" : rawType === "pct" ? "pct" : rawType === "nil" ? "nil" : "dxa";
+  return { value, type };
+}
+
+function readCellBorders(propertiesNode: XmlElementNode): ParsedTableCellBorders | undefined {
+  const bordersNode = findFirstChild(propertiesNode, "tcBorders");
+  if (!bordersNode) return undefined;
+  const borders: ParsedTableCellBorders = {};
+  for (const child of bordersNode.children) {
+    if (child.type !== "element") continue;
+    const name = localName(child.name);
+    if (name !== "top" && name !== "left" && name !== "bottom" && name !== "right" && name !== "insideH" && name !== "insideV") continue;
+    const spec = parseBorderSpec(child);
+    if (spec) borders[name] = spec;
+  }
+  return Object.keys(borders).length > 0 ? borders : undefined;
+}
+
+function readCellShading(propertiesNode: XmlElementNode): ParsedCellShading | undefined {
+  const shdNode = findFirstChild(propertiesNode, "shd");
+  if (!shdNode) return undefined;
+  const fill = shdNode.attributes["w:fill"] ?? shdNode.attributes.fill;
+  const color = shdNode.attributes["w:color"] ?? shdNode.attributes.color;
+  const val = shdNode.attributes["w:val"] ?? shdNode.attributes.val;
+  if (!fill && !color && !val) return undefined;
+  const result: ParsedCellShading = {};
+  if (fill) result.fill = fill;
+  if (color) result.color = color;
+  if (val) result.val = val;
+  return result;
+}
+
+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;
+  if (val === "center" || val === "top" || val === "bottom") return val;
+  return undefined;
+}
+
+// Table property readers
+
+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);
+  const rawType = (widthNode.attributes["w:type"] ?? widthNode.attributes.type ?? "dxa").toLowerCase();
+  const type: ParsedTableWidth["type"] =
+    rawType === "auto" ? "auto" : rawType === "pct" ? "pct" : rawType === "nil" ? "nil" : "dxa";
+  return { value, type };
+}
+
+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;
+  if (val === "left" || val === "center" || val === "right") return val;
+  return undefined;
+}
+
+function readTableBorders(propertiesNode: XmlElementNode): ParsedTableBorders | undefined {
+  const bordersNode = findFirstChild(propertiesNode, "tblBorders");
+  if (!bordersNode) return undefined;
+  const borders: ParsedTableBorders = {};
+  for (const child of bordersNode.children) {
+    if (child.type !== "element") continue;
+    const name = localName(child.name);
+    if (name !== "top" && name !== "left" && name !== "bottom" && name !== "right" && name !== "insideH" && name !== "insideV") continue;
+    const spec = parseBorderSpec(child);
+    if (spec) borders[name] = spec;
+  }
+  return Object.keys(borders).length > 0 ? borders : undefined;
+}
+
+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 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 };
+}
+
+// Row property readers
+
+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 {
+  const heightNode = findFirstChild(propertiesNode, "trHeight");
+  if (!heightNode) return undefined;
+  const raw = (heightNode.attributes["w:hRule"] ?? heightNode.attributes.hRule ?? "").toLowerCase();
+  if (raw === "atleast") return "atLeast";
+  if (raw === "exact") return "exact";
+  if (raw === "auto") return "auto";
+  return undefined;
+}
+
+function readRowIsHeader(propertiesNode: XmlElementNode): boolean | undefined {
+  const headerNode = findFirstChild(propertiesNode, "tblHeader");
+  if (!headerNode) return undefined;
+  const val = headerNode.attributes["w:val"] ?? headerNode.attributes.val;
+  return val !== "false" && val !== "0";
+}
+
+function parseBorderSpec(child: XmlElementNode): ParsedBorderSpec | undefined {
+  const value = child.attributes["w:val"] ?? child.attributes.val;
+  const sizeRaw = child.attributes["w:sz"] ?? child.attributes.sz;
+  const spaceRaw = child.attributes["w:space"] ?? child.attributes.space;
+  const color = child.attributes["w:color"] ?? child.attributes.color;
+  if (!value && !sizeRaw && !spaceRaw && !color) return undefined;
+  const spec: ParsedBorderSpec = {};
+  if (value) spec.value = value;
+  if (sizeRaw !== undefined) {
+    const n = Number.parseInt(sizeRaw, 10);
+    if (Number.isFinite(n)) spec.size = n;
+  }
+  if (spaceRaw !== undefined) {
+    const n = Number.parseInt(spaceRaw, 10);
+    if (Number.isFinite(n)) spec.space = n;
+  }
+  if (color) spec.color = color;
+  return spec;
+}