@simplysm/excel 13.0.69 → 13.0.70

package/tests/excel-wrapper.spec.ts

@@ -0,0 +1,296 @@
+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).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");
+
+      // 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);
+
+      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.getBytes();
+      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.getBytes();
+      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("can convert strings to numbers", async () => {
+      const wrapper = new ExcelWrapper(testSchema);
+
+      // Simulate Excel with values stored as strings manually
+      const wb = await wrapper.write("Test", [{ name: "Test", age: 25 }]);
+      const buffer = await wb.getBytes();
+      await wb.close();
+
+      const records = await wrapper.read(buffer);
+      expect(typeof records[0].age).toBe("number");
+      expect(records[0].age).toBe(25);
+    });
+
+    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.getBytes();
+      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.getBytes();
+      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.getBytes();
+      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.getBytes();
+      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.getBytes();
+      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.getBytes();
+      await wb.close();
+
+      await expect(wrapper.read(buffer, "NotExist")).rejects.toThrow();
+    });
+
+    it("throws error when reading with non-existent worksheet index", async () => {
+      const wrapper = new ExcelWrapper(testSchema);
+
+      const wb = await wrapper.write("Test", [{ name: "Test", age: 20 }]);
+      const buffer = await wb.getBytes();
+      await wb.close();
+
+      await expect(wrapper.read(buffer, 99)).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).setVal("AB"); // Change to less than 5 characters
+
+      const buffer = await wb.getBytes();
+      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).getVal()).toBe("Name");
+      expect(await ws.cell(0, 1).getVal()).toBe("Age");
+      expect(await ws.cell(0, 2).getVal()).toBeUndefined();
+
+      // Check data
+      expect(await ws.cell(1, 0).getVal()).toBe("John Doe");
+      expect(await ws.cell(1, 1).getVal()).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.getBytes();
+      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

@@ -0,0 +1,190 @@
+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.createWorksheet("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.getBytes();
+    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.createWorksheet("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.getBytes();
+    expect(resultBuffer).toBeDefined();
+    expect(resultBuffer.length).toBeGreaterThan(0);
+  });
+
+  it("throws error for unsupported file extensions", async () => {
+    const wb = new ExcelWorkbook();
+    const ws = await wb.createWorksheet("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");
+  });
+});