@yh-ui/components 0.1.0

package/dist/table/__tests__/use-column-drag.test.cjs

@@ -0,0 +1,238 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _vue = require("vue");
+var _useColumnDrag = require("../src/use-column-drag.cjs");
+(0, _vitest.describe)("useColumnDrag hook", () => {
+  const emit = _vitest.vi.fn();
+  const createMockColumns = () => [{
+    property: "a",
+    title: "A",
+    id: "1"
+  }, {
+    property: "b",
+    title: "B",
+    id: "2"
+  }, {
+    property: "c",
+    title: "C",
+    id: "3",
+    fixed: "left"
+  }, {
+    property: "d",
+    title: "D",
+    id: "4",
+    draggable: false
+  }, {
+    property: "e",
+    title: "E",
+    id: "5",
+    children: [{
+      property: "e1",
+      title: "E1",
+      id: "5-1"
+    }]
+  }];
+  (0, _vitest.it)("isColumnDraggable tests", () => {
+    const columns = (0, _vue.ref)(createMockColumns());
+    const flatColumns = (0, _vue.ref)([]);
+    const dragConfig1 = (0, _vue.ref)(void 0);
+    const hook1 = (0, _useColumnDrag.useColumnDrag)({
+      columns,
+      dragConfig: dragConfig1,
+      flatColumns,
+      emit
+    });
+    (0, _vitest.expect)(hook1.isColumnDraggable(columns.value[0])).toBe(false);
+    const dragConfig2 = (0, _vue.ref)({
+      column: true
+    });
+    const hook2 = (0, _useColumnDrag.useColumnDrag)({
+      columns,
+      dragConfig: dragConfig2,
+      flatColumns,
+      emit
+    });
+    (0, _vitest.expect)(hook2.isColumnDraggable(columns.value[0])).toBe(true);
+    (0, _vitest.expect)(hook2.isColumnDraggable(columns.value[2])).toBe(false);
+    (0, _vitest.expect)(hook2.isColumnDraggable(columns.value[3])).toBe(false);
+  });
+  (0, _vitest.it)("should handle drag events correctly", () => {
+    const columns = (0, _vue.ref)(createMockColumns());
+    const flatColumns = (0, _vue.ref)([...columns.value]);
+    const onDragStart = _vitest.vi.fn();
+    const onDragEnd = _vitest.vi.fn();
+    const dragConfig = (0, _vue.ref)({
+      column: true,
+      onDragStart,
+      onDragEnd
+    });
+    const hook = (0, _useColumnDrag.useColumnDrag)({
+      columns,
+      dragConfig,
+      flatColumns,
+      emit
+    });
+    const attrs0 = hook.getHeaderDragAttrs(columns.value[0], 0);
+    const attrs1 = hook.getHeaderDragAttrs(columns.value[1], 1);
+    const attrs3 = hook.getHeaderDragAttrs(columns.value[3], 3);
+    (0, _vitest.expect)(attrs3).toEqual({});
+    const mockTarget = document.createElement("div");
+    Object.defineProperty(mockTarget, "offsetX", {
+      value: 10,
+      writable: true
+    });
+    Object.defineProperty(mockTarget, "offsetY", {
+      value: 10,
+      writable: true
+    });
+    const mockDataTransfer = {
+      effectAllowed: "",
+      dropEffect: "",
+      setData: _vitest.vi.fn(),
+      setDragImage: _vitest.vi.fn()
+    };
+    const dragStartEvent = {
+      preventDefault: _vitest.vi.fn(),
+      dataTransfer: mockDataTransfer,
+      target: mockTarget,
+      offsetX: 10,
+      offsetY: 10
+    };
+    attrs0.onDragstart(dragStartEvent);
+    (0, _vitest.expect)(hook.isDraggingColumn.value).toBe(true);
+    (0, _vitest.expect)(hook.dragColumnIndex.value).toBe(0);
+    (0, _vitest.expect)(mockDataTransfer.setData).toHaveBeenCalledWith("text/plain", "0");
+    (0, _vitest.expect)(onDragStart).toHaveBeenCalled();
+    (0, _vitest.expect)(hook.getHeaderDragClass(0)).toContain("is-column-dragging");
+    const dragEnterEvent = {
+      preventDefault: _vitest.vi.fn(),
+      dataTransfer: mockDataTransfer
+    };
+    attrs1.onDragenter(dragEnterEvent);
+    (0, _vitest.expect)(hook.dropColumnIndex.value).toBe(1);
+    const dragOverEvent = {
+      preventDefault: _vitest.vi.fn(),
+      dataTransfer: mockDataTransfer
+    };
+    attrs1.onDragover(dragOverEvent);
+    (0, _vitest.expect)(mockDataTransfer.dropEffect).toBe("move");
+    (0, _vitest.expect)(hook.getHeaderDragClass(1)).toContain("is-column-drop-right");
+    const dropEvent = {
+      preventDefault: _vitest.vi.fn(),
+      dataTransfer: mockDataTransfer
+    };
+    attrs1.onDrop(dropEvent);
+    (0, _vitest.expect)(hook.isDraggingColumn.value).toBe(false);
+    (0, _vitest.expect)(emit).toHaveBeenCalledWith("drag-end", _vitest.expect.any(Object));
+    (0, _vitest.expect)(onDragEnd).toHaveBeenCalled();
+    (0, _vitest.expect)(columns.value[0].property).toBe("b");
+    (0, _vitest.expect)(columns.value[1].property).toBe("a");
+  });
+  (0, _vitest.it)("drop should do nothing if drop on same element", () => {
+    const columns = (0, _vue.ref)(createMockColumns());
+    const flatColumns = (0, _vue.ref)([...columns.value]);
+    const dragConfig = (0, _vue.ref)({
+      column: true
+    });
+    const hook = (0, _useColumnDrag.useColumnDrag)({
+      columns,
+      dragConfig,
+      flatColumns,
+      emit
+    });
+    const attrs0 = hook.getHeaderDragAttrs(columns.value[0], 0);
+    const mockEvent = {
+      preventDefault: _vitest.vi.fn(),
+      dataTransfer: {
+        setData: _vitest.vi.fn(),
+        setDragImage: _vitest.vi.fn()
+      }
+    };
+    attrs0.onDragstart(mockEvent);
+    attrs0.onDrop(mockEvent);
+    (0, _vitest.expect)(columns.value[0].property).toBe("a");
+  });
+  (0, _vitest.it)("dragEnd should reset state", () => {
+    const columns = (0, _vue.ref)(createMockColumns());
+    const flatColumns = (0, _vue.ref)([...columns.value]);
+    const dragConfig = (0, _vue.ref)({
+      column: true
+    });
+    const hook = (0, _useColumnDrag.useColumnDrag)({
+      columns,
+      dragConfig,
+      flatColumns,
+      emit
+    });
+    const attrs0 = hook.getHeaderDragAttrs(columns.value[0], 0);
+    const mockEvent = {
+      preventDefault: _vitest.vi.fn(),
+      dataTransfer: {
+        setData: _vitest.vi.fn(),
+        setDragImage: _vitest.vi.fn()
+      }
+    };
+    attrs0.onDragstart(mockEvent);
+    (0, _vitest.expect)(hook.isDraggingColumn.value).toBe(true);
+    attrs0.onDragend(mockEvent);
+    (0, _vitest.expect)(hook.isDraggingColumn.value).toBe(false);
+    (0, _vitest.expect)(hook.dragColumnIndex.value).toBe(-1);
+  });
+  (0, _vitest.it)("disabled conditions in events", () => {
+    const columns = (0, _vue.ref)(createMockColumns());
+    const flatColumns = (0, _vue.ref)([...columns.value]);
+    const dragConfig = (0, _vue.ref)({
+      column: true
+    });
+    const hook = (0, _useColumnDrag.useColumnDrag)({
+      columns,
+      dragConfig,
+      flatColumns,
+      emit
+    });
+    const mockEvent = {
+      preventDefault: _vitest.vi.fn()
+    };
+    const attrs2 = hook.getHeaderDragAttrs(columns.value[2], 2);
+    (0, _vitest.expect)(attrs2).toEqual({});
+    hook.isDraggingColumn.value = false;
+    const attrs0 = hook.getHeaderDragAttrs(columns.value[0], 0);
+    attrs0.onDragover(mockEvent);
+    attrs0.onDragenter(mockEvent);
+    attrs0.onDrop(mockEvent);
+    (0, _vitest.expect)(hook.getHeaderDragClass(0)).toBe("");
+  });
+  (0, _vitest.it)("should handle reorder columns with nested children", () => {
+    const columns = (0, _vue.ref)(createMockColumns());
+    const flatColumns = (0, _vue.ref)([columns.value[0],
+    // a
+    columns.value[4],
+    // e (has children)
+    columns.value[4].children[0]
+    // e1
+    ]);
+    const dragConfig = (0, _vue.ref)({
+      column: true
+    });
+    const hook = (0, _useColumnDrag.useColumnDrag)({
+      columns,
+      dragConfig,
+      flatColumns,
+      emit
+    });
+    const attrs0 = hook.getHeaderDragAttrs(flatColumns.value[0], 0);
+    const attrs2 = hook.getHeaderDragAttrs(flatColumns.value[2], 2);
+    const mockEvent = {
+      preventDefault: _vitest.vi.fn(),
+      dataTransfer: {
+        setData: _vitest.vi.fn(),
+        setDragImage: _vitest.vi.fn()
+      }
+    };
+    attrs0.onDragstart(mockEvent);
+    attrs2.onDragenter(mockEvent);
+    attrs2.onDrop(mockEvent);
+    (0, _vitest.expect)(columns.value).toBeTruthy();
+  });
+});

