@beyondwork/docx-react-component 1.0.29 → 1.0.30

package/src/formats/xlsx/io/parse-shared-strings.ts

@@ -0,0 +1,41 @@
+/**
+ * Parses xl/sharedStrings.xml and returns the shared string table as an ordered array.
+ *
+ * Handles both simple text (<si><t>...</t></si>) and rich text runs
+ * (<si><r><t>...</t></r></si>) by concatenating all <t> content within each <si>.
+ */
+export function parseSharedStringsXml(xml: string): string[] {
+  const result: string[] = [];
+  const siPattern = /<si>([\s\S]*?)<\/si>/g;
+  let siMatch: RegExpExecArray | null;
+
+  while ((siMatch = siPattern.exec(xml)) !== null) {
+    const siContent = siMatch[1] ?? "";
+    result.push(extractSharedStringText(siContent));
+  }
+
+  return result;
+}
+
+function extractSharedStringText(siContent: string): string {
+  // Collect text from all <t> elements (handles plain and rich text runs).
+  // The xml:space="preserve" attribute is not significant for the string value.
+  const tPattern = /<t(?:\s[^>]*)?>([^<]*)<\/t>/g;
+  const parts: string[] = [];
+  let tMatch: RegExpExecArray | null;
+
+  while ((tMatch = tPattern.exec(siContent)) !== null) {
+    parts.push(decodeXmlEntities(tMatch[1] ?? ""));
+  }
+
+  return parts.join("");
+}
+
+export function decodeXmlEntities(value: string): string {
+  return value
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&amp;/g, "&");
+}

package/src/formats/xlsx/io/parse-sheet.ts

