@beyondwork/docx-react-component 1.0.27 → 1.0.29

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

@@ -1,41 +0,0 @@
-/**
- * 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

@@ -1,459 +0,0 @@
-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

@@ -1,59 +0,0 @@
-/**
- * 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

@@ -1,75 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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;");
-}