@yh-ui/components 0.1.0

package/dist/table/__tests__/use-table-import.test.cjs

@@ -0,0 +1,200 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _vue = require("vue");
+var _useTableImport = require("../src/use-table-import.cjs");
+_vitest.vi.mock("@yh-ui/hooks", () => ({
+  useLocale: () => ({
+    t: key => key
+  })
+}));
+(0, _vitest.describe)("useTableImport hook", () => {
+  const mockData = (0, _vue.ref)([]);
+  const mockColumns = (0, _vue.ref)([{
+    prop: "id",
+    label: "ID"
+  }, {
+    prop: "name",
+    label: "Name"
+  }, {
+    prop: "age",
+    label: "Age"
+  }]);
+  (0, _vitest.it)("parseCSV / parseTXT should map rows correctly", () => {
+    const {
+      parseCSV,
+      parseTXT
+    } = (0, _useTableImport.useTableImport)(mockData, mockColumns);
+    const csvContent = `ID,Name,Age
+1,Alice,20
+2,"Bob, Jr.",`;
+    const rows = parseCSV(csvContent, {
+      numberFields: ["id", "age"]
+    });
+    (0, _vitest.expect)(rows.length).toBe(2);
+    (0, _vitest.expect)(rows[0].id).toBe(1);
+    (0, _vitest.expect)(rows[0].name).toBe("Alice");
+    (0, _vitest.expect)(rows[0].age).toBe(20);
+    (0, _vitest.expect)(rows[1].id).toBe(2);
+    (0, _vitest.expect)(rows[1].name).toBe("Bob, Jr.");
+    (0, _vitest.expect)(rows[1].age).toBe(0);
+    const txtContent = `ID	Name	Age
+1	Alice	20`;
+    const rowsTxt = parseTXT(txtContent);
+    (0, _vitest.expect)(rowsTxt.length).toBe(1);
+    (0, _vitest.expect)(rowsTxt[0].id).toBe("1");
+  });
+  (0, _vitest.it)("parseJSON should handle arrays and objects", () => {
+    const {
+      parseJSON
+    } = (0, _useTableImport.useTableImport)(mockData, mockColumns);
+    let rows = parseJSON('[{"ID": 1, "Name": "Alice"}]', {
+      autoMapping: true
+    });
+    (0, _vitest.expect)(rows[0].id).toBe(1);
+    rows = parseJSON('{"ID": 2, "Name": "Bob"}', {
+      fieldMapping: {
+        ID: "id",
+        Name: "name"
+      }
+    });
+    (0, _vitest.expect)(rows[0].id).toBe(2);
+    rows = parseJSON("invalid-json");
+    (0, _vitest.expect)(rows.length).toBe(0);
+  });
+  (0, _vitest.it)("parseXML should parse standard format", () => {
+    const {
+      parseXML
+    } = (0, _useTableImport.useTableImport)(mockData, mockColumns);
+    const xml = `
+      <table>
+        <columns>
+          <column name="ID"/>
+          <column name="Name"/>
+        </columns>
+        <rows>
+          <row><cell>1</cell><cell>Alice</cell></row>
+        </rows>
+      </table>
+    `;
+    const rows = parseXML(xml);
+    (0, _vitest.expect)(rows.length).toBe(1);
+    (0, _vitest.expect)(rows[0].id).toBe("1");
+    (0, _vitest.expect)(rows[0].name).toBe("Alice");
+    const domParserSpy = _vitest.vi.spyOn(DOMParser.prototype, "parseFromString").mockImplementationOnce(() => {
+      throw new Error("error");
+    });
+    (0, _vitest.expect)(parseXML("bad")).toEqual([]);
+    domParserSpy.mockRestore();
+  });
+  (0, _vitest.it)("parseHTML should parse standard format", () => {
+    const {
+      parseHTML
+    } = (0, _useTableImport.useTableImport)(mockData, mockColumns);
+    const html = `
+      <table>
+        <thead><tr><th>ID</th><th>Name</th></tr></thead>
+        <tbody>
+          <tr><td>1</td><td>Alice</td></tr>
+        </tbody>
+      </table>
+    `;
+    const rows = parseHTML(html);
+    (0, _vitest.expect)(rows.length).toBe(1);
+    (0, _vitest.expect)(rows[0].id).toBe("1");
+    (0, _vitest.expect)(rows[0].name).toBe("Alice");
+    const domParserSpy = _vitest.vi.spyOn(DOMParser.prototype, "parseFromString").mockImplementationOnce(() => {
+      throw new Error("error");
+    });
+    (0, _vitest.expect)(parseHTML("bad")).toEqual([]);
+    domParserSpy.mockRestore();
+  });
+  (0, _vitest.it)("parseXLSX should handle ArrayBuffer", () => {
+    const {
+      parseXLSX
+    } = (0, _useTableImport.useTableImport)(mockData, mockColumns);
+    const result = parseXLSX(new ArrayBuffer(10));
+    (0, _vitest.expect)(result).toEqual([]);
+  });
+  (0, _vitest.it)("importData should apply rows", async () => {
+    const dataRef = (0, _vue.ref)([{
+      existing: true
+    }]);
+    const {
+      importData
+    } = (0, _useTableImport.useTableImport)(dataRef, mockColumns);
+    await importData([{
+      added: true
+    }]);
+    (0, _vitest.expect)(dataRef.value.length).toBe(2);
+    (0, _vitest.expect)(dataRef.value[1].added).toBe(true);
+    await importData("ID,Name\n1,Alice", {
+      type: "csv"
+    });
+    (0, _vitest.expect)(dataRef.value.length).toBe(3);
+    (0, _vitest.expect)(dataRef.value[2].id).toBe("1");
+    await importData([{
+      top: true
+    }], {
+      mode: "insertTop"
+    });
+    (0, _vitest.expect)(dataRef.value[0].top).toBe(true);
+    await importData([{
+      cover: true
+    }], {
+      mode: "covering"
+    });
+    (0, _vitest.expect)(dataRef.value.length).toBe(1);
+    (0, _vitest.expect)(dataRef.value[0].cover).toBe(true);
+    const beforeImport = _vitest.vi.fn().mockResolvedValue([{
+      changed: true
+    }]);
+    await importData([{
+      original: true
+    }], {
+      beforeImport
+    });
+    (0, _vitest.expect)(dataRef.value[1].changed).toBe(true);
+  });
+  (0, _vitest.it)("importFile using FileReader", async () => {
+    const dataRef = (0, _vue.ref)([]);
+    const {
+      importFile
+    } = (0, _useTableImport.useTableImport)(dataRef, mockColumns);
+    const fakeFile = new File(["ID,Name\n1,Alice"], "test.csv", {
+      type: "text/csv"
+    });
+    const prom = importFile(fakeFile);
+    const rows = await prom;
+    (0, _vitest.expect)(rows.length).toBe(1);
+    (0, _vitest.expect)(rows[0].id).toBe("1");
+    (0, _vitest.expect)(dataRef.value.length).toBe(1);
+  });
+  (0, _vitest.it)("openImport should open file dialog", async () => {
+    const {
+      openImport
+    } = (0, _useTableImport.useTableImport)(mockData, mockColumns);
+    const oldCreate = document.createElement;
+    document.createElement = _vitest.vi.fn().mockImplementation(tag => {
+      if (tag === "input") {
+        return {
+          click() {
+            if (this.onchange) {
+              this.onchange({
+                target: {
+                  files: []
+                }
+              });
+            }
+          }
+        };
+      }
+      return oldCreate.call(document, tag);
+    });
+    const res = await openImport({
+      type: "csv"
+    });
+    (0, _vitest.expect)(res).toEqual([]);
+    document.createElement = oldCreate;
+  });
+});