@@ -0,0 +1,459 @@
+import { decodeXmlEntities } from "./parse-shared-strings.ts";
+import { parseXmlAttributes } from "./parse-styles.ts";
+
+// Re-export for external use
+export { decodeXmlEntities };
+
+/**
+ * A parsed cell from a SpreadsheetML worksheet.
+ *
+ * Row and col are zero-based indices. The value discriminated union covers all
+ * SpreadsheetML cell type codes: s (shared string), inlineStr, n/absent (number),
+ * b (boolean), e (error), str (formula string result), and blank.
+ */
+export type XlsxParsedCellValue =
+  | { type: "blank" }
+  | { type: "text"; value: string; fromSharedString: boolean }
+  | { type: "number"; value: number }
+  | { type: "boolean"; value: boolean }
+  | {
+      type: "formula";
+      formula: string;
+      referenceTokens: string[];
+      cachedValue: XlsxParsedFormulaCachedValue | null;
+    }
+  | { type: "error"; errorCode: string };
+
+export type XlsxParsedFormulaCachedValue =
+  | { type: "blank" }
+  | { type: "text"; value: string }
+  | { type: "number"; value: number }
+  | { type: "boolean"; value: boolean }
+  | { type: "error"; errorCode: string };
+
+export interface XlsxParsedCell {
+  row: number;
+  col: number;
+  value: XlsxParsedCellValue;
+  styleIndex: number | null;
+}
+
+/**
+ * A parsed merge range from the <mergeCells> section.
+ * All indices are zero-based.
+ */
+export interface XlsxParsedMerge {
+  startRow: number;
+  startCol: number;
+  endRow: number;
+  endCol: number;
+}
+
+export interface XlsxParsedDimension {
+  startRow: number;
+  startCol: number;
+  endRow: number;
+  endCol: number;
+}
+
+export interface SheetParseResult {
+  cells: XlsxParsedCell[];
+  merges: XlsxParsedMerge[];
+  dimension: XlsxParsedDimension | null;
+}
+
+/**
+ * Parses xl/worksheets/sheetN.xml.
+ *
+ * @param xml - Raw XML string of the worksheet part.
+ * @param sharedStrings - The shared string table from parseSharedStringsXml.
+ */
+export function parseSheetXml(
+  xml: string,
+  sharedStrings: readonly string[],
+): SheetParseResult {
+  const cells: XlsxParsedCell[] = [];
+  const merges: XlsxParsedMerge[] = [];
+  const dimension = parseSheetDimension(xml);
+
+  const sheetDataMatch = /<sheetData>([\s\S]*?)<\/sheetData>/i.exec(xml);
+  if (sheetDataMatch) {
+    parseSheetData(sheetDataMatch[1] ?? "", sharedStrings, cells);
+  }
+
+  const mergeCellsMatch = /<mergeCells\b[^>]*>([\s\S]*?)<\/mergeCells>/i.exec(xml);
+  if (mergeCellsMatch) {
+    parseMergeCells(mergeCellsMatch[1] ?? "", merges);
+  }
+
+  return { cells, merges, dimension };
+}
+
+function parseSheetData(
+  sheetDataXml: string,
+  sharedStrings: readonly string[],
+  out: XlsxParsedCell[],
+): void {
+  // Match non-empty rows (<row ...>...</row>)
+  const rowPattern = /<row\b([^>]*)>([\s\S]*?)<\/row>/g;
+  let rowMatch: RegExpExecArray | null;
+
+  while ((rowMatch = rowPattern.exec(sheetDataXml)) !== null) {
+    const rowContent = rowMatch[2] ?? "";
+    parseRowCells(rowContent, sharedStrings, out);
+  }
+}
+
+function parseRowCells(
+  rowXml: string,
+  sharedStrings: readonly string[],
+  out: XlsxParsedCell[],
+): void {
+  // Match cells: both non-empty (<c ...>...</c>) and self-closing (<c .../>)
+  const cellPattern = /<c\b([^>]*)(?:>([\s\S]*?)<\/c>|\/>)/g;
+  let cellMatch: RegExpExecArray | null;
+
+  while ((cellMatch = cellPattern.exec(rowXml)) !== null) {
+    const attrs = parseXmlAttributes(cellMatch[1] ?? "");
+    const content = cellMatch[2] ?? "";
+    const cell = parseCell(attrs, content, sharedStrings);
+    if (cell !== null) {
+      out.push(cell);
+    }
+  }
+}
+
+function parseCell(
+  attrs: Record<string, string>,
+  content: string,
+  sharedStrings: readonly string[],
+): XlsxParsedCell | null {
+  const ref = attrs["r"];
+  if (!ref) {
+    return null;
+  }
+
+  const cellRef = parseCellRef(ref);
+  if (cellRef === null) {
+    return null;
+  }
+
+  const styleIndexAttr = attrs["s"];
+  const styleIndex =
+    styleIndexAttr !== undefined ? parseInt(styleIndexAttr, 10) : null;
+
+  const typeCode = attrs["t"] ?? "n";
+  const rawValue = extractTextContent(content, "v");
+  const formulaText = extractTextContent(content, "f");
+  const inlineText = extractInlineStringText(content);
+
+  const value = resolveCellValue(typeCode, rawValue, formulaText, inlineText, sharedStrings);
+
+  return {
+    row: cellRef.row,
+    col: cellRef.col,
+    value,
+    styleIndex: styleIndex !== null && !Number.isNaN(styleIndex) ? styleIndex : null,
+  };
+}
+
+function resolveCellValue(
+  typeCode: string,
+  rawValue: string | null,
+  formulaText: string | null,
+  inlineText: string | null,
+  sharedStrings: readonly string[],
+): XlsxParsedCellValue {
+  // Formula cells may have any result type; store formula + cached value.
+  if (formulaText !== null) {
+    const decodedFormula = decodeXmlEntities(formulaText);
+    return {
+      type: "formula",
+      formula: decodedFormula,
+      referenceTokens: extractFormulaReferenceTokens(decodedFormula),
+      cachedValue: resolveFormulaCachedValue(typeCode, rawValue, inlineText, sharedStrings),
+    };
+  }
+
+  switch (typeCode) {
+    case "s": {
+      // Shared string reference
+      const index = rawValue !== null ? parseInt(rawValue, 10) : NaN;
+      const text =
+        !Number.isNaN(index) && index >= 0 && index < sharedStrings.length
+          ? (sharedStrings[index] ?? "")
+          : "";
+      return { type: "text", value: text, fromSharedString: true };
+    }
+
+    case "inlineStr": {
+      return { type: "text", value: inlineText ?? "", fromSharedString: false };
+    }
+
+    case "str": {
+      // Formula result is a string; formula text would have been captured above.
+      // Here the cell carries only the cached string value (no formula tag).
+      return {
+        type: "text",
+        value: rawValue !== null ? decodeXmlEntities(rawValue) : "",
+        fromSharedString: false,
+      };
+    }
+
+    case "b": {
+      return { type: "boolean", value: rawValue === "1" };
+    }
+
+    case "e": {
+      return {
+        type: "error",
+        errorCode:
+          rawValue !== null ? decodeXmlEntities(rawValue) : "#ERROR!",
+      };
+    }
+
+    default: {
+      // "n" or absent — numeric value
+      if (rawValue === null || rawValue === "") {
+        return { type: "blank" };
+      }
+
+      const numericValue = parseFloat(rawValue);
+      return Number.isNaN(numericValue)
+        ? { type: "blank" }
+        : { type: "number", value: numericValue };
+    }
+  }
+}
+
+function resolveFormulaCachedValue(
+  typeCode: string,
+  rawValue: string | null,
+  inlineText: string | null,
+  sharedStrings: readonly string[],
+): XlsxParsedFormulaCachedValue | null {
+  switch (typeCode) {
+    case "s": {
+      const index = rawValue !== null ? parseInt(rawValue, 10) : NaN;
+      return {
+        type: "text",
+        value:
+          !Number.isNaN(index) && index >= 0 && index < sharedStrings.length
+            ? (sharedStrings[index] ?? "")
+            : "",
+      };
+    }
+
+    case "inlineStr":
+      return { type: "text", value: inlineText ?? "" };
+
+    case "str":
+      return rawValue === null
+        ? { type: "blank" }
+        : { type: "text", value: decodeXmlEntities(rawValue) };
+
+    case "b":
+      return rawValue === null
+        ? { type: "blank" }
+        : { type: "boolean", value: rawValue === "1" };
+
+    case "e":
+      return rawValue === null
+        ? { type: "blank" }
+        : { type: "error", errorCode: decodeXmlEntities(rawValue) };
+
+    default: {
+      if (rawValue === null || rawValue === "") {
+        return { type: "blank" };
+      }
+
+      const numericValue = Number(rawValue);
+      if (!Number.isNaN(numericValue)) {
+        return { type: "number", value: numericValue };
+      }
+
+      if (rawValue === "TRUE" || rawValue === "FALSE") {
+        return { type: "boolean", value: rawValue === "TRUE" };
+      }
+
+      return { type: "text", value: decodeXmlEntities(rawValue) };
+    }
+  }
+}
+
+function extractTextContent(xml: string, tagName: string): string | null {
+  const pattern = new RegExp(`<${tagName}(?:\\s[^>]*)?>([^<]*)</${tagName}>`, "i");
+  const match = pattern.exec(xml);
+  return match ? (match[1] ?? null) : null;
+}
+
+function extractInlineStringText(cellContent: string): string | null {
+  // <is> contains rich text identical to shared string runs
+  const isMatch = /<is>([\s\S]*?)<\/is>/i.exec(cellContent);
+  if (!isMatch) {
+    return null;
+  }
+
+  const tPattern = /<t(?:\s[^>]*)?>([^<]*)<\/t>/g;
+  const parts: string[] = [];
+  let tMatch: RegExpExecArray | null;
+
+  while ((tMatch = tPattern.exec(isMatch[1] ?? "")) !== null) {
+    parts.push(decodeXmlEntities(tMatch[1] ?? ""));
+  }
+
+  return parts.join("");
+}
+
+function parseMergeCells(mergeCellsXml: string, out: XlsxParsedMerge[]): void {
+  const mergePattern = /<mergeCell\b([^>]*?)(?:\/>|>[\s\S]*?<\/mergeCell>)/g;
+  let match: RegExpExecArray | null;
+
+  while ((match = mergePattern.exec(mergeCellsXml)) !== null) {
+    const attrs = parseXmlAttributes(match[1] ?? "");
+    const ref = attrs["ref"] ?? "";
+    const merge = parseMergeRef(ref);
+    if (merge !== null) {
+      out.push(merge);
+    }
+  }
+}
+
+function parseMergeRef(ref: string): XlsxParsedMerge | null {
+  const parts = ref.split(":");
+  if (parts.length !== 2) {
+    return null;
+  }
+
+  const start = parseCellRef(parts[0] ?? "");
+  const end = parseCellRef(parts[1] ?? "");
+  if (start === null || end === null) {
+    return null;
+  }
+
+  return {
+    startRow: start.row,
+    startCol: start.col,
+    endRow: end.row,
+    endCol: end.col,
+  };
+}
+
+function parseSheetDimension(xml: string): XlsxParsedDimension | null {
+  const dimensionMatch = /<dimension\b([^>]*?)(?:\/>|>)/i.exec(xml);
+  if (!dimensionMatch) {
+    return null;
+  }
+
+  const attrs = parseXmlAttributes(dimensionMatch[1] ?? "");
+  const ref = attrs["ref"];
+  if (!ref) {
+    return null;
+  }
+
+  return parseDimensionRef(ref);
+}
+
+const SHEET_PREFIX_PATTERN =
+  "(?:'(?:[^']|'')+'|[A-Za-z_][A-Za-z0-9_.]*)!";
+const CELL_REFERENCE_PATTERN = "\\$?[A-Z]{1,3}\\$?[1-9][0-9]*";
+const RANGE_REFERENCE_PATTERN =
+  `${CELL_REFERENCE_PATTERN}(?::${CELL_REFERENCE_PATTERN})?`;
+const FORMULA_REFERENCE_PATTERN = new RegExp(
+  String.raw`(?<![A-Za-z0-9_.$])(?:${SHEET_PREFIX_PATTERN})?${RANGE_REFERENCE_PATTERN}(?![A-Za-z0-9_])`,
+  "g",
+);
+
+function extractFormulaReferenceTokens(formula: string): string[] {
+  const maskedFormula = maskQuotedFormulaStrings(formula);
+  const tokens: string[] = [];
+  const seen = new Set<string>();
+
+  for (const match of maskedFormula.matchAll(FORMULA_REFERENCE_PATTERN)) {
+    const index = match.index ?? -1;
+    if (index < 0) {
+      continue;
+    }
+    const token = formula.slice(index, index + match[0].length);
+    if (seen.has(token)) {
+      continue;
+    }
+    seen.add(token);
+    tokens.push(token);
+  }
+
+  return tokens;
+}
+
+function maskQuotedFormulaStrings(formula: string): string {
+  let output = "";
+  let inString = false;
+
+  for (let index = 0; index < formula.length; index += 1) {
+    const char = formula[index];
+    const next = formula[index + 1];
+
+    if (char === "\"") {
+      output += char;
+      if (inString && next === "\"") {
+        output += " ";
+        index += 1;
+        continue;
+      }
+      inString = !inString;
+      continue;
+    }
+
+    output += inString ? " " : char;
+  }
+
+  return output;
+}
+
+function parseDimensionRef(ref: string): XlsxParsedDimension | null {
+  const [startRef, endRef = startRef] = ref.split(":");
+  if (!startRef || !endRef) {
+    return null;
+  }
+
+  const start = parseCellRef(startRef);
+  const end = parseCellRef(endRef);
+  if (start === null || end === null) {
+    return null;
+  }
+
+  return {
+    startRow: start.row,
+    startCol: start.col,
+    endRow: end.row,
+    endCol: end.col,
+  };
+}
+
+function parseCellRef(ref: string): { row: number; col: number } | null {
+  const match = /^([A-Z]+)([0-9]+)$/i.exec(ref.trim());
+  if (!match) {
+    return null;
+  }
+
+  return {
+    col: colLettersToIndex(match[1] ?? ""),
+    row: parseInt(match[2] ?? "1", 10) - 1,
+  };
+}
+
+/**
+ * Converts a column letter sequence to a zero-based column index.
+ * "A" -> 0, "Z" -> 25, "AA" -> 26, "AZ" -> 51, "BA" -> 52.
+ */
+function colLettersToIndex(letters: string): number {
+  let result = 0;
+
+  for (const char of letters.toUpperCase()) {
+    result = result * 26 + (char.charCodeAt(0) - 64);
+  }
+
+  return result - 1;
+}
+
+export { parseCellRef, colLettersToIndex };

