@simplysm/excel 13.0.100 → 14.0.4

package/tests/excel-wrapper.spec.ts

@@ -1,273 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { z } from "zod";
-import { ExcelWrapper } from "../src/excel-wrapper";
-import { DateOnly, DateTime, Time } from "@simplysm/core-common";
-
-describe("ExcelWrapper", () => {
-  const testSchema = z.object({
-    name: z.string().describe("Name"),
-    age: z.number().describe("Age"),
-    email: z.string().optional().describe("Email"),
-    active: z.boolean().default(false).describe("Active"),
-  });
-
-  describe("write", () => {
-    it("can convert records to Excel", async () => {
-      const wrapper = new ExcelWrapper(testSchema);
-
-      const records = [
-        { name: "John Doe", age: 30, email: "john@test.com", active: true },
-        { name: "Jane Smith", age: 25 },
-      ];
-
-      const wb = await wrapper.write("Users", records);
-      const ws = await wb.getWorksheet("Users");
-
-      // Check headers
-      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).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();
-    });
-
-    it("applies yellow background to required fields", async () => {
-      const wrapper = new ExcelWrapper(testSchema);
-      const wb = await wrapper.write("Test", [{ name: "Test", age: 20 }]);
-      const ws = await wb.getWorksheet("Test");
-
-      // Required fields (name, age) have style applied
-      const nameStyleId = await ws.cell(0, 0).getStyleId();
-      const ageStyleId = await ws.cell(0, 1).getStyleId();
-
-      expect(nameStyleId).toBeDefined();
-      expect(ageStyleId).toBeDefined();
-
-      await wb.close();
-    });
-  });
-
-  describe("read", () => {
-    it("can read records from Excel", async () => {
-      const wrapper = new ExcelWrapper(testSchema);
-
-      // Create Excel first
-      const records = [
-        { name: "John Doe", age: 30, email: "john@test.com", active: true },
-        { name: "Jane Smith", age: 25, active: false },
-      ];
-
-      const wb = await wrapper.write("Users", records);
-      const buffer = await wb.toBytes();
-      await wb.close();
-
-      // Read from Excel
-      const readRecords = await wrapper.read(buffer, "Users");
-
-      expect(readRecords.length).toBe(2);
-      expect(readRecords[0].name).toBe("John Doe");
-      expect(readRecords[0].age).toBe(30);
-      expect(readRecords[0].email).toBe("john@test.com");
-      expect(readRecords[0].active).toBe(true);
-      expect(readRecords[1].name).toBe("Jane Smith");
-      expect(readRecords[1].age).toBe(25);
-    });
-
-    it("can specify worksheet by index", async () => {
-      const wrapper = new ExcelWrapper(testSchema);
-
-      const records = [{ name: "Test", age: 20 }];
-      const wb = await wrapper.write("Sheet1", records);
-      const buffer = await wb.toBytes();
-      await wb.close();
-
-      const readRecords = await wrapper.read(buffer, 0);
-      expect(readRecords.length).toBe(1);
-      expect(readRecords[0].name).toBe("Test");
-    });
-  });
-
-  describe("Type conversion", () => {
-    it("applies default values", async () => {
-      const wrapper = new ExcelWrapper(testSchema);
-
-      // Save without active field
-      const wb = await wrapper.write("Test", [{ name: "Test", age: 20 }]);
-      const buffer = await wb.toBytes();
-      await wb.close();
-
-      const records = await wrapper.read(buffer);
-      expect(records[0].active).toBe(false); // Default value
-    });
-  });
-
-  describe("Date type support", () => {
-    const dateSchema = z.object({
-      title: z.string().describe("Title"),
-      date: z.instanceof(DateOnly).optional().describe("Date"),
-    });
-
-    it("can read and write DateOnly type", async () => {
-      const wrapper = new ExcelWrapper(dateSchema);
-
-      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.toBytes();
-      await wb.close();
-
-      const readRecords = await wrapper.read(buffer, "Events");
-
-      expect(readRecords[0].title).toBe("Event 1");
-      expect(readRecords[0].date).toBeInstanceOf(DateOnly);
-      expect(readRecords[0].date!.year).toBe(2024);
-      expect(readRecords[0].date!.month).toBe(6);
-      expect(readRecords[0].date!.day).toBe(15);
-      expect(readRecords[1].date).toBeUndefined();
-    });
-
-    it("can read and write DateTime type", async () => {
-      const dateTimeSchema = z.object({
-        title: z.string().describe("Title"),
-        datetime: z.instanceof(DateTime).optional().describe("DateTime"),
-      });
-
-      const wrapper = new ExcelWrapper(dateTimeSchema);
-
-      const records = [{ title: "Meeting", datetime: new DateTime(2024, 6, 15, 14, 30, 0) }];
-
-      const wb = await wrapper.write("Events", records);
-      const buffer = await wb.toBytes();
-      await wb.close();
-
-      const readRecords = await wrapper.read(buffer, "Events");
-
-      expect(readRecords[0].datetime).toBeInstanceOf(DateTime);
-      expect(readRecords[0].datetime!.year).toBe(2024);
-      expect(readRecords[0].datetime!.month).toBe(6);
-      expect(readRecords[0].datetime!.day).toBe(15);
-      expect(readRecords[0].datetime!.hour).toBe(14);
-      expect(readRecords[0].datetime!.minute).toBe(30);
-    });
-
-    it("can read and write Time type", async () => {
-      const timeSchema = z.object({
-        title: z.string().describe("Title"),
-        time: z.instanceof(Time).optional().describe("Time"),
-      });
-
-      const wrapper = new ExcelWrapper(timeSchema);
-
-      const records = [{ title: "Alarm", time: new Time(9, 30, 0) }];
-
-      const wb = await wrapper.write("Events", records);
-      const buffer = await wb.toBytes();
-      await wb.close();
-
-      const readRecords = await wrapper.read(buffer, "Events");
-
-      expect(readRecords[0].time).toBeInstanceOf(Time);
-      expect(readRecords[0].time!.hour).toBe(9);
-      expect(readRecords[0].time!.minute).toBe(30);
-    });
-  });
-
-  describe("Error handling", () => {
-    it("throws error when reading empty data", async () => {
-      const wrapper = new ExcelWrapper(testSchema);
-
-      // Create empty Excel with only headers
-      const wb = await wrapper.write("Empty", []);
-      const buffer = await wb.toBytes();
-      await wb.close();
-
-      await expect(wrapper.read(buffer, "Empty")).rejects.toThrow(
-        "No data found in Excel file",
-      );
-    });
-
-    it("throws error when reading with non-existent worksheet name", async () => {
-      const wrapper = new ExcelWrapper(testSchema);
-
-      const wb = await wrapper.write("Test", [{ name: "Test", age: 20 }]);
-      const buffer = await wb.toBytes();
-      await wb.close();
-
-      await expect(wrapper.read(buffer, "NotExist")).rejects.toThrow();
-    });
-
-    it("throws error with worksheet name and detailed error when schema validation fails", async () => {
-      const strictSchema = z.object({
-        name: z.string().min(5).describe("이름"), // At least 5 characters
-        age: z.number().min(0).max(150).describe("나이"), // Between 0 and 150
-      });
-
-      // Create Excel with valid data
-      const wrapper = new ExcelWrapper(strictSchema);
-      const wb = await wrapper.write("Validation", [{ name: "홍길동홍길동", age: 30 }]);
-
-      // Modify data directly to trigger validation failure
-      const ws = await wb.getWorksheet("Validation");
-      await ws.cell(1, 0).setValue("AB"); // Change to less than 5 characters
-
-      const buffer = await wb.toBytes();
-      await wb.close();
-
-      // Should throw validation error
-      await expect(wrapper.read(buffer, "Validation")).rejects.toThrow();
-    });
-  });
-
-  describe("excludes option", () => {
-    const fullSchema = z.object({
-      name: z.string().describe("Name"),
-      age: z.number().describe("Age"),
-      email: z.string().optional().describe("Email"),
-      phone: z.string().optional().describe("Phone"),
-    });
-
-    it("excludes specified fields from columns on write", async () => {
-      const wrapper = new ExcelWrapper(fullSchema);
-
-      const records = [{ name: "John Doe", age: 30, email: "john@test.com", phone: "010-1234-5678" }];
-      const wb = await wrapper.write("Test", records, { excludes: ["email", "phone"] });
-      const ws = await wb.getWorksheet("Test");
-
-      // Headers: only name and age exist
-      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).getValue()).toBe("John Doe");
-      expect(await ws.cell(1, 1).getValue()).toBe(30);
-
-      await wb.close();
-    });
-
-    it("ignores excluded fields on read", async () => {
-      const wrapper = new ExcelWrapper(fullSchema);
-
-      // 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.toBytes();
-      await wb.close();
-
-      // Read with excludes
-      const readRecords = await wrapper.read(buffer, "Test", { excludes: ["email", "phone"] });
-
-      expect(readRecords[0].name).toBe("John Doe");
-      expect(readRecords[0].age).toBe(30);
-      expect(readRecords[0].email).toBeUndefined();
-      expect(readRecords[0].phone).toBeUndefined();
-    });
-  });
-});

