@frictionless-ts/table 1.0.1

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

@@ -0,0 +1,293 @@
+import { Buffer } from "node:buffer";
+import { writeTempFile } from "@frictionless-ts/dataset";
+import { describe, expect, it } from "vitest";
+import { useRecording } from "vitest-polly";
+import { loadCsvTable } from "./load.js";
+useRecording();
+describe("loadCsvTable", () => {
+    it("should load local file", async () => {
+        const path = await writeTempFile("id,name\n1,english\n2,中文");
+        const table = await loadCsvTable({ path });
+        expect((await table.collect()).toRecords()).toEqual([
+            { id: 1, name: "english" },
+            { id: 2, name: "中文" },
+        ]);
+    });
+    it("should load local file (multipart)", async () => {
+        const path1 = await writeTempFile("id,name\n1,english");
+        const path2 = await writeTempFile("id,name\n2,中文\n3,german");
+        const table = await loadCsvTable({ path: [path1, path2] });
+        expect((await table.collect()).toRecords()).toEqual([
+            { id: 1, name: "english" },
+            { id: 2, name: "中文" },
+            { id: 3, name: "german" },
+        ]);
+    });
+    it.fails("should load remote file", async () => {
+        const table = await loadCsvTable({
+            path: "https://raw.githubusercontent.com/datisthq/dpkit/refs/heads/main/csv/table/fixtures/table.csv",
+        });
+        expect((await table.collect()).toRecords()).toEqual([
+            { id: 1, name: "english" },
+            { id: 2, name: "中文" },
+        ]);
+    });
+    it.fails("should load remote file (multipart)", async () => {
+        const table = await loadCsvTable({
+            path: [
+                "https://raw.githubusercontent.com/datisthq/dpkit/refs/heads/main/csv/table/fixtures/table.csv",
+                "https://raw.githubusercontent.com/datisthq/dpkit/refs/heads/main/csv/table/fixtures/table.csv",
+            ],
+        });
+        expect((await table.collect()).toRecords()).toEqual([
+            { id: 1, name: "english" },
+            { id: 2, name: "中文" },
+            { id: 1, name: "english" },
+            { id: 2, name: "中文" },
+        ]);
+    });
+    it("should handle windows line terminator by default", async () => {
+        const path = await writeTempFile("id,name\r\n1,english\r\n2,中文");
+        const table = await loadCsvTable({ path });
+        expect((await table.collect()).toRecords()).toEqual([
+            { id: 1, name: "english" },
+            { id: 2, name: "中文" },
+        ]);
+    });
+    it("should handle custom delimiter", async () => {
+        const path = await writeTempFile("id|name\n1|alice\n2|bob");
+        const table = await loadCsvTable({
+            path,
+            dialect: { delimiter: "|" },
+        });
+        expect((await table.collect()).toRecords()).toEqual([
+            { id: 1, name: "alice" },
+            { id: 2, name: "bob" },
+        ]);
+    });
+    it("should handle files without header", async () => {
+        const path = await writeTempFile("1,alice\n2,bob");
+        const table = await loadCsvTable({
+            path,
+            dialect: { header: false },
+        });
+        const records = (await table.collect()).toRecords();
+        expect(records).toEqual([
+            { field1: 1, field2: "alice" },
+            { field1: 2, field2: "bob" },
+        ]);
+    });
+    it("should handle custom line terminator", async () => {
+        const path = await writeTempFile("id,name|1,alice|2,bob");
+        const table = await loadCsvTable({
+            path,
+            dialect: { lineTerminator: "|" },
+        });
+        expect((await table.collect()).toRecords()).toEqual([
+            { id: 1, name: "alice" },
+            { id: 2, name: "bob" },
+        ]);
+    });
+    it.skip("should handle escape char", async () => {
+        const path = await writeTempFile("id,name\n1,apple|,fruits\n2,orange|,fruits");
+        const table = await loadCsvTable({
+            path,
+            dialect: { escapeChar: "|" },
+        });
+        expect((await table.collect()).toRecords()).toEqual([
+            { id: 1, name: "apple,fruits" },
+            { id: 2, name: "orange,fruits" },
+        ]);
+    });
+    it("should handle custom quote character", async () => {
+        const path = await writeTempFile("id,name\n1,'alice smith'\n2,'bob jones'");
+        const table = await loadCsvTable({
+            path,
+            dialect: { quoteChar: "'" },
+        });
+        expect((await table.collect()).toRecords()).toEqual([
+            { id: 1, name: "alice smith" },
+            { id: 2, name: "bob jones" },
+        ]);
+    });
+    it("should handle double quote by default", async () => {
+        const path = await writeTempFile('id,name\n1,"alice""smith"\n2,"bob""jones"');
+        const table = await loadCsvTable({
+            path,
+            dialect: { doubleQuote: true },
+        });
+        expect((await table.collect()).toRecords()).toEqual([
+            { id: 1, name: 'alice"smith' },
+            { id: 2, name: 'bob"jones' },
+        ]);
+    });
+    it.skip("should handle disabling double quote", async () => {
+        const path = await writeTempFile('id,name\n1,"alice""smith"\n2,"bob""jones"');
+        const table = await loadCsvTable({
+            path,
+            dialect: { doubleQuote: false },
+        });
+        expect((await table.collect()).toRecords()).toEqual([
+            { id: 1, name: "alicesmith" },
+            { id: 2, name: "bobjones" },
+        ]);
+    });
+    it("should handle comment character", async () => {
+        const path = await writeTempFile("# This is a comment\nid,name\n1,alice\n# Another comment\n2,bob");
+        const table = await loadCsvTable({
+            path,
+            dialect: { commentChar: "#" },
+        });
+        const records = (await table.collect()).toRecords();
+        expect(records).toEqual([
+            { id: 1, name: "alice" },
+            { id: 2, name: "bob" },
+        ]);
+    });
+    it("should support headerRows", async () => {
+        const path = await writeTempFile("#comment\nid,name\n1,alice\n2,bob");
+        const table = await loadCsvTable({
+            path,
+            dialect: { headerRows: [2] },
+        });
+        const records = (await table.collect()).toRecords();
+        expect(records).toEqual([
+            { id: 1, name: "alice" },
+            { id: 2, name: "bob" },
+        ]);
+    });
+    it("should support headerJoin", async () => {
+        const path = await writeTempFile("#comment\nid,name\nint,str\n1,alice\n2,bob");
+        const table = await loadCsvTable({
+            path,
+            dialect: { headerRows: [2, 3], headerJoin: "_" },
+        });
+        const records = (await table.collect()).toRecords();
+        expect(records).toEqual([
+            { id_int: 1, name_str: "alice" },
+            { id_int: 2, name_str: "bob" },
+        ]);
+    });
+    it("should support commentRows", async () => {
+        const path = await writeTempFile("id,name\n1,alice\ncomment\n2,bob");
+        const table = await loadCsvTable({
+            path,
+            dialect: { commentRows: [3] },
+        });
+        const records = (await table.collect()).toRecords();
+        expect(records).toEqual([
+            { id: 1, name: "alice" },
+            { id: 2, name: "bob" },
+        ]);
+    });
+    it("should support headerRows and commentRows", async () => {
+        const path = await writeTempFile("#comment\nid,name\n1,alice\n#comment\n2,bob");
+        const table = await loadCsvTable({
+            path,
+            dialect: { headerRows: [2], commentRows: [4] },
+        });
+        const records = (await table.collect()).toRecords();
+        expect(records).toEqual([
+            { id: 1, name: "alice" },
+            { id: 2, name: "bob" },
+        ]);
+    });
+    it("should support headerJoin and commentRows", async () => {
+        const path = await writeTempFile("#comment\nid,name\nint,str\n1,alice\n#comment\n2,bob");
+        const table = await loadCsvTable({
+            path,
+            dialect: { headerRows: [2, 3], headerJoin: "_", commentRows: [5] },
+        });
+        const records = (await table.collect()).toRecords();
+        expect(records).toEqual([
+            { id_int: 1, name_str: "alice" },
+            { id_int: 2, name_str: "bob" },
+        ]);
+    });
+    it("should handle null sequence", async () => {
+        const path = await writeTempFile("id,name,age\n1,alice,25\n2,N/A,30\n3,bob,N/A");
+        const table = await loadCsvTable({
+            path,
+            dialect: { nullSequence: "N/A" },
+        });
+        expect((await table.collect()).toRecords()).toEqual([
+            { id: 1, name: "alice", age: 25 },
+            { id: 2, name: null, age: 30 },
+            { id: 3, name: "bob", age: null },
+        ]);
+    });
+    it("should handle skip initial space", async () => {
+        const path = await writeTempFile("id,name,category\n1, alice, fruits\n2,  bob,  vegetables\n3,charlie,grains");
+        const table = await loadCsvTable({
+            path,
+            dialect: { skipInitialSpace: true },
+        });
+        expect((await table.collect()).toRecords()).toEqual([
+            { id: 1, name: "alice", category: "fruits" },
+            { id: 2, name: "bob", category: "vegetables" },
+            { id: 3, name: "charlie", category: "grains" },
+        ]);
+    });
+    it("should handle multiple dialect options together", async () => {
+        const path = await writeTempFile("#comment\nid|'full name'|age\n1|'alice smith'|25\n2|'bob jones'|30");
+        const table = await loadCsvTable({
+            path,
+            dialect: {
+                delimiter: "|",
+                quoteChar: "'",
+                commentChar: "#",
+                header: true,
+            },
+        });
+        expect((await table.collect()).toRecords()).toEqual([
+            { id: 1, "full name": "alice smith", age: 25 },
+            { id: 2, "full name": "bob jones", age: 30 },
+        ]);
+    });
+    it("should handle utf8 encoding", async () => {
+        const path = await writeTempFile(Buffer.from("id,name\n1,café\n2,naïve", "utf8"));
+        const table = await loadCsvTable({
+            path,
+            encoding: "utf8",
+        });
+        expect((await table.collect()).toRecords()).toEqual([
+            { id: 1, name: "café" },
+            { id: 2, name: "naïve" },
+        ]);
+    });
+    // TODO: currently not supported by nodejs-polars
+    it.skip("should handle utf16 encoding", async () => {
+        const path = await writeTempFile(Buffer.from("id,name\n1,café\n2,naïve", "utf16le"));
+        const table = await loadCsvTable({
+            path,
+            encoding: "utf16",
+        });
+        expect((await table.collect()).toRecords()).toEqual([
+            { id: 1, name: "café" },
+            { id: 2, name: "naïve" },
+        ]);
+    });
+    // TODO: currently not supported by nodejs-polars
+    it.skip("should handle latin1 encoding", async () => {
+        const path = await writeTempFile(Buffer.from("id,name\n1,café\n2,résumé", "latin1"));
+        const table = await loadCsvTable({
+            path,
+            encoding: "latin1",
+        });
+        expect((await table.collect()).toRecords()).toEqual([
+            { id: 1, name: "café" },
+            { id: 2, name: "résumé" },
+        ]);
+    });
+});
+describe("loadCsvTable (format=tsv)", () => {
+    it("should load local file", async () => {
+        const path = await writeTempFile("id\tname\n1\tenglish\n2\t中文");
+        const table = await loadCsvTable({ path, format: "tsv" });
+        expect((await table.collect()).toRecords()).toEqual([
+            { id: 1, name: "english" },
+            { id: 2, name: "中文" },
+        ]);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"load.spec.js","sourceRoot":"","sources":["../../../../plugins/csv/table/load.spec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AACxD,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAA;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAExC,YAAY,EAAE,CAAA;AAEd,QAAQ,CAAC,cAAc,EAAE,GAAG,EAAE;IAC5B,EAAE,CAAC,wBAAwB,EAAE,KAAK,IAAI,EAAE;QACtC,MAAM,IAAI,GAAG,MAAM,aAAa,CAAC,0BAA0B,CAAC,CAAA;QAC5D,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC,EAAE,IAAI,EAAE,CAAC,CAAA;QAE1C,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC;YAClD,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE;YAC1B,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE;SACtB,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,oCAAoC,EAAE,KAAK,IAAI,EAAE;QAClD,MAAM,KAAK,GAAG,MAAM,aAAa,CAAC,oBAAoB,CAAC,CAAA;QACvD,MAAM,KAAK,GAAG,MAAM,aAAa,CAAC,yBAAyB,CAAC,CAAA;QAE5D,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC,CAAA;QAE1D,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC;YAClD,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE;YAC1B,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE;YACrB,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE;SAC1B,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,KAAK,CAAC,yBAAyB,EAAE,KAAK,IAAI,EAAE;QAC7C,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC;YAC/B,IAAI,EAAE,+FAA+F;SACtG,CAAC,CAAA;QAEF,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC;YAClD,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE;YAC1B,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE;SACtB,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,KAAK,CAAC,qCAAqC,EAAE,KAAK,IAAI,EAAE;QACzD,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC;YAC/B,IAAI,EAAE;gBACJ,+FAA+F;gBAC/F,+FAA+F;aAChG;SACF,CAAC,CAAA;QAEF,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC;YAClD,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE;YAC1B,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE;YACrB,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE;YAC1B,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE;SACtB,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,kDAAkD,EAAE,KAAK,IAAI,EAAE;QAChE,MAAM,IAAI,GAAG,MAAM,aAAa,CAAC,8BAA8B,CAAC,CAAA;QAChE,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC,EAAE,IAAI,EAAE,CAAC,CAAA;QAE1C,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC;YAClD,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE;YAC1B,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE;SACtB,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,gCAAgC,EAAE,KAAK,IAAI,EAAE;QAC9C,MAAM,IAAI,GAAG,MAAM,aAAa,CAAC,yBAAyB,CAAC,CAAA;QAC3D,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC;YAC/B,IAAI;YACJ,OAAO,EAAE,EAAE,SAAS,EAAE,GAAG,EAAE;SAC5B,CAAC,CAAA;QAEF,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC;YAClD,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE;YACxB,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE;SACvB,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,oCAAoC,EAAE,KAAK,IAAI,EAAE;QAClD,MAAM,IAAI,GAAG,MAAM,aAAa,CAAC,gBAAgB,CAAC,CAAA;QAClD,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC;YAC/B,IAAI;YACJ,OAAO,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE;SAC3B,CAAC,CAAA;QAEF,MAAM,OAAO,GAAG,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE,CAAA;QACnD,MAAM,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC;YACtB,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE;YAC9B,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE;SAC7B,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,sCAAsC,EAAE,KAAK,IAAI,EAAE;QACpD,MAAM,IAAI,GAAG,MAAM,aAAa,CAAC,uBAAuB,CAAC,CAAA;QACzD,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC;YAC/B,IAAI;YACJ,OAAO,EAAE,EAAE,cAAc,EAAE,GAAG,EAAE;SACjC,CAAC,CAAA;QAEF,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC;YAClD,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE;YACxB,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE;SACvB,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,IAAI,CAAC,2BAA2B,EAAE,KAAK,IAAI,EAAE;QAC9C,MAAM,IAAI,GAAG,MAAM,aAAa,CAC9B,4CAA4C,CAC7C,CAAA;QAED,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC;YAC/B,IAAI;YACJ,OAAO,EAAE,EAAE,UAAU,EAAE,GAAG,EAAE;SAC7B,CAAC,CAAA;QAEF,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC;YAClD,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE;YAC/B,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE;SACjC,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,sCAAsC,EAAE,KAAK,IAAI,EAAE;QACpD,MAAM,IAAI,GAAG,MAAM,aAAa,CAAC,yCAAyC,CAAC,CAAA;QAE3E,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC;YAC/B,IAAI;YACJ,OAAO,EAAE,EAAE,SAAS,EAAE,GAAG,EAAE;SAC5B,CAAC,CAAA;QAEF,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC;YAClD,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE;YAC9B,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE;SAC7B,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,uCAAuC,EAAE,KAAK,IAAI,EAAE;QACrD,MAAM,IAAI,GAAG,MAAM,aAAa,CAC9B,2CAA2C,CAC5C,CAAA;QAED,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC;YAC/B,IAAI;YACJ,OAAO,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE;SAC/B,CAAC,CAAA;QAEF,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC;YAClD,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE;YAC9B,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE;SAC7B,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,IAAI,CAAC,sCAAsC,EAAE,KAAK,IAAI,EAAE;QACzD,MAAM,IAAI,GAAG,MAAM,aAAa,CAC9B,2CAA2C,CAC5C,CAAA;QAED,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC;YAC/B,IAAI;YACJ,OAAO,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE;SAChC,CAAC,CAAA;QAEF,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC;YAClD,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE;YAC7B,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE;SAC5B,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,iCAAiC,EAAE,KAAK,IAAI,EAAE;QAC/C,MAAM,IAAI,GAAG,MAAM,aAAa,CAC9B,iEAAiE,CAClE,CAAA;QAED,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC;YAC/B,IAAI;YACJ,OAAO,EAAE,EAAE,WAAW,EAAE,GAAG,EAAE;SAC9B,CAAC,CAAA;QAEF,MAAM,OAAO,GAAG,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE,CAAA;QACnD,MAAM,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC;YACtB,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE;YACxB,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE;SACvB,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,2BAA2B,EAAE,KAAK,IAAI,EAAE;QACzC,MAAM,IAAI,GAAG,MAAM,aAAa,CAAC,mCAAmC,CAAC,CAAA;QAErE,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC;YAC/B,IAAI;YACJ,OAAO,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE;SAC7B,CAAC,CAAA;QAEF,MAAM,OAAO,GAAG,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE,CAAA;QACnD,MAAM,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC;YACtB,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE;YACxB,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE;SACvB,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,2BAA2B,EAAE,KAAK,IAAI,EAAE;QACzC,MAAM,IAAI,GAAG,MAAM,aAAa,CAC9B,4CAA4C,CAC7C,CAAA;QAED,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC;YAC/B,IAAI;YACJ,OAAO,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,EAAE,GAAG,EAAE;SACjD,CAAC,CAAA;QAEF,MAAM,OAAO,GAAG,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE,CAAA;QACnD,MAAM,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC;YACtB,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE;YAChC,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE;SAC/B,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,4BAA4B,EAAE,KAAK,IAAI,EAAE;QAC1C,MAAM,IAAI,GAAG,MAAM,aAAa,CAAC,kCAAkC,CAAC,CAAA;QAEpE,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC;YAC/B,IAAI;YACJ,OAAO,EAAE,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE;SAC9B,CAAC,CAAA;QAEF,MAAM,OAAO,GAAG,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE,CAAA;QACnD,MAAM,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC;YACtB,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE;YACxB,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE;SACvB,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,2CAA2C,EAAE,KAAK,IAAI,EAAE;QACzD,MAAM,IAAI,GAAG,MAAM,aAAa,CAC9B,6CAA6C,CAC9C,CAAA;QAED,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC;YAC/B,IAAI;YACJ,OAAO,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE;SAC/C,CAAC,CAAA;QAEF,MAAM,OAAO,GAAG,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE,CAAA;QACnD,MAAM,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC;YACtB,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE;YACxB,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE;SACvB,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,2CAA2C,EAAE,KAAK,IAAI,EAAE;QACzD,MAAM,IAAI,GAAG,MAAM,aAAa,CAC9B,sDAAsD,CACvD,CAAA;QAED,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC;YAC/B,IAAI;YACJ,OAAO,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,EAAE,GAAG,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE;SACnE,CAAC,CAAA;QAEF,MAAM,OAAO,GAAG,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE,CAAA;QACnD,MAAM,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC;YACtB,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE;YAChC,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE;SAC/B,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,6BAA6B,EAAE,KAAK,IAAI,EAAE;QAC3C,MAAM,IAAI,GAAG,MAAM,aAAa,CAC9B,8CAA8C,CAC/C,CAAA;QACD,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC;YAC/B,IAAI;YACJ,OAAO,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE;SACjC,CAAC,CAAA;QAEF,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC;YAClD,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,EAAE,EAAE;YACjC,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE;YAC9B,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE;SAClC,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,kCAAkC,EAAE,KAAK,IAAI,EAAE;QAChD,MAAM,IAAI,GAAG,MAAM,aAAa,CAC9B,4EAA4E,CAC7E,CAAA;QACD,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC;YAC/B,IAAI;YACJ,OAAO,EAAE,EAAE,gBAAgB,EAAE,IAAI,EAAE;SACpC,CAAC,CAAA;QAEF,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC;YAClD,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE;YAC5C,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE;YAC9C,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE;SAC/C,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,iDAAiD,EAAE,KAAK,IAAI,EAAE;QAC/D,MAAM,IAAI,GAAG,MAAM,aAAa,CAC9B,oEAAoE,CACrE,CAAA;QACD,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC;YAC/B,IAAI;YACJ,OAAO,EAAE;gBACP,SAAS,EAAE,GAAG;gBACd,SAAS,EAAE,GAAG;gBACd,WAAW,EAAE,GAAG;gBAChB,MAAM,EAAE,IAAI;aACb;SACF,CAAC,CAAA;QAEF,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC;YAClD,EAAE,EAAE,EAAE,CAAC,EAAE,WAAW,EAAE,aAAa,EAAE,GAAG,EAAE,EAAE,EAAE;YAC9C,EAAE,EAAE,EAAE,CAAC,EAAE,WAAW,EAAE,WAAW,EAAE,GAAG,EAAE,EAAE,EAAE;SAC7C,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,6BAA6B,EAAE,KAAK,IAAI,EAAE;QAC3C,MAAM,IAAI,GAAG,MAAM,aAAa,CAC9B,MAAM,CAAC,IAAI,CAAC,0BAA0B,EAAE,MAAM,CAAC,CAChD,CAAA;QAED,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC;YAC/B,IAAI;YACJ,QAAQ,EAAE,MAAM;SACjB,CAAC,CAAA;QAEF,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC;YAClD,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE;YACvB,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE;SACzB,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,iDAAiD;IACjD,EAAE,CAAC,IAAI,CAAC,8BAA8B,EAAE,KAAK,IAAI,EAAE;QACjD,MAAM,IAAI,GAAG,MAAM,aAAa,CAC9B,MAAM,CAAC,IAAI,CAAC,0BAA0B,EAAE,SAAS,CAAC,CACnD,CAAA;QAED,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC;YAC/B,IAAI;YACJ,QAAQ,EAAE,OAAO;SAClB,CAAC,CAAA;QAEF,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC;YAClD,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE;YACvB,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE;SACzB,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,iDAAiD;IACjD,EAAE,CAAC,IAAI,CAAC,+BAA+B,EAAE,KAAK,IAAI,EAAE;QAClD,MAAM,IAAI,GAAG,MAAM,aAAa,CAC9B,MAAM,CAAC,IAAI,CAAC,2BAA2B,EAAE,QAAQ,CAAC,CACnD,CAAA;QAED,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC;YAC/B,IAAI;YACJ,QAAQ,EAAE,QAAQ;SACnB,CAAC,CAAA;QAEF,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC;YAClD,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE;YACvB,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE;SAC1B,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA;AAEF,QAAQ,CAAC,2BAA2B,EAAE,GAAG,EAAE;IACzC,EAAE,CAAC,wBAAwB,EAAE,KAAK,IAAI,EAAE;QACtC,MAAM,IAAI,GAAG,MAAM,aAAa,CAAC,6BAA6B,CAAC,CAAA;QAC/D,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAA;QAEzD,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC;YAClD,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE;YAC1B,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE;SACtB,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA","sourcesContent":["import { Buffer } from \"node:buffer\"\nimport { writeTempFile } from \"@frictionless-ts/dataset\"\nimport { describe, expect, it } from \"vitest\"\nimport { useRecording } from \"vitest-polly\"\nimport { loadCsvTable } from \"./load.ts\"\n\nuseRecording()\n\ndescribe(\"loadCsvTable\", () => {\n  it(\"should load local file\", async () => {\n    const path = await writeTempFile(\"id,name\\n1,english\\n2,中文\")\n    const table = await loadCsvTable({ path })\n\n    expect((await table.collect()).toRecords()).toEqual([\n      { id: 1, name: \"english\" },\n      { id: 2, name: \"中文\" },\n    ])\n  })\n\n  it(\"should load local file (multipart)\", async () => {\n    const path1 = await writeTempFile(\"id,name\\n1,english\")\n    const path2 = await writeTempFile(\"id,name\\n2,中文\\n3,german\")\n\n    const table = await loadCsvTable({ path: [path1, path2] })\n\n    expect((await table.collect()).toRecords()).toEqual([\n      { id: 1, name: \"english\" },\n      { id: 2, name: \"中文\" },\n      { id: 3, name: \"german\" },\n    ])\n  })\n\n  it.fails(\"should load remote file\", async () => {\n    const table = await loadCsvTable({\n      path: \"https://raw.githubusercontent.com/datisthq/dpkit/refs/heads/main/csv/table/fixtures/table.csv\",\n    })\n\n    expect((await table.collect()).toRecords()).toEqual([\n      { id: 1, name: \"english\" },\n      { id: 2, name: \"中文\" },\n    ])\n  })\n\n  it.fails(\"should load remote file (multipart)\", async () => {\n    const table = await loadCsvTable({\n      path: [\n        \"https://raw.githubusercontent.com/datisthq/dpkit/refs/heads/main/csv/table/fixtures/table.csv\",\n        \"https://raw.githubusercontent.com/datisthq/dpkit/refs/heads/main/csv/table/fixtures/table.csv\",\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  it(\"should handle windows line terminator by default\", async () => {\n    const path = await writeTempFile(\"id,name\\r\\n1,english\\r\\n2,中文\")\n    const table = await loadCsvTable({ path })\n\n    expect((await table.collect()).toRecords()).toEqual([\n      { id: 1, name: \"english\" },\n      { id: 2, name: \"中文\" },\n    ])\n  })\n\n  it(\"should handle custom delimiter\", async () => {\n    const path = await writeTempFile(\"id|name\\n1|alice\\n2|bob\")\n    const table = await loadCsvTable({\n      path,\n      dialect: { delimiter: \"|\" },\n    })\n\n    expect((await table.collect()).toRecords()).toEqual([\n      { id: 1, name: \"alice\" },\n      { id: 2, name: \"bob\" },\n    ])\n  })\n\n  it(\"should handle files without header\", async () => {\n    const path = await writeTempFile(\"1,alice\\n2,bob\")\n    const table = await loadCsvTable({\n      path,\n      dialect: { header: false },\n    })\n\n    const records = (await table.collect()).toRecords()\n    expect(records).toEqual([\n      { field1: 1, field2: \"alice\" },\n      { field1: 2, field2: \"bob\" },\n    ])\n  })\n\n  it(\"should handle custom line terminator\", async () => {\n    const path = await writeTempFile(\"id,name|1,alice|2,bob\")\n    const table = await loadCsvTable({\n      path,\n      dialect: { lineTerminator: \"|\" },\n    })\n\n    expect((await table.collect()).toRecords()).toEqual([\n      { id: 1, name: \"alice\" },\n      { id: 2, name: \"bob\" },\n    ])\n  })\n\n  it.skip(\"should handle escape char\", async () => {\n    const path = await writeTempFile(\n      \"id,name\\n1,apple|,fruits\\n2,orange|,fruits\",\n    )\n\n    const table = await loadCsvTable({\n      path,\n      dialect: { escapeChar: \"|\" },\n    })\n\n    expect((await table.collect()).toRecords()).toEqual([\n      { id: 1, name: \"apple,fruits\" },\n      { id: 2, name: \"orange,fruits\" },\n    ])\n  })\n\n  it(\"should handle custom quote character\", async () => {\n    const path = await writeTempFile(\"id,name\\n1,'alice smith'\\n2,'bob jones'\")\n\n    const table = await loadCsvTable({\n      path,\n      dialect: { quoteChar: \"'\" },\n    })\n\n    expect((await table.collect()).toRecords()).toEqual([\n      { id: 1, name: \"alice smith\" },\n      { id: 2, name: \"bob jones\" },\n    ])\n  })\n\n  it(\"should handle double quote by default\", async () => {\n    const path = await writeTempFile(\n      'id,name\\n1,\"alice\"\"smith\"\\n2,\"bob\"\"jones\"',\n    )\n\n    const table = await loadCsvTable({\n      path,\n      dialect: { doubleQuote: true },\n    })\n\n    expect((await table.collect()).toRecords()).toEqual([\n      { id: 1, name: 'alice\"smith' },\n      { id: 2, name: 'bob\"jones' },\n    ])\n  })\n\n  it.skip(\"should handle disabling double quote\", async () => {\n    const path = await writeTempFile(\n      'id,name\\n1,\"alice\"\"smith\"\\n2,\"bob\"\"jones\"',\n    )\n\n    const table = await loadCsvTable({\n      path,\n      dialect: { doubleQuote: false },\n    })\n\n    expect((await table.collect()).toRecords()).toEqual([\n      { id: 1, name: \"alicesmith\" },\n      { id: 2, name: \"bobjones\" },\n    ])\n  })\n\n  it(\"should handle comment character\", async () => {\n    const path = await writeTempFile(\n      \"# This is a comment\\nid,name\\n1,alice\\n# Another comment\\n2,bob\",\n    )\n\n    const table = await loadCsvTable({\n      path,\n      dialect: { commentChar: \"#\" },\n    })\n\n    const records = (await table.collect()).toRecords()\n    expect(records).toEqual([\n      { id: 1, name: \"alice\" },\n      { id: 2, name: \"bob\" },\n    ])\n  })\n\n  it(\"should support headerRows\", async () => {\n    const path = await writeTempFile(\"#comment\\nid,name\\n1,alice\\n2,bob\")\n\n    const table = await loadCsvTable({\n      path,\n      dialect: { headerRows: [2] },\n    })\n\n    const records = (await table.collect()).toRecords()\n    expect(records).toEqual([\n      { id: 1, name: \"alice\" },\n      { id: 2, name: \"bob\" },\n    ])\n  })\n\n  it(\"should support headerJoin\", async () => {\n    const path = await writeTempFile(\n      \"#comment\\nid,name\\nint,str\\n1,alice\\n2,bob\",\n    )\n\n    const table = await loadCsvTable({\n      path,\n      dialect: { headerRows: [2, 3], headerJoin: \"_\" },\n    })\n\n    const records = (await table.collect()).toRecords()\n    expect(records).toEqual([\n      { id_int: 1, name_str: \"alice\" },\n      { id_int: 2, name_str: \"bob\" },\n    ])\n  })\n\n  it(\"should support commentRows\", async () => {\n    const path = await writeTempFile(\"id,name\\n1,alice\\ncomment\\n2,bob\")\n\n    const table = await loadCsvTable({\n      path,\n      dialect: { commentRows: [3] },\n    })\n\n    const records = (await table.collect()).toRecords()\n    expect(records).toEqual([\n      { id: 1, name: \"alice\" },\n      { id: 2, name: \"bob\" },\n    ])\n  })\n\n  it(\"should support headerRows and commentRows\", async () => {\n    const path = await writeTempFile(\n      \"#comment\\nid,name\\n1,alice\\n#comment\\n2,bob\",\n    )\n\n    const table = await loadCsvTable({\n      path,\n      dialect: { headerRows: [2], commentRows: [4] },\n    })\n\n    const records = (await table.collect()).toRecords()\n    expect(records).toEqual([\n      { id: 1, name: \"alice\" },\n      { id: 2, name: \"bob\" },\n    ])\n  })\n\n  it(\"should support headerJoin and commentRows\", async () => {\n    const path = await writeTempFile(\n      \"#comment\\nid,name\\nint,str\\n1,alice\\n#comment\\n2,bob\",\n    )\n\n    const table = await loadCsvTable({\n      path,\n      dialect: { headerRows: [2, 3], headerJoin: \"_\", commentRows: [5] },\n    })\n\n    const records = (await table.collect()).toRecords()\n    expect(records).toEqual([\n      { id_int: 1, name_str: \"alice\" },\n      { id_int: 2, name_str: \"bob\" },\n    ])\n  })\n\n  it(\"should handle null sequence\", async () => {\n    const path = await writeTempFile(\n      \"id,name,age\\n1,alice,25\\n2,N/A,30\\n3,bob,N/A\",\n    )\n    const table = await loadCsvTable({\n      path,\n      dialect: { nullSequence: \"N/A\" },\n    })\n\n    expect((await table.collect()).toRecords()).toEqual([\n      { id: 1, name: \"alice\", age: 25 },\n      { id: 2, name: null, age: 30 },\n      { id: 3, name: \"bob\", age: null },\n    ])\n  })\n\n  it(\"should handle skip initial space\", async () => {\n    const path = await writeTempFile(\n      \"id,name,category\\n1, alice, fruits\\n2,  bob,  vegetables\\n3,charlie,grains\",\n    )\n    const table = await loadCsvTable({\n      path,\n      dialect: { skipInitialSpace: true },\n    })\n\n    expect((await table.collect()).toRecords()).toEqual([\n      { id: 1, name: \"alice\", category: \"fruits\" },\n      { id: 2, name: \"bob\", category: \"vegetables\" },\n      { id: 3, name: \"charlie\", category: \"grains\" },\n    ])\n  })\n\n  it(\"should handle multiple dialect options together\", async () => {\n    const path = await writeTempFile(\n      \"#comment\\nid|'full name'|age\\n1|'alice smith'|25\\n2|'bob jones'|30\",\n    )\n    const table = await loadCsvTable({\n      path,\n      dialect: {\n        delimiter: \"|\",\n        quoteChar: \"'\",\n        commentChar: \"#\",\n        header: true,\n      },\n    })\n\n    expect((await table.collect()).toRecords()).toEqual([\n      { id: 1, \"full name\": \"alice smith\", age: 25 },\n      { id: 2, \"full name\": \"bob jones\", age: 30 },\n    ])\n  })\n\n  it(\"should handle utf8 encoding\", async () => {\n    const path = await writeTempFile(\n      Buffer.from(\"id,name\\n1,café\\n2,naïve\", \"utf8\"),\n    )\n\n    const table = await loadCsvTable({\n      path,\n      encoding: \"utf8\",\n    })\n\n    expect((await table.collect()).toRecords()).toEqual([\n      { id: 1, name: \"café\" },\n      { id: 2, name: \"naïve\" },\n    ])\n  })\n\n  // TODO: currently not supported by nodejs-polars\n  it.skip(\"should handle utf16 encoding\", async () => {\n    const path = await writeTempFile(\n      Buffer.from(\"id,name\\n1,café\\n2,naïve\", \"utf16le\"),\n    )\n\n    const table = await loadCsvTable({\n      path,\n      encoding: \"utf16\",\n    })\n\n    expect((await table.collect()).toRecords()).toEqual([\n      { id: 1, name: \"café\" },\n      { id: 2, name: \"naïve\" },\n    ])\n  })\n\n  // TODO: currently not supported by nodejs-polars\n  it.skip(\"should handle latin1 encoding\", async () => {\n    const path = await writeTempFile(\n      Buffer.from(\"id,name\\n1,café\\n2,résumé\", \"latin1\"),\n    )\n\n    const table = await loadCsvTable({\n      path,\n      encoding: \"latin1\",\n    })\n\n    expect((await table.collect()).toRecords()).toEqual([\n      { id: 1, name: \"café\" },\n      { id: 2, name: \"résumé\" },\n    ])\n  })\n})\n\ndescribe(\"loadCsvTable (format=tsv)\", () => {\n  it(\"should load local file\", async () => {\n    const path = await writeTempFile(\"id\\tname\\n1\\tenglish\\n2\\t中文\")\n    const table = await loadCsvTable({ path, format: \"tsv\" })\n\n    expect((await table.collect()).toRecords()).toEqual([\n      { id: 1, name: \"english\" },\n      { id: 2, name: \"中文\" },\n    ])\n  })\n})\n"]}

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

@@ -0,0 +1,5 @@
+import type { SaveTableOptions } from "../../../plugin.ts";
+import type { Table } from "../../../table/index.ts";
+export declare function saveCsvTable(table: Table, options: SaveTableOptions & {
+    format?: "csv" | "tsv";
+}): Promise<string>;

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

@@ -0,0 +1,29 @@
+import { assertLocalPathVacant } from "@frictionless-ts/dataset";
+import { inferSchemaFromTable } from "../../../schema/index.js";
+import { denormalizeTable } from "../../../table/index.js";
+export async function saveCsvTable(table, options) {
+    const { path, format, overwrite } = options;
+    const isTabs = format === "tsv";
+    if (!overwrite) {
+        await assertLocalPathVacant(path);
+    }
+    const schema = options.schema ??
+        (await inferSchemaFromTable(table, {
+            ...options,
+            keepStrings: true,
+        }));
+    table = await denormalizeTable(table, schema, {
+        nativeTypes: ["string"],
+    });
+    await table
+        .sinkCSV(path, {
+        maintainOrder: true,
+        includeHeader: options.dialect?.header ?? true,
+        separator: options.dialect?.delimiter ?? (isTabs ? "\t" : ","),
+        //lineTerminator: options.dialect?.lineTerminator ?? "\r\n",
+        quoteChar: options.dialect?.quoteChar ?? '"',
+    })
+        .collect();
+    return path;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1,137 @@
+import { readFile } from "node:fs/promises";
+import { getTempFilePath } from "@frictionless-ts/dataset";
+import * as pl from "nodejs-polars";
+import { describe, expect, it } from "vitest";
+import { loadCsvTable } from "./load.js";
+import { saveCsvTable } from "./save.js";
+describe("saveCsvTable", () => {
+    it("should save table to file", async () => {
+        const path = getTempFilePath();
+        const table = pl
+            .DataFrame({
+            id: [1.0, 2.0, 3.0],
+            name: ["Alice", "Bob", "Charlie"],
+        })
+            .lazy();
+        await saveCsvTable(table, { path });
+        const content = await readFile(path, "utf-8");
+        expect(content).toEqual("id,name\n1.0,Alice\n2.0,Bob\n3.0,Charlie\n");
+    });
+    it("should save with custom delimiter", async () => {
+        const path = getTempFilePath();
+        const table = pl
+            .DataFrame({
+            id: [1.0, 2.0, 3.0],
+            name: ["Alice", "Bob", "Charlie"],
+        })
+            .lazy();
+        await saveCsvTable(table, {
+            path,
+            dialect: { delimiter: ";" },
+        });
+        const content = await readFile(path, "utf-8");
+        expect(content).toEqual("id;name\n1.0;Alice\n2.0;Bob\n3.0;Charlie\n");
+    });
+    it("should save without header", async () => {
+        const path = getTempFilePath();
+        const table = pl
+            .DataFrame({
+            id: [1.0, 2.0, 3.0],
+            name: ["Alice", "Bob", "Charlie"],
+        })
+            .lazy();
+        await saveCsvTable(table, {
+            path,
+            dialect: { header: false },
+        });
+        const content = await readFile(path, "utf-8");
+        expect(content).toEqual("1.0,Alice\n2.0,Bob\n3.0,Charlie\n");
+    });
+    it("should save with custom quote char", async () => {
+        const path = getTempFilePath();
+        const table = pl
+            .DataFrame({
+            id: [1.0, 2.0, 3.0],
+            name: ["Alice,Smith", "Bob,Jones", "Charlie,Brown"],
+        })
+            .lazy();
+        await saveCsvTable(table, {
+            path,
+            dialect: { quoteChar: "'" },
+        });
+        const content = await readFile(path, "utf-8");
+        expect(content).toEqual("id,name\n1.0,'Alice,Smith'\n2.0,'Bob,Jones'\n3.0,'Charlie,Brown'\n");
+    });
+    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 saveCsvTable(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 loadCsvTable({ 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",
+            },
+        ]);
+    });
+});
+describe("saveCsvTable (format=tsv)", () => {
+    it("should save table to file", async () => {
+        const path = getTempFilePath();
+        const table = pl
+            .DataFrame({
+            id: [1.0, 2.0, 3.0],
+            name: ["Alice", "Bob", "Charlie"],
+        })
+            .lazy();
+        await saveCsvTable(table, { path, format: "tsv" });
+        const content = await readFile(path, "utf-8");
+        expect(content).toEqual("id\tname\n1.0\tAlice\n2.0\tBob\n3.0\tCharlie\n");
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"save.spec.js","sourceRoot":"","sources":["../../../../plugins/csv/table/save.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { readFile } from \"node:fs/promises\"\nimport { getTempFilePath } from \"@frictionless-ts/dataset\"\nimport * as pl from \"nodejs-polars\"\nimport { describe, expect, it } from \"vitest\"\nimport { loadCsvTable } from \"./load.ts\"\nimport { saveCsvTable } from \"./save.ts\"\n\ndescribe(\"saveCsvTable\", () => {\n  it(\"should save table to file\", async () => {\n    const path = getTempFilePath()\n    const table = pl\n      .DataFrame({\n        id: [1.0, 2.0, 3.0],\n        name: [\"Alice\", \"Bob\", \"Charlie\"],\n      })\n      .lazy()\n\n    await saveCsvTable(table, { path })\n\n    const content = await readFile(path, \"utf-8\")\n    expect(content).toEqual(\"id,name\\n1.0,Alice\\n2.0,Bob\\n3.0,Charlie\\n\")\n  })\n\n  it(\"should save with custom delimiter\", async () => {\n    const path = getTempFilePath()\n    const table = pl\n      .DataFrame({\n        id: [1.0, 2.0, 3.0],\n        name: [\"Alice\", \"Bob\", \"Charlie\"],\n      })\n      .lazy()\n\n    await saveCsvTable(table, {\n      path,\n      dialect: { delimiter: \";\" },\n    })\n\n    const content = await readFile(path, \"utf-8\")\n    expect(content).toEqual(\"id;name\\n1.0;Alice\\n2.0;Bob\\n3.0;Charlie\\n\")\n  })\n\n  it(\"should save without header\", async () => {\n    const path = getTempFilePath()\n    const table = pl\n      .DataFrame({\n        id: [1.0, 2.0, 3.0],\n        name: [\"Alice\", \"Bob\", \"Charlie\"],\n      })\n      .lazy()\n\n    await saveCsvTable(table, {\n      path,\n      dialect: { header: false },\n    })\n\n    const content = await readFile(path, \"utf-8\")\n    expect(content).toEqual(\"1.0,Alice\\n2.0,Bob\\n3.0,Charlie\\n\")\n  })\n\n  it(\"should save with custom quote char\", async () => {\n    const path = getTempFilePath()\n    const table = pl\n      .DataFrame({\n        id: [1.0, 2.0, 3.0],\n        name: [\"Alice,Smith\", \"Bob,Jones\", \"Charlie,Brown\"],\n      })\n      .lazy()\n\n    await saveCsvTable(table, {\n      path,\n      dialect: { quoteChar: \"'\" },\n    })\n\n    const content = await readFile(path, \"utf-8\")\n    expect(content).toEqual(\n      \"id,name\\n1.0,'Alice,Smith'\\n2.0,'Bob,Jones'\\n3.0,'Charlie,Brown'\\n\",\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 saveCsvTable(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 loadCsvTable({ 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\ndescribe(\"saveCsvTable (format=tsv)\", () => {\n  it(\"should save table to file\", async () => {\n    const path = getTempFilePath()\n    const table = pl\n      .DataFrame({\n        id: [1.0, 2.0, 3.0],\n        name: [\"Alice\", \"Bob\", \"Charlie\"],\n      })\n      .lazy()\n\n    await saveCsvTable(table, { path, format: \"tsv\" })\n\n    const content = await readFile(path, \"utf-8\")\n    expect(content).toEqual(\"id\\tname\\n1.0\\tAlice\\n2.0\\tBob\\n3.0\\tCharlie\\n\")\n  })\n})\n"]}

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

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

package/build/plugins/inline/index.js

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

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

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

package/build/plugins/inline/plugin.js

@@ -0,0 +1,14 @@
+import { loadInlineTable } from "./table/index.js";
+export class InlinePlugin {
+    async loadTable(resource, options) {
+        const isInline = getIsInline(resource);
+        if (!isInline)
+            return undefined;
+        return await loadInlineTable(resource, options);
+    }
+}
+function getIsInline(resource) {
+    const isTable = resource.type === "table" || !!resource.schema;
+    return isTable && !!resource.data;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2luLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcGx1Z2lucy9pbmxpbmUvcGx1Z2luLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQTtBQUVsRCxNQUFNLE9BQU8sWUFBWTtJQUN2QixLQUFLLENBQUMsU0FBUyxDQUFDLFFBQWtCLEVBQUUsT0FBMEI7UUFDNUQsTUFBTSxRQUFRLEdBQUcsV0FBVyxDQUFDLFFBQVEsQ0FBQyxDQUFBO1FBQ3RDLElBQUksQ0FBQyxRQUFRO1lBQUUsT0FBTyxTQUFTLENBQUE7UUFFL0IsT0FBTyxNQUFNLGVBQWUsQ0FBQyxRQUFRLEVBQUUsT0FBTyxDQUFDLENBQUE7SUFDakQsQ0FBQztDQUNGO0FBRUQsU0FBUyxXQUFXLENBQUMsUUFBa0I7SUFDckMsTUFBTSxPQUFPLEdBQUcsUUFBUSxDQUFDLElBQUksS0FBSyxPQUFPLElBQUksQ0FBQyxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUE7SUFDOUQsT0FBTyxPQUFPLElBQUksQ0FBQyxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUE7QUFDbkMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgUmVzb3VyY2UgfSBmcm9tIFwiQGZyaWN0aW9ubGVzcy10cy9tZXRhZGF0YVwiXG5pbXBvcnQgdHlwZSB7IExvYWRUYWJsZU9wdGlvbnMsIFRhYmxlUGx1Z2luIH0gZnJvbSBcIi4uLy4uL3BsdWdpbi50c1wiXG5pbXBvcnQgeyBsb2FkSW5saW5lVGFibGUgfSBmcm9tIFwiLi90YWJsZS9pbmRleC50c1wiXG5cbmV4cG9ydCBjbGFzcyBJbmxpbmVQbHVnaW4gaW1wbGVtZW50cyBUYWJsZVBsdWdpbiB7XG4gIGFzeW5jIGxvYWRUYWJsZShyZXNvdXJjZTogUmVzb3VyY2UsIG9wdGlvbnM/OiBMb2FkVGFibGVPcHRpb25zKSB7XG4gICAgY29uc3QgaXNJbmxpbmUgPSBnZXRJc0lubGluZShyZXNvdXJjZSlcbiAgICBpZiAoIWlzSW5saW5lKSByZXR1cm4gdW5kZWZpbmVkXG5cbiAgICByZXR1cm4gYXdhaXQgbG9hZElubGluZVRhYmxlKHJlc291cmNlLCBvcHRpb25zKVxuICB9XG59XG5cbmZ1bmN0aW9uIGdldElzSW5saW5lKHJlc291cmNlOiBSZXNvdXJjZSkge1xuICBjb25zdCBpc1RhYmxlID0gcmVzb3VyY2UudHlwZSA9PT0gXCJ0YWJsZVwiIHx8ICEhcmVzb3VyY2Uuc2NoZW1hXG4gIHJldHVybiBpc1RhYmxlICYmICEhcmVzb3VyY2UuZGF0YVxufVxuIl19

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

@@ -0,0 +1 @@
+export { loadInlineTable } from "./load.ts";

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

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

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

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