package/src/formats/xlsx/io/parse-styles.ts

@@ -0,0 +1,59 @@
+/**
+ * Parses xl/styles.xml for the cellXfs table (cell format entries).
+ *
+ * Each entry provides style references (numFmtId, fontId, fillId, borderId)
+ * that cells reference by zero-based index via the s= attribute.
+ */
+export interface XlsxStyleEntry {
+  numFmtId: number;
+  fontId: number;
+  fillId: number;
+  borderId: number;
+  rawAttributes: Record<string, string>;
+}
+
+export function parseStylesXml(xml: string): XlsxStyleEntry[] {
+  const cellXfsMatch = /<cellXfs\b[^>]*>([\s\S]*?)<\/cellXfs>/i.exec(xml);
+  if (!cellXfsMatch) {
+    return [];
+  }
+
+  const cellXfsContent = cellXfsMatch[1] ?? "";
+  const xfPattern = /<xf\b([^>]*?)(?:\/>|>[\s\S]*?<\/xf>)/g;
+  const entries: XlsxStyleEntry[] = [];
+  let xfMatch: RegExpExecArray | null;
+
+  while ((xfMatch = xfPattern.exec(cellXfsContent)) !== null) {
+    const attrs = parseXmlAttributes(xfMatch[1] ?? "");
+    entries.push({
+      numFmtId: parseIntAttr(attrs["numFmtId"], 0),
+      fontId: parseIntAttr(attrs["fontId"], 0),
+      fillId: parseIntAttr(attrs["fillId"], 0),
+      borderId: parseIntAttr(attrs["borderId"], 0),
+      rawAttributes: attrs,
+    });
+  }
+
+  return entries;
+}
+
+function parseIntAttr(value: string | undefined, defaultValue: number): number {
+  if (value === undefined || value === "") {
+    return defaultValue;
+  }
+
+  const parsed = parseInt(value, 10);
+  return Number.isNaN(parsed) ? defaultValue : parsed;
+}
+
+export function parseXmlAttributes(rawAttributes: string): Record<string, string> {
+  const attributes: Record<string, string> = {};
+  const attributePattern = /([A-Za-z_][\w:.-]*)="([^"]*)"/g;
+  let match: RegExpExecArray | null;
+
+  while ((match = attributePattern.exec(rawAttributes)) !== null) {
+    attributes[match[1]] = match[2];
+  }
+
+  return attributes;
+}

