@frictionless-ts/table 1.0.1

package/build/plugins/xlxs/plugin.spec.js

@@ -0,0 +1,142 @@
+import * as pl from "nodejs-polars";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { XlsxPlugin } from "./plugin.js";
+import * as loadModule from "./table/load.js";
+import * as saveModule from "./table/save.js";
+vi.mock("./table/load.ts", () => ({
+    loadXlsxTable: vi.fn(),
+}));
+vi.mock("./table/save.ts", () => ({
+    saveXlsxTable: vi.fn(),
+}));
+describe("XlsxPlugin", () => {
+    let plugin;
+    let mockLoadXlsxTable;
+    let mockSaveXlsxTable;
+    beforeEach(() => {
+        plugin = new XlsxPlugin();
+        mockLoadXlsxTable = vi.mocked(loadModule.loadXlsxTable);
+        mockSaveXlsxTable = vi.mocked(saveModule.saveXlsxTable);
+        vi.clearAllMocks();
+    });
+    describe("loadTable", () => {
+        it("should load table from xlsx file", async () => {
+            const resource = {
+                path: "test.xlsx",
+            };
+            const mockTable = pl.DataFrame().lazy();
+            mockLoadXlsxTable.mockResolvedValue(mockTable);
+            const result = await plugin.loadTable(resource);
+            expect(mockLoadXlsxTable).toHaveBeenCalledWith(resource, undefined);
+            expect(result).toEqual(mockTable);
+        });
+        it("should return undefined for non-xlsx files", async () => {
+            const resource = {
+                path: "test.csv",
+            };
+            const result = await plugin.loadTable(resource);
+            expect(mockLoadXlsxTable).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should handle explicit format specification", async () => {
+            const resource = {
+                path: "test.txt",
+                format: "xlsx",
+            };
+            const mockTable = pl.DataFrame().lazy();
+            mockLoadXlsxTable.mockResolvedValue(mockTable);
+            const result = await plugin.loadTable(resource);
+            expect(mockLoadXlsxTable).toHaveBeenCalledWith(resource, undefined);
+            expect(result).toEqual(mockTable);
+        });
+        it("should pass through load options", async () => {
+            const resource = {
+                path: "test.xlsx",
+            };
+            const options = { denormalized: true };
+            const mockTable = pl.DataFrame().lazy();
+            mockLoadXlsxTable.mockResolvedValue(mockTable);
+            await plugin.loadTable(resource, options);
+            expect(mockLoadXlsxTable).toHaveBeenCalledWith(resource, options);
+        });
+        it("should handle paths with directories", async () => {
+            const resource = {
+                path: "/path/to/data.xlsx",
+            };
+            const mockTable = pl.DataFrame().lazy();
+            mockLoadXlsxTable.mockResolvedValue(mockTable);
+            await plugin.loadTable(resource);
+            expect(mockLoadXlsxTable).toHaveBeenCalledWith(resource, undefined);
+        });
+        it("should return undefined for ods files", async () => {
+            const resource = {
+                path: "test.ods",
+            };
+            const result = await plugin.loadTable(resource);
+            expect(mockLoadXlsxTable).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should return undefined for json files", async () => {
+            const resource = {
+                path: "test.json",
+            };
+            const result = await plugin.loadTable(resource);
+            expect(mockLoadXlsxTable).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+    });
+    describe("saveTable", () => {
+        it("should save table to xlsx file", async () => {
+            const table = pl.DataFrame().lazy();
+            const options = { path: "output.xlsx" };
+            mockSaveXlsxTable.mockResolvedValue("output.xlsx");
+            const result = await plugin.saveTable(table, options);
+            expect(mockSaveXlsxTable).toHaveBeenCalledWith(table, options);
+            expect(result).toBe("output.xlsx");
+        });
+        it("should return undefined for non-xlsx files", async () => {
+            const table = pl.DataFrame().lazy();
+            const options = { path: "output.csv" };
+            const result = await plugin.saveTable(table, options);
+            expect(mockSaveXlsxTable).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should handle explicit format specification", async () => {
+            const table = pl.DataFrame().lazy();
+            const options = { path: "output.txt", format: "xlsx" };
+            mockSaveXlsxTable.mockResolvedValue("output.txt");
+            const result = await plugin.saveTable(table, options);
+            expect(mockSaveXlsxTable).toHaveBeenCalledWith(table, options);
+            expect(result).toBe("output.txt");
+        });
+        it("should handle paths with directories", async () => {
+            const table = pl.DataFrame().lazy();
+            const options = { path: "/path/to/output.xlsx" };
+            mockSaveXlsxTable.mockResolvedValue("/path/to/output.xlsx");
+            await plugin.saveTable(table, options);
+            expect(mockSaveXlsxTable).toHaveBeenCalledWith(table, options);
+        });
+        it("should return undefined for files without extension", async () => {
+            const table = pl.DataFrame().lazy();
+            const options = { path: "output" };
+            const result = await plugin.saveTable(table, options);
+            expect(mockSaveXlsxTable).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should return undefined for ods files", async () => {
+            const table = pl.DataFrame().lazy();
+            const options = { path: "output.ods" };
+            const result = await plugin.saveTable(table, options);
+            expect(mockSaveXlsxTable).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+        it("should return undefined for json files", async () => {
+            const table = pl.DataFrame().lazy();
+            const options = { path: "output.json" };
+            const result = await plugin.saveTable(table, options);
+            expect(mockSaveXlsxTable).not.toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.spec.js","sourceRoot":"","sources":["../../../plugins/xlxs/plugin.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Resource } from \"@frictionless-ts/metadata\"\nimport * as pl from \"nodejs-polars\"\nimport { beforeEach, describe, expect, it, vi } from \"vitest\"\nimport { XlsxPlugin } from \"./plugin.ts\"\nimport * as loadModule from \"./table/load.ts\"\nimport * as saveModule from \"./table/save.ts\"\n\nvi.mock(\"./table/load.ts\", () => ({\n  loadXlsxTable: vi.fn(),\n}))\n\nvi.mock(\"./table/save.ts\", () => ({\n  saveXlsxTable: vi.fn(),\n}))\n\ndescribe(\"XlsxPlugin\", () => {\n  let plugin: XlsxPlugin\n  let mockLoadXlsxTable: ReturnType<typeof vi.fn>\n  let mockSaveXlsxTable: ReturnType<typeof vi.fn>\n\n  beforeEach(() => {\n    plugin = new XlsxPlugin()\n    mockLoadXlsxTable = vi.mocked(loadModule.loadXlsxTable)\n    mockSaveXlsxTable = vi.mocked(saveModule.saveXlsxTable)\n    vi.clearAllMocks()\n  })\n\n  describe(\"loadTable\", () => {\n    it(\"should load table from xlsx file\", async () => {\n      const resource: Partial<Resource> = {\n        path: \"test.xlsx\",\n      }\n      const mockTable = pl.DataFrame().lazy()\n      mockLoadXlsxTable.mockResolvedValue(mockTable)\n\n      const result = await plugin.loadTable(resource)\n\n      expect(mockLoadXlsxTable).toHaveBeenCalledWith(resource, undefined)\n      expect(result).toEqual(mockTable)\n    })\n\n    it(\"should return undefined for non-xlsx files\", async () => {\n      const resource: Partial<Resource> = {\n        path: \"test.csv\",\n      }\n\n      const result = await plugin.loadTable(resource)\n\n      expect(mockLoadXlsxTable).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n\n    it(\"should handle explicit format specification\", async () => {\n      const resource: Partial<Resource> = {\n        path: \"test.txt\",\n        format: \"xlsx\",\n      }\n      const mockTable = pl.DataFrame().lazy()\n      mockLoadXlsxTable.mockResolvedValue(mockTable)\n\n      const result = await plugin.loadTable(resource)\n\n      expect(mockLoadXlsxTable).toHaveBeenCalledWith(resource, undefined)\n      expect(result).toEqual(mockTable)\n    })\n\n    it(\"should pass through load options\", async () => {\n      const resource: Partial<Resource> = {\n        path: \"test.xlsx\",\n      }\n      const options = { denormalized: true }\n      const mockTable = pl.DataFrame().lazy()\n      mockLoadXlsxTable.mockResolvedValue(mockTable)\n\n      await plugin.loadTable(resource, options)\n\n      expect(mockLoadXlsxTable).toHaveBeenCalledWith(resource, options)\n    })\n\n    it(\"should handle paths with directories\", async () => {\n      const resource: Partial<Resource> = {\n        path: \"/path/to/data.xlsx\",\n      }\n      const mockTable = pl.DataFrame().lazy()\n      mockLoadXlsxTable.mockResolvedValue(mockTable)\n\n      await plugin.loadTable(resource)\n\n      expect(mockLoadXlsxTable).toHaveBeenCalledWith(resource, undefined)\n    })\n\n    it(\"should return undefined for ods files\", async () => {\n      const resource: Partial<Resource> = {\n        path: \"test.ods\",\n      }\n\n      const result = await plugin.loadTable(resource)\n\n      expect(mockLoadXlsxTable).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n\n    it(\"should return undefined for json files\", async () => {\n      const resource: Partial<Resource> = {\n        path: \"test.json\",\n      }\n\n      const result = await plugin.loadTable(resource)\n\n      expect(mockLoadXlsxTable).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n  })\n\n  describe(\"saveTable\", () => {\n    it(\"should save table to xlsx file\", async () => {\n      const table = pl.DataFrame().lazy()\n      const options = { path: \"output.xlsx\" }\n      mockSaveXlsxTable.mockResolvedValue(\"output.xlsx\")\n\n      const result = await plugin.saveTable(table, options)\n\n      expect(mockSaveXlsxTable).toHaveBeenCalledWith(table, options)\n      expect(result).toBe(\"output.xlsx\")\n    })\n\n    it(\"should return undefined for non-xlsx files\", async () => {\n      const table = pl.DataFrame().lazy()\n      const options = { path: \"output.csv\" }\n\n      const result = await plugin.saveTable(table, options)\n\n      expect(mockSaveXlsxTable).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n\n    it(\"should handle explicit format specification\", async () => {\n      const table = pl.DataFrame().lazy()\n      const options = { path: \"output.txt\", format: \"xlsx\" as const }\n      mockSaveXlsxTable.mockResolvedValue(\"output.txt\")\n\n      const result = await plugin.saveTable(table, options)\n\n      expect(mockSaveXlsxTable).toHaveBeenCalledWith(table, options)\n      expect(result).toBe(\"output.txt\")\n    })\n\n    it(\"should handle paths with directories\", async () => {\n      const table = pl.DataFrame().lazy()\n      const options = { path: \"/path/to/output.xlsx\" }\n      mockSaveXlsxTable.mockResolvedValue(\"/path/to/output.xlsx\")\n\n      await plugin.saveTable(table, options)\n\n      expect(mockSaveXlsxTable).toHaveBeenCalledWith(table, options)\n    })\n\n    it(\"should return undefined for files without extension\", async () => {\n      const table = pl.DataFrame().lazy()\n      const options = { path: \"output\" }\n\n      const result = await plugin.saveTable(table, options)\n\n      expect(mockSaveXlsxTable).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n\n    it(\"should return undefined for ods files\", async () => {\n      const table = pl.DataFrame().lazy()\n      const options = { path: \"output.ods\" }\n\n      const result = await plugin.saveTable(table, options)\n\n      expect(mockSaveXlsxTable).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n\n    it(\"should return undefined for json files\", async () => {\n      const table = pl.DataFrame().lazy()\n      const options = { path: \"output.json\" }\n\n      const result = await plugin.saveTable(table, options)\n\n      expect(mockSaveXlsxTable).not.toHaveBeenCalled()\n      expect(result).toBeUndefined()\n    })\n  })\n})\n"]}

package/build/plugins/xlxs/table/index.d.ts

@@ -0,0 +1,2 @@
+export { loadXlsxTable } from "./load.ts";
+export { saveXlsxTable } from "./save.ts";

package/build/plugins/xlxs/table/index.js

@@ -0,0 +1,3 @@
+export { loadXlsxTable } from "./load.js";
+export { saveXlsxTable } from "./save.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wbHVnaW5zL3hseHMvdGFibGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLFdBQVcsQ0FBQTtBQUN6QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sV0FBVyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgbG9hZFhsc3hUYWJsZSB9IGZyb20gXCIuL2xvYWQudHNcIlxuZXhwb3J0IHsgc2F2ZVhsc3hUYWJsZSB9IGZyb20gXCIuL3NhdmUudHNcIlxuIl19

package/build/plugins/xlxs/table/load.d.ts

@@ -0,0 +1,4 @@
+import type { Resource } from "@frictionless-ts/metadata";
+import type { LoadTableOptions } from "../../../plugin.ts";
+import * as pl from "nodejs-polars";
+export declare function loadXlsxTable(resource: Partial<Resource>, options?: LoadTableOptions): Promise<pl.LazyDataFrame<any>>;

package/build/plugins/xlxs/table/load.js

@@ -0,0 +1,43 @@
+import { resolveDialect } from "@frictionless-ts/metadata";
+import { resolveSchema } from "@frictionless-ts/metadata";
+import { loadFile, prefetchFiles } from "@frictionless-ts/dataset";
+import { getRecordsFromRows } from "../../../data/index.js";
+import { inferSchemaFromTable } from "../../../schema/index.js";
+import { normalizeTable } from "../../../table/index.js";
+import * as pl from "nodejs-polars";
+import { read, utils } from "xlsx";
+// Currently, we use slow non-rust implementation as in the future
+// polars-rust might be able to provide a faster native implementation
+export async function loadXlsxTable(resource, options) {
+    const paths = await prefetchFiles(resource.path);
+    if (!paths.length) {
+        throw new Error("Resource path is not defined");
+    }
+    const dialect = await resolveDialect(resource.dialect);
+    const tables = [];
+    for (const path of paths) {
+        const buffer = await loadFile(path);
+        const book = read(buffer, { type: "buffer" });
+        const sheetIndex = dialect?.sheetNumber ? dialect.sheetNumber - 1 : 0;
+        const sheetName = dialect?.sheetName ?? book.SheetNames[sheetIndex];
+        const sheet = sheetName ? book.Sheets[sheetName] : undefined;
+        if (sheet) {
+            const rows = utils.sheet_to_json(sheet, {
+                header: 1,
+                raw: true,
+            });
+            const records = getRecordsFromRows(rows, dialect);
+            const table = pl.DataFrame(records).lazy();
+            tables.push(table);
+        }
+    }
+    let table = pl.concat(tables);
+    if (!options?.denormalized) {
+        let schema = await resolveSchema(resource.schema);
+        if (!schema)
+            schema = await inferSchemaFromTable(table, options);
+        table = await normalizeTable(table, schema);
+    }
+    return table;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/plugins/xlxs/table/load.spec.d.ts

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

package/build/plugins/xlxs/table/load.spec.js

@@ -0,0 +1,167 @@
+import { getTempFilePath } from "@frictionless-ts/dataset";
+import { describe, expect, it } from "vitest";
+import { useRecording } from "vitest-polly";
+import { loadXlsxTable } from "./load.js";
+import { writeTestData } from "./test.js";
+useRecording();
+const row1 = ["id", "name"];
+const row2 = [1, "english"];
+const row3 = [2, "中文"];
+const record1 = { id: 1, name: "english" };
+const record2 = { id: 2, name: "中文" };
+describe("loadXlsxTable", () => {
+    describe("file variations", () => {
+        it("should load local file", async () => {
+            const path = getTempFilePath();
+            await writeTestData(path, [row1, row2, row3]);
+            const table = await loadXlsxTable({ path });
+            expect((await table.collect()).toRecords()).toEqual([record1, record2]);
+        });
+        it("should load local file (multipart)", async () => {
+            const path1 = getTempFilePath();
+            const path2 = getTempFilePath();
+            await writeTestData(path1, [row1, row2, row3]);
+            await writeTestData(path2, [row1, row2, row3]);
+            const table = await loadXlsxTable({ path: [path1, path2] });
+            expect((await table.collect()).toRecords()).toEqual([
+                record1,
+                record2,
+                record1,
+                record2,
+            ]);
+        });
+        it("should load remote file", async () => {
+            const table = await loadXlsxTable({
+                path: "https://raw.githubusercontent.com/datisthq/dpkit/refs/heads/main/xlsx/table/fixtures/table.xlsx",
+            });
+            expect((await table.collect()).toRecords()).toEqual([
+                { id: 1, name: "english" },
+                { id: 2, name: "中文" },
+            ]);
+        });
+        it("should load multipart remote file", async () => {
+            const table = await loadXlsxTable({
+                path: [
+                    "https://raw.githubusercontent.com/datisthq/dpkit/refs/heads/main/xlsx/table/fixtures/table.xlsx",
+                    "https://raw.githubusercontent.com/datisthq/dpkit/refs/heads/main/xlsx/table/fixtures/table.xlsx",
+                ],
+            });
+            expect((await table.collect()).toRecords()).toEqual([
+                { id: 1, name: "english" },
+                { id: 2, name: "中文" },
+                { id: 1, name: "english" },
+                { id: 2, name: "中文" },
+            ]);
+        });
+    });
+    describe("dialect variations", () => {
+        it("should support sheetNumber", async () => {
+            const path = getTempFilePath();
+            await writeTestData(path, [row1, row2, row3], { sheetNumber: 2 });
+            const table = await loadXlsxTable({
+                path,
+                dialect: { sheetNumber: 2 },
+            });
+            expect((await table.collect()).toRecords()).toEqual([record1, record2]);
+        });
+        it("should support sheetName", async () => {
+            const path = getTempFilePath();
+            await writeTestData(path, [row1, row2, row3], { sheetName: "Sheet2" });
+            const table = await loadXlsxTable({
+                path,
+                dialect: { sheetName: "Sheet2" },
+            });
+            expect((await table.collect()).toRecords()).toEqual([record1, record2]);
+        });
+        it("should support no header", async () => {
+            const path = getTempFilePath();
+            await writeTestData(path, [row2, row3]);
+            const table = await loadXlsxTable({
+                path,
+                dialect: { header: false },
+            });
+            expect((await table.collect()).toRecords()).toEqual([
+                { field1: 1, field2: "english" },
+                { field1: 2, field2: "中文" },
+            ]);
+        });
+        it("should support headerRows offset", async () => {
+            const path = getTempFilePath();
+            await writeTestData(path, [row1, row2, row3]);
+            const table = await loadXlsxTable({
+                path,
+                dialect: { headerRows: [2] },
+            });
+            expect((await table.collect()).toRecords()).toEqual([
+                { 1: 2, english: "中文" },
+            ]);
+        });
+        it("should support multiline headerRows", async () => {
+            const path = getTempFilePath();
+            await writeTestData(path, [row1, row2, row3]);
+            const table = await loadXlsxTable({
+                path,
+                dialect: { headerRows: [1, 2] },
+            });
+            expect((await table.collect()).toRecords()).toEqual([
+                { "id 1": 2, "name english": "中文" },
+            ]);
+        });
+        it("should support headerJoin", async () => {
+            const path = getTempFilePath();
+            await writeTestData(path, [row1, row2, row3]);
+            const table = await loadXlsxTable({
+                path,
+                dialect: { headerRows: [1, 2], headerJoin: "-" },
+            });
+            expect((await table.collect()).toRecords()).toEqual([
+                { "id-1": 2, "name-english": "中文" },
+            ]);
+        });
+        it("should support commentRows", async () => {
+            const path = getTempFilePath();
+            await writeTestData(path, [row1, row2, row3]);
+            const table = await loadXlsxTable({
+                path,
+                dialect: { commentRows: [2] },
+            });
+            expect((await table.collect()).toRecords()).toEqual([record2]);
+        });
+        it("should support commentChar", async () => {
+            const path = getTempFilePath();
+            await writeTestData(path, [row1, row2, row3, ["#comment"]]);
+            const table = await loadXlsxTable({
+                path,
+                dialect: { commentChar: "#" },
+            });
+            expect((await table.collect()).toRecords()).toEqual([record1, record2]);
+        });
+        it("should handle longer rows", async () => {
+            const path = getTempFilePath();
+            await writeTestData(path, [row1, row2, row3, [3, "german", "bad"]]);
+            const table = await loadXlsxTable({
+                path,
+                dialect: { commentChar: "#" },
+            });
+            expect((await table.collect()).toRecords()).toEqual([
+                record1,
+                record2,
+                { id: 3, name: "german" },
+            ]);
+        });
+        it("should handle shorter rows", async () => {
+            const path = getTempFilePath();
+            await writeTestData(path, [row1, row2, row3, [3]]);
+            const table = await loadXlsxTable({
+                path,
+                dialect: { commentChar: "#" },
+            });
+            expect((await table.collect()).toRecords()).toEqual([
+                record1,
+                record2,
+                { id: 3, name: null },
+            ]);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"load.spec.js","sourceRoot":"","sources":["../../../../plugins/xlxs/table/load.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { getTempFilePath } from \"@frictionless-ts/dataset\"\nimport { describe, expect, it } from \"vitest\"\nimport { useRecording } from \"vitest-polly\"\nimport { loadXlsxTable } from \"./load.ts\"\nimport { writeTestData } from \"./test.ts\"\n\nuseRecording()\n\nconst row1 = [\"id\", \"name\"]\nconst row2 = [1, \"english\"]\nconst row3 = [2, \"中文\"]\n\nconst record1 = { id: 1, name: \"english\" }\nconst record2 = { id: 2, name: \"中文\" }\n\ndescribe(\"loadXlsxTable\", () => {\n  describe(\"file variations\", () => {\n    it(\"should load local file\", async () => {\n      const path = getTempFilePath()\n      await writeTestData(path, [row1, row2, row3])\n\n      const table = await loadXlsxTable({ path })\n      expect((await table.collect()).toRecords()).toEqual([record1, record2])\n    })\n\n    it(\"should load local file (multipart)\", async () => {\n      const path1 = getTempFilePath()\n      const path2 = getTempFilePath()\n      await writeTestData(path1, [row1, row2, row3])\n      await writeTestData(path2, [row1, row2, row3])\n\n      const table = await loadXlsxTable({ path: [path1, path2] })\n      expect((await table.collect()).toRecords()).toEqual([\n        record1,\n        record2,\n        record1,\n        record2,\n      ])\n    })\n\n    it(\"should load remote file\", async () => {\n      const table = await loadXlsxTable({\n        path: \"https://raw.githubusercontent.com/datisthq/dpkit/refs/heads/main/xlsx/table/fixtures/table.xlsx\",\n      })\n\n      expect((await table.collect()).toRecords()).toEqual([\n        { id: 1, name: \"english\" },\n        { id: 2, name: \"中文\" },\n      ])\n    })\n\n    it(\"should load multipart remote file\", async () => {\n      const table = await loadXlsxTable({\n        path: [\n          \"https://raw.githubusercontent.com/datisthq/dpkit/refs/heads/main/xlsx/table/fixtures/table.xlsx\",\n          \"https://raw.githubusercontent.com/datisthq/dpkit/refs/heads/main/xlsx/table/fixtures/table.xlsx\",\n        ],\n      })\n\n      expect((await table.collect()).toRecords()).toEqual([\n        { id: 1, name: \"english\" },\n        { id: 2, name: \"中文\" },\n        { id: 1, name: \"english\" },\n        { id: 2, name: \"中文\" },\n      ])\n    })\n  })\n\n  describe(\"dialect variations\", () => {\n    it(\"should support sheetNumber\", async () => {\n      const path = getTempFilePath()\n      await writeTestData(path, [row1, row2, row3], { sheetNumber: 2 })\n\n      const table = await loadXlsxTable({\n        path,\n        dialect: { sheetNumber: 2 },\n      })\n\n      expect((await table.collect()).toRecords()).toEqual([record1, record2])\n    })\n\n    it(\"should support sheetName\", async () => {\n      const path = getTempFilePath()\n      await writeTestData(path, [row1, row2, row3], { sheetName: \"Sheet2\" })\n\n      const table = await loadXlsxTable({\n        path,\n        dialect: { sheetName: \"Sheet2\" },\n      })\n\n      expect((await table.collect()).toRecords()).toEqual([record1, record2])\n    })\n\n    it(\"should support no header\", async () => {\n      const path = getTempFilePath()\n      await writeTestData(path, [row2, row3])\n\n      const table = await loadXlsxTable({\n        path,\n        dialect: { header: false },\n      })\n\n      expect((await table.collect()).toRecords()).toEqual([\n        { field1: 1, field2: \"english\" },\n        { field1: 2, field2: \"中文\" },\n      ])\n    })\n\n    it(\"should support headerRows offset\", async () => {\n      const path = getTempFilePath()\n      await writeTestData(path, [row1, row2, row3])\n\n      const table = await loadXlsxTable({\n        path,\n        dialect: { headerRows: [2] },\n      })\n\n      expect((await table.collect()).toRecords()).toEqual([\n        { 1: 2, english: \"中文\" },\n      ])\n    })\n\n    it(\"should support multiline headerRows\", async () => {\n      const path = getTempFilePath()\n      await writeTestData(path, [row1, row2, row3])\n\n      const table = await loadXlsxTable({\n        path,\n        dialect: { headerRows: [1, 2] },\n      })\n\n      expect((await table.collect()).toRecords()).toEqual([\n        { \"id 1\": 2, \"name english\": \"中文\" },\n      ])\n    })\n\n    it(\"should support headerJoin\", async () => {\n      const path = getTempFilePath()\n      await writeTestData(path, [row1, row2, row3])\n\n      const table = await loadXlsxTable({\n        path,\n        dialect: { headerRows: [1, 2], headerJoin: \"-\" },\n      })\n\n      expect((await table.collect()).toRecords()).toEqual([\n        { \"id-1\": 2, \"name-english\": \"中文\" },\n      ])\n    })\n\n    it(\"should support commentRows\", async () => {\n      const path = getTempFilePath()\n      await writeTestData(path, [row1, row2, row3])\n\n      const table = await loadXlsxTable({\n        path,\n        dialect: { commentRows: [2] },\n      })\n\n      expect((await table.collect()).toRecords()).toEqual([record2])\n    })\n\n    it(\"should support commentChar\", async () => {\n      const path = getTempFilePath()\n      await writeTestData(path, [row1, row2, row3, [\"#comment\"]])\n\n      const table = await loadXlsxTable({\n        path,\n        dialect: { commentChar: \"#\" },\n      })\n\n      expect((await table.collect()).toRecords()).toEqual([record1, record2])\n    })\n\n    it(\"should handle longer rows\", async () => {\n      const path = getTempFilePath()\n      await writeTestData(path, [row1, row2, row3, [3, \"german\", \"bad\"]])\n\n      const table = await loadXlsxTable({\n        path,\n        dialect: { commentChar: \"#\" },\n      })\n\n      expect((await table.collect()).toRecords()).toEqual([\n        record1,\n        record2,\n        { id: 3, name: \"german\" },\n      ])\n    })\n\n    it(\"should handle shorter rows\", async () => {\n      const path = getTempFilePath()\n      await writeTestData(path, [row1, row2, row3, [3]])\n\n      const table = await loadXlsxTable({\n        path,\n        dialect: { commentChar: \"#\" },\n      })\n\n      expect((await table.collect()).toRecords()).toEqual([\n        record1,\n        record2,\n        { id: 3, name: null },\n      ])\n    })\n  })\n})\n"]}

package/build/plugins/xlxs/table/save.d.ts

@@ -0,0 +1,3 @@
+import type { SaveTableOptions } from "../../../plugin.ts";
+import type { Table } from "../../../table/index.ts";
+export declare function saveXlsxTable(table: Table, options: SaveTableOptions): Promise<string>;

package/build/plugins/xlxs/table/save.js

@@ -0,0 +1,28 @@
+import { saveFile } from "@frictionless-ts/dataset";
+import { resolveDialect } from "@frictionless-ts/metadata";
+import { utils, write } from "xlsx";
+import { inferSchemaFromTable } from "../../../schema/index.js";
+import { denormalizeTable } from "../../../table/index.js";
+// Currently, we use slow non-rust implementation as in the future
+// polars-rust might be able to provide a faster native implementation
+export async function saveXlsxTable(table, options) {
+    const { path, overwrite } = options;
+    const schema = options.schema ??
+        (await inferSchemaFromTable(table, {
+            ...options,
+            keepStrings: true,
+        }));
+    table = await denormalizeTable(table, schema, {
+        nativeTypes: ["boolean", "integer", "number", "string", "year"],
+    });
+    const frame = await table.collect();
+    const dialect = await resolveDialect(options.dialect);
+    const sheetName = dialect?.sheetName ?? "Sheet1";
+    const sheet = utils.json_to_sheet(frame.toRecords());
+    const book = utils.book_new();
+    utils.book_append_sheet(book, sheet, sheetName);
+    const buffer = write(book, { type: "buffer", bookType: "xlsx" });
+    await saveFile(path, buffer, { overwrite });
+    return path;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/plugins/xlxs/table/save.spec.d.ts

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

package/build/plugins/xlxs/table/save.spec.js

@@ -0,0 +1,75 @@
+import { getTempFilePath } from "@frictionless-ts/dataset";
+import * as pl from "nodejs-polars";
+import { describe, expect, it } from "vitest";
+import { loadXlsxTable } from "./load.js";
+import { saveXlsxTable } from "./save.js";
+import { readTestData } from "./test.js";
+const row1 = { id: 1, name: "english" };
+const row2 = { id: 2, name: "中文" };
+const table = pl.readRecords([row1, row2]).lazy();
+describe("saveXlsxTable", () => {
+    it("should save table to file", async () => {
+        const path = getTempFilePath();
+        await saveXlsxTable(table, { path });
+        const data = await readTestData(path);
+        expect(data).toEqual([row1, row2]);
+    });
+    it("should save and load various data types", async () => {
+        const path = getTempFilePath();
+        const source = pl
+            .DataFrame([
+            pl.Series("array", ["[1, 2, 3]"], pl.String),
+            pl.Series("boolean", [true], pl.Bool),
+            pl.Series("date", [new Date(Date.UTC(2025, 0, 1))], pl.Date),
+            pl.Series("datetime", [new Date(Date.UTC(2025, 0, 1))], pl.Datetime),
+            pl.Series("duration", ["P23DT23H"], pl.String),
+            pl.Series("geojson", ['{"value": 1}'], pl.String),
+            pl.Series("geopoint", [[40.0, 50.0]], pl.List(pl.Float32)),
+            pl.Series("integer", [1], pl.Int32),
+            pl.Series("list", [[1.0, 2.0, 3.0]], pl.List(pl.Float32)),
+            pl.Series("number", [1.1], pl.Float64),
+            pl.Series("object", ['{"value": 1}']),
+            pl.Series("string", ["string"], pl.String),
+            pl.Series("time", [new Date(Date.UTC(2025, 0, 1))], pl.Time),
+            pl.Series("year", [2025], pl.Int32),
+            pl.Series("yearmonth", [[2025, 1]], pl.List(pl.Int16)),
+        ])
+            .lazy();
+        await saveXlsxTable(source, {
+            path,
+            fieldTypes: {
+                array: "array",
+                geojson: "geojson",
+                geopoint: "geopoint",
+                list: "list",
+                object: "object",
+                // TODO: Remove time after:
+                // https://github.com/pola-rs/nodejs-polars/issues/364
+                time: "time",
+                year: "year",
+                yearmonth: "yearmonth",
+            },
+        });
+        const target = await loadXlsxTable({ path }, { denormalized: true });
+        expect((await target.collect()).toRecords()).toEqual([
+            {
+                array: "[1, 2, 3]",
+                boolean: true,
+                date: "2025-01-01",
+                datetime: "2025-01-01T00:00:00",
+                duration: "P23DT23H",
+                geojson: '{"value": 1}',
+                geopoint: "40.0,50.0",
+                integer: 1,
+                list: "1.0,2.0,3.0",
+                number: 1.1,
+                object: '{"value": 1}',
+                string: "string",
+                time: "00:00:00",
+                year: 2025,
+                yearmonth: "2025-01",
+            },
+        ]);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"save.spec.js","sourceRoot":"","sources":["../../../../plugins/xlxs/table/save.spec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAC1D,OAAO,KAAK,EAAE,MAAM,eAAe,CAAA;AACnC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAA;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAExC,MAAM,IAAI,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,CAAA;AACvC,MAAM,IAAI,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAA;AAClC,MAAM,KAAK,GAAG,EAAE,CAAC,WAAW,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,CAAA;AAEjD,QAAQ,CAAC,eAAe,EAAE,GAAG,EAAE;IAC7B,EAAE,CAAC,2BAA2B,EAAE,KAAK,IAAI,EAAE;QACzC,MAAM,IAAI,GAAG,eAAe,EAAE,CAAA;QAC9B,MAAM,aAAa,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,CAAC,CAAA;QAEpC,MAAM,IAAI,GAAG,MAAM,YAAY,CAAC,IAAI,CAAC,CAAA;QACrC,MAAM,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAA;IACpC,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,yCAAyC,EAAE,KAAK,IAAI,EAAE;QACvD,MAAM,IAAI,GAAG,eAAe,EAAE,CAAA;QAE9B,MAAM,MAAM,GAAG,EAAE;aACd,SAAS,CAAC;YACT,EAAE,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,WAAW,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC;YAC5C,EAAE,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC;YACrC,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC;YAC5D,EAAE,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC;YACpE,EAAE,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,UAAU,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC;YAC9C,EAAE,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,cAAc,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC;YACjD,EAAE,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC;YAC1D,EAAE,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC;YACnC,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC;YACzD,EAAE,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC;YACtC,EAAE,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,cAAc,CAAC,CAAC;YACrC,EAAE,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC;YAC1C,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC;YAC5D,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC;YACnC,EAAE,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;SACvD,CAAC;aACD,IAAI,EAAE,CAAA;QAET,MAAM,aAAa,CAAC,MAAM,EAAE;YAC1B,IAAI;YACJ,UAAU,EAAE;gBACV,KAAK,EAAE,OAAO;gBACd,OAAO,EAAE,SAAS;gBAClB,QAAQ,EAAE,UAAU;gBACpB,IAAI,EAAE,MAAM;gBACZ,MAAM,EAAE,QAAQ;gBAChB,2BAA2B;gBAC3B,sDAAsD;gBACtD,IAAI,EAAE,MAAM;gBACZ,IAAI,EAAE,MAAM;gBACZ,SAAS,EAAE,WAAW;aACvB;SACF,CAAC,CAAA;QAEF,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAA;QACpE,MAAM,CAAC,CAAC,MAAM,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC;YACnD;gBACE,KAAK,EAAE,WAAW;gBAClB,OAAO,EAAE,IAAI;gBACb,IAAI,EAAE,YAAY;gBAClB,QAAQ,EAAE,qBAAqB;gBAC/B,QAAQ,EAAE,UAAU;gBACpB,OAAO,EAAE,cAAc;gBACvB,QAAQ,EAAE,WAAW;gBACrB,OAAO,EAAE,CAAC;gBACV,IAAI,EAAE,aAAa;gBACnB,MAAM,EAAE,GAAG;gBACX,MAAM,EAAE,cAAc;gBACtB,MAAM,EAAE,QAAQ;gBAChB,IAAI,EAAE,UAAU;gBAChB,IAAI,EAAE,IAAI;gBACV,SAAS,EAAE,SAAS;aACrB;SACF,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA","sourcesContent":["import { getTempFilePath } from \"@frictionless-ts/dataset\"\nimport * as pl from \"nodejs-polars\"\nimport { describe, expect, it } from \"vitest\"\nimport { loadXlsxTable } from \"./load.ts\"\nimport { saveXlsxTable } from \"./save.ts\"\nimport { readTestData } from \"./test.ts\"\n\nconst row1 = { id: 1, name: \"english\" }\nconst row2 = { id: 2, name: \"中文\" }\nconst table = pl.readRecords([row1, row2]).lazy()\n\ndescribe(\"saveXlsxTable\", () => {\n  it(\"should save table to file\", async () => {\n    const path = getTempFilePath()\n    await saveXlsxTable(table, { path })\n\n    const data = await readTestData(path)\n    expect(data).toEqual([row1, row2])\n  })\n\n  it(\"should save and load various data types\", async () => {\n    const path = getTempFilePath()\n\n    const source = pl\n      .DataFrame([\n        pl.Series(\"array\", [\"[1, 2, 3]\"], pl.String),\n        pl.Series(\"boolean\", [true], pl.Bool),\n        pl.Series(\"date\", [new Date(Date.UTC(2025, 0, 1))], pl.Date),\n        pl.Series(\"datetime\", [new Date(Date.UTC(2025, 0, 1))], pl.Datetime),\n        pl.Series(\"duration\", [\"P23DT23H\"], pl.String),\n        pl.Series(\"geojson\", ['{\"value\": 1}'], pl.String),\n        pl.Series(\"geopoint\", [[40.0, 50.0]], pl.List(pl.Float32)),\n        pl.Series(\"integer\", [1], pl.Int32),\n        pl.Series(\"list\", [[1.0, 2.0, 3.0]], pl.List(pl.Float32)),\n        pl.Series(\"number\", [1.1], pl.Float64),\n        pl.Series(\"object\", ['{\"value\": 1}']),\n        pl.Series(\"string\", [\"string\"], pl.String),\n        pl.Series(\"time\", [new Date(Date.UTC(2025, 0, 1))], pl.Time),\n        pl.Series(\"year\", [2025], pl.Int32),\n        pl.Series(\"yearmonth\", [[2025, 1]], pl.List(pl.Int16)),\n      ])\n      .lazy()\n\n    await saveXlsxTable(source, {\n      path,\n      fieldTypes: {\n        array: \"array\",\n        geojson: \"geojson\",\n        geopoint: \"geopoint\",\n        list: \"list\",\n        object: \"object\",\n        // TODO: Remove time after:\n        // https://github.com/pola-rs/nodejs-polars/issues/364\n        time: \"time\",\n        year: \"year\",\n        yearmonth: \"yearmonth\",\n      },\n    })\n\n    const target = await loadXlsxTable({ path }, { denormalized: true })\n    expect((await target.collect()).toRecords()).toEqual([\n      {\n        array: \"[1, 2, 3]\",\n        boolean: true,\n        date: \"2025-01-01\",\n        datetime: \"2025-01-01T00:00:00\",\n        duration: \"P23DT23H\",\n        geojson: '{\"value\": 1}',\n        geopoint: \"40.0,50.0\",\n        integer: 1,\n        list: \"1.0,2.0,3.0\",\n        number: 1.1,\n        object: '{\"value\": 1}',\n        string: \"string\",\n        time: \"00:00:00\",\n        year: 2025,\n        yearmonth: \"2025-01\",\n      },\n    ])\n  })\n})\n"]}

package/build/plugins/xlxs/table/test.d.ts

@@ -0,0 +1,5 @@
+export declare function readTestData(path: string): Promise<unknown[]>;
+export declare function writeTestData(path: string, rows: unknown[][], options?: {
+    sheetNumber?: number;
+    sheetName?: string;
+}): Promise<void>;

package/build/plugins/xlxs/table/test.js

@@ -0,0 +1,23 @@
+import { readFile } from "node:fs/promises";
+import { writeFile } from "node:fs/promises";
+import { read, utils, write } from "xlsx";
+// We intentionally don't use dpkit's function here to isolate the tests
+export async function readTestData(path) {
+    const buffer = await readFile(path);
+    const book = read(buffer, { type: "buffer" });
+    const sheetName = book.SheetNames[0];
+    const sheet = sheetName ? book.Sheets[sheetName] : undefined;
+    return sheet ? utils.sheet_to_json(sheet) : [];
+}
+export async function writeTestData(path, rows, options) {
+    const book = utils.book_new();
+    const sheet = utils.aoa_to_sheet(rows);
+    const sheetNumber = options?.sheetNumber ?? 1;
+    for (let i = 0; i < sheetNumber; i++) {
+        const sheetName = options?.sheetName ?? `Sheet${i + 1}`;
+        utils.book_append_sheet(book, sheet, sheetName);
+    }
+    const buffer = write(book, { type: "buffer", bookType: "xlsx" });
+    await writeFile(path, buffer);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/schema/Mapping.d.ts

@@ -0,0 +1,6 @@
+import type { Schema } from "@frictionless-ts/metadata";
+import type { PolarsSchema } from "./Schema.ts";
+export interface SchemaMapping {
+    source: PolarsSchema;
+    target: Schema;
+}

package/build/schema/Mapping.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTWFwcGluZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NjaGVtYS9NYXBwaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFNjaGVtYSB9IGZyb20gXCJAZnJpY3Rpb25sZXNzLXRzL21ldGFkYXRhXCJcbmltcG9ydCB0eXBlIHsgUG9sYXJzU2NoZW1hIH0gZnJvbSBcIi4vU2NoZW1hLnRzXCJcblxuZXhwb3J0IGludGVyZmFjZSBTY2hlbWFNYXBwaW5nIHtcbiAgc291cmNlOiBQb2xhcnNTY2hlbWFcbiAgdGFyZ2V0OiBTY2hlbWFcbn1cbiJdfQ==