@lotics/xlsx 0.1.0

package/src/xlsx_writer.test.ts

@@ -0,0 +1,488 @@
+import { describe, it, expect } from "vitest";
+import { exportWorkbook } from "./xlsx_writer";
+import { parseExcelBuffer, parseExcelFromZip } from "./excel_parser";
+import { unzipXlsx } from "./ooxml_zip";
+import { WorkbookModel, SheetModel, StyleRegistry } from "./workbook_model";
+
+function createTestWorkbook(): WorkbookModel {
+  const styles = new StyleRegistry();
+  const sheet = new SheetModel("TestSheet", styles);
+
+  // String, number, boolean values
+  sheet.set("A1", "hello");
+  sheet.set("B1", 42);
+  sheet.set("C1", true);
+
+  // Bold style
+  const boldIdx = styles.intern({ fontBold: true });
+  sheet.set("A2", "bold", styles.get(boldIdx));
+
+  // Color style
+  const colorIdx = styles.intern({ fontColor: "#FF0000", backgroundColor: "#00FF00" });
+  sheet.set("A3", "colored", styles.get(colorIdx));
+
+  // Merged cells
+  sheet.mergedCells.push("D1:E2");
+
+  // Freeze pane
+  sheet.freeze = { row: 1, col: 0 };
+
+  // Second sheet
+  const sheet2 = new SheetModel("Sheet2");
+  sheet2.set("A1", "other");
+
+  return new WorkbookModel({ sheets: [sheet, sheet2], activeSheetIndex: 0, styles });
+}
+
+describe("xlsx round-trip: exportWorkbook -> parseExcelBuffer", () => {
+  const wb = createTestWorkbook();
+  const xlsx = exportWorkbook(wb);
+  const parsed = parseExcelBuffer(xlsx.buffer as ArrayBuffer);
+
+  it("preserves sheet count and names", () => {
+    expect(parsed.sheets).toHaveLength(2);
+    expect(parsed.sheets[0].name).toBe("TestSheet");
+    expect(parsed.sheets[1].name).toBe("Sheet2");
+  });
+
+  it("preserves string cell value", () => {
+    const row1 = parsed.sheets[0].rows.find((r) => r.index === 1);
+    expect(row1).toBeDefined();
+    const cellA1 = row1!.cells.find((c) => c.column === 1);
+    expect(cellA1).toBeDefined();
+    expect(cellA1!.value).toBe("hello");
+  });
+
+  it("preserves number cell value", () => {
+    const row1 = parsed.sheets[0].rows.find((r) => r.index === 1);
+    const cellB1 = row1!.cells.find((c) => c.column === 2);
+    expect(cellB1).toBeDefined();
+    expect(cellB1!.value).toBe("42");
+  });
+
+  it("preserves boolean cell value", () => {
+    const row1 = parsed.sheets[0].rows.find((r) => r.index === 1);
+    const cellC1 = row1!.cells.find((c) => c.column === 3);
+    expect(cellC1).toBeDefined();
+    expect(cellC1!.value).toBe("TRUE");
+  });
+
+  it("preserves bold style", () => {
+    const row2 = parsed.sheets[0].rows.find((r) => r.index === 2);
+    const cellA2 = row2!.cells.find((c) => c.column === 1);
+    expect(cellA2).toBeDefined();
+    expect(cellA2!.style.fontBold).toBe(true);
+  });
+
+  it("preserves font and background color", () => {
+    const row3 = parsed.sheets[0].rows.find((r) => r.index === 3);
+    const cellA3 = row3!.cells.find((c) => c.column === 1);
+    expect(cellA3).toBeDefined();
+    expect(cellA3!.style.fontColor).toMatch(/FF0000|rgb\(255,\s*0,\s*0\)/);
+    expect(cellA3!.style.backgroundColor).toMatch(/00FF00|rgb\(0,\s*255,\s*0\)/);
+  });
+
+  it("preserves merged cells", () => {
+    const merges = parsed.sheets[0].mergedCells;
+    expect(merges.length).toBeGreaterThanOrEqual(1);
+    const merge = merges.find(
+      (m) => m.startCol === 4 && m.startRow === 1 && m.endCol === 5 && m.endRow === 2,
+    );
+    expect(merge).toBeDefined();
+  });
+
+  it("preserves freeze pane", () => {
+    expect(parsed.sheets[0].freezePane).toBeDefined();
+    expect(parsed.sheets[0].freezePane!.frozenRows).toBe(1);
+    expect(parsed.sheets[0].freezePane!.frozenCols).toBe(0);
+  });
+
+  it("preserves second sheet content", () => {
+    const row1 = parsed.sheets[1].rows.find((r) => r.index === 1);
+    expect(row1).toBeDefined();
+    const cellA1 = row1!.cells.find((c) => c.column === 1);
+    expect(cellA1).toBeDefined();
+    expect(cellA1!.value).toBe("other");
+  });
+});
+
+describe("border serialization round-trip", () => {
+  const styles = new StyleRegistry();
+  const sheet = new SheetModel("Borders", styles);
+
+  const thinBorderIdx = styles.intern({
+    borderTop: { width: 1, style: "thin", color: "#000000" },
+    borderBottom: { width: 1, style: "thin", color: "#000000" },
+    borderLeft: { width: 1, style: "thin", color: "#000000" },
+    borderRight: { width: 1, style: "thin", color: "#000000" },
+  });
+  sheet.set("A1", "bordered", styles.get(thinBorderIdx));
+
+  const thickTopIdx = styles.intern({
+    borderTop: { width: 2, style: "thick", color: "#FF0000" },
+  });
+  sheet.set("B1", "thick top", styles.get(thickTopIdx));
+
+  const wb = new WorkbookModel({ sheets: [sheet], activeSheetIndex: 0, styles });
+  const xlsx = exportWorkbook(wb);
+  const parsed = parseExcelBuffer(xlsx.buffer as ArrayBuffer);
+
+  it("preserves thin borders on all sides", () => {
+    const row1 = parsed.sheets[0].rows.find((r) => r.index === 1);
+    const cellA1 = row1!.cells.find((c) => c.column === 1);
+    expect(cellA1).toBeDefined();
+    // Parser maps OOXML "thin" → CSS {width: 1, style: "solid"}
+    expect(cellA1!.style.borderTop).toBeDefined();
+    expect(cellA1!.style.borderTop!.style).toBe("solid");
+    expect(cellA1!.style.borderTop!.width).toBe(1);
+    expect(cellA1!.style.borderBottom).toBeDefined();
+    expect(cellA1!.style.borderLeft).toBeDefined();
+    expect(cellA1!.style.borderRight).toBeDefined();
+  });
+
+  it("preserves thick border with color", () => {
+    const row1 = parsed.sheets[0].rows.find((r) => r.index === 1);
+    const cellB1 = row1!.cells.find((c) => c.column === 2);
+    expect(cellB1).toBeDefined();
+    // Parser maps OOXML "thick" → CSS {width: 3, style: "solid"}
+    // (writer converts width=2 + style="thick" → OOXML "thick" → parser reads back as width=3 "solid")
+    expect(cellB1!.style.borderTop).toBeDefined();
+    expect(cellB1!.style.borderTop!.style).toBe("solid");
+    expect(cellB1!.style.borderTop!.width).toBeGreaterThanOrEqual(2);
+  });
+});
+
+describe("number format serialization round-trip", () => {
+  const styles = new StyleRegistry();
+  const sheet = new SheetModel("NumFmt");
+
+  sheet.set("A1", 1234.56, undefined, "#,##0.00");
+  sheet.set("A2", 0.75, undefined, "0.00%");
+  sheet.set("A3", 45000, undefined, "dd/mm/yyyy");
+  sheet.set("A4", 100); // no custom format
+
+  const wb = new WorkbookModel({ sheets: [sheet], activeSheetIndex: 0, styles });
+  const xlsx = exportWorkbook(wb);
+  const parsed = parseExcelBuffer(xlsx.buffer as ArrayBuffer);
+
+  it("preserves number format on cells", () => {
+    const row1 = parsed.sheets[0].rows.find((r) => r.index === 1);
+    const cellA1 = row1!.cells.find((c) => c.column === 1);
+    expect(cellA1).toBeDefined();
+    // The displayed value should be formatted
+    expect(cellA1!.value).toBe("1,234.56");
+  });
+
+  it("preserves percentage format", () => {
+    const row2 = parsed.sheets[0].rows.find((r) => r.index === 2);
+    const cellA2 = row2!.cells.find((c) => c.column === 1);
+    expect(cellA2).toBeDefined();
+    // Percentage format: 0.75 → "75.00%"
+    expect(cellA2!.value).toBe("75.00%");
+  });
+
+  it("preserves general format as-is", () => {
+    const row4 = parsed.sheets[0].rows.find((r) => r.index === 4);
+    const cellA4 = row4!.cells.find((c) => c.column === 1);
+    expect(cellA4).toBeDefined();
+    expect(cellA4!.value).toBe("100");
+  });
+});
+
+describe("chart serialization round-trip", () => {
+  const styles = new StyleRegistry();
+  const sheet = new SheetModel("Charts");
+
+  sheet.set("A1", "Q1");
+  sheet.set("A2", "Q2");
+  sheet.set("B1", 100);
+  sheet.set("B2", 200);
+
+  sheet.charts.push({
+    title: "Sales",
+    chartType: "col",
+    series: [{ name: "Revenue", values: [100, 200], color: "#4472C4" }],
+    categories: ["Q1", "Q2"],
+    legendPosition: "bottom",
+    anchor: { from: { row: 4, col: 0 }, to: { row: 18, col: 6 } },
+  });
+
+  const wb = new WorkbookModel({ sheets: [sheet], activeSheetIndex: 0, styles });
+  const xlsx = exportWorkbook(wb);
+  const parsed = parseExcelBuffer(xlsx.buffer as ArrayBuffer);
+
+  it("preserves chart with correct type and title", () => {
+    expect(parsed.sheets[0].charts).toBeDefined();
+    expect(parsed.sheets[0].charts!.length).toBe(1);
+    const chart = parsed.sheets[0].charts![0];
+    expect(chart.title).toBe("Sales");
+    expect(chart.chartType).toBe("col");
+  });
+
+  it("preserves chart series data", () => {
+    const chart = parsed.sheets[0].charts![0];
+    expect(chart.series.length).toBe(1);
+    expect(chart.series[0].name).toBe("Revenue");
+    expect(chart.series[0].values).toEqual([100, 200]);
+  });
+
+  it("preserves chart categories", () => {
+    const chart = parsed.sheets[0].charts![0];
+    expect(chart.categories).toEqual(["Q1", "Q2"]);
+  });
+});
+
+describe("table serialization round-trip", () => {
+  const styles = new StyleRegistry();
+  const sheet = new SheetModel("Tables");
+
+  sheet.set("A1", "Name");
+  sheet.set("B1", "Value");
+  sheet.set("A2", "Item1");
+  sheet.set("B2", 42);
+
+  sheet.tables.push({
+    name: "Table1",
+    displayName: "Table1",
+    ref: "A1:B2",
+    columns: [
+      { id: 1, name: "Name" },
+      { id: 2, name: "Value" },
+    ],
+    headerRow: true,
+    totalsRow: false,
+    autoFilter: true,
+  });
+
+  const wb = new WorkbookModel({ sheets: [sheet], activeSheetIndex: 0, styles });
+  const xlsx = exportWorkbook(wb);
+  const parsed = parseExcelBuffer(xlsx.buffer as ArrayBuffer);
+
+  it("preserves table structure", () => {
+    expect(parsed.sheets[0].tables).toBeDefined();
+    expect(parsed.sheets[0].tables!.length).toBe(1);
+    const table = parsed.sheets[0].tables![0];
+    expect(table.name).toBe("Table1");
+    expect(table.ref).toBe("A1:B2");
+    expect(table.columns.length).toBe(2);
+    expect(table.columns[0].name).toBe("Name");
+  });
+});
+
+describe("conditional formatting serialization round-trip", () => {
+  const styles = new StyleRegistry();
+  const sheet = new SheetModel("CF");
+
+  sheet.set("A1", 10);
+  sheet.set("A2", 50);
+  sheet.set("A3", 90);
+
+  sheet.conditionalFormats.push({
+    ref: "A1:A3",
+    rules: [{
+      ruleType: "colorScale",
+      priority: 1,
+      colors: ["#FF0000", "#00FF00"],
+    }],
+  });
+
+  const wb = new WorkbookModel({ sheets: [sheet], activeSheetIndex: 0, styles });
+  const xlsx = exportWorkbook(wb);
+  const parsed = parseExcelBuffer(xlsx.buffer as ArrayBuffer);
+
+  it("preserves conditional formatting rules", () => {
+    expect(parsed.sheets[0].conditionalFormats).toBeDefined();
+    expect(parsed.sheets[0].conditionalFormats!.length).toBeGreaterThanOrEqual(1);
+    const cf = parsed.sheets[0].conditionalFormats![0];
+    expect(cf.ref).toBe("A1:A3");
+    expect(cf.rules.length).toBe(1);
+    expect(cf.rules[0].ruleType).toBe("colorScale");
+  });
+});
+
+describe("hyperlink serialization round-trip", () => {
+  const styles = new StyleRegistry();
+  const sheet = new SheetModel("Links");
+
+  sheet.set("A1", "Click me");
+  sheet.hyperlinks.set("A1", "https://example.com");
+
+  const wb = new WorkbookModel({ sheets: [sheet], activeSheetIndex: 0, styles });
+  const xlsx = exportWorkbook(wb);
+  const parsed = parseExcelBuffer(xlsx.buffer as ArrayBuffer);
+
+  it("preserves hyperlink on cell", () => {
+    const row1 = parsed.sheets[0].rows.find((r) => r.index === 1);
+    const cellA1 = row1!.cells.find((c) => c.column === 1);
+    expect(cellA1).toBeDefined();
+    expect(cellA1!.content.type).toBe("hyperlink");
+    if (cellA1!.content.type === "hyperlink") {
+      expect(cellA1!.content.url).toBe("https://example.com");
+    }
+  });
+});
+
+describe("parseExcelFromZip", () => {
+  it("parses from pre-unzipped entries", () => {
+    const wb = createTestWorkbook();
+    const xlsx = exportWorkbook(wb);
+    const zip = unzipXlsx(xlsx.buffer as ArrayBuffer);
+    const parsed = parseExcelFromZip(zip);
+    expect(parsed.sheets).toHaveLength(2);
+    expect(parsed.sheets[0].name).toBe("TestSheet");
+  });
+});
+
+describe("page setup, print titles, header/footer", () => {
+  function getSheetXml(wb: WorkbookModel): string {
+    const zip = unzipXlsx(exportWorkbook(wb).buffer as ArrayBuffer);
+    return new TextDecoder().decode(zip["xl/worksheets/sheet1.xml"]);
+  }
+
+  function getWorkbookXml(wb: WorkbookModel): string {
+    const zip = unzipXlsx(exportWorkbook(wb).buffer as ArrayBuffer);
+    return new TextDecoder().decode(zip["xl/workbook.xml"]);
+  }
+
+  it("emits pageSetup with orientation + fit-to-page + sheetPr", () => {
+    const styles = new StyleRegistry();
+    const sheet = new SheetModel("S", styles);
+    sheet.pageSetup = { orientation: "landscape", paperSize: 9, fitToWidth: 1, fitToHeight: 0 };
+    const wb = new WorkbookModel({ sheets: [sheet], activeSheetIndex: 0, styles });
+    const xml = getSheetXml(wb);
+    expect(xml).toContain(`<sheetPr><pageSetUpPr fitToPage="1"/></sheetPr>`);
+    expect(xml).toContain(`orientation="landscape"`);
+    expect(xml).toContain(`paperSize="9"`);
+    expect(xml).toContain(`fitToWidth="1"`);
+    expect(xml).toContain(`fitToHeight="0"`);
+  });
+
+  it("overrides pageMargins when pageSetup.margins is set", () => {
+    const styles = new StyleRegistry();
+    const sheet = new SheetModel("S", styles);
+    sheet.pageSetup = { margins: { left: 0.4, right: 0.4, top: 0.5, bottom: 0.5 } };
+    const wb = new WorkbookModel({ sheets: [sheet], activeSheetIndex: 0, styles });
+    const xml = getSheetXml(wb);
+    expect(xml).toContain(`<pageMargins left="0.4" right="0.4" top="0.5" bottom="0.5" header="0.3" footer="0.3"/>`);
+  });
+
+  it("emits sheet-scoped Print_Titles defined name", () => {
+    const styles = new StyleRegistry();
+    const sheet = new SheetModel("Report", styles);
+    sheet.printTitles = { repeatRows: [1, 2], repeatCols: [1, 1] };
+    const wb = new WorkbookModel({ sheets: [sheet], activeSheetIndex: 0, styles });
+    const xml = getWorkbookXml(wb);
+    expect(xml).toContain(`<definedName name="_xlnm.Print_Titles" localSheetId="0">`);
+    expect(xml).toContain(`Report!$A:$A,Report!$1:$2`);
+  });
+
+  it("quotes sheet names with non-alphanumerics in Print_Titles", () => {
+    const styles = new StyleRegistry();
+    const sheet = new SheetModel("Sales Q1", styles);
+    sheet.printTitles = { repeatRows: [1, 1] };
+    const wb = new WorkbookModel({ sheets: [sheet], activeSheetIndex: 0, styles });
+    const xml = getWorkbookXml(wb);
+    expect(xml).toContain(`&apos;Sales Q1&apos;!$1:$1`);
+  });
+
+  it("emits header/footer with page-field codes", () => {
+    const styles = new StyleRegistry();
+    const sheet = new SheetModel("S", styles);
+    sheet.headerFooter = {
+      oddHeader: "&LLeft&CTitle&RPage &P of &N",
+      oddFooter: "Confidential",
+    };
+    const wb = new WorkbookModel({ sheets: [sheet], activeSheetIndex: 0, styles });
+    const xml = getSheetXml(wb);
+    expect(xml).toContain(`<headerFooter>`);
+    expect(xml).toContain(`<oddHeader>&amp;LLeft&amp;CTitle&amp;RPage &amp;P of &amp;N</oddHeader>`);
+    expect(xml).toContain(`<oddFooter>Confidential</oddFooter>`);
+  });
+
+  it("emits differentOddEven + differentFirst attributes", () => {
+    const styles = new StyleRegistry();
+    const sheet = new SheetModel("S", styles);
+    sheet.headerFooter = {
+      differentOddEven: true,
+      differentFirst: true,
+      oddHeader: "Odd",
+      evenHeader: "Even",
+      firstHeader: "First",
+    };
+    const wb = new WorkbookModel({ sheets: [sheet], activeSheetIndex: 0, styles });
+    const xml = getSheetXml(wb);
+    expect(xml).toContain(`<headerFooter differentOddEven="1" differentFirst="1">`);
+  });
+
+  it("setFreeze('B2') freezes row 1 + col A", () => {
+    const styles = new StyleRegistry();
+    const sheet = new SheetModel("S", styles);
+    sheet.setFreeze("B2");
+    expect(sheet.freeze).toEqual({ row: 1, col: 1 });
+  });
+
+  it("setFreeze(null) clears the freeze", () => {
+    const styles = new StyleRegistry();
+    const sheet = new SheetModel("S", styles);
+    sheet.freeze = { row: 1, col: 0 };
+    sheet.setFreeze(null);
+    expect(sheet.freeze).toBeUndefined();
+  });
+
+  it("round-trips pageSetup + headerFooter + printTitles through parser", () => {
+    const styles = new StyleRegistry();
+    const sheet = new SheetModel("Report", styles);
+    sheet.set("A1", "x");
+    sheet.pageSetup = {
+      orientation: "landscape",
+      paperSize: 9,
+      fitToWidth: 1,
+      fitToHeight: 0,
+      margins: { left: 0.4, right: 0.4, top: 0.5, bottom: 0.5, header: 0.3, footer: 0.3 },
+    };
+    sheet.printTitles = { repeatRows: [1, 2], repeatCols: [1, 1] };
+    sheet.headerFooter = {
+      oddHeader: "&LLeft&CTitle&RPage &P of &N",
+      oddFooter: "Confidential",
+    };
+    const wb = new WorkbookModel({ sheets: [sheet], activeSheetIndex: 0, styles });
+    const xlsx = exportWorkbook(wb);
+    const parsed = parseExcelBuffer(xlsx.buffer as ArrayBuffer);
+
+    const s = parsed.sheets[0];
+    expect(s.pageSetup?.orientation).toBe("landscape");
+    expect(s.pageSetup?.paperSize).toBe(9);
+    expect(s.pageSetup?.fitToWidth).toBe(1);
+    expect(s.pageSetup?.fitToHeight).toBe(0);
+    expect(s.pageSetup?.margins?.left).toBeCloseTo(0.4, 3);
+    expect(s.pageSetup?.margins?.top).toBeCloseTo(0.5, 3);
+
+    expect(s.printTitles?.repeatRows).toEqual([1, 2]);
+    expect(s.printTitles?.repeatCols).toEqual([1, 1]);
+
+    expect(s.headerFooter?.oddHeader).toBe("&LLeft&CTitle&RPage &P of &N");
+    expect(s.headerFooter?.oddFooter).toBe("Confidential");
+  });
+
+  it("round-trips Print_Titles with Unicode sheet name (quoted emission + parse)", () => {
+    const styles = new StyleRegistry();
+    const sheet = new SheetModel("Báo giá", styles);
+    sheet.set("A1", "x");
+    sheet.printTitles = { repeatRows: [1, 1] };
+    const wb = new WorkbookModel({ sheets: [sheet], activeSheetIndex: 0, styles });
+    const xlsx = exportWorkbook(wb);
+    const parsed = parseExcelBuffer(xlsx.buffer as ArrayBuffer);
+    expect(parsed.sheets[0].printTitles?.repeatRows).toEqual([1, 1]);
+  });
+
+  it("emits no pageSetup tag when pageSetup is undefined", () => {
+    const styles = new StyleRegistry();
+    const sheet = new SheetModel("S", styles);
+    sheet.set("A1", "x");
+    const wb = new WorkbookModel({ sheets: [sheet], activeSheetIndex: 0, styles });
+    const xml = getSheetXml(wb);
+    expect(xml).not.toContain(`<pageSetup`);
+    expect(xml).not.toContain(`<headerFooter`);
+    expect(xml).not.toContain(`<sheetPr>`);
+  });
+});