package/src/formats/xlsx/io/parse-workbook.ts

@@ -0,0 +1,75 @@
+import { parseXmlAttributes } from "./parse-styles.ts";
+
+/**
+ * Represents a single sheet entry from the workbook's sheet registry.
+ */
+export interface WorkbookSheetEntry {
+  /** Human-readable sheet name. */
+  name: string;
+  /** Workbook-internal numeric sheet ID string. */
+  sheetId: string;
+  /** Relationship ID used to look up the sheet part path. */
+  relationshipId: string;
+  /** Visibility state; defaults to "visible" when absent. */
+  state: "visible" | "hidden" | "veryHidden";
+}
+
+export interface WorkbookParseResult {
+  sheets: WorkbookSheetEntry[];
+  /**
+   * Whether the workbook uses the 1904 date base.
+   * Most xlsx files use 1900 (false). Mac-originated files may use 1904 (true).
+   */
+  date1904: boolean;
+}
+
+/**
+ * Parses xl/workbook.xml and returns the ordered sheet registry.
+ *
+ * The r:id attribute in <sheet> elements uses the XML namespace prefix r.
+ * The attribute parser handles namespace-prefixed names (e.g. "r:id") correctly.
+ */
+export function parseWorkbookXml(xml: string): WorkbookParseResult {
+  const sheets: WorkbookSheetEntry[] = [];
+  const sheetPattern = /<sheet\b([^>]*?)(?:\/>|>[\s\S]*?<\/sheet>)/g;
+  let match: RegExpExecArray | null;
+
+  while ((match = sheetPattern.exec(xml)) !== null) {
+    const attrs = parseXmlAttributes(match[1] ?? "");
+    const name = attrs["name"] ?? "";
+    const sheetId = attrs["sheetId"] ?? "";
+    const relationshipId = attrs["r:id"] ?? attrs["id"] ?? "";
+
+    if (!name || !sheetId || !relationshipId) {
+      continue;
+    }
+
+    const stateAttr = attrs["state"];
+    const state: WorkbookSheetEntry["state"] =
+      stateAttr === "hidden"
+        ? "hidden"
+        : stateAttr === "veryHidden"
+          ? "veryHidden"
+          : "visible";
+
+    sheets.push({ name, sheetId, relationshipId, state });
+  }
+
+  const date1904 = parseDate1904(xml);
+
+  return { sheets, date1904 };
+}
+
+/**
+ * Extracts the date1904 flag from the <workbookPr> element.
+ * Returns false (1900 base) if the attribute is absent or not "1" or "true".
+ */
+function parseDate1904(xml: string): boolean {
+  const workbookPrMatch = /<workbookPr\b([^>]*?)(?:\/>|>)/i.exec(xml);
+  if (!workbookPrMatch) {
+    return false;
+  }
+  const attrs = parseXmlAttributes(workbookPrMatch[1] ?? "");
+  const val = attrs["date1904"];
+  return val === "1" || val === "true";
+}