package/tests/image-insert.spec.ts

@@ -1,190 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { ExcelWorkbook } from "../src/excel-workbook";
-
-// If globalThis.window doesn't exist, it's a Node.js environment
-declare const window: unknown;
-// Node.js only types (to pass type checking in browser environment as well)
-declare const require: (id: string) => unknown;
-
-/**
- * Load PNG file (branching between Node/browser environments)
- */
-async function loadPngFile(): Promise<Uint8Array> {
-  const url = new URL("./fixtures/logo.png", import.meta.url);
-
-  // Node environment: use fs
-  if (typeof window === "undefined") {
-    const fs = require("fs") as { readFileSync: (path: string) => Uint8Array };
-    const { fileURLToPath } = require("url") as { fileURLToPath: (url: URL) => string };
-    const filePath = fileURLToPath(url);
-    return new Uint8Array(fs.readFileSync(filePath));
-  }
-
-  // Browser environment: use fetch
-  const response = await fetch(url);
-  const arrayBuffer = await response.arrayBuffer();
-  return new Uint8Array(arrayBuffer);
-}
-
-/**
- * Integration test: verify ExcelWorksheet.addImage behavior
- */
-
-describe("ExcelWorksheet.addImage integration", () => {
-  it("should write media, drawing, drawing rels, worksheet rel and content types", async () => {
-    const wb = new ExcelWorkbook();
-    const ws = await wb.addWorksheet("Sheet1");
-
-    const bytes = await loadPngFile();
-
-    // call addImage (the single entry API)
-    await ws.addImage({
-      bytes,
-      ext: "png",
-      from: { r: 0, c: 0 },
-      to: { r: 2, c: 2 },
-    });
-
-    // --- 1) Check media exists and its content
-    const mediaPath = `xl/media/image1.png`;
-    const mediaObj = await (ws as any)._zipCache.get(mediaPath);
-    expect(mediaObj).toBeDefined();
-    expect(mediaObj instanceof Uint8Array).toBe(true);
-    expect(mediaObj).toEqual(bytes);
-
-    // --- 2) Check Content Types has media / drawing override
-    const types = await (ws as any)._zipCache.get("[Content_Types].xml");
-    expect(types).toBeDefined();
-    // types is likely an ExcelXmlContentType instance
-    const overrides = types.data?.Types?.Override ?? [];
-    expect(overrides.some((o: any) => o.$.PartName === "/xl/media/image1.png")).toBeTruthy();
-    expect(overrides.some((o: any) => o.$.PartName === "/xl/drawings/drawing1.xml")).toBeTruthy();
-
-    // --- 3) Check drawing xml exists and a:blip r:embed is set as rId
-    const drawingPath = "xl/drawings/drawing1.xml";
-    const drawingObj = await (ws as any)._zipCache.get(drawingPath);
-    expect(drawingObj).toBeDefined();
-
-    // drawingObj is likely an ExcelXmlDrawing object — check internal structure
-    const wsDr = drawingObj?.data?.wsDr;
-    expect(wsDr).toBeDefined();
-    const anchors = wsDr.twoCellAnchor ?? [];
-    expect(anchors.length).toBeGreaterThan(0);
-    const pic = anchors[0].pic?.[0];
-    expect(pic).toBeDefined();
-    const aBlip = pic?.blipFill?.[0]?.["a:blip"]?.[0];
-    expect(aBlip).toBeDefined();
-    const embedVal = aBlip?.$?.["r:embed"];
-    expect(typeof embedVal === "string" && /^rId\d+$/.test(embedVal)).toBeTruthy();
-
-    // --- 4) Check drawing rels exists and references media target
-    const drawingRels = await (ws as any)._zipCache.get("xl/drawings/_rels/drawing1.xml.rels");
-    expect(drawingRels).toBeDefined();
-    const relsArr = drawingRels?.data?.Relationships?.Relationship ?? [];
-    expect(relsArr.some((r: any) => r.$.Target === "../media/image1.png")).toBeTruthy();
-
-    // --- 5) Check worksheet rels has drawing rel added and worksheet xml has <drawing r:id="..."/>
-    const sheetFileName = (ws as any)._targetFileName; // e.g., "sheet1.xml"
-    const sheetRelsPath = `xl/worksheets/_rels/${sheetFileName}.rels`;
-    const sheetRels = await (ws as any)._zipCache.get(sheetRelsPath);
-    expect(sheetRels).toBeDefined();
-    const sheetRelsArr = sheetRels?.data?.Relationships?.Relationship ?? [];
-    expect(
-      sheetRelsArr.some(
-        (r: any) => r.$.Target != null && r.$.Target.indexOf("/drawings/drawing") !== -1,
-      ),
-    ).toBeTruthy();
-
-    const wsXml = await (ws as any)._zipCache.get(`xl/worksheets/${sheetFileName}`);
-    expect(wsXml).toBeDefined();
-    expect(Array.isArray(wsXml.data?.worksheet?.drawing)).toBeTruthy();
-    const drawingElems = wsXml.data.worksheet.drawing;
-    expect(drawingElems.some((d: any) => d.$ != null && d.$["r:id"] != null)).toBeTruthy();
-
-    // Verify buffer creation
-    const resultBuffer = await wb.toBytes();
-    expect(resultBuffer).toBeDefined();
-    expect(resultBuffer.length).toBeGreaterThan(0);
-  });
-
-  it("can insert multiple images into the same worksheet", async () => {
-    const wb = new ExcelWorkbook();
-    const ws = await wb.addWorksheet("Sheet1");
-
-    const bytes = await loadPngFile();
-
-    // Insert first image
-    await ws.addImage({
-      bytes,
-      ext: "png",
-      from: { r: 0, c: 0 },
-      to: { r: 2, c: 2 },
-    });
-
-    // Insert second image (different location)
-    await ws.addImage({
-      bytes,
-      ext: "png",
-      from: { r: 3, c: 0 },
-      to: { r: 5, c: 2 },
-    });
-
-    // --- 1) Check that two media files were created
-    const media1 = await (ws as any)._zipCache.get("xl/media/image1.png");
-    const media2 = await (ws as any)._zipCache.get("xl/media/image2.png");
-    expect(media1).toBeDefined();
-    expect(media2).toBeDefined();
-    expect(media1 instanceof Uint8Array).toBe(true);
-    expect(media2 instanceof Uint8Array).toBe(true);
-
-    // --- 2) Check that both images are registered in Content Types
-    const types = await (ws as any)._zipCache.get("[Content_Types].xml");
-    const overrides = types.data?.Types?.Override ?? [];
-    expect(overrides.some((o: any) => o.$.PartName === "/xl/media/image1.png")).toBeTruthy();
-    expect(overrides.some((o: any) => o.$.PartName === "/xl/media/image2.png")).toBeTruthy();
-
-    // --- 3) Check that drawing xml has two anchors
-    const drawingObj = await (ws as any)._zipCache.get("xl/drawings/drawing1.xml");
-    const anchors = drawingObj?.data?.wsDr?.twoCellAnchor ?? [];
-    expect(anchors.length).toBe(2);
-
-    // First image anchor
-    const pic1 = anchors[0].pic?.[0];
-    expect(pic1).toBeDefined();
-    const embed1 = pic1?.blipFill?.[0]?.["a:blip"]?.[0]?.$?.["r:embed"];
-    expect(embed1).toBeDefined();
-
-    // Second image anchor
-    const pic2 = anchors[1].pic?.[0];
-    expect(pic2).toBeDefined();
-    const embed2 = pic2?.blipFill?.[0]?.["a:blip"]?.[0]?.$?.["r:embed"];
-    expect(embed2).toBeDefined();
-
-    // Check that rIds are different
-    expect(embed1).not.toBe(embed2);
-
-    // --- 4) Check that drawing rels have relationships for both images
-    const drawingRels = await (ws as any)._zipCache.get("xl/drawings/_rels/drawing1.xml.rels");
-    const relsArr = drawingRels?.data?.Relationships?.Relationship ?? [];
-    expect(relsArr.some((r: any) => r.$.Target === "../media/image1.png")).toBeTruthy();
-    expect(relsArr.some((r: any) => r.$.Target === "../media/image2.png")).toBeTruthy();
-
-    // Verify buffer creation
-    const resultBuffer = await wb.toBytes();
-    expect(resultBuffer).toBeDefined();
-    expect(resultBuffer.length).toBeGreaterThan(0);
-  });
-
-  it("throws error for unsupported file extensions", async () => {
-    const wb = new ExcelWorkbook();
-    const ws = await wb.addWorksheet("Sheet1");
-
-    await expect(
-      ws.addImage({
-        bytes: new Uint8Array([0, 1, 2, 3]),
-        ext: "xyz123",
-        from: { r: 0, c: 0 },
-      }),
-    ).rejects.toThrow("Cannot determine MIME type");
-  });
-});