package/dist/table/__tests__/use-table-import.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/table/__tests__/use-table-import.test.mjs

@@ -0,0 +1,137 @@
+import { describe, it, expect, vi } from "vitest";
+import { ref } from "vue";
+import { useTableImport } from "../src/use-table-import.mjs";
+vi.mock("@yh-ui/hooks", () => ({
+  useLocale: () => ({ t: (key) => key })
+}));
+describe("useTableImport hook", () => {
+  const mockData = ref([]);
+  const mockColumns = ref([
+    { prop: "id", label: "ID" },
+    { prop: "name", label: "Name" },
+    { prop: "age", label: "Age" }
+  ]);
+  it("parseCSV / parseTXT should map rows correctly", () => {
+    const { parseCSV, parseTXT } = useTableImport(mockData, mockColumns);
+    const csvContent = `ID,Name,Age
+1,Alice,20
+2,"Bob, Jr.",`;
+    const rows = parseCSV(csvContent, { numberFields: ["id", "age"] });
+    expect(rows.length).toBe(2);
+    expect(rows[0].id).toBe(1);
+    expect(rows[0].name).toBe("Alice");
+    expect(rows[0].age).toBe(20);
+    expect(rows[1].id).toBe(2);
+    expect(rows[1].name).toBe("Bob, Jr.");
+    expect(rows[1].age).toBe(0);
+    const txtContent = `ID	Name	Age
+1	Alice	20`;
+    const rowsTxt = parseTXT(txtContent);
+    expect(rowsTxt.length).toBe(1);
+    expect(rowsTxt[0].id).toBe("1");
+  });
+  it("parseJSON should handle arrays and objects", () => {
+    const { parseJSON } = useTableImport(mockData, mockColumns);
+    let rows = parseJSON('[{"ID": 1, "Name": "Alice"}]', { autoMapping: true });
+    expect(rows[0].id).toBe(1);
+    rows = parseJSON('{"ID": 2, "Name": "Bob"}', { fieldMapping: { ID: "id", Name: "name" } });
+    expect(rows[0].id).toBe(2);
+    rows = parseJSON("invalid-json");
+    expect(rows.length).toBe(0);
+  });
+  it("parseXML should parse standard format", () => {
+    const { parseXML } = useTableImport(mockData, mockColumns);
+    const xml = `
+      <table>
+        <columns>
+          <column name="ID"/>
+          <column name="Name"/>
+        </columns>
+        <rows>
+          <row><cell>1</cell><cell>Alice</cell></row>
+        </rows>
+      </table>
+    `;
+    const rows = parseXML(xml);
+    expect(rows.length).toBe(1);
+    expect(rows[0].id).toBe("1");
+    expect(rows[0].name).toBe("Alice");
+    const domParserSpy = vi.spyOn(DOMParser.prototype, "parseFromString").mockImplementationOnce(() => {
+      throw new Error("error");
+    });
+    expect(parseXML("bad")).toEqual([]);
+    domParserSpy.mockRestore();
+  });
+  it("parseHTML should parse standard format", () => {
+    const { parseHTML } = useTableImport(mockData, mockColumns);
+    const html = `
+      <table>
+        <thead><tr><th>ID</th><th>Name</th></tr></thead>
+        <tbody>
+          <tr><td>1</td><td>Alice</td></tr>
+        </tbody>
+      </table>
+    `;
+    const rows = parseHTML(html);
+    expect(rows.length).toBe(1);
+    expect(rows[0].id).toBe("1");
+    expect(rows[0].name).toBe("Alice");
+    const domParserSpy = vi.spyOn(DOMParser.prototype, "parseFromString").mockImplementationOnce(() => {
+      throw new Error("error");
+    });
+    expect(parseHTML("bad")).toEqual([]);
+    domParserSpy.mockRestore();
+  });
+  it("parseXLSX should handle ArrayBuffer", () => {
+    const { parseXLSX } = useTableImport(mockData, mockColumns);
+    const result = parseXLSX(new ArrayBuffer(10));
+    expect(result).toEqual([]);
+  });
+  it("importData should apply rows", async () => {
+    const dataRef = ref([{ existing: true }]);
+    const { importData } = useTableImport(dataRef, mockColumns);
+    await importData([{ added: true }]);
+    expect(dataRef.value.length).toBe(2);
+    expect(dataRef.value[1].added).toBe(true);
+    await importData("ID,Name\n1,Alice", { type: "csv" });
+    expect(dataRef.value.length).toBe(3);
+    expect(dataRef.value[2].id).toBe("1");
+    await importData([{ top: true }], { mode: "insertTop" });
+    expect(dataRef.value[0].top).toBe(true);
+    await importData([{ cover: true }], { mode: "covering" });
+    expect(dataRef.value.length).toBe(1);
+    expect(dataRef.value[0].cover).toBe(true);
+    const beforeImport = vi.fn().mockResolvedValue([{ changed: true }]);
+    await importData([{ original: true }], { beforeImport });
+    expect(dataRef.value[1].changed).toBe(true);
+  });
+  it("importFile using FileReader", async () => {
+    const dataRef = ref([]);
+    const { importFile } = useTableImport(dataRef, mockColumns);
+    const fakeFile = new File(["ID,Name\n1,Alice"], "test.csv", { type: "text/csv" });
+    const prom = importFile(fakeFile);
+    const rows = await prom;
+    expect(rows.length).toBe(1);
+    expect(rows[0].id).toBe("1");
+    expect(dataRef.value.length).toBe(1);
+  });
+  it("openImport should open file dialog", async () => {
+    const { openImport } = useTableImport(mockData, mockColumns);
+    const oldCreate = document.createElement;
+    document.createElement = vi.fn().mockImplementation((tag) => {
+      if (tag === "input") {
+        return {
+          click() {
+            if (this.onchange) {
+              this.onchange({ target: { files: [] } });
+            }
+          }
+        };
+      }
+      return oldCreate.call(document, tag);
+    });
+    const res = await openImport({ type: "csv" });
+    expect(res).toEqual([]);
+    document.createElement = oldCreate;
+  });
+});