package/dist/table/__tests__/use-column-drag.test.d.ts

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

package/dist/table/__tests__/use-column-drag.test.mjs

@@ -0,0 +1,150 @@
+import { describe, it, expect, vi } from "vitest";
+import { ref } from "vue";
+import { useColumnDrag } from "../src/use-column-drag.mjs";
+describe("useColumnDrag hook", () => {
+  const emit = vi.fn();
+  const createMockColumns = () => [
+    { property: "a", title: "A", id: "1" },
+    { property: "b", title: "B", id: "2" },
+    { property: "c", title: "C", id: "3", fixed: "left" },
+    { property: "d", title: "D", id: "4", draggable: false },
+    { property: "e", title: "E", id: "5", children: [{ property: "e1", title: "E1", id: "5-1" }] }
+  ];
+  it("isColumnDraggable tests", () => {
+    const columns = ref(createMockColumns());
+    const flatColumns = ref([]);
+    const dragConfig1 = ref(void 0);
+    const hook1 = useColumnDrag({ columns, dragConfig: dragConfig1, flatColumns, emit });
+    expect(hook1.isColumnDraggable(columns.value[0])).toBe(false);
+    const dragConfig2 = ref({ column: true });
+    const hook2 = useColumnDrag({ columns, dragConfig: dragConfig2, flatColumns, emit });
+    expect(hook2.isColumnDraggable(columns.value[0])).toBe(true);
+    expect(hook2.isColumnDraggable(columns.value[2])).toBe(false);
+    expect(hook2.isColumnDraggable(columns.value[3])).toBe(false);
+  });
+  it("should handle drag events correctly", () => {
+    const columns = ref(createMockColumns());
+    const flatColumns = ref([...columns.value]);
+    const onDragStart = vi.fn();
+    const onDragEnd = vi.fn();
+    const dragConfig = ref({ column: true, onDragStart, onDragEnd });
+    const hook = useColumnDrag({ columns, dragConfig, flatColumns, emit });
+    const attrs0 = hook.getHeaderDragAttrs(columns.value[0], 0);
+    const attrs1 = hook.getHeaderDragAttrs(columns.value[1], 1);
+    const attrs3 = hook.getHeaderDragAttrs(columns.value[3], 3);
+    expect(attrs3).toEqual({});
+    const mockTarget = document.createElement("div");
+    Object.defineProperty(mockTarget, "offsetX", { value: 10, writable: true });
+    Object.defineProperty(mockTarget, "offsetY", { value: 10, writable: true });
+    const mockDataTransfer = {
+      effectAllowed: "",
+      dropEffect: "",
+      setData: vi.fn(),
+      setDragImage: vi.fn()
+    };
+    const dragStartEvent = {
+      preventDefault: vi.fn(),
+      dataTransfer: mockDataTransfer,
+      target: mockTarget,
+      offsetX: 10,
+      offsetY: 10
+    };
+    attrs0.onDragstart(dragStartEvent);
+    expect(hook.isDraggingColumn.value).toBe(true);
+    expect(hook.dragColumnIndex.value).toBe(0);
+    expect(mockDataTransfer.setData).toHaveBeenCalledWith("text/plain", "0");
+    expect(onDragStart).toHaveBeenCalled();
+    expect(hook.getHeaderDragClass(0)).toContain("is-column-dragging");
+    const dragEnterEvent = {
+      preventDefault: vi.fn(),
+      dataTransfer: mockDataTransfer
+    };
+    attrs1.onDragenter(dragEnterEvent);
+    expect(hook.dropColumnIndex.value).toBe(1);
+    const dragOverEvent = {
+      preventDefault: vi.fn(),
+      dataTransfer: mockDataTransfer
+    };
+    attrs1.onDragover(dragOverEvent);
+    expect(mockDataTransfer.dropEffect).toBe("move");
+    expect(hook.getHeaderDragClass(1)).toContain("is-column-drop-right");
+    const dropEvent = {
+      preventDefault: vi.fn(),
+      dataTransfer: mockDataTransfer
+    };
+    attrs1.onDrop(dropEvent);
+    expect(hook.isDraggingColumn.value).toBe(false);
+    expect(emit).toHaveBeenCalledWith("drag-end", expect.any(Object));
+    expect(onDragEnd).toHaveBeenCalled();
+    expect(columns.value[0].property).toBe("b");
+    expect(columns.value[1].property).toBe("a");
+  });
+  it("drop should do nothing if drop on same element", () => {
+    const columns = ref(createMockColumns());
+    const flatColumns = ref([...columns.value]);
+    const dragConfig = ref({ column: true });
+    const hook = useColumnDrag({ columns, dragConfig, flatColumns, emit });
+    const attrs0 = hook.getHeaderDragAttrs(columns.value[0], 0);
+    const mockEvent = {
+      preventDefault: vi.fn(),
+      dataTransfer: { setData: vi.fn(), setDragImage: vi.fn() }
+    };
+    attrs0.onDragstart(mockEvent);
+    attrs0.onDrop(mockEvent);
+    expect(columns.value[0].property).toBe("a");
+  });
+  it("dragEnd should reset state", () => {
+    const columns = ref(createMockColumns());
+    const flatColumns = ref([...columns.value]);
+    const dragConfig = ref({ column: true });
+    const hook = useColumnDrag({ columns, dragConfig, flatColumns, emit });
+    const attrs0 = hook.getHeaderDragAttrs(columns.value[0], 0);
+    const mockEvent = {
+      preventDefault: vi.fn(),
+      dataTransfer: { setData: vi.fn(), setDragImage: vi.fn() }
+    };
+    attrs0.onDragstart(mockEvent);
+    expect(hook.isDraggingColumn.value).toBe(true);
+    attrs0.onDragend(mockEvent);
+    expect(hook.isDraggingColumn.value).toBe(false);
+    expect(hook.dragColumnIndex.value).toBe(-1);
+  });
+  it("disabled conditions in events", () => {
+    const columns = ref(createMockColumns());
+    const flatColumns = ref([...columns.value]);
+    const dragConfig = ref({ column: true });
+    const hook = useColumnDrag({ columns, dragConfig, flatColumns, emit });
+    const mockEvent = { preventDefault: vi.fn() };
+    const attrs2 = hook.getHeaderDragAttrs(columns.value[2], 2);
+    expect(attrs2).toEqual({});
+    hook.isDraggingColumn.value = false;
+    const attrs0 = hook.getHeaderDragAttrs(columns.value[0], 0);
+    attrs0.onDragover(mockEvent);
+    attrs0.onDragenter(mockEvent);
+    attrs0.onDrop(mockEvent);
+    expect(hook.getHeaderDragClass(0)).toBe("");
+  });
+  it("should handle reorder columns with nested children", () => {
+    const columns = ref(createMockColumns());
+    const flatColumns = ref([
+      columns.value[0],
+      // a
+      columns.value[4],
+      // e (has children)
+      columns.value[4].children[0]
+      // e1
+    ]);
+    const dragConfig = ref({ column: true });
+    const hook = useColumnDrag({ columns, dragConfig, flatColumns, emit });
+    const attrs0 = hook.getHeaderDragAttrs(flatColumns.value[0], 0);
+    const attrs2 = hook.getHeaderDragAttrs(flatColumns.value[2], 2);
+    const mockEvent = {
+      preventDefault: vi.fn(),
+      dataTransfer: { setData: vi.fn(), setDragImage: vi.fn() }
+    };
+    attrs0.onDragstart(mockEvent);
+    attrs2.onDragenter(mockEvent);
+    attrs2.onDrop(mockEvent);
+    expect(columns.value).toBeTruthy();
+  });
+});

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

