@frictionless-ts/table 1.0.1

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

@@ -0,0 +1,7 @@
+import type { Resource } from "@frictionless-ts/metadata";
+import type { LoadTableOptions, SaveTableOptions, TablePlugin } from "../../plugin.ts";
+import type { Table } from "../../table/index.ts";
+export declare class ParquetPlugin implements TablePlugin {
+    loadTable(resource: Partial<Resource>, options?: LoadTableOptions): Promise<import("nodejs-polars").LazyDataFrame<any> | undefined>;
+    saveTable(table: Table, options: SaveTableOptions): Promise<string | undefined>;
+}

package/build/plugins/parquet/plugin.js

@@ -0,0 +1,23 @@
+import { inferFormat } from "@frictionless-ts/metadata";
+import { loadParquetTable } from "./table/index.js";
+import { saveParquetTable } from "./table/index.js";
+export class ParquetPlugin {
+    async loadTable(resource, options) {
+        const isParquet = getIsParquet(resource);
+        if (!isParquet)
+            return undefined;
+        return await loadParquetTable(resource, options);
+    }
+    async saveTable(table, options) {
+        const { path, format } = options;
+        const isParquet = getIsParquet({ path, format });
+        if (!isParquet)
+            return undefined;
+        return await saveParquetTable(table, options);
+    }
+}
+function getIsParquet(resource) {
+    const format = inferFormat(resource);
+    return format === "parquet";
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/plugins/parquet/plugin.spec.d.ts

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,23 @@
+import { resolveSchema } from "@frictionless-ts/metadata";
+import { prefetchFiles } from "@frictionless-ts/dataset";
+import { inferSchemaFromTable } from "../../../schema/index.js";
+import { normalizeTable } from "../../../table/index.js";
+import * as pl from "nodejs-polars";
+export async function loadParquetTable(resource, options) {
+    const [firstPath, ...restPaths] = await prefetchFiles(resource.path);
+    if (!firstPath) {
+        throw new Error("Resource path is not defined");
+    }
+    let table = pl.scanParquet(firstPath);
+    if (restPaths.length) {
+        table = pl.concat([table, ...restPaths.map(path => pl.scanParquet(path))]);
+    }
+    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/parquet/table/load.spec.d.ts

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

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

@@ -0,0 +1,56 @@
+import { getTempFilePath } from "@frictionless-ts/dataset";
+import * as pl from "nodejs-polars";
+import { describe, expect, it } from "vitest";
+import { useRecording } from "vitest-polly";
+import { loadParquetTable } from "./load.js";
+useRecording();
+describe("loadParquetTable", () => {
+    describe("file variations", () => {
+        it("should load local file", async () => {
+            const path = getTempFilePath();
+            pl.DataFrame({ id: [1, 2], name: ["english", "中文"] }).writeParquet(path);
+            const table = await loadParquetTable({ path });
+            expect((await table.collect()).toRecords()).toEqual([
+                { id: 1, name: "english" },
+                { id: 2, name: "中文" },
+            ]);
+        });
+        it("should load local file (multipart)", async () => {
+            const path1 = getTempFilePath();
+            const path2 = getTempFilePath();
+            pl.DataFrame({ id: [1, 2], name: ["english", "中文"] }).writeParquet(path1);
+            pl.DataFrame({ id: [1, 2], name: ["english", "中文"] }).writeParquet(path2);
+            const table = await loadParquetTable({ path: [path1, path2] });
+            expect((await table.collect()).toRecords()).toEqual([
+                { id: 1, name: "english" },
+                { id: 2, name: "中文" },
+                { id: 1, name: "english" },
+                { id: 2, name: "中文" },
+            ]);
+        });
+        it("should load remote file", async () => {
+            const table = await loadParquetTable({
+                path: "https://raw.githubusercontent.com/datisthq/dpkit/refs/heads/main/parquet/table/fixtures/table.parquet",
+            });
+            expect((await table.collect()).toRecords()).toEqual([
+                { id: 1, name: "english" },
+                { id: 2, name: "中文" },
+            ]);
+        });
+        it("should load remote file (multipart)", async () => {
+            const table = await loadParquetTable({
+                path: [
+                    "https://raw.githubusercontent.com/datisthq/dpkit/refs/heads/main/parquet/table/fixtures/table.parquet",
+                    "https://raw.githubusercontent.com/datisthq/dpkit/refs/heads/main/parquet/table/fixtures/table.parquet",
+                ],
+            });
+            expect((await table.collect()).toRecords()).toEqual([
+                { id: 1, name: "english" },
+                { id: 2, name: "中文" },
+                { id: 1, name: "english" },
+                { id: 2, name: "中文" },
+            ]);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1,32 @@
+import { assertLocalPathVacant } from "@frictionless-ts/dataset";
+import { inferSchemaFromTable } from "../../../schema/index.js";
+import { denormalizeTable } from "../../../table/index.js";
+export async function saveParquetTable(table, options) {
+    const { path, overwrite } = options;
+    if (!overwrite) {
+        await assertLocalPathVacant(path);
+    }
+    const schema = options.schema ??
+        (await inferSchemaFromTable(table, {
+            ...options,
+            keepStrings: true,
+        }));
+    table = await denormalizeTable(table, schema, {
+        nativeTypes: [
+            "boolean",
+            "datetime",
+            "integer",
+            "list",
+            "number",
+            "string",
+            "year",
+        ],
+    });
+    await table
+        .sinkParquet(path, {
+        maintainOrder: true,
+    })
+        .collect();
+    return path;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1,81 @@
+import { getTempFilePath } from "@frictionless-ts/dataset";
+import * as pl from "nodejs-polars";
+import { describe, expect, it } from "vitest";
+import { loadParquetTable } from "./load.js";
+import { saveParquetTable } from "./save.js";
+describe("saveParquetTable", () => {
+    it("should save table to Parquet file", async () => {
+        const path = getTempFilePath();
+        const source = pl
+            .DataFrame({
+            id: [1.0, 2.0, 3.0],
+            name: ["Alice", "Bob", "Charlie"],
+        })
+            .lazy();
+        await saveParquetTable(source, { path });
+        const table = await loadParquetTable({ path });
+        expect((await table.collect()).toRecords()).toEqual([
+            { id: 1.0, name: "Alice" },
+            { id: 2.0, name: "Bob" },
+            { id: 3.0, name: "Charlie" },
+        ]);
+    });
+    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 saveParquetTable(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 loadParquetTable({ path }, { denormalized: true });
+        expect((await target.collect()).toRecords()).toEqual([
+            {
+                array: "[1, 2, 3]",
+                boolean: true,
+                date: "2025-01-01",
+                datetime: new Date(Date.UTC(2025, 0, 1)),
+                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/parquet/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 { loadParquetTable } from \"./load.ts\"\nimport { saveParquetTable } from \"./save.ts\"\n\ndescribe(\"saveParquetTable\", () => {\n  it(\"should save table to Parquet file\", async () => {\n    const path = getTempFilePath()\n    const source = pl\n      .DataFrame({\n        id: [1.0, 2.0, 3.0],\n        name: [\"Alice\", \"Bob\", \"Charlie\"],\n      })\n      .lazy()\n\n    await saveParquetTable(source, { path })\n\n    const table = await loadParquetTable({ path })\n    expect((await table.collect()).toRecords()).toEqual([\n      { id: 1.0, name: \"Alice\" },\n      { id: 2.0, name: \"Bob\" },\n      { id: 3.0, name: \"Charlie\" },\n    ])\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 saveParquetTable(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 loadParquetTable({ 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: new Date(Date.UTC(2025, 0, 1)),\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/index.d.ts

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

package/build/plugins/xlxs/index.js

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

package/build/plugins/xlxs/plugin.d.ts

@@ -0,0 +1,7 @@
+import type { Resource } from "@frictionless-ts/metadata";
+import type { LoadTableOptions, SaveTableOptions, TablePlugin } from "../../plugin.ts";
+import type { Table } from "../../table/index.ts";
+export declare class XlsxPlugin implements TablePlugin {
+    loadTable(resource: Partial<Resource>, options?: LoadTableOptions): Promise<import("nodejs-polars").LazyDataFrame<any> | undefined>;
+    saveTable(table: Table, options: SaveTableOptions): Promise<string | undefined>;
+}

package/build/plugins/xlxs/plugin.js

@@ -0,0 +1,23 @@
+import { inferFormat } from "@frictionless-ts/metadata";
+import { loadXlsxTable } from "./table/index.js";
+import { saveXlsxTable } from "./table/index.js";
+export class XlsxPlugin {
+    async loadTable(resource, options) {
+        const isXlsx = getIsXlsx(resource);
+        if (!isXlsx)
+            return undefined;
+        return await loadXlsxTable(resource, options);
+    }
+    async saveTable(table, options) {
+        const { path, format } = options;
+        const isXlsx = getIsXlsx({ path, format });
+        if (!isXlsx)
+            return undefined;
+        return await saveXlsxTable(table, options);
+    }
+}
+function getIsXlsx(resource) {
+    const format = inferFormat(resource);
+    return ["xlsx"].includes(format ?? "");
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2luLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcGx1Z2lucy94bHhzL3BsdWdpbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sMkJBQTJCLENBQUE7QUFPdkQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGtCQUFrQixDQUFBO0FBQ2hELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQTtBQUVoRCxNQUFNLE9BQU8sVUFBVTtJQUNyQixLQUFLLENBQUMsU0FBUyxDQUFDLFFBQTJCLEVBQUUsT0FBMEI7UUFDckUsTUFBTSxNQUFNLEdBQUcsU0FBUyxDQUFDLFFBQVEsQ0FBQyxDQUFBO1FBQ2xDLElBQUksQ0FBQyxNQUFNO1lBQUUsT0FBTyxTQUFTLENBQUE7UUFFN0IsT0FBTyxNQUFNLGFBQWEsQ0FBQyxRQUFRLEVBQUUsT0FBTyxDQUFDLENBQUE7SUFDL0MsQ0FBQztJQUVELEtBQUssQ0FBQyxTQUFTLENBQUMsS0FBWSxFQUFFLE9BQXlCO1FBQ3JELE1BQU0sRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLEdBQUcsT0FBTyxDQUFBO1FBRWhDLE1BQU0sTUFBTSxHQUFHLFNBQVMsQ0FBQyxFQUFFLElBQUksRUFBRSxNQUFNLEVBQUUsQ0FBQyxDQUFBO1FBQzFDLElBQUksQ0FBQyxNQUFNO1lBQUUsT0FBTyxTQUFTLENBQUE7UUFFN0IsT0FBTyxNQUFNLGFBQWEsQ0FBQyxLQUFLLEVBQUUsT0FBTyxDQUFDLENBQUE7SUFDNUMsQ0FBQztDQUNGO0FBRUQsU0FBUyxTQUFTLENBQUMsUUFBMkI7SUFDNUMsTUFBTSxNQUFNLEdBQUcsV0FBVyxDQUFDLFFBQVEsQ0FBQyxDQUFBO0lBQ3BDLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQyxRQUFRLENBQUMsTUFBTSxJQUFJLEVBQUUsQ0FBQyxDQUFBO0FBQ3hDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFJlc291cmNlIH0gZnJvbSBcIkBmcmljdGlvbmxlc3MtdHMvbWV0YWRhdGFcIlxuaW1wb3J0IHsgaW5mZXJGb3JtYXQgfSBmcm9tIFwiQGZyaWN0aW9ubGVzcy10cy9tZXRhZGF0YVwiXG5pbXBvcnQgdHlwZSB7XG4gIExvYWRUYWJsZU9wdGlvbnMsXG4gIFNhdmVUYWJsZU9wdGlvbnMsXG4gIFRhYmxlUGx1Z2luLFxufSBmcm9tIFwiLi4vLi4vcGx1Z2luLnRzXCJcbmltcG9ydCB0eXBlIHsgVGFibGUgfSBmcm9tIFwiLi4vLi4vdGFibGUvaW5kZXgudHNcIlxuaW1wb3J0IHsgbG9hZFhsc3hUYWJsZSB9IGZyb20gXCIuL3RhYmxlL2luZGV4LnRzXCJcbmltcG9ydCB7IHNhdmVYbHN4VGFibGUgfSBmcm9tIFwiLi90YWJsZS9pbmRleC50c1wiXG5cbmV4cG9ydCBjbGFzcyBYbHN4UGx1Z2luIGltcGxlbWVudHMgVGFibGVQbHVnaW4ge1xuICBhc3luYyBsb2FkVGFibGUocmVzb3VyY2U6IFBhcnRpYWw8UmVzb3VyY2U+LCBvcHRpb25zPzogTG9hZFRhYmxlT3B0aW9ucykge1xuICAgIGNvbnN0IGlzWGxzeCA9IGdldElzWGxzeChyZXNvdXJjZSlcbiAgICBpZiAoIWlzWGxzeCkgcmV0dXJuIHVuZGVmaW5lZFxuXG4gICAgcmV0dXJuIGF3YWl0IGxvYWRYbHN4VGFibGUocmVzb3VyY2UsIG9wdGlvbnMpXG4gIH1cblxuICBhc3luYyBzYXZlVGFibGUodGFibGU6IFRhYmxlLCBvcHRpb25zOiBTYXZlVGFibGVPcHRpb25zKSB7XG4gICAgY29uc3QgeyBwYXRoLCBmb3JtYXQgfSA9IG9wdGlvbnNcblxuICAgIGNvbnN0IGlzWGxzeCA9IGdldElzWGxzeCh7IHBhdGgsIGZvcm1hdCB9KVxuICAgIGlmICghaXNYbHN4KSByZXR1cm4gdW5kZWZpbmVkXG5cbiAgICByZXR1cm4gYXdhaXQgc2F2ZVhsc3hUYWJsZSh0YWJsZSwgb3B0aW9ucylcbiAgfVxufVxuXG5mdW5jdGlvbiBnZXRJc1hsc3gocmVzb3VyY2U6IFBhcnRpYWw8UmVzb3VyY2U+KSB7XG4gIGNvbnN0IGZvcm1hdCA9IGluZmVyRm9ybWF0KHJlc291cmNlKVxuICByZXR1cm4gW1wieGxzeFwiXS5pbmNsdWRlcyhmb3JtYXQgPz8gXCJcIilcbn1cbiJdfQ==

package/build/plugins/xlxs/plugin.spec.d.ts

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