package/tests/utils/excel-utils.spec.ts

@@ -1,198 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { ExcelUtils } from "../../src/utils/excel-utils";
-
-describe("ExcelUtils", () => {
-  describe("stringifyColAddr / parseColAddr", () => {
-    it("converts 26 and above to AA, AB, etc.", () => {
-      expect(ExcelUtils.stringifyColAddr(26)).toBe("AA");
-      expect(ExcelUtils.stringifyColAddr(27)).toBe("AB");
-      expect(ExcelUtils.stringifyColAddr(51)).toBe("AZ");
-      expect(ExcelUtils.stringifyColAddr(52)).toBe("BA");
-    });
-
-    it("handles large column indices", () => {
-      // 702 = AAA (26^2 + 26 = 702)
-      expect(ExcelUtils.stringifyColAddr(702)).toBe("AAA");
-    });
-
-    it("handles Excel maximum column index (XFD, 16383)", () => {
-      // Excel maximum column is XFD (index 16383, 0-based)
-      expect(ExcelUtils.stringifyColAddr(16383)).toBe("XFD");
-      expect(ExcelUtils.parseColAddr("XFD")).toBe(16383);
-    });
-
-    it("round-trip: stringify → parse returns original value", () => {
-      for (let i = 0; i < 100; i++) {
-        const stringified = ExcelUtils.stringifyColAddr(i);
-        const parsed = ExcelUtils.parseColAddr(stringified);
-        expect(parsed).toBe(i);
-      }
-    });
-
-    it("throws error on negative column index input", () => {
-      expect(() => ExcelUtils.stringifyColAddr(-1)).toThrow();
-      expect(() => ExcelUtils.stringifyColAddr(-100)).toThrow();
-    });
-  });
-
-  describe("stringifyRowAddr / parseRowAddr", () => {
-    it("converts 0-based index to 1-based string", () => {
-      expect(ExcelUtils.stringifyRowAddr(0)).toBe("1");
-      expect(ExcelUtils.stringifyRowAddr(9)).toBe("10");
-      expect(ExcelUtils.stringifyRowAddr(99)).toBe("100");
-    });
-
-    it("parses 1-based string to 0-based index", () => {
-      expect(ExcelUtils.parseRowAddr("A1")).toBe(0);
-      expect(ExcelUtils.parseRowAddr("B10")).toBe(9);
-      expect(ExcelUtils.parseRowAddr("AA100")).toBe(99);
-    });
-  });
-
-  describe("stringifyAddr / parseCellAddr", () => {
-    it("correctly converts cell address", () => {
-      expect(ExcelUtils.stringifyAddr({ r: 0, c: 0 })).toBe("A1");
-      expect(ExcelUtils.stringifyAddr({ r: 9, c: 1 })).toBe("B10");
-      expect(ExcelUtils.stringifyAddr({ r: 99, c: 26 })).toBe("AA100");
-    });
-
-    it("correctly parses cell address", () => {
-      expect(ExcelUtils.parseCellAddr("A1")).toEqual({ r: 0, c: 0 });
-      expect(ExcelUtils.parseCellAddr("B10")).toEqual({ r: 9, c: 1 });
-      expect(ExcelUtils.parseCellAddr("AA100")).toEqual({ r: 99, c: 26 });
-    });
-  });
-
-  describe("parseRangeAddr / stringifyRangeAddr", () => {
-    it("parses single cell range", () => {
-      const range = ExcelUtils.parseRangeAddr("A1");
-      expect(range.s).toEqual({ r: 0, c: 0 });
-      expect(range.e).toEqual({ r: 0, c: 0 });
-    });
-
-    it("parses multi-cell range", () => {
-      const range = ExcelUtils.parseRangeAddr("A1:C3");
-      expect(range.s).toEqual({ r: 0, c: 0 });
-      expect(range.e).toEqual({ r: 2, c: 2 });
-    });
-
-    it("converts single cell range to string", () => {
-      const addr = ExcelUtils.stringifyRangeAddr({
-        s: { r: 0, c: 0 },
-        e: { r: 0, c: 0 },
-      });
-      expect(addr).toBe("A1");
-    });
-
-    it("converts multi-cell range to string", () => {
-      const addr = ExcelUtils.stringifyRangeAddr({
-        s: { r: 0, c: 0 },
-        e: { r: 2, c: 2 },
-      });
-      expect(addr).toBe("A1:C3");
-    });
-  });
-
-  describe("convertTimeTickToNumber / convertNumberToTimeTick", () => {
-    it("correctly converts 1970-01-01", () => {
-      const date = new Date(Date.UTC(1970, 0, 1, 0, 0, 0));
-      const tick = date.getTime();
-      const excelNum = ExcelUtils.convertTimeTickToNumber(tick);
-      // 1970-01-01 is 25569 days in Excel's date system
-      expect(excelNum).toBeCloseTo(25569, 0);
-    });
-
-    it("round-trip: tick → number → tick returns original value", () => {
-      const originalDate = new Date(Date.UTC(2024, 5, 15, 14, 30, 45));
-      const tick = originalDate.getTime();
-      const excelNum = ExcelUtils.convertTimeTickToNumber(tick);
-      const recoveredTick = ExcelUtils.convertNumberToTimeTick(excelNum);
-      // May not match exactly to milliseconds, so compare at second level
-      expect(Math.floor(recoveredTick / 1000)).toBe(Math.floor(tick / 1000));
-    });
-  });
-
-  describe("convertNumFmtCodeToName", () => {
-    it("recognizes General as number", () => {
-      expect(ExcelUtils.convertNumFmtCodeToName("General")).toBe("number");
-    });
-
-    it("recognizes date pattern as DateOnly", () => {
-      expect(ExcelUtils.convertNumFmtCodeToName("yyyy-mm-dd")).toBe("DateOnly");
-      expect(ExcelUtils.convertNumFmtCodeToName("yy/mm/dd")).toBe("DateOnly");
-      expect(ExcelUtils.convertNumFmtCodeToName("dd-mmm-yyyy")).toBe("DateOnly");
-    });
-
-    // NOTE: In the current implementation, 'mm' is used in both date (month) and time (minute)
-    // Regex: hasDate = /yy|dd|mm/i, hasTime = /hh|ss/i
-    // Therefore "hh:mm:ss" has hasDate(mm)=true, hasTime(hh,ss)=true → DateTime
-    // "h:mm" has hasDate(mm)=true, hasTime=false (h≠hh) → DateOnly
-    it("handles time pattern (note mm ambiguity)", () => {
-      // "hh:mm:ss": hasDate(mm)=true, hasTime(hh,ss)=true → DateTime
-      expect(ExcelUtils.convertNumFmtCodeToName("hh:mm:ss")).toBe("DateTime");
-      // "h:mm": hasDate(mm)=true, hasTime=false (h≠hh) → DateOnly
-      expect(ExcelUtils.convertNumFmtCodeToName("h:mm")).toBe("DateOnly");
-      // Pure time format (only ss, no mm)
-      expect(ExcelUtils.convertNumFmtCodeToName("[h]:ss")).toBe("Time");
-    });
-
-    it("recognizes date+time pattern as DateTime", () => {
-      expect(ExcelUtils.convertNumFmtCodeToName("yyyy-mm-dd hh:mm:ss")).toBe("DateTime");
-      // "yy/mm/dd h:mm" detects only date (h:mm has no hh and no ss)
-      expect(ExcelUtils.convertNumFmtCodeToName("yy/mm/dd h:mm")).toBe("DateOnly");
-      // Clear DateTime pattern
-      expect(ExcelUtils.convertNumFmtCodeToName("yyyy/mm/dd hh:mm:ss")).toBe("DateTime");
-    });
-
-    it("recognizes number pattern as number", () => {
-      expect(ExcelUtils.convertNumFmtCodeToName("#,##0")).toBe("number");
-      expect(ExcelUtils.convertNumFmtCodeToName("0.00")).toBe("number");
-      expect(ExcelUtils.convertNumFmtCodeToName("#,0")).toBe("number");
-    });
-
-    it("throws error on unknown format code input", () => {
-      expect(() => ExcelUtils.convertNumFmtCodeToName("unknown-format-xyz")).toThrow();
-    });
-  });
-
-  describe("convertNumFmtIdToName", () => {
-    it("recognizes common number formats", () => {
-      expect(ExcelUtils.convertNumFmtIdToName(0)).toBe("number");
-      expect(ExcelUtils.convertNumFmtIdToName(1)).toBe("number");
-      expect(ExcelUtils.convertNumFmtIdToName(2)).toBe("number");
-    });
-
-    it("recognizes date format", () => {
-      expect(ExcelUtils.convertNumFmtIdToName(14)).toBe("DateOnly");
-      expect(ExcelUtils.convertNumFmtIdToName(15)).toBe("DateOnly");
-    });
-
-    it("recognizes date+time format", () => {
-      expect(ExcelUtils.convertNumFmtIdToName(22)).toBe("DateTime");
-    });
-
-    it("recognizes time format", () => {
-      expect(ExcelUtils.convertNumFmtIdToName(18)).toBe("Time");
-      expect(ExcelUtils.convertNumFmtIdToName(19)).toBe("Time");
-    });
-
-    it("recognizes text format", () => {
-      expect(ExcelUtils.convertNumFmtIdToName(49)).toBe("string");
-    });
-
-    it("throws error on unknown numFmtId input", () => {
-      expect(() => ExcelUtils.convertNumFmtIdToName(23)).toThrow();
-      expect(() => ExcelUtils.convertNumFmtIdToName(100)).toThrow();
-    });
-  });
-
-  describe("convertNumFmtNameToId", () => {
-    it("converts format name to ID", () => {
-      expect(ExcelUtils.convertNumFmtNameToId("number")).toBe(0);
-      expect(ExcelUtils.convertNumFmtNameToId("DateOnly")).toBe(14);
-      expect(ExcelUtils.convertNumFmtNameToId("DateTime")).toBe(22);
-      expect(ExcelUtils.convertNumFmtNameToId("Time")).toBe(18);
-      expect(ExcelUtils.convertNumFmtNameToId("string")).toBe(49);
-    });
-  });
-});