@frictionless-ts/table 1.0.1

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

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

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

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

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

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

package/build/plugins/ods/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 loadOdsTable(resource: Partial<Resource>, options?: LoadTableOptions): Promise<pl.LazyDataFrame<any>>;

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

@@ -0,0 +1,41 @@
+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";
+export async function loadOdsTable(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/ods/table/load.spec.d.ts

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

package/build/plugins/ods/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 { loadOdsTable } 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("loadOdsTable", () => {
+    describe("file variations", () => {
+        it("should load local file", async () => {
+            const path = getTempFilePath();
+            await writeTestData(path, [row1, row2, row3]);
+            const table = await loadOdsTable({ 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 loadOdsTable({ path: [path1, path2] });
+            expect((await table.collect()).toRecords()).toEqual([
+                record1,
+                record2,
+                record1,
+                record2,
+            ]);
+        });
+        it("should load remote file", async () => {
+            const table = await loadOdsTable({
+                path: "https://raw.githubusercontent.com/datisthq/dpkit/refs/heads/main/ods/table/fixtures/table.ods",
+            });
+            expect((await table.collect()).toRecords()).toEqual([
+                { id: 1, name: "english" },
+                { id: 2, name: "中文" },
+            ]);
+        });
+        it("should load multipart remote file", async () => {
+            const table = await loadOdsTable({
+                path: [
+                    "https://raw.githubusercontent.com/datisthq/dpkit/refs/heads/main/ods/table/fixtures/table.ods",
+                    "https://raw.githubusercontent.com/datisthq/dpkit/refs/heads/main/ods/table/fixtures/table.ods",
+                ],
+            });
+            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 loadOdsTable({
+                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 loadOdsTable({
+                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 loadOdsTable({
+                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 loadOdsTable({
+                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 loadOdsTable({
+                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 loadOdsTable({
+                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 loadOdsTable({
+                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 loadOdsTable({
+                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 loadOdsTable({
+                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 loadOdsTable({
+                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/ods/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 { loadOdsTable } 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(\"loadOdsTable\", () => {\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 loadOdsTable({ 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 loadOdsTable({ 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 loadOdsTable({\n        path: \"https://raw.githubusercontent.com/datisthq/dpkit/refs/heads/main/ods/table/fixtures/table.ods\",\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 loadOdsTable({\n        path: [\n          \"https://raw.githubusercontent.com/datisthq/dpkit/refs/heads/main/ods/table/fixtures/table.ods\",\n          \"https://raw.githubusercontent.com/datisthq/dpkit/refs/heads/main/ods/table/fixtures/table.ods\",\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 loadOdsTable({\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 loadOdsTable({\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 loadOdsTable({\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 loadOdsTable({\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 loadOdsTable({\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 loadOdsTable({\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 loadOdsTable({\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 loadOdsTable({\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 loadOdsTable({\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 loadOdsTable({\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/ods/table/save.d.ts

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

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

@@ -0,0 +1,26 @@
+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";
+export async function saveOdsTable(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: "ods" });
+    await saveFile(path, buffer, { overwrite });
+    return path;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2F2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BsdWdpbnMvb2RzL3RhYmxlL3NhdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLDBCQUEwQixDQUFBO0FBQ25ELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQTtBQUMxRCxPQUFPLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLE1BQU0sQ0FBQTtBQUVuQyxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQTtBQUMvRCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQTtBQUcxRCxNQUFNLENBQUMsS0FBSyxVQUFVLFlBQVksQ0FBQyxLQUFZLEVBQUUsT0FBeUI7SUFDeEUsTUFBTSxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUUsR0FBRyxPQUFPLENBQUE7SUFFbkMsTUFBTSxNQUFNLEdBQ1YsT0FBTyxDQUFDLE1BQU07UUFDZCxDQUFDLE1BQU0sb0JBQW9CLENBQUMsS0FBSyxFQUFFO1lBQ2pDLEdBQUcsT0FBTztZQUNWLFdBQVcsRUFBRSxJQUFJO1NBQ2xCLENBQUMsQ0FBQyxDQUFBO0lBRUwsS0FBSyxHQUFHLE1BQU0sZ0JBQWdCLENBQUMsS0FBSyxFQUFFLE1BQU0sRUFBRTtRQUM1QyxXQUFXLEVBQUUsQ0FBQyxTQUFTLEVBQUUsU0FBUyxFQUFFLFFBQVEsRUFBRSxRQUFRLEVBQUUsTUFBTSxDQUFDO0tBQ2hFLENBQUMsQ0FBQTtJQUVGLE1BQU0sS0FBSyxHQUFHLE1BQU0sS0FBSyxDQUFDLE9BQU8sRUFBRSxDQUFBO0lBQ25DLE1BQU0sT0FBTyxHQUFHLE1BQU0sY0FBYyxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FBQTtJQUNyRCxNQUFNLFNBQVMsR0FBRyxPQUFPLEVBQUUsU0FBUyxJQUFJLFFBQVEsQ0FBQTtJQUVoRCxNQUFNLEtBQUssR0FBRyxLQUFLLENBQUMsYUFBYSxDQUFDLEtBQUssQ0FBQyxTQUFTLEVBQUUsQ0FBQyxDQUFBO0lBQ3BELE1BQU0sSUFBSSxHQUFHLEtBQUssQ0FBQyxRQUFRLEVBQUUsQ0FBQTtJQUM3QixLQUFLLENBQUMsaUJBQWlCLENBQUMsSUFBSSxFQUFFLEtBQUssRUFBRSxTQUFTLENBQUMsQ0FBQTtJQUUvQyxNQUFNLE1BQU0sR0FBRyxLQUFLLENBQUMsSUFBSSxFQUFFLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRSxRQUFRLEVBQUUsS0FBSyxFQUFFLENBQUMsQ0FBQTtJQUMvRCxNQUFNLFFBQVEsQ0FBQyxJQUFJLEVBQUUsTUFBTSxFQUFFLEVBQUUsU0FBUyxFQUFFLENBQUMsQ0FBQTtJQUUzQyxPQUFPLElBQUksQ0FBQTtBQUNiLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBzYXZlRmlsZSB9IGZyb20gXCJAZnJpY3Rpb25sZXNzLXRzL2RhdGFzZXRcIlxuaW1wb3J0IHsgcmVzb2x2ZURpYWxlY3QgfSBmcm9tIFwiQGZyaWN0aW9ubGVzcy10cy9tZXRhZGF0YVwiXG5pbXBvcnQgeyB1dGlscywgd3JpdGUgfSBmcm9tIFwieGxzeFwiXG5pbXBvcnQgdHlwZSB7IFNhdmVUYWJsZU9wdGlvbnMgfSBmcm9tIFwiLi4vLi4vLi4vcGx1Z2luLnRzXCJcbmltcG9ydCB7IGluZmVyU2NoZW1hRnJvbVRhYmxlIH0gZnJvbSBcIi4uLy4uLy4uL3NjaGVtYS9pbmRleC50c1wiXG5pbXBvcnQgeyBkZW5vcm1hbGl6ZVRhYmxlIH0gZnJvbSBcIi4uLy4uLy4uL3RhYmxlL2luZGV4LnRzXCJcbmltcG9ydCB0eXBlIHsgVGFibGUgfSBmcm9tIFwiLi4vLi4vLi4vdGFibGUvaW5kZXgudHNcIlxuXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gc2F2ZU9kc1RhYmxlKHRhYmxlOiBUYWJsZSwgb3B0aW9uczogU2F2ZVRhYmxlT3B0aW9ucykge1xuICBjb25zdCB7IHBhdGgsIG92ZXJ3cml0ZSB9ID0gb3B0aW9uc1xuXG4gIGNvbnN0IHNjaGVtYSA9XG4gICAgb3B0aW9ucy5zY2hlbWEgPz9cbiAgICAoYXdhaXQgaW5mZXJTY2hlbWFGcm9tVGFibGUodGFibGUsIHtcbiAgICAgIC4uLm9wdGlvbnMsXG4gICAgICBrZWVwU3RyaW5nczogdHJ1ZSxcbiAgICB9KSlcblxuICB0YWJsZSA9IGF3YWl0IGRlbm9ybWFsaXplVGFibGUodGFibGUsIHNjaGVtYSwge1xuICAgIG5hdGl2ZVR5cGVzOiBbXCJib29sZWFuXCIsIFwiaW50ZWdlclwiLCBcIm51bWJlclwiLCBcInN0cmluZ1wiLCBcInllYXJcIl0sXG4gIH0pXG5cbiAgY29uc3QgZnJhbWUgPSBhd2FpdCB0YWJsZS5jb2xsZWN0KClcbiAgY29uc3QgZGlhbGVjdCA9IGF3YWl0IHJlc29sdmVEaWFsZWN0KG9wdGlvbnMuZGlhbGVjdClcbiAgY29uc3Qgc2hlZXROYW1lID0gZGlhbGVjdD8uc2hlZXROYW1lID8/IFwiU2hlZXQxXCJcblxuICBjb25zdCBzaGVldCA9IHV0aWxzLmpzb25fdG9fc2hlZXQoZnJhbWUudG9SZWNvcmRzKCkpXG4gIGNvbnN0IGJvb2sgPSB1dGlscy5ib29rX25ldygpXG4gIHV0aWxzLmJvb2tfYXBwZW5kX3NoZWV0KGJvb2ssIHNoZWV0LCBzaGVldE5hbWUpXG5cbiAgY29uc3QgYnVmZmVyID0gd3JpdGUoYm9vaywgeyB0eXBlOiBcImJ1ZmZlclwiLCBib29rVHlwZTogXCJvZHNcIiB9KVxuICBhd2FpdCBzYXZlRmlsZShwYXRoLCBidWZmZXIsIHsgb3ZlcndyaXRlIH0pXG5cbiAgcmV0dXJuIHBhdGhcbn1cbiJdfQ==

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

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

package/build/plugins/ods/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 { loadOdsTable } from "./load.js";
+import { saveOdsTable } 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("saveOdsTable", () => {
+    it("should save table to file", async () => {
+        const path = getTempFilePath();
+        await saveOdsTable(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 saveOdsTable(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 loadOdsTable({ 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/ods/table/save.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { getTempFilePath } from \"@frictionless-ts/dataset\"\nimport * as pl from \"nodejs-polars\"\nimport { describe, expect, it } from \"vitest\"\nimport { loadOdsTable } from \"./load.ts\"\nimport { saveOdsTable } 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(\"saveOdsTable\", () => {\n  it(\"should save table to file\", async () => {\n    const path = getTempFilePath()\n    await saveOdsTable(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 saveOdsTable(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 loadOdsTable({ 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/ods/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/ods/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: "ods" });
+    await writeFile(path, buffer);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/plugins/parquet/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./table/index.ts";
+export * from "./plugin.ts";

package/build/plugins/parquet/index.js

@@ -0,0 +1,3 @@
+export * from "./table/index.js";
+export * from "./plugin.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9wbHVnaW5zL3BhcnF1ZXQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxrQkFBa0IsQ0FBQTtBQUNoQyxjQUFjLGFBQWEsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL3RhYmxlL2luZGV4LnRzXCJcbmV4cG9ydCAqIGZyb20gXCIuL3BsdWdpbi50c1wiXG4iXX0=