package/src/formats/xlsx/io/serialize-shared-strings.ts

@@ -0,0 +1,72 @@
+import type { CanonicalWorkbook } from "../model/workbook.ts";
+import { listSheets } from "../model/workbook.ts";
+
+const SHARED_STRINGS_NAMESPACE = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+
+export interface SharedStringTableSerialization {
+  xml: string;
+  strings: string[];
+  indexByValue: Map<string, number>;
+  totalCount: number;
+}
+
+export function buildSharedStringsTable(
+  workbook: CanonicalWorkbook,
+): SharedStringTableSerialization {
+  const strings: string[] = [];
+  const indexByValue = new Map<string, number>();
+  let totalCount = 0;
+
+  for (const sheet of listSheets(workbook)) {
+    for (const cell of sheet.cells.values()) {
+      if (cell.kind !== "text") {
+        continue;
+      }
+
+      totalCount += 1;
+
+      if (!indexByValue.has(cell.value)) {
+        indexByValue.set(cell.value, strings.length);
+        strings.push(cell.value);
+      }
+    }
+  }
+
+  return {
+    xml: serializeSharedStringsXml(strings, totalCount),
+    strings,
+    indexByValue,
+    totalCount,
+  };
+}
+
+export function serializeSharedStringsXml(
+  strings: readonly string[],
+  totalCount: number = strings.length,
+): string {
+  const items = strings.map(serializeSharedStringItem);
+  const body = items.length > 0 ? `\n${items.join("\n")}\n` : "";
+
+  return [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    `<sst xmlns="${SHARED_STRINGS_NAMESPACE}" count="${totalCount}" uniqueCount="${strings.length}">${body}</sst>`,
+  ].join("\n");
+}
+
+function serializeSharedStringItem(value: string): string {
+  const preserveSpace = requiresPreservedSpace(value) ? ` xml:space="preserve"` : "";
+  return `  <si><t${preserveSpace}>${escapeXml(value)}</t></si>`;
+}
+
+function requiresPreservedSpace(value: string): boolean {
+  return /^\s/.test(value) || /\s$/.test(value);
+}
+
+function escapeXml(value: string): string {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/"/g, "&quot;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/'/g, "&apos;");
+}