@frictionless-ts/table 1.0.1

package/build/plugins/arrow/plugin.js

@@ -0,0 +1,22 @@
+import { inferFormat } from "@frictionless-ts/metadata";
+import { loadArrowTable, saveArrowTable } from "./table/index.js";
+export class ArrowPlugin {
+    async loadTable(resource, options) {
+        const isArrow = getIsArrow(resource);
+        if (!isArrow)
+            return undefined;
+        return await loadArrowTable(resource, options);
+    }
+    async saveTable(table, options) {
+        const { path, format } = options;
+        const isArrow = getIsArrow({ path, format });
+        if (!isArrow)
+            return undefined;
+        return await saveArrowTable(table, options);
+    }
+}
+function getIsArrow(resource) {
+    const format = inferFormat(resource);
+    return format === "arrow" || format === "feather";
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

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

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

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

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

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

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

package/build/plugins/arrow/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 loadArrowTable(resource, options) {
+    const [firstPath, ...restPaths] = await prefetchFiles(resource.path);
+    if (!firstPath) {
+        throw new Error("Resource path is not defined");
+    }
+    let table = pl.scanIPC(firstPath);
+    if (restPaths.length) {
+        table = pl.concat([table, ...restPaths.map(path => pl.scanIPC(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/arrow/table/load.spec.d.ts

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

package/build/plugins/arrow/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 { loadArrowTable } from "./load.js";
+useRecording();
+describe("loadArrowTable", () => {
+    describe("file variations", () => {
+        it("should load local file", async () => {
+            const path = getTempFilePath();
+            pl.DataFrame({ id: [1, 2], name: ["english", "中文"] }).writeIPC(path);
+            const table = await loadArrowTable({ 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", "中文"] }).writeIPC(path1);
+            pl.DataFrame({ id: [1, 2], name: ["english", "中文"] }).writeIPC(path2);
+            const table = await loadArrowTable({ 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 loadArrowTable({
+                path: "https://raw.githubusercontent.com/datisthq/dpkit/refs/heads/main/arrow/table/fixtures/table.arrow",
+            });
+            expect((await table.collect()).toRecords()).toEqual([
+                { id: 1, name: "english" },
+                { id: 2, name: "中文" },
+            ]);
+        });
+        it("should load remote file (multipart)", async () => {
+            const table = await loadArrowTable({
+                path: [
+                    "https://raw.githubusercontent.com/datisthq/dpkit/refs/heads/main/arrow/table/fixtures/table.arrow",
+                    "https://raw.githubusercontent.com/datisthq/dpkit/refs/heads/main/arrow/table/fixtures/table.arrow",
+                ],
+            });
+            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/arrow/table/save.d.ts

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

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

@@ -0,0 +1,31 @@
+import { assertLocalPathVacant } from "@frictionless-ts/dataset";
+import { inferSchemaFromTable } from "../../../schema/index.js";
+import { denormalizeTable } from "../../../table/index.js";
+// TODO: rebase on sinkIPC when it is available
+// https://github.com/pola-rs/nodejs-polars/issues/353
+export async function saveArrowTable(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",
+        ],
+    });
+    const frame = await table.collect();
+    frame.writeIPC(path);
+    return path;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/build/plugins/arrow/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 { loadArrowTable } from "./load.js";
+import { saveArrowTable } from "./save.js";
+describe("saveArrowTable", () => {
+    it("should save table to Arrow file", async () => {
+        const path = getTempFilePath();
+        const source = pl
+            .DataFrame({
+            id: [1.0, 2.0, 3.0],
+            name: ["Alice", "Bob", "Charlie"],
+        })
+            .lazy();
+        await saveArrowTable(source, { path });
+        const table = await loadArrowTable({ 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 saveArrowTable(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 loadArrowTable({ 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/arrow/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 { loadArrowTable } from \"./load.ts\"\nimport { saveArrowTable } from \"./save.ts\"\n\ndescribe(\"saveArrowTable\", () => {\n  it(\"should save table to Arrow 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 saveArrowTable(source, { path })\n\n    const table = await loadArrowTable({ 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 saveArrowTable(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 loadArrowTable({ 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/csv/dialect/index.d.ts

@@ -0,0 +1 @@
+export { inferCsvDialect } from "./infer.ts";

package/build/plugins/csv/dialect/index.js

@@ -0,0 +1,2 @@
+export { inferCsvDialect } from "./infer.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wbHVnaW5zL2Nzdi9kaWFsZWN0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxZQUFZLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBpbmZlckNzdkRpYWxlY3QgfSBmcm9tIFwiLi9pbmZlci50c1wiXG4iXX0=

package/build/plugins/csv/dialect/infer.d.ts

@@ -0,0 +1,4 @@
+import type { Dialect, Resource } from "@frictionless-ts/metadata";
+export declare function inferCsvDialect(resource: Partial<Resource>, options?: {
+    sampleBytes?: number;
+}): Promise<Dialect>;

package/build/plugins/csv/dialect/infer.js

@@ -0,0 +1,44 @@
+import { text } from "node:stream/consumers";
+import { loadFileStream } from "@frictionless-ts/dataset";
+import { default as CsvSnifferFactory } from "csv-sniffer";
+const CSV_DELIMITERS = [",", ";", ":", "|", "\t", "^", "*", "&"];
+const TSV_DELIMITERS = ["\t"];
+export async function inferCsvDialect(resource, options) {
+    const { sampleBytes = 10_000 } = options ?? {};
+    const isTabs = resource.format === "tsv";
+    const dialect = {};
+    if (resource.path) {
+        const stream = await loadFileStream(resource.path, {
+            maxBytes: sampleBytes,
+        });
+        const sample = await text(stream);
+        const result = sniffSample(sample, isTabs ? TSV_DELIMITERS : CSV_DELIMITERS);
+        if (result?.delimiter) {
+            dialect.delimiter = result.delimiter;
+        }
+        if (result?.quoteChar) {
+            dialect.quoteChar = result.quoteChar;
+        }
+        //if (result.lineTerminator) {
+        //  dialect.lineTerminator = result.lineTerminator
+        //}
+        // TODO: it gives false positives
+        //if (!result.hasHeader) {
+        //  dialect.header = false
+        //}
+    }
+    return dialect;
+}
+// Sniffer can fail for some reasons
+function sniffSample(sample, delimiters) {
+    try {
+        const CsvSniffer = CsvSnifferFactory();
+        const sniffer = new CsvSniffer(delimiters);
+        const result = sniffer.sniff(sample);
+        return result;
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/plugins/csv/dialect/infer.spec.d.ts

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

package/build/plugins/csv/dialect/infer.spec.js

@@ -0,0 +1,54 @@
+import { writeTempFile } from "@frictionless-ts/dataset";
+import { describe, expect, it } from "vitest";
+import { inferCsvDialect } from "./infer.js";
+describe("inferCsvDialect", () => {
+    it("should infer a simple CSV file", async () => {
+        const path = await writeTempFile("id,name\n1,english\n2,中文");
+        const dialect = await inferCsvDialect({ path });
+        expect(dialect).toEqual({
+            delimiter: ",",
+        });
+    });
+    it("should infer quoteChar", async () => {
+        const path = await writeTempFile('id,name\n1,"John Doe"\n2,"Jane Smith"');
+        const dialect = await inferCsvDialect({ path });
+        expect(dialect).toEqual({
+            delimiter: ",",
+            quoteChar: '"',
+        });
+    });
+    it("should infer quoteChar with single quotes", async () => {
+        const path = await writeTempFile("id,name\n1,'John Doe'\n2,'Jane Smith'");
+        const dialect = await inferCsvDialect({ path });
+        expect(dialect).toEqual({
+            delimiter: ",",
+            quoteChar: "'",
+        });
+    });
+    // TODO: it gives false positives
+    it.skip("should infer header false when no header present", async () => {
+        const path = await writeTempFile("1,english\n2,中文\n3,español");
+        const dialect = await inferCsvDialect({ path });
+        expect(dialect).toEqual({
+            delimiter: ",",
+            header: false,
+        });
+    });
+    it("should not set header when header is present", async () => {
+        const path = await writeTempFile("id,name\n1,english\n2,中文");
+        const dialect = await inferCsvDialect({ path });
+        expect(dialect).toEqual({
+            delimiter: ",",
+        });
+    });
+    // TODO: recover if possible with csv-sniffer
+    it.skip("should infer complex CSV with quotes and header", async () => {
+        const path = await writeTempFile('name,description\n"Product A","A great product with, commas"\n"Product B","Another product"');
+        const dialect = await inferCsvDialect({ path });
+        expect(dialect).toEqual({
+            delimiter: ",",
+            quoteChar: '"',
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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