@lotics/xlsx 0.1.0

package/src/excel_parser.test.ts

@@ -0,0 +1,1061 @@
+import { parseExcelFile, parseExcelFromZip } from "./excel_parser";
+import type { ParsedSpreadsheet, ParsedRow } from "./excel_parser";
+import type { ParsedConditionalFormat } from "./excel_cf_types";
+import { formatNumber } from "./ooxml_cell_format";
+import { resolveColor, applyTint, parseTheme, prefixHex, normalizeColor, hexToArgb } from "./ooxml_color";
+import type { ThemeData, OoxmlColor } from "./ooxml_color";
+import { parseCsvText } from "./csv_parser";
+import { getPatternFillCSS } from "./excel_pattern_fills";
+import { getCfIcon } from "./excel_cf_icons";
+import { evaluateConditionalFormats } from "./excel_cf_evaluate";
+import { vi } from "vitest";
+import ExcelJS from "exceljs";
+
+// =============================================================================
+// resolveColor
+// =============================================================================
+
+describe("resolveColor", () => {
+  const theme: ThemeData = {
+    colors: [
+      "FFFFFF", "000000", "E7E6E6", "44546A",
+      "4472C4", "ED7D31", "A5A5A5", "FFC000",
+      "5B9BD5", "70AD47", "0563C1", "954F72",
+    ],
+    majorFont: "Calibri",
+    minorFont: "Calibri",
+  };
+  const indexed = [
+    "000000", "FFFFFF", "FF0000", "00FF00", "0000FF", "FFFF00", "FF00FF", "00FFFF",
+  ];
+
+  test("resolves rgb color (8-char AARRGGBB)", () => {
+    const color: OoxmlColor = { rgb: "FFFF0000" };
+    expect(resolveColor(color, theme, indexed, "font")).toBe("FF0000");
+  });
+
+  test("resolves rgb color (6-char RRGGBB)", () => {
+    const color: OoxmlColor = { rgb: "00FF00" };
+    expect(resolveColor(color, theme, indexed, "font")).toBe("00FF00");
+  });
+
+  test("resolves theme color (theme=0 → lt1 = FFFFFF)", () => {
+    const color: OoxmlColor = { theme: 0 };
+    expect(resolveColor(color, theme, indexed, "font")).toBe("FFFFFF");
+  });
+
+  test("resolves theme color (theme=1 → dk1 = 000000)", () => {
+    const color: OoxmlColor = { theme: 1 };
+    expect(resolveColor(color, theme, indexed, "font")).toBe("000000");
+  });
+
+  test("resolves theme color with tint", () => {
+    const color: OoxmlColor = { theme: 1, tint: 0.5 };
+    const result = resolveColor(color, theme, indexed, "font");
+    expect(result).toBeDefined();
+    // Black with +0.5 tint should lighten to ~808080
+    expect(result).not.toBe("000000");
+  });
+
+  test("resolves indexed color", () => {
+    const color: OoxmlColor = { indexed: 2 };
+    expect(resolveColor(color, theme, indexed, "font")).toBe("FF0000");
+  });
+
+  test("returns undefined for auto color on fill", () => {
+    const color: OoxmlColor = { auto: true };
+    expect(resolveColor(color, theme, indexed, "fill")).toBeUndefined();
+  });
+
+  test("returns black for auto color on font", () => {
+    const color: OoxmlColor = { auto: true };
+    expect(resolveColor(color, theme, indexed, "font")).toBe("000000");
+  });
+
+  test("returns undefined for empty color", () => {
+    expect(resolveColor(undefined, theme, indexed, "font")).toBeUndefined();
+    expect(resolveColor({}, theme, indexed, "font")).toBeUndefined();
+  });
+});
+
+// =============================================================================
+// Color helpers — canonical #RRGGBB internal format
+// =============================================================================
+
+describe("prefixHex", () => {
+  test("prefixes 6-char hex with #", () => {
+    expect(prefixHex("FF0000")).toBe("#FF0000");
+    expect(prefixHex("ffffff")).toBe("#FFFFFF");
+    expect(prefixHex("000000")).toBe("#000000");
+  });
+
+  test("returns black on invalid input length", () => {
+    expect(prefixHex("FFF")).toBe("#000000");
+    expect(prefixHex("")).toBe("#000000");
+  });
+});
+
+describe("normalizeColor", () => {
+  test("accepts canonical #RRGGBB", () => {
+    expect(normalizeColor("#FF0000")).toBe("#FF0000");
+    expect(normalizeColor("#abcdef")).toBe("#ABCDEF");
+  });
+
+  test("accepts bare 6-char hex", () => {
+    expect(normalizeColor("FF0000")).toBe("#FF0000");
+    expect(normalizeColor("abcdef")).toBe("#ABCDEF");
+  });
+
+  test("accepts CSS rgb() and rgba()", () => {
+    expect(normalizeColor("rgb(255, 0, 0)")).toBe("#FF0000");
+    expect(normalizeColor("rgba(0, 51, 102, 1)")).toBe("#003366");
+  });
+
+  test("expands #RGB shorthand", () => {
+    expect(normalizeColor("#f00")).toBe("#FF0000");
+    expect(normalizeColor("#0a3")).toBe("#00AA33");
+  });
+
+  test("returns undefined for empty/invalid input", () => {
+    expect(normalizeColor(undefined)).toBeUndefined();
+    expect(normalizeColor("")).toBeUndefined();
+    expect(normalizeColor("not a color")).toBeUndefined();
+  });
+});
+
+describe("hexToArgb", () => {
+  test("returns 8-char ARGB for OOXML", () => {
+    expect(hexToArgb("#FF0000")).toBe("FFFF0000");
+    expect(hexToArgb("rgb(0, 51, 102)")).toBe("FF003366");
+    expect(hexToArgb("003366")).toBe("FF003366");
+  });
+
+  test("falls back to opaque black on invalid input", () => {
+    expect(hexToArgb(undefined)).toBe("FF000000");
+    expect(hexToArgb("not a color")).toBe("FF000000");
+  });
+});
+
+// =============================================================================
+// applyTint
+// =============================================================================
+
+describe("applyTint", () => {
+  test("positive tint lightens color", () => {
+    const result = applyTint("000000", 0.5);
+    // Black with +0.5 tint should produce a gray
+    expect(result).not.toBe("000000");
+    // Should be something around 808080
+    const r = parseInt(result.slice(0, 2), 16);
+    expect(r).toBeGreaterThan(64);
+    expect(r).toBeLessThan(160);
+  });
+
+  test("negative tint darkens color", () => {
+    const result = applyTint("FFFFFF", -0.5);
+    // White with -0.5 tint should produce a gray
+    expect(result).not.toBe("FFFFFF");
+    const r = parseInt(result.slice(0, 2), 16);
+    expect(r).toBeGreaterThan(64);
+    expect(r).toBeLessThan(160);
+  });
+
+  test("zero tint returns same color", () => {
+    expect(applyTint("FF0000", 0)).toBe("FF0000");
+  });
+});
+
+// =============================================================================
+// parseTheme
+// =============================================================================
+
+describe("parseTheme", () => {
+  test("parses minimal theme XML", () => {
+    const xml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<a:theme xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" name="Test">
+  <a:themeElements>
+    <a:clrScheme name="Office">
+      <a:dk1><a:sysClr val="windowText" lastClr="000000"/></a:dk1>
+      <a:lt1><a:sysClr val="window" lastClr="FFFFFF"/></a:lt1>
+      <a:dk2><a:srgbClr val="44546A"/></a:dk2>
+      <a:lt2><a:srgbClr val="E7E6E6"/></a:lt2>
+      <a:accent1><a:srgbClr val="4472C4"/></a:accent1>
+      <a:accent2><a:srgbClr val="ED7D31"/></a:accent2>
+      <a:accent3><a:srgbClr val="A5A5A5"/></a:accent3>
+      <a:accent4><a:srgbClr val="FFC000"/></a:accent4>
+      <a:accent5><a:srgbClr val="5B9BD5"/></a:accent5>
+      <a:accent6><a:srgbClr val="70AD47"/></a:accent6>
+      <a:hlink><a:srgbClr val="0563C1"/></a:hlink>
+      <a:folHlink><a:srgbClr val="954F72"/></a:folHlink>
+    </a:clrScheme>
+    <a:fontScheme name="Office">
+      <a:majorFont><a:latin typeface="Calibri Light"/></a:majorFont>
+      <a:minorFont><a:latin typeface="Calibri"/></a:minorFont>
+    </a:fontScheme>
+  </a:themeElements>
+</a:theme>`;
+
+    const result = parseTheme(xml);
+
+    // Theme index 0 = lt1 (FFFFFF), index 1 = dk1 (000000) — swapped from XML order
+    expect(result.colors[0]).toBe("FFFFFF");
+    expect(result.colors[1]).toBe("000000");
+    // Theme index 2 = lt2, index 3 = dk2 — also swapped
+    expect(result.colors[2]).toBe("E7E6E6");
+    expect(result.colors[3]).toBe("44546A");
+    // Accents stay in order
+    expect(result.colors[4]).toBe("4472C4");
+    expect(result.majorFont).toBe("Calibri Light");
+    expect(result.minorFont).toBe("Calibri");
+  });
+});
+
+// =============================================================================
+// formatNumber
+// =============================================================================
+
+describe("formatNumber", () => {
+  test("returns General format as plain string", () => {
+    expect(formatNumber(1234, "General")).toBe("1234");
+  });
+
+  test("formats percentages with decimals", () => {
+    expect(formatNumber(0.5, "0.00%")).toBe("50.00%");
+  });
+
+  test("formats percentages without decimals", () => {
+    expect(formatNumber(0.75, "0%")).toBe("75%");
+  });
+
+  test("formats with thousands separator", () => {
+    expect(formatNumber(1234567, "#,##0")).toBe("1,234,567");
+  });
+
+  test("formats with thousands separator and decimals", () => {
+    expect(formatNumber(1234.5, "#,##0.00")).toBe("1,234.50");
+  });
+
+  test("formats currency with dollar sign", () => {
+    expect(formatNumber(1234.56, "$#,##0.00")).toBe("$1,234.56");
+  });
+
+  test("formats currency with euro sign", () => {
+    expect(formatNumber(1234.56, "€#,##0.00")).toBe("€1,234.56");
+  });
+
+  test("formats quoted currency like VND", () => {
+    expect(formatNumber(50000, '#,##0 "VND"')).toBe("50,000 VND");
+  });
+
+  test("formats accounting negative in parens", () => {
+    expect(formatNumber(-1234.56, "#,##0.00_);(#,##0.00)")).toBe("(1,234.56)");
+  });
+
+  test("formats accounting positive with underscore spacing", () => {
+    expect(formatNumber(1234.56, "#,##0.00_);(#,##0.00)")).toBe("1,234.56 ");
+  });
+
+  test("formats negative numbers with minus sign by default", () => {
+    expect(formatNumber(-42, "#,##0")).toBe("-42");
+  });
+
+  test("formats zero", () => {
+    expect(formatNumber(0, "#,##0.00")).toBe("0.00");
+  });
+
+  test("handles empty format string", () => {
+    expect(formatNumber(42, "")).toBe("42");
+  });
+
+  test("formats fixed decimal places", () => {
+    expect(formatNumber(3.1, "0.000")).toBe("3.100");
+  });
+
+  test("formats integer format truncates decimals", () => {
+    expect(formatNumber(3.7, "0")).toBe("4");
+  });
+});
+
+// =============================================================================
+// parseExcelFile (integration with in-memory workbook created by ExcelJS)
+// =============================================================================
+
+describe("parseExcelFile", () => {
+  const originalFetch = globalThis.fetch;
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  function mockFetch(buffer: ExcelJS.Buffer): void {
+    globalThis.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      arrayBuffer: () => Promise.resolve(buffer),
+    });
+  }
+
+  test("parses a workbook with cell data and styles", async () => {
+    const workbook = new ExcelJS.Workbook();
+    const ws = workbook.addWorksheet("Sales");
+
+    ws.getCell("A1").value = "Product";
+    ws.getCell("A1").font = { bold: true };
+    ws.getCell("B1").value = "Revenue";
+    ws.getCell("B1").font = { bold: true };
+    ws.getCell("A2").value = "Widget";
+    ws.getCell("B2").value = 1234.56;
+    ws.getCell("A3").value = "Gadget";
+    ws.getCell("B3").value = 789;
+
+    const buffer = await workbook.xlsx.writeBuffer();
+    mockFetch(buffer);
+
+    const result: ParsedSpreadsheet = await parseExcelFile("https://example.com/test.xlsx");
+
+
+    expect(result.sheets).toHaveLength(1);
+    expect(result.sheets[0].name).toBe("Sales");
+    expect(result.sheets[0].rows.length).toBeGreaterThanOrEqual(3);
+
+    const headerRow = result.sheets[0].rows[0];
+    const productCell = headerRow.cells.find((c) => c.column === 1);
+    expect(productCell?.value).toBe("Product");
+    expect(productCell?.style.fontBold).toBe(true);
+
+    const dataRow = result.sheets[0].rows[1];
+    const widgetCell = dataRow.cells.find((c) => c.column === 1);
+    expect(widgetCell?.value).toBe("Widget");
+  });
+
+  test("parses merged cells", async () => {
+    const workbook = new ExcelJS.Workbook();
+    const ws = workbook.addWorksheet("Merged");
+
+    ws.getCell("A1").value = "Merged Title";
+    ws.mergeCells("A1:C1");
+    ws.getCell("A2").value = "Col1";
+    ws.getCell("B2").value = "Col2";
+    ws.getCell("C2").value = "Col3";
+
+    const buffer = await workbook.xlsx.writeBuffer();
+    mockFetch(buffer);
+
+    const result = await parseExcelFile("https://example.com/test.xlsx");
+
+
+    expect(result.sheets[0].mergedCells.length).toBeGreaterThanOrEqual(1);
+
+    const merge = result.sheets[0].mergedCells[0];
+    expect(merge.startRow).toBe(1);
+    expect(merge.startCol).toBe(1);
+    expect(merge.endRow).toBe(1);
+    expect(merge.endCol).toBe(3);
+  });
+
+  test("skips hidden sheets", async () => {
+    const workbook = new ExcelJS.Workbook();
+    workbook.addWorksheet("Visible");
+    const hidden = workbook.addWorksheet("Hidden");
+    hidden.state = "hidden";
+
+    const buffer = await workbook.xlsx.writeBuffer();
+    mockFetch(buffer);
+
+    const result = await parseExcelFile("https://example.com/test.xlsx");
+
+
+    expect(result.sheets).toHaveLength(1);
+    expect(result.sheets[0].name).toBe("Visible");
+  });
+
+  test("preserves cell text when <v> carries xml:space=\"preserve\"", () => {
+    // Excel/SheetJS emit `<v xml:space="preserve">` whenever the cell text
+    // has leading/trailing whitespace or newlines. fast-xml-parser then
+    // returns the element as an object, not a string, and a naive
+    // `String(vEl)` produces "[object Object]".
+    const enc = new TextEncoder();
+    const sheetXml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+  <sheetData>
+    <row r="1"><c r="A1" t="str" xml:space="preserve"><v xml:space="preserve">DATE OF
+EST</v></c></row>
+    <row r="2"><c r="A2" t="str"><v>plain</v></c></row>
+  </sheetData>
+</worksheet>`;
+    const workbookXml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+  <sheets><sheet name="S" sheetId="1" r:id="rId1"/></sheets>
+</workbook>`;
+    const wbRels = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet1.xml"/>
+</Relationships>`;
+    const rootRels = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/>
+</Relationships>`;
+    const contentTypes = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+  <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
+  <Default Extension="xml" ContentType="application/xml"/>
+  <Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>
+  <Override PartName="/xl/worksheets/sheet1.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>
+</Types>`;
+    const zip: Record<string, Uint8Array> = {
+      "[Content_Types].xml": enc.encode(contentTypes),
+      "_rels/.rels": enc.encode(rootRels),
+      "xl/workbook.xml": enc.encode(workbookXml),
+      "xl/_rels/workbook.xml.rels": enc.encode(wbRels),
+      "xl/worksheets/sheet1.xml": enc.encode(sheetXml),
+    };
+
+    const parsed = parseExcelFromZip(zip);
+    const cellA1 = parsed.sheets[0].rows[0].cells.find((c) => c.column === 1);
+    const cellA2 = parsed.sheets[0].rows[1].cells.find((c) => c.column === 1);
+    expect(cellA1?.value).toBe("DATE OF\nEST");
+    expect(cellA1?.value).not.toBe("[object Object]");
+    expect(cellA2?.value).toBe("plain");
+  });
+
+  test("preserves inline-string and CF/DV formulas under xml:space=\"preserve\"", () => {
+    // Three sites that share the same fast-xml-parser shape bug as <v>:
+    //   1. <is><t xml:space="preserve">…</t></is>     (inline strings)
+    //   2. <cfRule><formula xml:space="preserve">…</formula></cfRule>
+    //   3. <dataValidation><formula1 xml:space="preserve">…</formula1></dataValidation>
+    // All four sites use the shared `extractElementText` helper. This test
+    // exercises the three not covered above.
+    const enc = new TextEncoder();
+    const sheetXml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+  <sheetData>
+    <row r="1"><c r="A1" t="inlineStr"><is><t xml:space="preserve"> hello world </t></is></c></row>
+  </sheetData>
+  <conditionalFormatting sqref="A1">
+    <cfRule type="expression" priority="1">
+      <formula xml:space="preserve">A1 &gt; 0</formula>
+    </cfRule>
+  </conditionalFormatting>
+  <dataValidations count="1">
+    <dataValidation type="list" allowBlank="1" sqref="A1">
+      <formula1 xml:space="preserve">"yes,no"</formula1>
+    </dataValidation>
+  </dataValidations>
+</worksheet>`;
+    const workbookXml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+  <sheets><sheet name="S" sheetId="1" r:id="rId1"/></sheets>
+</workbook>`;
+    const wbRels = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet1.xml"/>
+</Relationships>`;
+    const rootRels = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/>
+</Relationships>`;
+    const contentTypes = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+  <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
+  <Default Extension="xml" ContentType="application/xml"/>
+  <Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>
+  <Override PartName="/xl/worksheets/sheet1.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>
+</Types>`;
+    const zip: Record<string, Uint8Array> = {
+      "[Content_Types].xml": enc.encode(contentTypes),
+      "_rels/.rels": enc.encode(rootRels),
+      "xl/workbook.xml": enc.encode(workbookXml),
+      "xl/_rels/workbook.xml.rels": enc.encode(wbRels),
+      "xl/worksheets/sheet1.xml": enc.encode(sheetXml),
+    };
+
+    const parsed = parseExcelFromZip(zip);
+    const sheet = parsed.sheets[0];
+
+    // Inline string with surrounding spaces — must round-trip the spaces, not "[object Object]".
+    expect(sheet.rows[0]?.cells[0]?.value).toBe(" hello world ");
+
+    // Conditional format formula — should preserve "A1 > 0", not "[object Object]".
+    const cf = sheet.conditionalFormats[0];
+    expect(cf).toBeTruthy();
+    const rule = cf.rules[0];
+    expect(rule.ruleType).toBe("style");
+    if (rule.ruleType === "style") {
+      expect(rule.formulae?.[0]).toContain("A1");
+      expect(rule.formulae?.[0]).not.toContain("[object Object]");
+    }
+
+    // Data validation formula1 — should preserve `"yes,no"`, not "[object Object]".
+    const dv = sheet.dataValidations?.[0];
+    expect(dv).toBeTruthy();
+    expect(dv?.formula1).toContain("yes");
+    expect(dv?.formula1).not.toContain("[object Object]");
+  });
+
+  test("handles empty workbook", async () => {
+    const workbook = new ExcelJS.Workbook();
+    const buffer = await workbook.xlsx.writeBuffer();
+    mockFetch(buffer);
+
+    const result = await parseExcelFile("https://example.com/test.xlsx");
+
+
+    expect(result.sheets).toHaveLength(1);
+    expect(result.sheets[0].name).toBe("Sheet1");
+    expect(result.sheets[0].rows).toHaveLength(0);
+  });
+
+  test("handles fetch error", async () => {
+    globalThis.fetch = vi.fn().mockResolvedValue({
+      ok: false,
+      status: 404,
+      statusText: "Not Found",
+    });
+
+    await expect(parseExcelFile("https://example.com/missing.xlsx")).rejects.toThrow(
+      "Failed to fetch file",
+    );
+  });
+
+  test("extracts background color", async () => {
+    const workbook = new ExcelJS.Workbook();
+    const ws = workbook.addWorksheet("Styled");
+
+    ws.getCell("A1").value = "Red Background";
+    ws.getCell("A1").fill = {
+      type: "pattern",
+      pattern: "solid",
+      fgColor: { argb: "FFFF0000" },
+    };
+
+    const buffer = await workbook.xlsx.writeBuffer();
+    mockFetch(buffer);
+
+    const result = await parseExcelFile("https://example.com/test.xlsx");
+
+
+    const cell = result.sheets[0].rows[0].cells[0];
+    expect(cell.style.backgroundColor).toBe("#FF0000");
+  });
+
+  test("extracts content field with plain text", async () => {
+    const workbook = new ExcelJS.Workbook();
+    const ws = workbook.addWorksheet("Content");
+
+    ws.getCell("A1").value = "Hello";
+
+    const buffer = await workbook.xlsx.writeBuffer();
+    mockFetch(buffer);
+
+    const result = await parseExcelFile("https://example.com/test.xlsx");
+
+
+    const cell = result.sheets[0].rows[0].cells[0];
+    expect(cell.content).toEqual({ type: "plain", text: "Hello" });
+  });
+
+  test("extracts rich text content with font properties", async () => {
+    const workbook = new ExcelJS.Workbook();
+    const ws = workbook.addWorksheet("RichText");
+
+    ws.getCell("A1").value = {
+      richText: [
+        { text: "Bold ", font: { bold: true } },
+        { text: "Red", font: { color: { argb: "FFFF0000" } } },
+      ],
+    };
+
+    const buffer = await workbook.xlsx.writeBuffer();
+    mockFetch(buffer);
+
+    const result = await parseExcelFile("https://example.com/test.xlsx");
+
+
+    const cell = result.sheets[0].rows[0].cells[0];
+    expect(cell.content.type).toBe("rich_text");
+    if (cell.content.type === "rich_text") {
+      expect(cell.content.parts).toHaveLength(2);
+      expect(cell.content.parts[0].text).toBe("Bold ");
+      expect(cell.content.parts[0].font?.bold).toBe(true);
+      expect(cell.content.parts[1].text).toBe("Red");
+      expect(cell.content.parts[1].font?.color).toBe("#FF0000");
+    }
+  });
+
+  test("extracts formula string", async () => {
+    const workbook = new ExcelJS.Workbook();
+    const ws = workbook.addWorksheet("Formulas");
+
+    ws.getCell("A1").value = 10;
+    ws.getCell("A2").value = 20;
+    ws.getCell("A3").value = { formula: "SUM(A1:A2)", result: 30 };
+
+    const buffer = await workbook.xlsx.writeBuffer();
+    mockFetch(buffer);
+
+    const result = await parseExcelFile("https://example.com/test.xlsx");
+
+
+    const cell = result.sheets[0].rows[2].cells[0];
+    expect(cell.formula).toBe("SUM(A1:A2)");
+    expect(cell.value).toBe("30");
+  });
+
+  test("extracts font name from cell style", async () => {
+    const workbook = new ExcelJS.Workbook();
+    const ws = workbook.addWorksheet("Fonts");
+
+    ws.getCell("A1").value = "Custom Font";
+    ws.getCell("A1").font = { name: "Courier New", size: 14 };
+
+    const buffer = await workbook.xlsx.writeBuffer();
+    mockFetch(buffer);
+
+    const result = await parseExcelFile("https://example.com/test.xlsx");
+
+
+    const cell = result.sheets[0].rows[0].cells[0];
+    expect(cell.style.fontName).toBe("Courier New");
+    expect(cell.style.fontSize).toBe(14);
+  });
+
+  test("extracts underline style", async () => {
+    const workbook = new ExcelJS.Workbook();
+    const ws = workbook.addWorksheet("Underline");
+
+    ws.getCell("A1").value = "Underlined";
+    ws.getCell("A1").font = { underline: true };
+    ws.getCell("A2").value = "Double";
+    ws.getCell("A2").font = { underline: "double" };
+
+    const buffer = await workbook.xlsx.writeBuffer();
+    mockFetch(buffer);
+
+    const result = await parseExcelFile("https://example.com/test.xlsx");
+
+
+    expect(result.sheets[0].rows[0].cells[0].style.fontUnderline).toBe("single");
+    expect(result.sheets[0].rows[1].cells[0].style.fontUnderline).toBe("double");
+  });
+
+  test("extracts strikethrough style", async () => {
+    const workbook = new ExcelJS.Workbook();
+    const ws = workbook.addWorksheet("Strike");
+
+    ws.getCell("A1").value = "Struck";
+    ws.getCell("A1").font = { strike: true };
+
+    const buffer = await workbook.xlsx.writeBuffer();
+    mockFetch(buffer);
+
+    const result = await parseExcelFile("https://example.com/test.xlsx");
+
+
+    expect(result.sheets[0].rows[0].cells[0].style.fontStrike).toBe(true);
+  });
+
+  test("skips hidden rows", async () => {
+    const workbook = new ExcelJS.Workbook();
+    const ws = workbook.addWorksheet("HiddenRows");
+
+    ws.getCell("A1").value = "Visible";
+    ws.getCell("A2").value = "Hidden";
+    ws.getRow(2).hidden = true;
+    ws.getCell("A3").value = "Also Visible";
+
+    const buffer = await workbook.xlsx.writeBuffer();
+    mockFetch(buffer);
+
+    const result = await parseExcelFile("https://example.com/test.xlsx");
+
+
+    const rowIndices = result.sheets[0].rows.map((r) => r.index);
+    expect(rowIndices).toContain(1);
+    expect(rowIndices).not.toContain(2);
+    expect(rowIndices).toContain(3);
+  });
+
+  test("marks hidden columns", async () => {
+    const workbook = new ExcelJS.Workbook();
+    const ws = workbook.addWorksheet("HiddenCols");
+
+    ws.getCell("A1").value = "A";
+    ws.getCell("B1").value = "B";
+    ws.getColumn(2).hidden = true;
+
+    const buffer = await workbook.xlsx.writeBuffer();
+    mockFetch(buffer);
+
+    const result = await parseExcelFile("https://example.com/test.xlsx");
+
+
+    const col2 = result.sheets[0].columns.find((c) => c.index === 2);
+    expect(col2?.hidden).toBe(true);
+
+    const col1 = result.sheets[0].columns.find((c) => c.index === 1);
+    expect(col1?.hidden).toBe(false);
+  });
+
+  test("extracts freeze panes", async () => {
+    const workbook = new ExcelJS.Workbook();
+    const ws = workbook.addWorksheet("Frozen");
+
+    ws.getCell("A1").value = "Header";
+    ws.getCell("A2").value = "Data";
+    ws.views = [{ state: "frozen", xSplit: 1, ySplit: 1, topLeftCell: "B2", activeCell: "B2" }];
+
+    const buffer = await workbook.xlsx.writeBuffer();
+    mockFetch(buffer);
+
+    const result = await parseExcelFile("https://example.com/test.xlsx");
+
+
+    expect(result.sheets[0].freezePane).toEqual({
+      frozenRows: 1,
+      frozenCols: 1,
+    });
+  });
+
+  test("includes new sheet-level fields", async () => {
+    const workbook = new ExcelJS.Workbook();
+    const ws = workbook.addWorksheet("Fields");
+    ws.getCell("A1").value = "Test";
+
+    const buffer = await workbook.xlsx.writeBuffer();
+    mockFetch(buffer);
+
+    const result = await parseExcelFile("https://example.com/test.xlsx");
+
+
+    const sheet = result.sheets[0];
+    expect(sheet.defaultRowHeight).toBeGreaterThan(0);
+    expect(sheet.defaultColWidth).toBeGreaterThan(0);
+    expect(typeof sheet.showGridLines).toBe("boolean");
+    expect(sheet.conditionalFormats).toEqual([]);
+    expect(sheet.images).toEqual([]);
+    expect(sheet.rowOutlineLevels).toBeInstanceOf(Map);
+    expect(sheet.colOutlineLevels).toBeInstanceOf(Map);
+  });
+
+  test("extracts hyperlink content", async () => {
+    const workbook = new ExcelJS.Workbook();
+    const ws = workbook.addWorksheet("Links");
+
+    ws.getCell("A1").value = {
+      text: "Google",
+      hyperlink: "https://google.com",
+    } as unknown as ExcelJS.CellHyperlinkValue;
+
+    const buffer = await workbook.xlsx.writeBuffer();
+    mockFetch(buffer);
+
+    const result = await parseExcelFile("https://example.com/test.xlsx");
+
+
+    const cell = result.sheets[0].rows[0].cells[0];
+    expect(cell.content.type).toBe("hyperlink");
+    if (cell.content.type === "hyperlink") {
+      expect(cell.content.text).toBe("Google");
+      expect(cell.content.url).toBe("https://google.com");
+    }
+  });
+});
+
+// =============================================================================
+// Pattern fills
+// =============================================================================
+
+describe("getPatternFillCSS", () => {
+  test("returns CSS for darkVertical pattern", () => {
+    const result = getPatternFillCSS("darkVertical", "black", "white");
+    expect(result).toBeDefined();
+    expect(result).toContain("repeating-linear-gradient");
+  });
+
+  test("returns CSS for lightGrid pattern", () => {
+    const result = getPatternFillCSS("lightGrid", "black", "white");
+    expect(result).toBeDefined();
+    expect(result).toContain("repeating-linear-gradient");
+  });
+
+  test("returns CSS for gray125 pattern", () => {
+    const result = getPatternFillCSS("gray125", "#333", "#fff");
+    expect(result).toBeDefined();
+  });
+
+  test("returns undefined for unknown pattern", () => {
+    expect(getPatternFillCSS("unknownPattern", "black", "white")).toBeUndefined();
+  });
+});
+
+// =============================================================================
+// CF icons
+// =============================================================================
+
+describe("getCfIcon", () => {
+  test("returns SVG data URI for valid icon set and index", () => {
+    const icon = getCfIcon("3TrafficLights1", 0);
+    expect(icon).toBeDefined();
+    expect(icon).toContain("data:image/svg+xml");
+  });
+
+  test("returns different icons for different indices", () => {
+    const icon0 = getCfIcon("3Arrows", 0);
+    const icon1 = getCfIcon("3Arrows", 1);
+    const icon2 = getCfIcon("3Arrows", 2);
+    expect(icon0).toBeDefined();
+    expect(icon1).toBeDefined();
+    expect(icon2).toBeDefined();
+    expect(icon0).not.toBe(icon1);
+    expect(icon1).not.toBe(icon2);
+  });
+
+  test("returns undefined for invalid icon set", () => {
+    expect(getCfIcon("nonexistent", 0)).toBeUndefined();
+  });
+
+  test("returns undefined for out-of-range index", () => {
+    expect(getCfIcon("3Arrows", 5)).toBeUndefined();
+  });
+
+  test("supports 4-icon and 5-icon sets", () => {
+    expect(getCfIcon("4Arrows", 3)).toBeDefined();
+    expect(getCfIcon("5Arrows", 4)).toBeDefined();
+  });
+});
+
+// =============================================================================
+// CF evaluation
+// =============================================================================
+
+describe("evaluateConditionalFormats", () => {
+  function makeRows(values: number[]): ParsedRow[] {
+    return values.map((v, i) => ({
+      index: i + 1,
+      height: 20,
+      hidden: false,
+      cells: [{
+        column: 1,
+        value: String(v),
+        content: { type: "plain" as const, text: String(v) },
+        style: {},
+      }],
+    }));
+  }
+
+  test("evaluates cellIs greaterThan rule", () => {
+    const rows = makeRows([10, 50, 100]);
+    const cfs: ParsedConditionalFormat[] = [{
+      ref: "A1:A3",
+      rules: [{
+        ruleType: "style",
+        priority: 1,
+        type: "cellIs",
+        operator: "greaterThan",
+        formulae: [50],
+        style: { backgroundColor: "#FF0000" },
+      }],
+    }];
+
+    const result = evaluateConditionalFormats(cfs, rows, getCfIcon);
+
+    expect(result.has("3:1")).toBe(true);
+    expect(result.get("3:1")?.backgroundColor).toBe("#FF0000");
+    expect(result.has("1:1")).toBe(false);
+    expect(result.has("2:1")).toBe(false);
+  });
+
+  test("evaluates containsText rule", () => {
+    const rows: ParsedRow[] = [
+      { index: 1, height: 20, hidden: false, cells: [{ column: 1, value: "Apple Pie", content: { type: "plain", text: "Apple Pie" }, style: {} }] },
+      { index: 2, height: 20, hidden: false, cells: [{ column: 1, value: "Banana", content: { type: "plain", text: "Banana" }, style: {} }] },
+    ];
+
+    const cfs: ParsedConditionalFormat[] = [{
+      ref: "A1:A2",
+      rules: [{
+        ruleType: "style",
+        priority: 1,
+        type: "containsText",
+        operator: "containsText",
+        text: "apple",
+        style: { fontBold: true },
+      }],
+    }];
+
+    const result = evaluateConditionalFormats(cfs, rows, getCfIcon);
+    expect(result.get("1:1")?.fontBold).toBe(true);
+    expect(result.has("2:1")).toBe(false);
+  });
+
+  test("evaluates top10 rule", () => {
+    const rows = makeRows([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+    const cfs: ParsedConditionalFormat[] = [{
+      ref: "A1:A10",
+      rules: [{
+        ruleType: "style",
+        priority: 1,
+        type: "top10",
+        rank: 3,
+        style: { backgroundColor: "#00FF00" },
+      }],
+    }];
+
+    const result = evaluateConditionalFormats(cfs, rows, getCfIcon);
+
+    expect(result.has("8:1")).toBe(true);
+    expect(result.has("9:1")).toBe(true);
+    expect(result.has("10:1")).toBe(true);
+    expect(result.has("1:1")).toBe(false);
+  });
+
+  test("evaluates aboveAverage rule", () => {
+    const rows = makeRows([10, 20, 30, 40, 50]);
+    const cfs: ParsedConditionalFormat[] = [{
+      ref: "A1:A5",
+      rules: [{
+        ruleType: "style",
+        priority: 1,
+        type: "aboveAverage",
+        aboveAverage: true,
+        style: { fontColor: "#008000" },
+      }],
+    }];
+
+    const result = evaluateConditionalFormats(cfs, rows, getCfIcon);
+
+    expect(result.has("4:1")).toBe(true);
+    expect(result.has("5:1")).toBe(true);
+    expect(result.has("3:1")).toBe(false);
+  });
+
+  test("evaluates color scale rule", () => {
+    const rows = makeRows([0, 50, 100]);
+    const cfs: ParsedConditionalFormat[] = [{
+      ref: "A1:A3",
+      rules: [{
+        ruleType: "colorScale",
+        priority: 1,
+        colors: ["#FF0000", "#00FF00"],
+      }],
+    }];
+
+    const result = evaluateConditionalFormats(cfs, rows, getCfIcon);
+
+    expect(result.get("1:1")?.backgroundColor).toBeDefined();
+    expect(result.get("2:1")?.backgroundColor).toBeDefined();
+    expect(result.get("3:1")?.backgroundColor).toBeDefined();
+
+    expect(result.get("1:1")?.backgroundColor).toBe("#FF0000");
+    expect(result.get("3:1")?.backgroundColor).toBe("#00FF00");
+  });
+
+  test("evaluates data bar rule", () => {
+    const rows = makeRows([10, 50, 100]);
+    const cfs: ParsedConditionalFormat[] = [{
+      ref: "A1:A3",
+      rules: [{
+        ruleType: "dataBar",
+        priority: 1,
+        color: "#638EC6",
+        minLength: 10,
+        maxLength: 90,
+        showValue: true,
+      }],
+    }];
+
+    const result = evaluateConditionalFormats(cfs, rows, getCfIcon);
+
+    expect(result.get("1:1")?.dataBarWidth).toBeDefined();
+    expect(result.get("3:1")?.dataBarWidth).toBeDefined();
+    expect(result.get("1:1")!.dataBarWidth).toBeLessThan(result.get("3:1")!.dataBarWidth!);
+  });
+
+  test("evaluates icon set rule", () => {
+    const rows = makeRows([10, 50, 90]);
+    const cfs: ParsedConditionalFormat[] = [{
+      ref: "A1:A3",
+      rules: [{
+        ruleType: "iconSet",
+        priority: 1,
+        iconSet: "3Arrows",
+        thresholds: [],
+        showValue: true,
+        reverse: false,
+      }],
+    }];
+
+    const result = evaluateConditionalFormats(cfs, rows, getCfIcon);
+
+    expect(result.get("1:1")?.iconSvg).toBeDefined();
+    expect(result.get("3:1")?.iconSvg).toBeDefined();
+    expect(result.get("1:1")?.iconSvg).not.toBe(result.get("3:1")?.iconSvg);
+  });
+});
+
+// =============================================================================
+// CSV parser backward compat
+// =============================================================================
+
+describe("csv parser backward compat", () => {
+  test("CSV cells have content field", () => {
+    const result = parseCsvText("A,B\n1,2");
+    const cell = result.rows[0].cells[0];
+    expect(cell.content).toEqual({ type: "plain", text: "A" });
+  });
+
+  test("CSV rows have hidden field", () => {
+    const result = parseCsvText("A\n1");
+    expect(result.rows[0].hidden).toBe(false);
+  });
+
+  test("CSV columns have hidden field", () => {
+    const result = parseCsvText("A,B\n1,2");
+    expect(result.columns[0].hidden).toBe(false);
+  });
+
+  test("CSV sheet has new fields", () => {
+    const result = parseCsvText("A\n1");
+    expect(result.defaultRowHeight).toBe(20);
+    expect(result.defaultColWidth).toBe(8);
+    expect(result.showGridLines).toBe(true);
+    expect(result.conditionalFormats).toEqual([]);
+    expect(result.images).toEqual([]);
+  });
+});
+
+// =============================================================================
+// Gradient fills
+// =============================================================================
+
+describe("gradient fills", () => {
+  const originalFetch = globalThis.fetch;
+  afterEach(() => { globalThis.fetch = originalFetch; });
+
+  test("extracts linear gradient from angle fill", async () => {
+    const workbook = new ExcelJS.Workbook();
+    const ws = workbook.addWorksheet("Gradient");
+
+    ws.getCell("A1").value = "Gradient";
+    ws.getCell("A1").fill = {
+      type: "gradient",
+      gradient: "angle",
+      degree: 90,
+      stops: [
+        { position: 0, color: { argb: "FFFF0000" } },
+        { position: 1, color: { argb: "FF0000FF" } },
+      ],
+    };
+
+    const buffer = await workbook.xlsx.writeBuffer();
+    globalThis.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      arrayBuffer: () => Promise.resolve(buffer),
+    });
+
+    const result = await parseExcelFile("https://example.com/test.xlsx");
+    const cell = result.sheets[0].rows[0].cells[0];
+    expect(cell.style.backgroundGradient).toBeDefined();
+    expect(cell.style.backgroundGradient).toContain("linear-gradient");
+  });
+});
+