@simplysm/excel 13.0.76 → 13.0.77

package/tests/excel-worksheet.spec.ts

@@ -5,7 +5,7 @@ describe("ExcelWorksheet", () => {
   describe("Sheet name", () => {
     it("should change sheet name", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("OldName");
+      const ws = await wb.addWorksheet("OldName");
 
       await ws.setName("NewName");
       const name = await ws.getName();
@@ -14,10 +14,10 @@ describe("ExcelWorksheet", () => {
 
     it("should preserve changed sheet name after roundtrip", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("OldName");
+      const ws = await wb.addWorksheet("OldName");
       await ws.setName("NewName");
 
-      const bytes = await wb.getBytes();
+      const bytes = await wb.toBytes();
 
       const wb2 = new ExcelWorkbook(bytes);
       const names = await wb2.getWorksheetNames();
@@ -33,47 +33,47 @@ describe("ExcelWorksheet", () => {
   describe("Row/Column copy", () => {
     it("should copy row", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
       // Set source row
-      await ws.cell(0, 0).setVal("A");
-      await ws.cell(0, 1).setVal("B");
-      await ws.cell(0, 2).setVal("C");
+      await ws.cell(0, 0).setValue("A");
+      await ws.cell(0, 1).setValue("B");
+      await ws.cell(0, 2).setValue("C");
 
       // Copy row
       await ws.copyRow(0, 2);
 
-      expect(await ws.cell(2, 0).getVal()).toBe("A");
-      expect(await ws.cell(2, 1).getVal()).toBe("B");
-      expect(await ws.cell(2, 2).getVal()).toBe("C");
+      expect(await ws.cell(2, 0).getValue()).toBe("A");
+      expect(await ws.cell(2, 1).getValue()).toBe("B");
+      expect(await ws.cell(2, 2).getValue()).toBe("C");
     });
 
     it("should copy cell", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
-      await ws.cell(0, 0).setVal("Original");
+      await ws.cell(0, 0).setValue("Original");
       await ws.copyCell({ r: 0, c: 0 }, { r: 1, c: 1 });
 
-      expect(await ws.cell(1, 1).getVal()).toBe("Original");
+      expect(await ws.cell(1, 1).getValue()).toBe("Original");
     });
 
     it("should copy only row style", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
       // Set styles
-      await ws.cell(0, 0).setVal("Styled");
+      await ws.cell(0, 0).setValue("Styled");
       await ws.cell(0, 0).setStyle({ background: "00FF0000" });
-      await ws.cell(0, 1).setVal("Also Styled");
+      await ws.cell(0, 1).setValue("Also Styled");
       await ws.cell(0, 1).setStyle({ background: "0000FF00" });
 
       // Copy only styles
       await ws.copyRowStyle(0, 2);
 
       // Values should not be copied
-      expect(await ws.cell(2, 0).getVal()).toBeUndefined();
-      expect(await ws.cell(2, 1).getVal()).toBeUndefined();
+      expect(await ws.cell(2, 0).getValue()).toBeUndefined();
+      expect(await ws.cell(2, 1).getValue()).toBeUndefined();
 
       // Styles should be copied
       const styleId0 = await ws.cell(0, 0).getStyleId();
@@ -83,65 +83,85 @@ describe("ExcelWorksheet", () => {
 
     it("should insert copy row when srcR < targetR", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
-      await ws.cell(0, 0).setVal("Row0");
-      await ws.cell(1, 0).setVal("Row1");
-      await ws.cell(2, 0).setVal("Row2");
+      await ws.cell(0, 0).setValue("Row0");
+      await ws.cell(1, 0).setValue("Row1");
+      await ws.cell(2, 0).setValue("Row2");
 
       // Insert copy row 0 at position 1 (existing rows are shifted)
       await ws.insertCopyRow(0, 1);
 
-      expect(await ws.cell(0, 0).getVal()).toBe("Row0");
-      expect(await ws.cell(1, 0).getVal()).toBe("Row0"); // copied
-      expect(await ws.cell(2, 0).getVal()).toBe("Row1"); // shifted
-      expect(await ws.cell(3, 0).getVal()).toBe("Row2"); // shifted
+      expect(await ws.cell(0, 0).getValue()).toBe("Row0");
+      expect(await ws.cell(1, 0).getValue()).toBe("Row0"); // copied
+      expect(await ws.cell(2, 0).getValue()).toBe("Row1"); // shifted
+      expect(await ws.cell(3, 0).getValue()).toBe("Row2"); // shifted
     });
 
     it("should insert copy row when srcR > targetR", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
-      await ws.cell(0, 0).setVal("Row0");
-      await ws.cell(1, 0).setVal("Row1");
-      await ws.cell(2, 0).setVal("Row2");
-      await ws.cell(3, 0).setVal("Row3");
+      await ws.cell(0, 0).setValue("Row0");
+      await ws.cell(1, 0).setValue("Row1");
+      await ws.cell(2, 0).setValue("Row2");
+      await ws.cell(3, 0).setValue("Row3");
 
       // Insert copy row 2 at position 1 (existing rows are shifted)
       await ws.insertCopyRow(2, 1);
 
-      expect(await ws.cell(0, 0).getVal()).toBe("Row0");
-      expect(await ws.cell(1, 0).getVal()).toBe("Row2"); // copied
-      expect(await ws.cell(2, 0).getVal()).toBe("Row1"); // shifted
-      expect(await ws.cell(3, 0).getVal()).toBe("Row2"); // shifted (original Row2)
-      expect(await ws.cell(4, 0).getVal()).toBe("Row3"); // shifted
+      expect(await ws.cell(0, 0).getValue()).toBe("Row0");
+      expect(await ws.cell(1, 0).getValue()).toBe("Row2"); // copied
+      expect(await ws.cell(2, 0).getValue()).toBe("Row1"); // shifted
+      expect(await ws.cell(3, 0).getValue()).toBe("Row2"); // shifted (original Row2)
+      expect(await ws.cell(4, 0).getValue()).toBe("Row3"); // shifted
     });
 
     it("should insert copy row when srcR == targetR", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
-      await ws.cell(0, 0).setVal("Row0");
-      await ws.cell(1, 0).setVal("Row1");
-      await ws.cell(2, 0).setVal("Row2");
+      await ws.cell(0, 0).setValue("Row0");
+      await ws.cell(1, 0).setValue("Row1");
+      await ws.cell(2, 0).setValue("Row2");
 
       // Insert copy row 1 at position 1 (copy itself)
       await ws.insertCopyRow(1, 1);
 
-      expect(await ws.cell(0, 0).getVal()).toBe("Row0");
-      expect(await ws.cell(1, 0).getVal()).toBe("Row1"); // copied
-      expect(await ws.cell(2, 0).getVal()).toBe("Row1"); // shifted (original Row1)
-      expect(await ws.cell(3, 0).getVal()).toBe("Row2"); // shifted
+      expect(await ws.cell(0, 0).getValue()).toBe("Row0");
+      expect(await ws.cell(1, 0).getValue()).toBe("Row1"); // copied
+      expect(await ws.cell(2, 0).getValue()).toBe("Row1"); // shifted (original Row1)
+      expect(await ws.cell(3, 0).getValue()).toBe("Row2"); // shifted
+    });
+
+    it("should skip merge handling when skipMerge is true", async () => {
+      const wb = new ExcelWorkbook();
+      const ws = await wb.addWorksheet("Test");
+
+      await ws.cell(0, 0).setValue("Row0");
+      await ws.cell(1, 0).setValue("Row1");
+      await ws.cell(0, 0).merge(0, 1); // Merge A1:B1
+
+      const wsData = await ws["_getWsData"]();
+
+      // Copy row 0 to row 1, but skip merge handling
+      wsData.copyRow(0, 1, { skipMerge: true });
+
+      // Row 1 should have the data but merge should not be copied
+      const merges = wsData.getMergeCells();
+      expect(merges).toEqual([
+        { s: { r: 0, c: 0 }, e: { r: 0, c: 1 } }, // original merge, unchanged
+      ]);
     });
   });
 
   describe("Range and cell access", () => {
     it("should get data range", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
-      await ws.cell(0, 0).setVal("A");
-      await ws.cell(2, 3).setVal("D");
+      await ws.cell(0, 0).setValue("A");
+      await ws.cell(2, 3).setValue("D");
 
       const range = await ws.getRange();
       expect(range.s.r).toBe(0);
@@ -152,12 +172,12 @@ describe("ExcelWorksheet", () => {
 
     it("should get all cells", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
-      await ws.cell(0, 0).setVal("A");
-      await ws.cell(0, 1).setVal("B");
-      await ws.cell(1, 0).setVal("C");
-      await ws.cell(1, 1).setVal("D");
+      await ws.cell(0, 0).setValue("A");
+      await ws.cell(0, 1).setValue("B");
+      await ws.cell(1, 0).setValue("C");
+      await ws.cell(1, 1).setValue("D");
 
       const cells = await ws.getCells();
       expect(cells.length).toBe(2);
@@ -168,16 +188,16 @@ describe("ExcelWorksheet", () => {
   describe("Data table", () => {
     it("should get data table", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
       // Headers
-      await ws.cell(0, 0).setVal("Name");
-      await ws.cell(0, 1).setVal("Age");
+      await ws.cell(0, 0).setValue("Name");
+      await ws.cell(0, 1).setValue("Age");
       // Data
-      await ws.cell(1, 0).setVal("Alice");
-      await ws.cell(1, 1).setVal(30);
-      await ws.cell(2, 0).setVal("Bob");
-      await ws.cell(2, 1).setVal(25);
+      await ws.cell(1, 0).setValue("Alice");
+      await ws.cell(1, 1).setValue(30);
+      await ws.cell(2, 0).setValue("Bob");
+      await ws.cell(2, 1).setValue(25);
 
       const data = await ws.getDataTable();
       expect(data.length).toBe(2);
@@ -189,14 +209,14 @@ describe("ExcelWorksheet", () => {
 
     it("should filter specific headers only", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
-      await ws.cell(0, 0).setVal("Name");
-      await ws.cell(0, 1).setVal("Age");
-      await ws.cell(0, 2).setVal("Ignore");
-      await ws.cell(1, 0).setVal("Alice");
-      await ws.cell(1, 1).setVal(30);
-      await ws.cell(1, 2).setVal("X");
+      await ws.cell(0, 0).setValue("Name");
+      await ws.cell(0, 1).setValue("Age");
+      await ws.cell(0, 2).setValue("Ignore");
+      await ws.cell(1, 0).setValue("Alice");
+      await ws.cell(1, 1).setValue(30);
+      await ws.cell(1, 2).setValue("X");
 
       const data = await ws.getDataTable({
         usableHeaderNameFn: (name) => name !== "Ignore",
@@ -209,7 +229,7 @@ describe("ExcelWorksheet", () => {
 
     it("should set data matrix", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
       const matrix = [
         ["A", "B", "C"],
@@ -219,14 +239,14 @@ describe("ExcelWorksheet", () => {
 
       await ws.setDataMatrix(matrix);
 
-      expect(await ws.cell(0, 0).getVal()).toBe("A");
-      expect(await ws.cell(0, 2).getVal()).toBe("C");
-      expect(await ws.cell(2, 2).getVal()).toBe(6);
+      expect(await ws.cell(0, 0).getValue()).toBe("A");
+      expect(await ws.cell(0, 2).getValue()).toBe("C");
+      expect(await ws.cell(2, 2).getValue()).toBe(6);
     });
 
     it("should set records array", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
       const records = [
         { Name: "Alice", Age: 30 },
@@ -236,7 +256,7 @@ describe("ExcelWorksheet", () => {
       await ws.setRecords(records);
 
       // Check headers
-      const headers = [await ws.cell(0, 0).getVal(), await ws.cell(0, 1).getVal()];
+      const headers = [await ws.cell(0, 0).getValue(), await ws.cell(0, 1).getValue()];
       expect(headers).toContain("Name");
       expect(headers).toContain("Age");
 
@@ -249,13 +269,13 @@ describe("ExcelWorksheet", () => {
   describe("Column width", () => {
     it("should preserve column width after roundtrip", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
-      await ws.cell(0, 0).setVal("A1");
+      await ws.cell(0, 0).setValue("A1");
       await ws.col(0).setWidth(25);
       await ws.col(2).setWidth(30);
 
-      const bytes = await wb.getBytes();
+      const bytes = await wb.toBytes();
 
       const wb2 = new ExcelWorkbook(bytes);
       await wb2.getWorksheet("Test");
@@ -279,33 +299,33 @@ describe("ExcelWorksheet", () => {
   describe("Column access", () => {
     it("should get all cells in column", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
-      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 cells = await ws.col(0).getCells();
       expect(cells.length).toBe(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");
     });
   });
 
   describe("Data table edge cases", () => {
     it("should return empty array when calling getDataTable on empty sheet", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Empty");
+      const ws = await wb.addWorksheet("Empty");
       const data = await ws.getDataTable();
       expect(data).toEqual([]);
     });
 
     it("should return empty array when only headers exist without data", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
-      await ws.cell(0, 0).setVal("Header1");
-      await ws.cell(0, 1).setVal("Header2");
+      const ws = await wb.addWorksheet("Test");
+      await ws.cell(0, 0).setValue("Header1");
+      await ws.cell(0, 1).setValue("Header2");
       const data = await ws.getDataTable();
       expect(data).toEqual([]);
     });
@@ -314,16 +334,16 @@ describe("ExcelWorksheet", () => {
   describe("Data table options", () => {
     it("should specify header row with headerRowIndex", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
+      const ws = await wb.addWorksheet("Test");
 
       // Row 0 is title
-      await ws.cell(0, 0).setVal("Title");
+      await ws.cell(0, 0).setValue("Title");
       // Row 1 is header
-      await ws.cell(1, 0).setVal("Name");
-      await ws.cell(1, 1).setVal("Age");
+      await ws.cell(1, 0).setValue("Name");
+      await ws.cell(1, 1).setValue("Age");
       // Data starts from row 2
-      await ws.cell(2, 0).setVal("Alice");
-      await ws.cell(2, 1).setVal(30);
+      await ws.cell(2, 0).setValue("Alice");
+      await ws.cell(2, 1).setValue(30);
 
       const data = await ws.getDataTable({ headerRowIndex: 1 });
       expect(data.length).toBe(1);
@@ -333,16 +353,16 @@ describe("ExcelWorksheet", () => {
 
     it("should detect data end with checkEndColIndex", async () => {
       const wb = new ExcelWorkbook();
-      const ws = await wb.createWorksheet("Test");
-
-      await ws.cell(0, 0).setVal("Name");
-      await ws.cell(0, 1).setVal("Age");
-      await ws.cell(1, 0).setVal("Alice");
-      await ws.cell(1, 1).setVal(30);
-      await ws.cell(2, 0).setVal("Bob");
-      await ws.cell(2, 1).setVal(25);
+      const ws = await wb.addWorksheet("Test");
+
+      await ws.cell(0, 0).setValue("Name");
+      await ws.cell(0, 1).setValue("Age");
+      await ws.cell(1, 0).setValue("Alice");
+      await ws.cell(1, 1).setValue(30);
+      await ws.cell(2, 0).setValue("Bob");
+      await ws.cell(2, 1).setValue(25);
       // Row 3 has empty Name column -> data end
-      await ws.cell(3, 1).setVal(999);
+      await ws.cell(3, 1).setValue(999);
 
       const data = await ws.getDataTable({ checkEndColIndex: 0 });
       expect(data.length).toBe(2);
@@ -350,4 +370,100 @@ describe("ExcelWorksheet", () => {
       expect(data[1]["Name"]).toBe("Bob");
     });
   });
+
+  describe("Merge cells", () => {
+    it("should shift merge cells when inserting row", async () => {
+      const wb = new ExcelWorkbook();
+      const ws = await wb.addWorksheet("Test");
+
+      // Create merged cells: A1:B2 and C3:D4
+      await ws.cell(0, 0).merge(1, 1); // A1:B2
+      await ws.cell(2, 2).merge(3, 3); // C3:D4
+
+      const wsData = await ws["_getWsData"](); // Access private method for testing
+      wsData.shiftMergeCells(2, 1); // Shift rows >= 2 by +1
+
+      const merges = wsData.getMergeCells();
+      expect(merges).toEqual([
+        { s: { r: 0, c: 0 }, e: { r: 1, c: 1 } }, // unchanged
+        { s: { r: 3, c: 2 }, e: { r: 4, c: 3 } }, // shifted down by 1
+      ]);
+    });
+
+    it("should shift merge cells when inserting row with merges", async () => {
+      const wb = new ExcelWorkbook();
+      const ws = await wb.addWorksheet("Test");
+
+      await ws.cell(0, 0).setValue("Row0");
+      await ws.cell(1, 0).setValue("Row1");
+      await ws.cell(2, 0).setValue("Row2");
+
+      // Create merge A3:B4 (rows 2-3, well below insertion point)
+      await ws.cell(2, 0).merge(3, 1);
+
+      // Insert copy of row 0 at position 1
+      await ws.insertCopyRow(0, 1);
+
+      // Check that merge was shifted correctly
+      const wsData = await ws["_getWsData"]();
+      const merges = wsData.getMergeCells();
+
+      // Merge at rows 2-3 should shift to rows 3-4
+      expect(merges).toEqual([
+        { s: { r: 3, c: 0 }, e: { r: 4, c: 1 } },
+      ]);
+
+      expect(await ws.cell(0, 0).getValue()).toBe("Row0");
+      expect(await ws.cell(1, 0).getValue()).toBe("Row0"); // copied
+      expect(await ws.cell(2, 0).getValue()).toBe("Row1"); // shifted
+      expect(await ws.cell(3, 0).getValue()).toBe("Row2"); // shifted
+    });
+
+    it("should handle multi-row merge when inserting row", async () => {
+      const wb = new ExcelWorkbook();
+      const ws = await wb.addWorksheet("Test");
+
+      await ws.cell(0, 0).setValue("Row0");
+      await ws.cell(1, 0).setValue("Row1");
+      await ws.cell(2, 0).setValue("Row2");
+      await ws.cell(3, 0).setValue("Row3");
+
+      // Create merge A3:B4 (rows 2-3, below insertion point)
+      await ws.cell(2, 0).merge(3, 1);
+
+      // Insert copy of row 0 at position 1
+      await ws.insertCopyRow(0, 1);
+
+      const wsData = await ws["_getWsData"]();
+      const merges = wsData.getMergeCells();
+
+      // Merge at rows 2-3 should shift to rows 3-4 (rows >= 1 shift by 1)
+      expect(merges).toHaveLength(1);
+      expect(merges[0].s).toEqual({ r: 3, c: 0 });
+      expect(merges[0].e).toEqual({ r: 4, c: 1 }); // shifted from 2-3 to 3-4
+    });
+
+    it("should not shift merge above insertion point", async () => {
+      const wb = new ExcelWorkbook();
+      const ws = await wb.addWorksheet("Test");
+
+      await ws.cell(0, 0).setValue("Row0");
+      await ws.cell(1, 0).setValue("Row1");
+      await ws.cell(2, 0).setValue("Row2");
+
+      // Create merge A1:B1 (row 0)
+      await ws.cell(0, 0).merge(0, 1);
+
+      // Insert copy of row 1 at position 2
+      await ws.insertCopyRow(1, 2);
+
+      const wsData = await ws["_getWsData"]();
+      const merges = wsData.getMergeCells();
+
+      // Merge should remain unchanged at A1:B1
+      expect(merges).toEqual([
+        { s: { r: 0, c: 0 }, e: { r: 0, c: 1 } },
+      ]);
+    });
+  });
 });

package/tests/excel-wrapper.spec.ts

@@ -24,16 +24,16 @@ describe("ExcelWrapper", () => {
       const ws = await wb.getWorksheet("Users");
 
       // Check headers
-      expect(await ws.cell(0, 0).getVal()).toBe("Name");
-      expect(await ws.cell(0, 1).getVal()).toBe("Age");
-      expect(await ws.cell(0, 2).getVal()).toBe("Email");
-      expect(await ws.cell(0, 3).getVal()).toBe("Active");
+      expect(await ws.cell(0, 0).getValue()).toBe("Name");
+      expect(await ws.cell(0, 1).getValue()).toBe("Age");
+      expect(await ws.cell(0, 2).getValue()).toBe("Email");
+      expect(await ws.cell(0, 3).getValue()).toBe("Active");
 
       // Check data
-      expect(await ws.cell(1, 0).getVal()).toBe("John Doe");
-      expect(await ws.cell(1, 1).getVal()).toBe(30);
-      expect(await ws.cell(2, 0).getVal()).toBe("Jane Smith");
-      expect(await ws.cell(2, 1).getVal()).toBe(25);
+      expect(await ws.cell(1, 0).getValue()).toBe("John Doe");
+      expect(await ws.cell(1, 1).getValue()).toBe(30);
+      expect(await ws.cell(2, 0).getValue()).toBe("Jane Smith");
+      expect(await ws.cell(2, 1).getValue()).toBe(25);
 
       await wb.close();
     });
@@ -65,7 +65,7 @@ describe("ExcelWrapper", () => {
       ];
 
       const wb = await wrapper.write("Users", records);
-      const buffer = await wb.getBytes();
+      const buffer = await wb.toBytes();
       await wb.close();
 
       // Read from Excel
@@ -85,7 +85,7 @@ describe("ExcelWrapper", () => {
 
       const records = [{ name: "Test", age: 20 }];
       const wb = await wrapper.write("Sheet1", records);
-      const buffer = await wb.getBytes();
+      const buffer = await wb.toBytes();
       await wb.close();
 
       const readRecords = await wrapper.read(buffer, 0);
@@ -100,7 +100,7 @@ describe("ExcelWrapper", () => {
 
       // Save without active field
       const wb = await wrapper.write("Test", [{ name: "Test", age: 20 }]);
-      const buffer = await wb.getBytes();
+      const buffer = await wb.toBytes();
       await wb.close();
 
       const records = await wrapper.read(buffer);
@@ -120,7 +120,7 @@ describe("ExcelWrapper", () => {
       const records = [{ title: "Event 1", date: new DateOnly(2024, 6, 15) }, { title: "Event 2" }];
 
       const wb = await wrapper.write("Events", records);
-      const buffer = await wb.getBytes();
+      const buffer = await wb.toBytes();
       await wb.close();
 
       const readRecords = await wrapper.read(buffer, "Events");
@@ -144,7 +144,7 @@ describe("ExcelWrapper", () => {
       const records = [{ title: "Meeting", datetime: new DateTime(2024, 6, 15, 14, 30, 0) }];
 
       const wb = await wrapper.write("Events", records);
-      const buffer = await wb.getBytes();
+      const buffer = await wb.toBytes();
       await wb.close();
 
       const readRecords = await wrapper.read(buffer, "Events");
@@ -168,7 +168,7 @@ describe("ExcelWrapper", () => {
       const records = [{ title: "Alarm", time: new Time(9, 30, 0) }];
 
       const wb = await wrapper.write("Events", records);
-      const buffer = await wb.getBytes();
+      const buffer = await wb.toBytes();
       await wb.close();
 
       const readRecords = await wrapper.read(buffer, "Events");
@@ -185,7 +185,7 @@ describe("ExcelWrapper", () => {
 
       // Create empty Excel with only headers
       const wb = await wrapper.write("Empty", []);
-      const buffer = await wb.getBytes();
+      const buffer = await wb.toBytes();
       await wb.close();
 
       await expect(wrapper.read(buffer, "Empty")).rejects.toThrow(
@@ -197,7 +197,7 @@ describe("ExcelWrapper", () => {
       const wrapper = new ExcelWrapper(testSchema);
 
       const wb = await wrapper.write("Test", [{ name: "Test", age: 20 }]);
-      const buffer = await wb.getBytes();
+      const buffer = await wb.toBytes();
       await wb.close();
 
       await expect(wrapper.read(buffer, "NotExist")).rejects.toThrow();
@@ -215,9 +215,9 @@ describe("ExcelWrapper", () => {
 
       // Modify data directly to trigger validation failure
       const ws = await wb.getWorksheet("Validation");
-      await ws.cell(1, 0).setVal("AB"); // Change to less than 5 characters
+      await ws.cell(1, 0).setValue("AB"); // Change to less than 5 characters
 
-      const buffer = await wb.getBytes();
+      const buffer = await wb.toBytes();
       await wb.close();
 
       // Should throw validation error
@@ -241,13 +241,13 @@ describe("ExcelWrapper", () => {
       const ws = await wb.getWorksheet("Test");
 
       // Headers: only name and age exist
-      expect(await ws.cell(0, 0).getVal()).toBe("Name");
-      expect(await ws.cell(0, 1).getVal()).toBe("Age");
-      expect(await ws.cell(0, 2).getVal()).toBeUndefined();
+      expect(await ws.cell(0, 0).getValue()).toBe("Name");
+      expect(await ws.cell(0, 1).getValue()).toBe("Age");
+      expect(await ws.cell(0, 2).getValue()).toBeUndefined();
 
       // Check data
-      expect(await ws.cell(1, 0).getVal()).toBe("John Doe");
-      expect(await ws.cell(1, 1).getVal()).toBe(30);
+      expect(await ws.cell(1, 0).getValue()).toBe("John Doe");
+      expect(await ws.cell(1, 1).getValue()).toBe(30);
 
       await wb.close();
     });
@@ -258,7 +258,7 @@ describe("ExcelWrapper", () => {
       // Create Excel with all fields
       const records = [{ name: "John Doe", age: 30, email: "john@test.com", phone: "010-1234-5678" }];
       const wb = await wrapper.write("Test", records);
-      const buffer = await wb.getBytes();
+      const buffer = await wb.toBytes();
       await wb.close();
 
       // Read with excludes