package/dist/table/__tests__/use-table-print.test.cjs

@@ -0,0 +1,190 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _vue = require("vue");
+var _useTablePrint = require("../src/use-table-print.cjs");
+_vitest.vi.mock("@yh-ui/hooks", () => ({
+  useLocale: () => ({
+    t: key => key
+  })
+}));
+(0, _vitest.describe)("useTablePrint hook", () => {
+  const mockData = (0, _vue.ref)([{
+    id: 1,
+    name: "Alice",
+    role: "Admin"
+  }, {
+    id: 2,
+    name: "Bob",
+    role: "User"
+  }, {
+    id: 3,
+    name: "Carol",
+    role: "Guest"
+  }]);
+  const mockColumns = (0, _vue.ref)([{
+    prop: "id",
+    label: "ID",
+    align: "center"
+  }, {
+    prop: "name",
+    label: "Name"
+  }, {
+    prop: "role",
+    label: "Role",
+    visible: false
+  }, {
+    label: "Action"
+  }]);
+  let mockWin;
+  (0, _vitest.beforeEach)(() => {
+    _vitest.vi.clearAllMocks();
+    mockWin = {
+      document: {
+        write: _vitest.vi.fn(),
+        close: _vitest.vi.fn()
+      },
+      print: _vitest.vi.fn(),
+      onload: null
+    };
+    _vitest.vi.spyOn(window, "open").mockImplementation(() => mockWin);
+  });
+  (0, _vitest.it)("getPrintColumns checks visibility and includes/excludes", () => {
+    const {
+      getPrintColumns
+    } = (0, _useTablePrint.useTablePrint)(mockData, mockColumns);
+    let cols = getPrintColumns();
+    (0, _vitest.expect)(cols.length).toBe(2);
+    (0, _vitest.expect)(cols[0].prop).toBe("id");
+    (0, _vitest.expect)(cols[1].prop).toBe("name");
+    cols = getPrintColumns({
+      columns: ["id", "role"]
+    });
+    (0, _vitest.expect)(cols.length).toBe(1);
+    cols = getPrintColumns({
+      excludeColumns: ["name"]
+    });
+    (0, _vitest.expect)(cols.length).toBe(1);
+    (0, _vitest.expect)(cols[0].prop).toBe("id");
+  });
+  (0, _vitest.it)("print should handle different configs", async () => {
+    const {
+      print
+    } = (0, _useTablePrint.useTablePrint)(mockData, mockColumns);
+    await print({
+      title: "Report",
+      showIndex: true,
+      pageSize: 2,
+      showPageNumber: true,
+      extraCss: ".custom { color: red }",
+      tableStyle: "border: 1px solid black",
+      headerHtml: "<p>Header</p>",
+      footerHtml: "<p>Footer</p>",
+      formatCell: (val, col) => col.prop === "id" ? `ID-${val}` : String(val),
+      columnTitles: {
+        name: "Full Name"
+      },
+      autoPrint: true
+    });
+    (0, _vitest.expect)(window.open).toHaveBeenCalled();
+    (0, _vitest.expect)(mockWin.document.write).toHaveBeenCalled();
+    const html = mockWin.document.write.mock.calls[0][0];
+    (0, _vitest.expect)(html).toContain("Full Name");
+    (0, _vitest.expect)(html).toContain("ID-1");
+    (0, _vitest.expect)(html).toContain("Report");
+    (0, _vitest.expect)(html).toContain("Header");
+    (0, _vitest.expect)(html).toContain("Footer");
+    (0, _vitest.expect)(html).toContain("page-break");
+    if (mockWin.onload) {
+      mockWin.onload();
+      (0, _vitest.expect)(mockWin.print).toHaveBeenCalled();
+    }
+  });
+  (0, _vitest.it)("print aborted if beforePrint returns false", async () => {
+    const {
+      print
+    } = (0, _useTablePrint.useTablePrint)(mockData, mockColumns);
+    const beforePrint = _vitest.vi.fn().mockReturnValue(false);
+    await print({
+      beforePrint
+    });
+    (0, _vitest.expect)(window.open).not.toHaveBeenCalled();
+  });
+  (0, _vitest.it)("printMultiple handles multiple tables", async () => {
+    const {
+      printMultiple
+    } = (0, _useTablePrint.useTablePrint)(mockData, mockColumns);
+    const afterPrint = _vitest.vi.fn();
+    await printMultiple([{
+      title: "Table 1",
+      data: [{
+        a: 1
+      }],
+      columns: [{
+        prop: "a",
+        label: "A"
+      }]
+    }, {
+      title: "Table 2",
+      data: [{
+        b: 2
+      }]
+      // Use fallback columns from hook
+    }], {
+      orientation: "landscape",
+      margin: {
+        top: "5mm",
+        bottom: "5mm",
+        left: "5mm",
+        right: "5mm"
+      },
+      showTime: false,
+      showCount: false,
+      afterPrint
+    });
+    (0, _vitest.expect)(window.open).toHaveBeenCalled();
+    const html = mockWin.document.write.mock.calls[0][0];
+    (0, _vitest.expect)(html).toContain("Table 1");
+    (0, _vitest.expect)(html).toContain("Table 2");
+    (0, _vitest.expect)(html).toContain("landscape");
+    (0, _vitest.expect)(afterPrint).toHaveBeenCalled();
+  });
+  (0, _vitest.it)("printMultiple aborted if global beforePrint returns false", async () => {
+    const {
+      printMultiple
+    } = (0, _useTablePrint.useTablePrint)(mockData, mockColumns);
+    await printMultiple([], {
+      beforePrint: () => false
+    });
+    (0, _vitest.expect)(window.open).not.toHaveBeenCalled();
+  });
+  (0, _vitest.it)("printTemplate pushes raw html", async () => {
+    const {
+      printTemplate
+    } = (0, _useTablePrint.useTablePrint)(mockData, mockColumns);
+    await printTemplate('<div id="custom-template">OK</div>', {
+      autoPrint: true
+    });
+    (0, _vitest.expect)(window.open).toHaveBeenCalled();
+    const html = mockWin.document.write.mock.calls[0][0];
+    (0, _vitest.expect)(html).toContain("custom-template");
+    if (mockWin.onload) mockWin.onload();
+    (0, _vitest.expect)(mockWin.print).toHaveBeenCalled();
+  });
+  (0, _vitest.it)("printTemplate aborted if beforePrint returns false", async () => {
+    const {
+      printTemplate
+    } = (0, _useTablePrint.useTablePrint)(mockData, mockColumns);
+    await printTemplate('<div id="custom-template">OK</div>', {
+      beforePrint: () => false
+    });
+    (0, _vitest.expect)(window.open).not.toHaveBeenCalled();
+  });
+  (0, _vitest.it)("covers null window.open", async () => {
+    _vitest.vi.spyOn(window, "open").mockReturnValueOnce(null);
+    const {
+      print
+    } = (0, _useTablePrint.useTablePrint)(mockData, mockColumns);
+    await print();
+  });
+});