@@ -0,0 +1,179 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _vue = require("vue");
+var _useTableExport = require("../src/use-table-export.cjs");
+_vitest.vi.mock("@yh-ui/hooks", () => ({
+  useLocale: () => ({
+    t: key => key
+  })
+}));
+(0, _vitest.describe)("useTableExport hook", () => {
+  const mockData = (0, _vue.ref)([{
+    id: 1,
+    name: "Alice",
+    age: 20,
+    active: true
+  }, {
+    id: 2,
+    name: "Bob",
+    age: null,
+    active: false
+  }]);
+  const mockColumns = (0, _vue.ref)([{
+    prop: "id",
+    label: "ID"
+  }, {
+    prop: "name",
+    label: "Name"
+  }, {
+    prop: "age",
+    label: "Age",
+    visible: false
+  }, {
+    prop: "active",
+    label: "Active"
+  }, {
+    label: "Action"
+  }
+  // no prop
+  ]);
+  (0, _vitest.beforeEach)(() => {
+    global.URL.createObjectURL = _vitest.vi.fn().mockReturnValue("blob:mock");
+    global.URL.revokeObjectURL = _vitest.vi.fn();
+  });
+  (0, _vitest.it)("getExportColumns should correctly filter columns", () => {
+    const {
+      getExportColumns
+    } = (0, _useTableExport.useTableExport)(mockData, mockColumns);
+    let cols = getExportColumns();
+    (0, _vitest.expect)(cols.length).toBe(3);
+    (0, _vitest.expect)(cols.map(c => c.prop)).toEqual(["id", "name", "active"]);
+    cols = getExportColumns({
+      visibleOnly: false
+    });
+    (0, _vitest.expect)(cols.length).toBe(4);
+    cols = getExportColumns({
+      columns: ["id"]
+    });
+    (0, _vitest.expect)(cols.length).toBe(1);
+    cols = getExportColumns({
+      excludeColumns: ["active"]
+    });
+    (0, _vitest.expect)(cols.length).toBe(2);
+  });
+  (0, _vitest.it)("toCSV should format correctly", () => {
+    const {
+      toCSV
+    } = (0, _useTableExport.useTableExport)(mockData, mockColumns);
+    const csv = toCSV({
+      showIndex: true,
+      indexTitle: "No."
+    });
+    (0, _vitest.expect)(csv.includes("\uFEFF")).toBe(true);
+    (0, _vitest.expect)(csv.includes("No.,ID,Name,Active")).toBe(true);
+    (0, _vitest.expect)(csv.includes("1,1,Alice")).toBe(true);
+    (0, _vitest.expect)(csv.includes("2,2,Bob")).toBe(true);
+  });
+  (0, _vitest.it)("toTXT should use tab separator", () => {
+    const {
+      toTXT
+    } = (0, _useTableExport.useTableExport)(mockData, mockColumns);
+    const txt = toTXT({
+      bom: false
+    });
+    (0, _vitest.expect)(txt.includes("\uFEFF")).toBe(false);
+    (0, _vitest.expect)(txt.includes("ID	Name	Active")).toBe(true);
+  });
+  (0, _vitest.it)("toJSON should serialize items correctly", () => {
+    const {
+      toJSON
+    } = (0, _useTableExport.useTableExport)(mockData, mockColumns);
+    const jsonStr = toJSON({
+      showIndex: true,
+      indexTitle: "idx",
+      formatCell: (val, col) => col.prop === "id" ? `ID-${val}` : String(val)
+    });
+    const jsonObj = JSON.parse(jsonStr);
+    (0, _vitest.expect)(jsonObj.length).toBe(2);
+    (0, _vitest.expect)(jsonObj[0].idx).toBe(1);
+    (0, _vitest.expect)(jsonObj[0].ID).toBe("ID-1");
+  });
+  (0, _vitest.it)("toXML should wrap with xml tags", () => {
+    const {
+      toXML
+    } = (0, _useTableExport.useTableExport)(mockData, mockColumns);
+    const xml = toXML({
+      showIndex: true,
+      includeHeader: true
+    });
+    (0, _vitest.expect)(xml.includes('<?xml version="1.0" encoding="UTF-8"?>')).toBe(true);
+    (0, _vitest.expect)(xml.includes('<column name="ID" />')).toBe(true);
+    (0, _vitest.expect)(xml.includes("<cell>1</cell>")).toBe(true);
+  });
+  (0, _vitest.it)("toHTML should wrap with html tags", () => {
+    const {
+      toHTML
+    } = (0, _useTableExport.useTableExport)(mockData, mockColumns);
+    const html = toHTML({
+      showIndex: true
+    });
+    (0, _vitest.expect)(html.includes("<!DOCTYPE html>")).toBe(true);
+    (0, _vitest.expect)(html.includes("<th>ID</th>")).toBe(true);
+    (0, _vitest.expect)(html.includes('<td style="text-align:center">1</td>')).toBe(true);
+    (0, _vitest.expect)(html.includes("<td>Alice</td>")).toBe(true);
+  });
+  (0, _vitest.it)("toXLSX should convert properly", () => {
+    const {
+      toXLSX
+    } = (0, _useTableExport.useTableExport)(mockData, mockColumns);
+    const buffer = toXLSX({
+      showIndex: true,
+      sheetName: "TestSheet",
+      columnWidths: {
+        name: 20
+      },
+      autoWidth: true,
+      formatCell: val => `Format:${val}`
+    });
+    (0, _vitest.expect)(buffer).toBeInstanceOf(ArrayBuffer);
+  });
+  (0, _vitest.it)("exportData string mode", async () => {
+    const {
+      exportData
+    } = (0, _useTableExport.useTableExport)(mockData, mockColumns);
+    const resValue = await exportData({
+      type: "json",
+      mode: "string"
+    });
+    (0, _vitest.expect)(typeof resValue).toBe("string");
+    const result = await exportData({
+      type: "csv",
+      beforeExport: () => false
+    });
+    (0, _vitest.expect)(result).toBeUndefined();
+    const xlsxVal = await exportData({
+      type: "xlsx",
+      mode: "string",
+      afterExport: _vitest.vi.fn()
+    });
+    (0, _vitest.expect)(typeof xlsxVal).toBe("string");
+  });
+  (0, _vitest.it)("exportData download mode triggers dom manipulation", async () => {
+    const {
+      exportData
+    } = (0, _useTableExport.useTableExport)(mockData, mockColumns);
+    await exportData({
+      type: "html",
+      filename: "test"
+    });
+    (0, _vitest.expect)(URL.createObjectURL).toHaveBeenCalled();
+    (0, _vitest.expect)(URL.revokeObjectURL).toHaveBeenCalled();
+    await exportData({
+      type: "xlsx",
+      filename: "testXlsx",
+      afterExport: _vitest.vi.fn()
+    });
+    (0, _vitest.expect)(URL.createObjectURL).toHaveBeenCalled();
+  });
+});

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

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

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

