@simplysm/excel 13.0.76 → 13.0.78

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,70 +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();
+      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);
@@ -119,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);
@@ -136,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);
@@ -150,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);
@@ -171,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);
@@ -195,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);
@@ -218,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
@@ -229,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);
@@ -239,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);
@@ -259,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
 
@@ -299,9 +300,9 @@ describe("ExcelCell", () => {
   describe("Cell Style", () => {
     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"],
@@ -315,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"],
@@ -334,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
@@ -375,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);
@@ -30,51 +30,51 @@ describe("ExcelCol", () => {
   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");
     });
 
   });

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);
@@ -30,32 +30,32 @@ describe("ExcelRow", () => {
   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();
     });
   });
 });

package/tests/excel-workbook.spec.ts

@@ -6,7 +6,7 @@ describe("ExcelWorkbook", () => {
   describe("Creating empty workbook", () => {
     it("Can create a worksheet", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("TestSheet");
+      const ws = await wb.addWorksheet("TestSheet");
 
       expect(ws).toBeDefined();
       const name = await ws.getName();
@@ -15,9 +15,9 @@ describe("ExcelWorkbook", () => {
 
     it("Can create multiple worksheets", async () => {
       const wb = new ExcelWorkbook();
-      await wb.createWorksheet("Sheet1");
-      await wb.createWorksheet("Sheet2");
-      await wb.createWorksheet("Sheet3");
+      await wb.addWorksheet("Sheet1");
+      await wb.addWorksheet("Sheet2");
+      await wb.addWorksheet("Sheet3");
 
       const names = await wb.getWorksheetNames();
       expect(names).toEqual(["Sheet1", "Sheet2", "Sheet3"]);
@@ -27,8 +27,8 @@ describe("ExcelWorkbook", () => {
   describe("Accessing worksheets", () => {
     it("Can get worksheet by index", async () => {
       const wb = new ExcelWorkbook();
-      await wb.createWorksheet("First");
-      await wb.createWorksheet("Second");
+      await wb.addWorksheet("First");
+      await wb.addWorksheet("Second");
 
       const ws = await wb.getWorksheet(1);
       const name = await ws.getName();
@@ -37,7 +37,7 @@ describe("ExcelWorkbook", () => {
 
     it("Can get worksheet by name", async () => {
       const wb = new ExcelWorkbook();
-      await wb.createWorksheet("MySheet");
+      await wb.addWorksheet("MySheet");
 
       const ws = await wb.getWorksheet("MySheet");
       const name = await ws.getName();
@@ -46,7 +46,7 @@ describe("ExcelWorkbook", () => {
 
     it("Error when accessing non-existent sheet", async () => {
       const wb = new ExcelWorkbook();
-      await wb.createWorksheet("Sheet1");
+      await wb.addWorksheet("Sheet1");
 
       await expect(wb.getWorksheet("NotExist")).rejects.toThrow();
       await expect(wb.getWorksheet(10)).rejects.toThrow();
@@ -56,20 +56,20 @@ describe("ExcelWorkbook", () => {
   describe("Bytes/Blob export", () => {
     it("Can export as Bytes", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
-      await ws.cell(0, 0).setVal("Hello");
+      const ws = await wb.addWorksheet("Test");
+      await ws.cell(0, 0).setValue("Hello");
 
-      const bytes: Bytes = await wb.getBytes();
+      const bytes: Bytes = await wb.toBytes();
       expect(bytes).toBeInstanceOf(Uint8Array);
       expect(bytes.length).toBeGreaterThan(0);
     });
 
     it("Can export as Blob", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
-      await ws.cell(0, 0).setVal("Hello");
+      const ws = await wb.addWorksheet("Test");
+      await ws.cell(0, 0).setValue("Hello");
 
-      const blob = await wb.getBlob();
+      const blob = await wb.toBlob();
       expect(blob).toBeInstanceOf(Blob);
       expect(blob.type).toBe("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
       expect(blob.size).toBeGreaterThan(0);
@@ -80,9 +80,9 @@ describe("ExcelWorkbook", () => {
     it("Can create workbook from Blob", async () => {
       // First create workbook with Bytes
       const wb1 = new ExcelWorkbook();
-      const ws1 = await wb1.createWorksheet("Test");
-      await ws1.cell(0, 0).setVal("BlobTest");
-      const bytes = await wb1.getBytes();
+      const ws1 = await wb1.addWorksheet("Test");
+      await ws1.cell(0, 0).setValue("BlobTest");
+      const bytes = await wb1.toBytes();
       await wb1.close();
 
       // Convert to Blob
@@ -93,7 +93,7 @@ describe("ExcelWorkbook", () => {
       // Read workbook from Blob
       const wb2 = new ExcelWorkbook(blob);
       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("BlobTest");
       await wb2.close();
@@ -102,12 +102,12 @@ describe("ExcelWorkbook", () => {
     it("Can save created workbook as Bytes and read again", async () => {
       // Create
       const wb1 = new ExcelWorkbook();
-      const ws1 = await wb1.createWorksheet("RoundTrip");
-      await ws1.cell(0, 0).setVal("TestValue");
-      await ws1.cell(0, 1).setVal(12345);
+      const ws1 = await wb1.addWorksheet("RoundTrip");
+      await ws1.cell(0, 0).setValue("TestValue");
+      await ws1.cell(0, 1).setValue(12345);
 
       // Save
-      const bytes = await wb1.getBytes();
+      const bytes = await wb1.toBytes();
       await wb1.close();
 
       // Read again
@@ -116,8 +116,8 @@ describe("ExcelWorkbook", () => {
       expect(names).toContain("RoundTrip");
 
       const ws2 = await wb2.getWorksheet("RoundTrip");
-      const val1 = await ws2.cell(0, 0).getVal();
-      const val2 = await ws2.cell(0, 1).getVal();
+      const val1 = await ws2.cell(0, 0).getValue();
+      const val2 = await ws2.cell(0, 1).getValue();
 
       expect(val1).toBe("TestValue");
       expect(val2).toBe(12345);
@@ -129,7 +129,7 @@ describe("ExcelWorkbook", () => {
   describe("Error after resource cleanup", () => {
     it("Error when calling getWorksheetNames() after close()", async () => {
       const wb = new ExcelWorkbook();
-      await wb.createWorksheet("Test");
+      await wb.addWorksheet("Test");
       await wb.close();
 
       await expect(wb.getWorksheetNames()).rejects.toThrow();
@@ -137,7 +137,7 @@ describe("ExcelWorkbook", () => {
 
     it("Error when calling getWorksheet() after close()", async () => {
       const wb = new ExcelWorkbook();
-      await wb.createWorksheet("Test");
+      await wb.addWorksheet("Test");
       await wb.close();
 
       await expect(wb.getWorksheet(0)).rejects.toThrow();