@beyondwork/docx-react-component 1.0.11 → 1.0.13

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

@@ -1,4 +1,4 @@
-import { decodeXmlEntities, parseSharedStringsXml as _unused } from "./parse-shared-strings.ts";
+import { decodeXmlEntities } from "./parse-shared-strings.ts";
 import { parseXmlAttributes } from "./parse-styles.ts";
 
 // Re-export for external use
@@ -12,11 +12,23 @@ export { decodeXmlEntities };
  * 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: "formula"; formula: string; cachedValue: string | null }
   | { type: "error"; errorCode: string };
 
 export interface XlsxParsedCell {
@@ -37,9 +49,17 @@ export interface XlsxParsedMerge {
   endCol: number;
 }
 
+export interface XlsxParsedDimension {
+  startRow: number;
+  startCol: number;
+  endRow: number;
+  endCol: number;
+}
+
 export interface SheetParseResult {
   cells: XlsxParsedCell[];
   merges: XlsxParsedMerge[];
+  dimension: XlsxParsedDimension | null;
 }
 
 /**
@@ -54,6 +74,7 @@ export function parseSheetXml(
 ): SheetParseResult {
   const cells: XlsxParsedCell[] = [];
   const merges: XlsxParsedMerge[] = [];
+  const dimension = parseSheetDimension(xml);
 
   const sheetDataMatch = /<sheetData>([\s\S]*?)<\/sheetData>/i.exec(xml);
   if (sheetDataMatch) {
@@ -65,7 +86,7 @@ export function parseSheetXml(
     parseMergeCells(mergeCellsMatch[1] ?? "", merges);
   }
 
-  return { cells, merges };
+  return { cells, merges, dimension };
 }
 
 function parseSheetData(
@@ -145,10 +166,12 @@ function resolveCellValue(
 ): XlsxParsedCellValue {
   // Formula cells may have any result type; store formula + cached value.
   if (formulaText !== null) {
+    const decodedFormula = decodeXmlEntities(formulaText);
     return {
       type: "formula",
-      formula: decodeXmlEntities(formulaText),
-      cachedValue: rawValue !== null ? decodeXmlEntities(rawValue) : null,
+      formula: decodedFormula,
+      referenceTokens: extractFormulaReferenceTokens(decodedFormula),
+      cachedValue: resolveFormulaCachedValue(typeCode, rawValue, inlineText, sharedStrings),
     };
   }
 
@@ -160,11 +183,11 @@ function resolveCellValue(
         !Number.isNaN(index) && index >= 0 && index < sharedStrings.length
           ? (sharedStrings[index] ?? "")
           : "";
-      return { type: "text", value: text };
+      return { type: "text", value: text, fromSharedString: true };
     }
 
     case "inlineStr": {
-      return { type: "text", value: inlineText ?? "" };
+      return { type: "text", value: inlineText ?? "", fromSharedString: false };
     }
 
     case "str": {
@@ -173,6 +196,7 @@ function resolveCellValue(
       return {
         type: "text",
         value: rawValue !== null ? decodeXmlEntities(rawValue) : "",
+        fromSharedString: false,
       };
     }
 
@@ -202,6 +226,61 @@ function resolveCellValue(
   }
 }
 
+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);
@@ -260,6 +339,97 @@ function parseMergeRef(ref: string): XlsxParsedMerge | null {
   };
 }
 
+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) {

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

@@ -9,6 +9,7 @@ export interface XlsxStyleEntry {
   fontId: number;
   fillId: number;
   borderId: number;
+  rawAttributes: Record<string, string>;
 }
 
 export function parseStylesXml(xml: string): XlsxStyleEntry[] {
@@ -29,6 +30,7 @@ export function parseStylesXml(xml: string): XlsxStyleEntry[] {
       fontId: parseIntAttr(attrs["fontId"], 0),
       fillId: parseIntAttr(attrs["fillId"], 0),
       borderId: parseIntAttr(attrs["borderId"], 0),
+      rawAttributes: attrs,
     });
   }
 

package/src/formats/xlsx/io/xlsx-session.ts

@@ -33,7 +33,7 @@ import { parseWorkbookXml } from "./parse-workbook.ts";
 import { parseSharedStringsXml } from "./parse-shared-strings.ts";
 import { parseStylesXml, parseXmlAttributes } from "./parse-styles.ts";
 import { parseSheetXml } from "./parse-sheet.ts";
-import type { XlsxParsedCellValue } from "./parse-sheet.ts";
+import type { XlsxParsedCellValue, XlsxParsedFormulaCachedValue } from "./parse-sheet.ts";
 
 // ---------------------------------------------------------------------------
 // Relationship type constants (SpreadsheetML / OPC)
@@ -177,7 +177,7 @@ function buildStyleRegistry(stylesXml: string): WorkbookStyleRegistry {
       fillId: entry.fillId,
       borderId: entry.borderId,
       numFmtId: entry.numFmtId,
-      rawAttributes: {},
+      rawAttributes: entry.rawAttributes,
     }),
   );
 
@@ -239,7 +239,7 @@ function convertParsedCellValue(
       return styleRef ? makeBlankCell(styleRef) : null;
 
     case "text":
-      return makeTextCell(parsed.value, false, styleRef);
+      return makeTextCell(parsed.value, parsed.fromSharedString, styleRef);
 
     case "number":
       return makeNumberCell(parsed.value, styleRef);
@@ -255,6 +255,7 @@ function convertParsedCellValue(
         parsed.formula,
         convertCachedFormulaValue(parsed.cachedValue),
         styleRef,
+        parsed.referenceTokens,
       );
   }
 }
@@ -282,19 +283,24 @@ function normalizeErrorCode(raw: string): CellErrorCode {
  * parse layer does not currently surface for formula cells.
  */
 function convertCachedFormulaValue(
-  raw: string | null,
+  cachedValue: XlsxParsedFormulaCachedValue | null,
 ): CachedFormulaValue | undefined {
-  if (raw === null) {
+  if (cachedValue === null) {
     return undefined;
   }
-  const num = Number(raw);
-  if (!Number.isNaN(num)) {
-    return { type: "number", value: num };
-  }
-  if (raw === "TRUE" || raw === "FALSE") {
-    return { type: "boolean", value: raw === "TRUE" };
+
+  switch (cachedValue.type) {
+    case "blank":
+      return { type: "blank" };
+    case "number":
+      return { type: "number", value: cachedValue.value };
+    case "text":
+      return { type: "text", value: cachedValue.value };
+    case "boolean":
+      return { type: "boolean", value: cachedValue.value };
+    case "error":
+      return { type: "error", errorCode: normalizeErrorCode(cachedValue.errorCode) };
   }
-  return { type: "text", value: raw };
 }
 
 // ---------------------------------------------------------------------------

package/src/formats/xlsx/model/sheet.ts

@@ -5,7 +5,7 @@
  * explicit style are stored. Row and column metadata is also sparse.
  */
 
-import type { CellAddress, CellKey, CellValue, ColIndex, RowIndex } from "./cell.ts";
+import type { CellAddress, CellKey, CellValue, ColIndex, RowIndex, StyleRef } from "./cell.ts";
 import { cellKey } from "./cell.ts";
 
 export type { ColIndex, RowIndex } from "./cell.ts";
@@ -23,6 +23,8 @@ export interface RowProperties {
   hidden?: boolean;
   /** Whether the row height was set via customHeight attribute. */
   customHeight?: boolean;
+  /** Style index reference applied at the row level, if present. */
+  styleRef?: StyleRef;
 }
 
 export interface ColProperties {
@@ -34,6 +36,8 @@ export interface ColProperties {
   hidden?: boolean;
   /** Whether the width was explicitly customized. */
   customWidth?: boolean;
+  /** Style index reference applied at the column level, if present. */
+  styleRef?: StyleRef;
 }
 
 // ---------------------------------------------------------------------------
@@ -164,6 +168,60 @@ export function getCell(
   return sheet.cells.get(cellKey(row, col));
 }
 
+/**
+ * Set sparse row metadata.
+ * Passing `undefined`, or only default fields, removes the row entry.
+ */
+export function setRowProperties(
+  sheet: CanonicalSheet,
+  rowIndex: RowIndex,
+  props: Omit<RowProperties, "rowIndex"> | undefined,
+): void {
+  if (!props || isDefaultRowProperties(props)) {
+    sheet.rowProps.delete(rowIndex);
+    return;
+  }
+
+  sheet.rowProps.set(rowIndex, {
+    rowIndex,
+    ...props,
+  });
+}
+
+export function getRowProperties(
+  sheet: CanonicalSheet,
+  rowIndex: RowIndex,
+): RowProperties | undefined {
+  return sheet.rowProps.get(rowIndex);
+}
+
+/**
+ * Set sparse column metadata.
+ * Passing `undefined`, or only default fields, removes the column entry.
+ */
+export function setColProperties(
+  sheet: CanonicalSheet,
+  colIndex: ColIndex,
+  props: Omit<ColProperties, "colIndex"> | undefined,
+): void {
+  if (!props || isDefaultColProperties(props)) {
+    sheet.colProps.delete(colIndex);
+    return;
+  }
+
+  sheet.colProps.set(colIndex, {
+    colIndex,
+    ...props,
+  });
+}
+
+export function getColProperties(
+  sheet: CanonicalSheet,
+  colIndex: ColIndex,
+): ColProperties | undefined {
+  return sheet.colProps.get(colIndex);
+}
+
 /**
  * Return the effective address bounds for all occupied cells.
  * Returns `null` when the sheet has no cells.
@@ -244,3 +302,25 @@ export function findMergesContaining(
       col <= m.endCol,
   );
 }
+
+function isDefaultRowProperties(
+  props: Omit<RowProperties, "rowIndex">,
+): boolean {
+  return (
+    props.heightPt === undefined &&
+    props.hidden === undefined &&
+    props.customHeight === undefined &&
+    props.styleRef === undefined
+  );
+}
+
+function isDefaultColProperties(
+  props: Omit<ColProperties, "colIndex">,
+): boolean {
+  return (
+    props.widthChars === undefined &&
+    props.hidden === undefined &&
+    props.customWidth === undefined &&
+    props.styleRef === undefined
+  );
+}

package/src/formats/xlsx/model/workbook.ts

@@ -158,15 +158,15 @@ export function addSheet(
   }
   const orderIndex =
     atIndex !== undefined
-      ? Math.min(atIndex, workbook.sheetOrder.length)
+      ? clampSheetIndex(atIndex, workbook.sheetOrder.length)
       : workbook.sheetOrder.length;
   const sheet = createSheet(sheetId, name, orderIndex);
   workbook.sheets.set(sheetId, sheet);
 
-  if (atIndex !== undefined && atIndex < workbook.sheetOrder.length) {
-    workbook.sheetOrder.splice(atIndex, 0, sheetId);
+  if (atIndex !== undefined && orderIndex < workbook.sheetOrder.length) {
+    workbook.sheetOrder.splice(orderIndex, 0, sheetId);
     // Reindex sheets after the insertion point
-    for (let i = atIndex + 1; i < workbook.sheetOrder.length; i++) {
+    for (let i = orderIndex + 1; i < workbook.sheetOrder.length; i++) {
       const id = workbook.sheetOrder[i];
       const s = workbook.sheets.get(id);
       if (s) s.orderIndex = i;
@@ -258,10 +258,10 @@ export function moveSheet(
 ): void {
   const currentIndex = workbook.sheetOrder.indexOf(sheetId);
   if (currentIndex === -1) throw new Error(`Sheet not found: ${sheetId}`);
-  if (currentIndex === toIndex) return;
+  const clampedTarget = clampSheetIndex(toIndex, workbook.sheetOrder.length - 1);
+  if (currentIndex === clampedTarget) return;
 
   workbook.sheetOrder.splice(currentIndex, 1);
-  const clampedTarget = Math.min(toIndex, workbook.sheetOrder.length);
   workbook.sheetOrder.splice(clampedTarget, 0, sheetId);
 
   // Reindex all sheets
@@ -272,6 +272,10 @@ export function moveSheet(
   }
 }
 
+function clampSheetIndex(index: number, maxIndex: number): number {
+  return Math.max(0, Math.min(index, maxIndex));
+}
+
 // ---------------------------------------------------------------------------
 // Shared string table helpers
 // ---------------------------------------------------------------------------