@@ -0,0 +1,105 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ref } from "vue";
+import { useTableExport } from "../src/use-table-export.mjs";
+vi.mock("@yh-ui/hooks", () => ({
+  useLocale: () => ({ t: (key) => key })
+}));
+describe("useTableExport hook", () => {
+  const mockData = ref([
+    { id: 1, name: "Alice", age: 20, active: true },
+    { id: 2, name: "Bob", age: null, active: false }
+  ]);
+  const mockColumns = ref([
+    { prop: "id", label: "ID" },
+    { prop: "name", label: "Name" },
+    { prop: "age", label: "Age", visible: false },
+    { prop: "active", label: "Active" },
+    { label: "Action" }
+    // no prop
+  ]);
+  beforeEach(() => {
+    global.URL.createObjectURL = vi.fn().mockReturnValue("blob:mock");
+    global.URL.revokeObjectURL = vi.fn();
+  });
+  it("getExportColumns should correctly filter columns", () => {
+    const { getExportColumns } = useTableExport(mockData, mockColumns);
+    let cols = getExportColumns();
+    expect(cols.length).toBe(3);
+    expect(cols.map((c) => c.prop)).toEqual(["id", "name", "active"]);
+    cols = getExportColumns({ visibleOnly: false });
+    expect(cols.length).toBe(4);
+    cols = getExportColumns({ columns: ["id"] });
+    expect(cols.length).toBe(1);
+    cols = getExportColumns({ excludeColumns: ["active"] });
+    expect(cols.length).toBe(2);
+  });
+  it("toCSV should format correctly", () => {
+    const { toCSV } = useTableExport(mockData, mockColumns);
+    const csv = toCSV({ showIndex: true, indexTitle: "No." });
+    expect(csv.includes("\uFEFF")).toBe(true);
+    expect(csv.includes("No.,ID,Name,Active")).toBe(true);
+    expect(csv.includes("1,1,Alice")).toBe(true);
+    expect(csv.includes("2,2,Bob")).toBe(true);
+  });
+  it("toTXT should use tab separator", () => {
+    const { toTXT } = useTableExport(mockData, mockColumns);
+    const txt = toTXT({ bom: false });
+    expect(txt.includes("\uFEFF")).toBe(false);
+    expect(txt.includes("ID	Name	Active")).toBe(true);
+  });
+  it("toJSON should serialize items correctly", () => {
+    const { toJSON } = useTableExport(mockData, mockColumns);
+    const jsonStr = toJSON({
+      showIndex: true,
+      indexTitle: "idx",
+      formatCell: (val, col) => col.prop === "id" ? `ID-${val}` : String(val)
+    });
+    const jsonObj = JSON.parse(jsonStr);
+    expect(jsonObj.length).toBe(2);
+    expect(jsonObj[0].idx).toBe(1);
+    expect(jsonObj[0].ID).toBe("ID-1");
+  });
+  it("toXML should wrap with xml tags", () => {
+    const { toXML } = useTableExport(mockData, mockColumns);
+    const xml = toXML({ showIndex: true, includeHeader: true });
+    expect(xml.includes('<?xml version="1.0" encoding="UTF-8"?>')).toBe(true);
+    expect(xml.includes('<column name="ID" />')).toBe(true);
+    expect(xml.includes("<cell>1</cell>")).toBe(true);
+  });
+  it("toHTML should wrap with html tags", () => {
+    const { toHTML } = useTableExport(mockData, mockColumns);
+    const html = toHTML({ showIndex: true });
+    expect(html.includes("<!DOCTYPE html>")).toBe(true);
+    expect(html.includes("<th>ID</th>")).toBe(true);
+    expect(html.includes('<td style="text-align:center">1</td>')).toBe(true);
+    expect(html.includes("<td>Alice</td>")).toBe(true);
+  });
+  it("toXLSX should convert properly", () => {
+    const { toXLSX } = useTableExport(mockData, mockColumns);
+    const buffer = toXLSX({
+      showIndex: true,
+      sheetName: "TestSheet",
+      columnWidths: { name: 20 },
+      autoWidth: true,
+      formatCell: (val) => `Format:${val}`
+    });
+    expect(buffer).toBeInstanceOf(ArrayBuffer);
+  });
+  it("exportData string mode", async () => {
+    const { exportData } = useTableExport(mockData, mockColumns);
+    const resValue = await exportData({ type: "json", mode: "string" });
+    expect(typeof resValue).toBe("string");
+    const result = await exportData({ type: "csv", beforeExport: () => false });
+    expect(result).toBeUndefined();
+    const xlsxVal = await exportData({ type: "xlsx", mode: "string", afterExport: vi.fn() });
+    expect(typeof xlsxVal).toBe("string");
+  });
+  it("exportData download mode triggers dom manipulation", async () => {
+    const { exportData } = useTableExport(mockData, mockColumns);
+    await exportData({ type: "html", filename: "test" });
+    expect(URL.createObjectURL).toHaveBeenCalled();
+    expect(URL.revokeObjectURL).toHaveBeenCalled();
+    await exportData({ type: "xlsx", filename: "testXlsx", afterExport: vi.fn() });
+    expect(URL.createObjectURL).toHaveBeenCalled();
+  });
+});