@simplysm/excel 13.0.75 → 13.0.77

package/tests/excel-cell.spec.ts

@@ -2,6 +2,7 @@ import { describe, expect, it } from "vitest";
 import { ExcelWorkbook } from "../src/excel-workbook";
 import { ExcelXmlWorksheet } from "../src/xml/excel-xml-worksheet";
 import { DateOnly, DateTime, Time } from "@simplysm/core-common";
+import type { ExcelCellData, ExcelCellType } from "../src";
 
 describe("ExcelXmlWorksheet.getCellVal - inline string", () => {
   it("should read plain string inline text (no attributes)", () => {
@@ -47,94 +48,70 @@ describe("ExcelCell", () => {
   describe("Cell Value Read/Write - Basic Types", () => {
     it("Can read and write string values", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
-      await ws.cell(0, 0).setVal("Hello World");
-      const val = await ws.cell(0, 0).getVal();
+      await ws.cell(0, 0).setValue("Hello World");
+      const val = await ws.cell(0, 0).getValue();
 
       expect(val).toBe("Hello World");
     });
 
     it("Can read and write number values", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
-      await ws.cell(0, 0).setVal(12345);
-      await ws.cell(0, 1).setVal(3.14159);
-      await ws.cell(0, 2).setVal(-100);
-      await ws.cell(0, 3).setVal(0);
+      await ws.cell(0, 0).setValue(12345);
+      await ws.cell(0, 1).setValue(3.14159);
+      await ws.cell(0, 2).setValue(-100);
+      await ws.cell(0, 3).setValue(0);
 
-      expect(await ws.cell(0, 0).getVal()).toBe(12345);
-      expect(await ws.cell(0, 1).getVal()).toBe(3.14159);
-      expect(await ws.cell(0, 2).getVal()).toBe(-100);
-      expect(await ws.cell(0, 3).getVal()).toBe(0);
+      expect(await ws.cell(0, 0).getValue()).toBe(12345);
+      expect(await ws.cell(0, 1).getValue()).toBe(3.14159);
+      expect(await ws.cell(0, 2).getValue()).toBe(-100);
+      expect(await ws.cell(0, 3).getValue()).toBe(0);
     });
 
     it("Can read and write boolean values", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
-      await ws.cell(0, 0).setVal(true);
-      await ws.cell(0, 1).setVal(false);
+      await ws.cell(0, 0).setValue(true);
+      await ws.cell(0, 1).setValue(false);
 
-      expect(await ws.cell(0, 0).getVal()).toBe(true);
-      expect(await ws.cell(0, 1).getVal()).toBe(false);
+      expect(await ws.cell(0, 0).getValue()).toBe(true);
+      expect(await ws.cell(0, 1).getValue()).toBe(false);
     });
 
     it("Setting undefined value deletes the cell", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
-      await ws.cell(0, 0).setVal("Initial");
-      expect(await ws.cell(0, 0).getVal()).toBe("Initial");
+      await ws.cell(0, 0).setValue("Initial");
+      expect(await ws.cell(0, 0).getValue()).toBe("Initial");
 
-      await ws.cell(0, 0).setVal(undefined);
-      expect(await ws.cell(0, 0).getVal()).toBeUndefined();
-    });
-
-    it("Can handle very large numbers", async () => {
-      const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
-
-      // Large number below MAX_SAFE_INTEGER
-      const bigNumber = Number.MAX_SAFE_INTEGER;
-      await ws.cell(0, 0).setVal(bigNumber);
-
-      const val = await ws.cell(0, 0).getVal();
-      expect(val).toBe(bigNumber);
-    });
-
-    it("Can handle very small decimals", async () => {
-      const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
-
-      // Small decimal within Excel's precision range
-      const smallDecimal = 0.0001;
-      await ws.cell(0, 0).setVal(smallDecimal);
-
-      const val = await ws.cell(0, 0).getVal();
-      expect(val).toBeCloseTo(smallDecimal, 6);
+      await ws.cell(0, 0).setValue(undefined);
+      expect(await ws.cell(0, 0).getValue()).toBeUndefined();
     });
 
     it("Throws error when setting unsupported type", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
-      await expect(ws.cell(0, 0).setVal({} as any)).rejects.toThrow("Unsupported type");
+      await expect(ws.cell(0, 0).setValue({} as any)).rejects.toThrow("Unsupported type");
 
-      await expect(ws.cell(0, 1).setVal([] as any)).rejects.toThrow("Unsupported type");
+      await expect(ws.cell(0, 1).setValue([] as any)).rejects.toThrow("Unsupported type");
     });
   });
 
   describe("Cell Value Read/Write - Date/Time Types", () => {
     it("Can read and write DateOnly values", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
       const date = new DateOnly(2024, 6, 15);
-      await ws.cell(0, 0).setVal(date);
+      await ws.cell(0, 0).setValue(date);
 
-      const val = await ws.cell(0, 0).getVal();
+      const val = await ws.cell(0, 0).getValue();
       expect(val).toBeInstanceOf(DateOnly);
       expect((val as DateOnly).year).toBe(2024);
       expect((val as DateOnly).month).toBe(6);
@@ -143,12 +120,12 @@ describe("ExcelCell", () => {
 
     it("Can read and write DateTime values", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
       const dateTime = new DateTime(2024, 6, 15, 14, 30, 45);
-      await ws.cell(0, 0).setVal(dateTime);
+      await ws.cell(0, 0).setValue(dateTime);
 
-      const val = await ws.cell(0, 0).getVal();
+      const val = await ws.cell(0, 0).getValue();
       expect(val).toBeInstanceOf(DateTime);
       expect((val as DateTime).year).toBe(2024);
       expect((val as DateTime).month).toBe(6);
@@ -160,12 +137,12 @@ describe("ExcelCell", () => {
 
     it("Can read and write Time values", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
       const time = new Time(14, 30, 45);
-      await ws.cell(0, 0).setVal(time);
+      await ws.cell(0, 0).setValue(time);
 
-      const val = await ws.cell(0, 0).getVal();
+      const val = await ws.cell(0, 0).getValue();
       expect(val).toBeInstanceOf(Time);
       expect((val as Time).hour).toBe(14);
       expect((val as Time).minute).toBe(30);
@@ -174,18 +151,18 @@ describe("ExcelCell", () => {
 
     it("DateOnly values persist after round-trip", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
       const date = new DateOnly(2024, 6, 15);
-      await ws.cell(0, 0).setVal(date);
+      await ws.cell(0, 0).setValue(date);
 
-      const bytes = await wb.getBytes();
+      const bytes = await wb.toBytes();
       await wb.close();
 
       const wb2 = new ExcelWorkbook(bytes);
       const ws2 = await wb2.getWorksheet(0);
 
-      const val = await ws2.cell(0, 0).getVal();
+      const val = await ws2.cell(0, 0).getValue();
       expect(val).toBeInstanceOf(DateOnly);
       expect((val as DateOnly).year).toBe(2024);
       expect((val as DateOnly).month).toBe(6);
@@ -195,18 +172,18 @@ describe("ExcelCell", () => {
 
     it("DateTime values persist after round-trip", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
       const dateTime = new DateTime(2024, 6, 15, 14, 30, 45);
-      await ws.cell(0, 0).setVal(dateTime);
+      await ws.cell(0, 0).setValue(dateTime);
 
-      const bytes = await wb.getBytes();
+      const bytes = await wb.toBytes();
       await wb.close();
 
       const wb2 = new ExcelWorkbook(bytes);
       const ws2 = await wb2.getWorksheet(0);
 
-      const val = await ws2.cell(0, 0).getVal();
+      const val = await ws2.cell(0, 0).getValue();
       expect(val).toBeInstanceOf(DateTime);
       expect((val as DateTime).year).toBe(2024);
       expect((val as DateTime).month).toBe(6);
@@ -219,18 +196,18 @@ describe("ExcelCell", () => {
 
     it("Time values persist after round-trip", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
       const time = new Time(14, 30, 45);
-      await ws.cell(0, 0).setVal(time);
+      await ws.cell(0, 0).setValue(time);
 
-      const bytes = await wb.getBytes();
+      const bytes = await wb.toBytes();
       await wb.close();
 
       const wb2 = new ExcelWorkbook(bytes);
       const ws2 = await wb2.getWorksheet(0);
 
-      const val = await ws2.cell(0, 0).getVal();
+      const val = await ws2.cell(0, 0).getValue();
       expect(val).toBeInstanceOf(Time);
       expect((val as Time).hour).toBe(14);
       expect((val as Time).minute).toBe(30);
@@ -242,10 +219,10 @@ describe("ExcelCell", () => {
   describe("Formulas", () => {
     it("Can set formulas", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
-      await ws.cell(0, 0).setVal(10);
-      await ws.cell(0, 1).setVal(20);
+      await ws.cell(0, 0).setValue(10);
+      await ws.cell(0, 1).setValue(20);
       await ws.cell(0, 2).setFormula("A1+B1");
 
       // Verify formula directly
@@ -253,7 +230,7 @@ describe("ExcelCell", () => {
       expect(formula).toBe("A1+B1");
 
       // Also verify with round-trip
-      const buffer = await wb.getBytes();
+      const buffer = await wb.toBytes();
 
       const wb2 = new ExcelWorkbook(buffer);
       const ws2 = await wb2.getWorksheet(0);
@@ -263,13 +240,13 @@ describe("ExcelCell", () => {
 
     it("Formulas persist after round-trip", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
-      await ws.cell(0, 0).setVal(10);
-      await ws.cell(0, 1).setVal(20);
+      await ws.cell(0, 0).setValue(10);
+      await ws.cell(0, 1).setValue(20);
       await ws.cell(0, 2).setFormula("SUM(A1:B1)");
 
-      const buffer = await wb.getBytes();
+      const buffer = await wb.toBytes();
       await wb.close();
 
       const wb2 = new ExcelWorkbook(buffer);
@@ -283,35 +260,35 @@ describe("ExcelCell", () => {
 
     it("Setting formula to undefined deletes it", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
       await ws.cell(0, 0).setFormula("A1+B1");
       await ws.cell(0, 0).setFormula(undefined);
 
-      expect(await ws.cell(0, 0).getVal()).toBeUndefined();
+      expect(await ws.cell(0, 0).getValue()).toBeUndefined();
     });
   });
 
   describe("Cell Merge", () => {
     it("Can merge cells", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
-      await ws.cell(0, 0).setVal("Merged");
+      await ws.cell(0, 0).setValue("Merged");
       await ws.cell(0, 0).merge(2, 3); // Merge 2 rows x 3 columns
 
       // Verify merge with round-trip
-      const buffer = await wb.getBytes();
+      const buffer = await wb.toBytes();
       const wb2 = new ExcelWorkbook(buffer);
       const ws2 = await wb2.getWorksheet(0);
 
-      const val = await ws2.cell(0, 0).getVal();
+      const val = await ws2.cell(0, 0).getValue();
       expect(val).toBe("Merged");
     });
 
     it("Throws error when attempting to merge overlapping ranges", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
       await ws.cell(0, 0).merge(2, 2); // Merge A1:B2
 
@@ -321,58 +298,11 @@ describe("ExcelCell", () => {
   });
 
   describe("Cell Style", () => {
-    it("Can set background color", async () => {
-      const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
-
-      await ws.cell(0, 0).setVal("Colored");
-      await ws.cell(0, 0).setStyle({ background: "00FF0000" }); // Red
-
-      const styleId = await ws.cell(0, 0).getStyleId();
-      expect(styleId).toBeDefined();
-    });
-
-    it("Can set borders", async () => {
-      const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
-
-      await ws.cell(0, 0).setVal("Bordered");
-      await ws.cell(0, 0).setStyle({ border: ["left", "right", "top", "bottom"] });
-
-      const styleId = await ws.cell(0, 0).getStyleId();
-      expect(styleId).toBeDefined();
-    });
-
-    it("Can set alignment", async () => {
-      const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
-
-      await ws.cell(0, 0).setVal("Aligned");
-      await ws.cell(0, 0).setStyle({
-        horizontalAlign: "center",
-        verticalAlign: "center",
-      });
-
-      const styleId = await ws.cell(0, 0).getStyleId();
-      expect(styleId).toBeDefined();
-    });
-
-    it("Can set number format", async () => {
-      const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
-
-      await ws.cell(0, 0).setVal(12345.6789);
-      await ws.cell(0, 0).setStyle({ numberFormat: "number" });
-
-      const styleId = await ws.cell(0, 0).getStyleId();
-      expect(styleId).toBeDefined();
-    });
-
     it("Can set multiple styles simultaneously", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
-      await ws.cell(0, 0).setVal("Multi-Style");
+      await ws.cell(0, 0).setValue("Multi-Style");
       await ws.cell(0, 0).setStyle({
         background: "00FFFF00",
         border: ["left", "right"],
@@ -386,18 +316,18 @@ describe("ExcelCell", () => {
 
     it("Throws error for invalid color format", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
-      await ws.cell(0, 0).setVal("Test");
+      await ws.cell(0, 0).setValue("Test");
       await expect(ws.cell(0, 0).setStyle({ background: "invalid" })).rejects.toThrow();
     });
 
     it("Styles persist after round-trip", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
       // Set various styles
-      await ws.cell(0, 0).setVal("Styled");
+      await ws.cell(0, 0).setValue("Styled");
       await ws.cell(0, 0).setStyle({
         background: "00FF0000", // Red
         border: ["left", "right", "top", "bottom"],
@@ -405,14 +335,14 @@ describe("ExcelCell", () => {
         verticalAlign: "top",
       });
 
-      const bytes = await wb.getBytes();
+      const bytes = await wb.toBytes();
 
       // Verify styles after round-trip
       const wb2 = new ExcelWorkbook(bytes);
       const ws2 = await wb2.getWorksheet("Test");
 
       // Verify value
-      const val = await ws2.cell(0, 0).getVal();
+      const val = await ws2.cell(0, 0).getValue();
       expect(val).toBe("Styled");
 
       // Verify style ID exists
@@ -446,3 +376,18 @@ describe("ExcelCell", () => {
     });
   });
 });
+
+describe("ExcelCellData type narrowing", () => {
+  it("should type cell type field as ExcelCellType", () => {
+    const cellData: ExcelCellData = {
+      $: { r: "A1", t: "s" },
+      v: ["test"],
+    };
+
+    const cellType: ExcelCellType | undefined = cellData.$.t;
+    expect(cellType).toBe("s");
+
+    // This should compile: no cast needed
+    expect(["s", "b", "str", "n", "inlineStr", "e", undefined].includes(cellData.$.t)).toBe(true);
+  });
+});

package/tests/excel-col.spec.ts

@@ -5,18 +5,18 @@ describe("ExcelCol", () => {
   describe("cell()", () => {
     it("Returns cell corresponding to row index", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
       const col = ws.col(0);
       const cell = col.cell(0);
 
-      await cell.setVal("Hello");
-      expect(await cell.getVal()).toBe("Hello");
+      await cell.setValue("Hello");
+      expect(await cell.getValue()).toBe("Hello");
     });
 
     it("Returns same instance for same index (caching)", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
       const col = ws.col(0);
       const cell1 = col.cell(0);
@@ -25,88 +25,57 @@ describe("ExcelCol", () => {
       expect(cell1).toBe(cell2);
     });
 
-    it("Returns different instance for different index", async () => {
-      const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
-
-      const col = ws.col(0);
-      const cell1 = col.cell(0);
-      const cell2 = col.cell(1);
-
-      expect(cell1).not.toBe(cell2);
-    });
   });
 
   describe("getCells()", () => {
     it("Returns all cells within range", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
       // Set data to define range
-      await ws.cell(0, 0).setVal("A1");
-      await ws.cell(1, 0).setVal("A2");
-      await ws.cell(2, 0).setVal("A3");
+      await ws.cell(0, 0).setValue("A1");
+      await ws.cell(1, 0).setValue("A2");
+      await ws.cell(2, 0).setValue("A3");
 
       const col = ws.col(0);
       const cells = await col.getCells();
 
       expect(cells.length).toBeGreaterThanOrEqual(3);
-      expect(await cells[0].getVal()).toBe("A1");
-      expect(await cells[1].getVal()).toBe("A2");
-      expect(await cells[2].getVal()).toBe("A3");
+      expect(await cells[0].getValue()).toBe("A1");
+      expect(await cells[1].getValue()).toBe("A2");
+      expect(await cells[2].getValue()).toBe("A3");
     });
 
     it("Returns cell corresponding to default range (0,0) from empty worksheet", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
       const col = ws.col(0);
       const cells = await col.getCells();
 
       // Default range of empty worksheet is (0,0)-(0,0), so returns one cell
       expect(cells.length).toBe(1);
-      expect(await cells[0].getVal()).toBeUndefined();
+      expect(await cells[0].getValue()).toBeUndefined();
     });
   });
 
   describe("setWidth()", () => {
     it("Can set column width", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
       // Add data and set width
-      await ws.cell(0, 0).setVal("Test");
+      await ws.cell(0, 0).setValue("Test");
       await ws.col(0).setWidth(20);
 
       // Verify settings via round-trip
-      const bytes = await wb.getBytes();
+      const bytes = await wb.toBytes();
       const wb2 = new ExcelWorkbook(bytes);
       const ws2 = await wb2.getWorksheet(0);
 
       // Verify value is preserved (width is hard to verify directly, so just check it works without error)
-      expect(await ws2.cell(0, 0).getVal()).toBe("Test");
+      expect(await ws2.cell(0, 0).getValue()).toBe("Test");
     });
 
-    it("Can set different widths for multiple columns", async () => {
-      const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
-
-      await ws.cell(0, 0).setVal("A");
-      await ws.cell(0, 1).setVal("B");
-      await ws.cell(0, 2).setVal("C");
-
-      await ws.col(0).setWidth(10);
-      await ws.col(1).setWidth(20);
-      await ws.col(2).setWidth(30);
-
-      // Can round-trip without error
-      const bytes = await wb.getBytes();
-      const wb2 = new ExcelWorkbook(bytes);
-      const ws2 = await wb2.getWorksheet(0);
-
-      expect(await ws2.cell(0, 0).getVal()).toBe("A");
-      expect(await ws2.cell(0, 1).getVal()).toBe("B");
-      expect(await ws2.cell(0, 2).getVal()).toBe("C");
-    });
   });
 });

package/tests/excel-row.spec.ts

@@ -5,18 +5,18 @@ describe("ExcelRow", () => {
   describe("cell()", () => {
     it("returns cell corresponding to column index", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
       const row = ws.row(0);
       const cell = row.cell(0);
 
-      await cell.setVal("Hello");
-      expect(await cell.getVal()).toBe("Hello");
+      await cell.setValue("Hello");
+      expect(await cell.getValue()).toBe("Hello");
     });
 
     it("returns same instance for same index (caching)", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
       const row = ws.row(0);
       const cell1 = row.cell(0);
@@ -25,47 +25,37 @@ describe("ExcelRow", () => {
       expect(cell1).toBe(cell2);
     });
 
-    it("returns different instances for different indices", async () => {
-      const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
-
-      const row = ws.row(0);
-      const cell1 = row.cell(0);
-      const cell2 = row.cell(1);
-
-      expect(cell1).not.toBe(cell2);
-    });
   });
 
   describe("getCells()", () => {
     it("returns all cells within range", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
       // Set range by configuring data
-      await ws.cell(0, 0).setVal("A1");
-      await ws.cell(0, 1).setVal("B1");
-      await ws.cell(0, 2).setVal("C1");
+      await ws.cell(0, 0).setValue("A1");
+      await ws.cell(0, 1).setValue("B1");
+      await ws.cell(0, 2).setValue("C1");
 
       const row = ws.row(0);
       const cells = await row.getCells();
 
       expect(cells.length).toBeGreaterThanOrEqual(3);
-      expect(await cells[0].getVal()).toBe("A1");
-      expect(await cells[1].getVal()).toBe("B1");
-      expect(await cells[2].getVal()).toBe("C1");
+      expect(await cells[0].getValue()).toBe("A1");
+      expect(await cells[1].getValue()).toBe("B1");
+      expect(await cells[2].getValue()).toBe("C1");
     });
 
     it("returns cell corresponding to default range (0,0) in empty worksheet", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
       const row = ws.row(0);
       const cells = await row.getCells();
 
       // Empty worksheet default range is (0,0)-(0,0) so returns one cell
       expect(cells.length).toBe(1);
-      expect(await cells[0].getVal()).toBeUndefined();
+      expect(await cells[0].getValue()).toBeUndefined();
     });
   });
 });