package/dist/table/__tests__/use-table-print.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/table/__tests__/use-table-print.test.mjs

@@ -0,0 +1,134 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ref } from "vue";
+import { useTablePrint } from "../src/use-table-print.mjs";
+vi.mock("@yh-ui/hooks", () => ({
+  useLocale: () => ({ t: (key) => key })
+}));
+describe("useTablePrint hook", () => {
+  const mockData = ref([
+    { id: 1, name: "Alice", role: "Admin" },
+    { id: 2, name: "Bob", role: "User" },
+    { id: 3, name: "Carol", role: "Guest" }
+  ]);
+  const mockColumns = ref([
+    { prop: "id", label: "ID", align: "center" },
+    { prop: "name", label: "Name" },
+    { prop: "role", label: "Role", visible: false },
+    { label: "Action" }
+  ]);
+  let mockWin;
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockWin = {
+      document: {
+        write: vi.fn(),
+        close: vi.fn()
+      },
+      print: vi.fn(),
+      onload: null
+    };
+    vi.spyOn(window, "open").mockImplementation(() => mockWin);
+  });
+  it("getPrintColumns checks visibility and includes/excludes", () => {
+    const { getPrintColumns } = useTablePrint(mockData, mockColumns);
+    let cols = getPrintColumns();
+    expect(cols.length).toBe(2);
+    expect(cols[0].prop).toBe("id");
+    expect(cols[1].prop).toBe("name");
+    cols = getPrintColumns({ columns: ["id", "role"] });
+    expect(cols.length).toBe(1);
+    cols = getPrintColumns({ excludeColumns: ["name"] });
+    expect(cols.length).toBe(1);
+    expect(cols[0].prop).toBe("id");
+  });
+  it("print should handle different configs", async () => {
+    const { print } = useTablePrint(mockData, mockColumns);
+    await print({
+      title: "Report",
+      showIndex: true,
+      pageSize: 2,
+      showPageNumber: true,
+      extraCss: ".custom { color: red }",
+      tableStyle: "border: 1px solid black",
+      headerHtml: "<p>Header</p>",
+      footerHtml: "<p>Footer</p>",
+      formatCell: (val, col) => col.prop === "id" ? `ID-${val}` : String(val),
+      columnTitles: { name: "Full Name" },
+      autoPrint: true
+    });
+    expect(window.open).toHaveBeenCalled();
+    expect(mockWin.document.write).toHaveBeenCalled();
+    const html = mockWin.document.write.mock.calls[0][0];
+    expect(html).toContain("Full Name");
+    expect(html).toContain("ID-1");
+    expect(html).toContain("Report");
+    expect(html).toContain("Header");
+    expect(html).toContain("Footer");
+    expect(html).toContain("page-break");
+    if (mockWin.onload) {
+      mockWin.onload();
+      expect(mockWin.print).toHaveBeenCalled();
+    }
+  });
+  it("print aborted if beforePrint returns false", async () => {
+    const { print } = useTablePrint(mockData, mockColumns);
+    const beforePrint = vi.fn().mockReturnValue(false);
+    await print({ beforePrint });
+    expect(window.open).not.toHaveBeenCalled();
+  });
+  it("printMultiple handles multiple tables", async () => {
+    const { printMultiple } = useTablePrint(mockData, mockColumns);
+    const afterPrint = vi.fn();
+    await printMultiple(
+      [
+        {
+          title: "Table 1",
+          data: [{ a: 1 }],
+          columns: [{ prop: "a", label: "A" }]
+        },
+        {
+          title: "Table 2",
+          data: [{ b: 2 }]
+          // Use fallback columns from hook
+        }
+      ],
+      {
+        orientation: "landscape",
+        margin: { top: "5mm", bottom: "5mm", left: "5mm", right: "5mm" },
+        showTime: false,
+        showCount: false,
+        afterPrint
+      }
+    );
+    expect(window.open).toHaveBeenCalled();
+    const html = mockWin.document.write.mock.calls[0][0];
+    expect(html).toContain("Table 1");
+    expect(html).toContain("Table 2");
+    expect(html).toContain("landscape");
+    expect(afterPrint).toHaveBeenCalled();
+  });
+  it("printMultiple aborted if global beforePrint returns false", async () => {
+    const { printMultiple } = useTablePrint(mockData, mockColumns);
+    await printMultiple([], { beforePrint: () => false });
+    expect(window.open).not.toHaveBeenCalled();
+  });
+  it("printTemplate pushes raw html", async () => {
+    const { printTemplate } = useTablePrint(mockData, mockColumns);
+    await printTemplate('<div id="custom-template">OK</div>', { autoPrint: true });
+    expect(window.open).toHaveBeenCalled();
+    const html = mockWin.document.write.mock.calls[0][0];
+    expect(html).toContain("custom-template");
+    if (mockWin.onload) mockWin.onload();
+    expect(mockWin.print).toHaveBeenCalled();
+  });
+  it("printTemplate aborted if beforePrint returns false", async () => {
+    const { printTemplate } = useTablePrint(mockData, mockColumns);
+    await printTemplate('<div id="custom-template">OK</div>', { beforePrint: () => false });
+    expect(window.open).not.toHaveBeenCalled();
+  });
+  it("covers null window.open", async () => {
+    vi.spyOn(window, "open").mockReturnValueOnce(null);
+    const { print } = useTablePrint(mockData, mockColumns);
+    await print();
+  });
+});