@lotics/xlsx 0.1.0

package/src/workbook_model.test.ts

@@ -0,0 +1,536 @@
+import {
+  StyleRegistry,
+  SheetModel,
+  WorkbookModel,
+  loadWorkbookFromSnapshot,
+} from "./workbook_model";
+import type { ParsedSpreadsheet, CellStyle } from "./types";
+import { colNumToLetters, refToRowCol, rowColToRef } from "./excel_utils";
+
+// =============================================================================
+// excel_utils
+// =============================================================================
+
+describe("colNumToLetters", () => {
+  test("single letter columns", () => {
+    expect(colNumToLetters(1)).toBe("A");
+    expect(colNumToLetters(26)).toBe("Z");
+  });
+
+  test("multi-letter columns", () => {
+    expect(colNumToLetters(27)).toBe("AA");
+    expect(colNumToLetters(28)).toBe("AB");
+    expect(colNumToLetters(702)).toBe("ZZ");
+    expect(colNumToLetters(703)).toBe("AAA");
+  });
+});
+
+describe("refToRowCol", () => {
+  test("parses simple refs", () => {
+    expect(refToRowCol("A1")).toEqual({ row: 1, col: 1 });
+    expect(refToRowCol("Z99")).toEqual({ row: 99, col: 26 });
+    expect(refToRowCol("AA100")).toEqual({ row: 100, col: 27 });
+  });
+
+  test("parses absolute refs", () => {
+    expect(refToRowCol("$A$1")).toEqual({ row: 1, col: 1 });
+    expect(refToRowCol("$AB$50")).toEqual({ row: 50, col: 28 });
+  });
+
+  test("returns undefined for invalid refs", () => {
+    expect(refToRowCol("")).toBeUndefined();
+    expect(refToRowCol("123")).toBeUndefined();
+  });
+});
+
+describe("rowColToRef", () => {
+  test("produces A1-style refs", () => {
+    expect(rowColToRef(1, 1)).toBe("A1");
+    expect(rowColToRef(99, 26)).toBe("Z99");
+    expect(rowColToRef(100, 27)).toBe("AA100");
+  });
+});
+
+// =============================================================================
+// StyleRegistry
+// =============================================================================
+
+describe("StyleRegistry", () => {
+  test("starts with empty default style at index 0", () => {
+    const reg = new StyleRegistry();
+    expect(reg.get(0)).toEqual({});
+    expect(reg.size).toBe(1);
+  });
+
+  test("interns a new style and returns index", () => {
+    const reg = new StyleRegistry();
+    const style: CellStyle = { fontBold: true, fontSize: 14 };
+    const idx = reg.intern(style);
+    expect(idx).toBe(1);
+    expect(reg.get(idx)).toEqual({ fontBold: true, fontSize: 14 });
+  });
+
+  test("deduplicates identical styles", () => {
+    const reg = new StyleRegistry();
+    const s1 = { fontBold: true, fontSize: 14 };
+    const s2 = { fontBold: true, fontSize: 14 };
+    const idx1 = reg.intern(s1);
+    const idx2 = reg.intern(s2);
+    expect(idx1).toBe(idx2);
+    expect(reg.size).toBe(2); // default + one interned
+  });
+
+  test("different styles get different indices", () => {
+    const reg = new StyleRegistry();
+    const idx1 = reg.intern({ fontBold: true });
+    const idx2 = reg.intern({ fontItalic: true });
+    expect(idx1).not.toBe(idx2);
+    expect(reg.size).toBe(3);
+  });
+
+  test("empty style returns index 0", () => {
+    const reg = new StyleRegistry();
+    expect(reg.intern({})).toBe(0);
+  });
+
+  test("merge creates new style from base + override", () => {
+    const reg = new StyleRegistry();
+    const baseIdx = reg.intern({ fontBold: true, fontSize: 12 });
+    const mergedIdx = reg.merge(baseIdx, { fontItalic: true });
+    expect(mergedIdx).not.toBe(baseIdx);
+    expect(reg.get(mergedIdx)).toEqual({
+      fontBold: true,
+      fontSize: 12,
+      fontItalic: true,
+    });
+  });
+
+  test("merge with same properties deduplicates", () => {
+    const reg = new StyleRegistry();
+    const idx1 = reg.intern({ fontBold: true, fontItalic: true });
+    const baseIdx = reg.intern({ fontBold: true });
+    const mergedIdx = reg.merge(baseIdx, { fontItalic: true });
+    expect(mergedIdx).toBe(idx1);
+  });
+
+  test("get returns empty style for invalid index", () => {
+    const reg = new StyleRegistry();
+    expect(reg.get(999)).toEqual({});
+    expect(reg.get(-1)).toEqual({});
+  });
+});
+
+// =============================================================================
+// SheetModel
+// =============================================================================
+
+describe("SheetModel", () => {
+  test("constructor sets name", () => {
+    const sheet = new SheetModel("Sheet1");
+    expect(sheet.name).toBe("Sheet1");
+  });
+
+  test("starts with no cells", () => {
+    const sheet = new SheetModel("Sheet1");
+    expect(sheet.cells.size).toBe(0);
+    expect(sheet.getCell("A1")).toBeUndefined();
+  });
+
+  test("setCell creates a cell", () => {
+    const sheet = new SheetModel("Sheet1");
+    const cell = sheet.set("A1", 42);
+    expect(cell.value).toBe(42);
+    expect(cell.displayValue).toBe("42");
+    expect(cell.styleIndex).toBe(0);
+    expect(sheet.getCell("A1")).toBe(cell);
+  });
+
+  test("setCell with formula", () => {
+    const sheet = new SheetModel("Sheet1");
+    const cell = sheet.set("A3", 30, undefined, undefined, "SUM(A1:A2)");
+    expect(cell.formula).toBe("SUM(A1:A2)");
+  });
+
+  test("setCell with string value", () => {
+    const sheet = new SheetModel("Sheet1");
+    const cell = sheet.set("A1", "Hello");
+    expect(cell.value).toBe("Hello");
+    expect(cell.displayValue).toBe("Hello");
+  });
+
+  test("setCell with boolean value", () => {
+    const sheet = new SheetModel("Sheet1");
+    const cell = sheet.set("A1", true);
+    expect(cell.displayValue).toBe("TRUE");
+  });
+
+  test("setCell with null value", () => {
+    const sheet = new SheetModel("Sheet1");
+    const cell = sheet.set("A1", null);
+    expect(cell.displayValue).toBe("");
+  });
+
+  test("setCell with number format", () => {
+    const sheet = new SheetModel("Sheet1");
+    const cell = sheet.set("A1", 0.5, undefined, "0.00%");
+    expect(cell.displayValue).toBe("50.00%");
+  });
+
+  test("deleteCell removes a cell", () => {
+    const sheet = new SheetModel("Sheet1");
+    sheet.set("A1", 42);
+    expect(sheet.deleteCell("A1")).toBe(true);
+    expect(sheet.getCell("A1")).toBeUndefined();
+  });
+
+  test("deleteCell returns false for non-existent cell", () => {
+    const sheet = new SheetModel("Sheet1");
+    expect(sheet.deleteCell("A1")).toBe(false);
+  });
+
+  test("getUsedRange computes bounding box", () => {
+    const sheet = new SheetModel("Sheet1");
+    sheet.set("B2", 1);
+    sheet.set("D5", 2);
+    sheet.set("C3", 3);
+
+    const range = sheet.getUsedRange();
+    expect(range).toEqual({ minRow: 2, maxRow: 5, minCol: 2, maxCol: 4 });
+  });
+
+  test("getUsedRange returns 1,1 for empty sheet", () => {
+    const sheet = new SheetModel("Sheet1");
+    expect(sheet.getUsedRange()).toEqual({ minRow: 1, maxRow: 1, minCol: 1, maxCol: 1 });
+  });
+});
+
+// =============================================================================
+// WorkbookModel
+// =============================================================================
+
+describe("WorkbookModel", () => {
+  test("constructor sets properties", () => {
+    const styles = new StyleRegistry();
+    const sheet = new SheetModel("Sheet1");
+    const wb = new WorkbookModel({
+      sheets: [sheet],
+      activeSheetIndex: 0,
+      styles,
+    });
+    expect(wb.sheets).toHaveLength(1);
+    expect(wb.activeSheetIndex).toBe(0);
+    expect(wb.date1904).toBe(false);
+  });
+
+  test("emit calls onChange", () => {
+    const styles = new StyleRegistry();
+    const wb = new WorkbookModel({
+      sheets: [new SheetModel("Sheet1")],
+      activeSheetIndex: 0,
+      styles,
+    });
+
+    const events: ChangeEvent[] = [];
+    wb.onChange = (e) => events.push(e);
+
+    wb.emit({ type: "cell_value", sheet: 0, ref: "A1", oldValue: null, newValue: 42 });
+    expect(events).toHaveLength(1);
+    expect(events[0].type).toBe("cell_value");
+  });
+
+  test("emit is safe without onChange", () => {
+    const styles = new StyleRegistry();
+    const wb = new WorkbookModel({
+      sheets: [new SheetModel("Sheet1")],
+      activeSheetIndex: 0,
+      styles,
+    });
+    // Should not throw
+    wb.emit({ type: "cell_value", sheet: 0, ref: "A1", oldValue: null, newValue: 42 });
+  });
+});
+
+// =============================================================================
+// loadWorkbookFromSnapshot + toSnapshot round-trip
+// =============================================================================
+
+describe("loadWorkbookFromSnapshot", () => {
+  function makeSnapshot(): ParsedSpreadsheet {
+    return {
+      sheets: [
+        {
+          name: "Sales",
+          columns: [
+            { index: 1, width: 10, hidden: false },
+            { index: 2, width: 15, hidden: false },
+          ],
+          rows: [
+            {
+              index: 1,
+              height: 20,
+              hidden: false,
+              cells: [
+                {
+                  column: 1,
+                  value: "Product",
+                  content: { type: "plain", text: "Product" },
+                  style: { fontBold: true },
+                },
+                {
+                  column: 2,
+                  value: "Revenue",
+                  content: { type: "plain", text: "Revenue" },
+                  style: { fontBold: true },
+                },
+              ],
+            },
+            {
+              index: 2,
+              height: 15,
+              hidden: false,
+              cells: [
+                {
+                  column: 1,
+                  value: "Widget",
+                  content: { type: "plain", text: "Widget" },
+                  style: {},
+                },
+                {
+                  column: 2,
+                  value: "1234",
+                  content: { type: "plain", text: "1234" },
+                  style: {},
+                  formula: "SUM(C2:C10)",
+                },
+              ],
+            },
+          ],
+          mergedCells: [{ startRow: 1, startCol: 1, endRow: 1, endCol: 2 }],
+          totalRowCount: 2,
+          truncated: false,
+          defaultRowHeight: 15,
+          defaultColWidth: 8,
+          showGridLines: true,
+          freezePane: { frozenRows: 1, frozenCols: 0 },
+          conditionalFormats: [],
+          images: [],
+          rowOutlineLevels: new Map(),
+          colOutlineLevels: new Map(),
+        },
+      ],
+      activeSheetIndex: 0,
+    };
+  }
+
+  test("loads cells into sparse map", () => {
+    const wb = loadWorkbookFromSnapshot(makeSnapshot());
+    const sheet = wb.sheets[0];
+    expect(sheet.cells.size).toBe(4);
+    expect(sheet.getCell("A1")?.displayValue).toBe("Product");
+    expect(sheet.getCell("B2")?.displayValue).toBe("1234");
+  });
+
+  test("preserves formulas", () => {
+    const wb = loadWorkbookFromSnapshot(makeSnapshot());
+    expect(wb.sheets[0].getCell("B2")?.formula).toBe("SUM(C2:C10)");
+  });
+
+  test("interns styles into registry", () => {
+    const wb = loadWorkbookFromSnapshot(makeSnapshot());
+    const boldIdx = wb.sheets[0].getCell("A1")!.styleIndex;
+    const plainIdx = wb.sheets[0].getCell("A2")!.styleIndex;
+    expect(boldIdx).not.toBe(plainIdx);
+    expect(wb.styles.get(boldIdx)).toEqual({ fontBold: true });
+    expect(wb.styles.get(plainIdx)).toEqual({});
+  });
+
+  test("deduplicates same style across cells", () => {
+    const wb = loadWorkbookFromSnapshot(makeSnapshot());
+    const a1Style = wb.sheets[0].getCell("A1")!.styleIndex;
+    const b1Style = wb.sheets[0].getCell("B1")!.styleIndex;
+    expect(a1Style).toBe(b1Style); // Both bold
+  });
+
+  test("preserves metadata", () => {
+    const wb = loadWorkbookFromSnapshot(makeSnapshot());
+    const sheet = wb.sheets[0];
+    expect(sheet.name).toBe("Sales");
+    expect(sheet.freeze).toEqual({ row: 1, col: 0 });
+    expect(sheet.mergedCells).toEqual(["A1:B1"]);
+    expect(sheet.colWidths.get(1)).toBe(10);
+    expect(sheet.colWidths.get(2)).toBe(15);
+    expect(sheet.rowHeights.get(1)).toBe(20);
+    expect(sheet.view.showGridLines).toBe(true);
+  });
+
+  test("preserves numeric raw values", () => {
+    const wb = loadWorkbookFromSnapshot(makeSnapshot());
+    expect(wb.sheets[0].getCell("B2")?.value).toBe(1234);
+  });
+
+  test("preserves string raw values", () => {
+    const wb = loadWorkbookFromSnapshot(makeSnapshot());
+    expect(wb.sheets[0].getCell("A2")?.value).toBe("Widget");
+  });
+});
+
+describe("toSnapshot round-trip", () => {
+  test("round-trips cell data", () => {
+    const original = {
+      sheets: [{
+        name: "Test",
+        columns: [{ index: 1, width: 8, hidden: false }],
+        rows: [{
+          index: 1,
+          height: 15,
+          hidden: false,
+          cells: [{
+            column: 1,
+            value: "Hello",
+            content: { type: "plain" as const, text: "Hello" },
+            style: { fontBold: true },
+          }],
+        }],
+        mergedCells: [],
+        totalRowCount: 1,
+        truncated: false,
+        defaultRowHeight: 15,
+        defaultColWidth: 8,
+        showGridLines: true,
+        conditionalFormats: [],
+        images: [],
+        rowOutlineLevels: new Map<number, number>(),
+        colOutlineLevels: new Map<number, number>(),
+      }],
+      activeSheetIndex: 0,
+    };
+
+    const wb = loadWorkbookFromSnapshot(original);
+    const snapshot = wb.toSnapshot();
+
+    expect(snapshot.sheets).toHaveLength(1);
+    expect(snapshot.sheets[0].name).toBe("Test");
+    expect(snapshot.sheets[0].rows).toHaveLength(1);
+    expect(snapshot.sheets[0].rows[0].cells).toHaveLength(1);
+    expect(snapshot.sheets[0].rows[0].cells[0].value).toBe("Hello");
+    expect(snapshot.sheets[0].rows[0].cells[0].style.fontBold).toBe(true);
+  });
+
+  test("round-trips merged cells", () => {
+    const original: ParsedSpreadsheet = {
+      sheets: [{
+        name: "Test",
+        columns: [],
+        rows: [{
+          index: 1,
+          height: 15,
+          hidden: false,
+          cells: [{
+            column: 1,
+            value: "Merged",
+            content: { type: "plain", text: "Merged" },
+            style: {},
+          }],
+        }],
+        mergedCells: [{ startRow: 1, startCol: 1, endRow: 1, endCol: 3 }],
+        totalRowCount: 1,
+        truncated: false,
+        defaultRowHeight: 15,
+        defaultColWidth: 8,
+        showGridLines: true,
+        conditionalFormats: [],
+        images: [],
+        rowOutlineLevels: new Map(),
+        colOutlineLevels: new Map(),
+      }],
+      activeSheetIndex: 0,
+    };
+
+    const wb = loadWorkbookFromSnapshot(original);
+    const snapshot = wb.toSnapshot();
+
+    expect(snapshot.sheets[0].mergedCells).toHaveLength(1);
+    expect(snapshot.sheets[0].mergedCells[0]).toEqual({
+      startRow: 1,
+      startCol: 1,
+      endRow: 1,
+      endCol: 3,
+    });
+  });
+
+  test("round-trips freeze pane", () => {
+    const original: ParsedSpreadsheet = {
+      sheets: [{
+        name: "Test",
+        columns: [],
+        rows: [],
+        mergedCells: [],
+        totalRowCount: 0,
+        truncated: false,
+        defaultRowHeight: 15,
+        defaultColWidth: 8,
+        showGridLines: true,
+        freezePane: { frozenRows: 2, frozenCols: 1 },
+        conditionalFormats: [],
+        images: [],
+        rowOutlineLevels: new Map(),
+        colOutlineLevels: new Map(),
+      }],
+      activeSheetIndex: 0,
+    };
+
+    const wb = loadWorkbookFromSnapshot(original);
+    const snapshot = wb.toSnapshot();
+    expect(snapshot.sheets[0].freezePane).toEqual({ frozenRows: 2, frozenCols: 1 });
+  });
+});
+
+// =============================================================================
+// Mutation tests
+// =============================================================================
+
+describe("WorkbookModel mutations", () => {
+  test("setCell on existing cell overwrites it", () => {
+    const styles = new StyleRegistry();
+    const sheet = new SheetModel("Sheet1");
+    new WorkbookModel({ sheets: [sheet], activeSheetIndex: 0, styles });
+
+    sheet.set("A1", 10);
+    expect(sheet.getCell("A1")?.value).toBe(10);
+
+    sheet.set("A1", 20);
+    expect(sheet.getCell("A1")?.value).toBe(20);
+  });
+
+  test("toSnapshot reflects mutations", () => {
+    const styles = new StyleRegistry();
+    const sheet = new SheetModel("Sheet1");
+    const wb = new WorkbookModel({ sheets: [sheet], activeSheetIndex: 0, styles });
+
+    sheet.set("A1", "Hello");
+    sheet.set("B1", 42);
+
+    const snapshot = wb.toSnapshot();
+    expect(snapshot.sheets[0].rows).toHaveLength(1);
+    expect(snapshot.sheets[0].rows[0].cells).toHaveLength(2);
+    expect(snapshot.sheets[0].rows[0].cells[0].value).toBe("Hello");
+    expect(snapshot.sheets[0].rows[0].cells[1].value).toBe("42");
+  });
+
+  test("deleteCell is reflected in toSnapshot", () => {
+    const styles = new StyleRegistry();
+    const sheet = new SheetModel("Sheet1");
+    const wb = new WorkbookModel({ sheets: [sheet], activeSheetIndex: 0, styles });
+
+    sheet.set("A1", "Hello");
+    sheet.set("A2", "World");
+    sheet.deleteCell("A1");
+
+    const snapshot = wb.toSnapshot();
+    expect(snapshot.sheets[0].rows).toHaveLength(1);
+    expect(snapshot.sheets[0].rows[0].index).toBe(2);
+  });
+});
+
+// Import ChangeEvent type
+import type { ChangeEvent } from "./workbook_model";