@frictionless-ts/table 1.0.1

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

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

package/build/plugins/csv/index.js

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

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

@@ -0,0 +1,8 @@
+import type { Resource } from "@frictionless-ts/metadata";
+import type { LoadTableOptions, SaveTableOptions } from "../../plugin.ts";
+import type { TablePlugin } from "../../plugin.ts";
+import type { Table } from "../../table/index.ts";
+export declare class CsvPlugin 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/csv/plugin.js

@@ -0,0 +1,22 @@
+import { inferFormat } from "@frictionless-ts/metadata";
+import { loadCsvTable, saveCsvTable } from "./table/index.js";
+export class CsvPlugin {
+    async loadTable(resource, options) {
+        const csvFormat = getCsvFormat(resource);
+        if (!csvFormat)
+            return undefined;
+        return await loadCsvTable({ ...resource, format: csvFormat }, options);
+    }
+    async saveTable(table, options) {
+        const { path, format } = options;
+        const csvFormat = getCsvFormat({ path, format });
+        if (!csvFormat)
+            return undefined;
+        return await saveCsvTable(table, { ...options, format: csvFormat });
+    }
+}
+function getCsvFormat(resource) {
+    const format = inferFormat(resource);
+    return format === "csv" || format === "tsv" ? format : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

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

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

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

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

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

package/build/plugins/csv/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 loadCsvTable(resource: Partial<Resource> & {
+    format?: "csv" | "tsv";
+}, options?: LoadTableOptions): Promise<pl.LazyDataFrame<any>>;

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

@@ -0,0 +1,86 @@
+import { resolveDialect, resolveSchema } from "@frictionless-ts/metadata";
+import { prefetchFiles } from "@frictionless-ts/dataset";
+import { inferSchemaFromTable } from "../../../schema/index.js";
+import { joinHeaderRows } from "../../../table/index.js";
+import { normalizeTable } from "../../../table/index.js";
+import { skipCommentRows } from "../../../table/index.js";
+import { stripInitialSpace } from "../../../table/index.js";
+import * as pl from "nodejs-polars";
+import { inferCsvDialect } from "../dialect/index.js";
+// TODO: Condier using sample to extract header first
+// for better commentChar + headerRows/commentRows support
+// (consult with the Data Package Working Group)
+export async function loadCsvTable(resource, options) {
+    const paths = await prefetchFiles(resource.path);
+    if (!paths.length) {
+        throw new Error("Resource path is not defined");
+    }
+    let dialect = await resolveDialect(resource.dialect);
+    if (!dialect) {
+        dialect = await inferCsvDialect({ ...resource, path: paths[0] }, options);
+    }
+    const scanOptions = getScanOptions(resource, dialect);
+    const tables = [];
+    for (const path of paths) {
+        const table = pl.scanCSV(path, scanOptions);
+        tables.push(table);
+    }
+    // There is no way to specify column names in nodejs-polars by default
+    // so we have to rename `column_*` to `field*` is table doesn't have header
+    let table = pl.concat(tables);
+    if (!scanOptions.hasHeader) {
+        table = table.rename(Object.fromEntries(table.columns.map(name => [name, name.replace("column_", "field")])));
+    }
+    if (dialect) {
+        table = await joinHeaderRows(table, { dialect });
+        table = skipCommentRows(table, { dialect });
+        table = stripInitialSpace(table, { dialect });
+    }
+    if (!options?.denormalized) {
+        let schema = await resolveSchema(resource.schema);
+        if (!schema)
+            schema = await inferSchemaFromTable(table, options);
+        table = await normalizeTable(table, schema);
+    }
+    return table;
+}
+function getScanOptions(resource, dialect) {
+    const options = {
+        inferSchemaLength: 0,
+        truncateRaggedLines: true,
+    };
+    if (resource.encoding) {
+        options.encoding = resource.encoding;
+        // Polars supports only utf-8 and utf-8-lossy encodings
+        if (options.encoding === "utf-8") {
+            options.encoding = "utf8";
+        }
+        if (options.encoding !== "utf8") {
+            throw new Error(`Encoding ${options.encoding} for CSV files is not supported`);
+        }
+    }
+    options.skipRows = getRowsToSkip(dialect);
+    options.hasHeader = dialect?.header !== false;
+    options.eolChar = dialect?.lineTerminator ?? "\n";
+    options.sep = dialect?.delimiter ?? ",";
+    // TODO: try convincing nodejs-polars to support escapeChar
+    // https://github.com/pola-rs/polars/issues/3074
+    //options.escapeChar = dialect?.escapeChar
+    options.quoteChar = dialect?.quoteChar ?? '"';
+    options.nullValues = dialect?.nullSequence;
+    // TODO: try convincing nodejs-polars to support doubleQuote
+    //options.doubleQuote = dialect?.doubleQuote ?? true
+    // TODO: remove ts-ignore when issues is fixed
+    // https://github.com/pola-rs/nodejs-polars/issues/334
+    // @ts-ignore
+    options.commentPrefix = dialect?.commentChar;
+    return options;
+}
+function getRowsToSkip(dialect) {
+    const headerRows = getHeaderRows(dialect);
+    return headerRows[0] ? headerRows[0] - 1 : 0;
+}
+function getHeaderRows(dialect) {
+    return dialect?.header !== false ? (dialect?.headerRows ?? [1]) : [];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"load.js","sourceRoot":"","sources":["../../../../plugins/csv/table/load.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Dialect, Resource } from \"@frictionless-ts/metadata\"\nimport { resolveDialect, resolveSchema } from \"@frictionless-ts/metadata\"\nimport { prefetchFiles } from \"@frictionless-ts/dataset\"\nimport type { LoadTableOptions } from \"../../../plugin.ts\"\nimport { inferSchemaFromTable } from \"../../../schema/index.ts\"\nimport { joinHeaderRows } from \"../../../table/index.ts\"\nimport { normalizeTable } from \"../../../table/index.ts\"\nimport { skipCommentRows } from \"../../../table/index.ts\"\nimport { stripInitialSpace } from \"../../../table/index.ts\"\nimport type { Table } from \"../../../table/index.ts\"\nimport * as pl from \"nodejs-polars\"\nimport { inferCsvDialect } from \"../dialect/index.ts\"\n\n// TODO: Condier using sample to extract header first\n// for better commentChar + headerRows/commentRows support\n// (consult with the Data Package Working Group)\n\nexport async function loadCsvTable(\n  resource: Partial<Resource> & { format?: \"csv\" | \"tsv\" },\n  options?: LoadTableOptions,\n) {\n  const paths = await prefetchFiles(resource.path)\n  if (!paths.length) {\n    throw new Error(\"Resource path is not defined\")\n  }\n\n  let dialect = await resolveDialect(resource.dialect)\n  if (!dialect) {\n    dialect = await inferCsvDialect({ ...resource, path: paths[0] }, options)\n  }\n\n  const scanOptions = getScanOptions(resource, dialect)\n  const tables: Table[] = []\n  for (const path of paths) {\n    const table = pl.scanCSV(path, scanOptions)\n    tables.push(table)\n  }\n\n  // There is no way to specify column names in nodejs-polars by default\n  // so we have to rename `column_*` to `field*` is table doesn't have header\n  let table = pl.concat(tables)\n  if (!scanOptions.hasHeader) {\n    table = table.rename(\n      Object.fromEntries(\n        table.columns.map(name => [name, name.replace(\"column_\", \"field\")]),\n      ),\n    )\n  }\n\n  if (dialect) {\n    table = await joinHeaderRows(table, { dialect })\n    table = skipCommentRows(table, { dialect })\n    table = stripInitialSpace(table, { dialect })\n  }\n\n  if (!options?.denormalized) {\n    let schema = await resolveSchema(resource.schema)\n    if (!schema) schema = await inferSchemaFromTable(table, options)\n    table = await normalizeTable(table, schema)\n  }\n\n  return table\n}\n\nfunction getScanOptions(resource: Partial<Resource>, dialect?: Dialect) {\n  const options: Partial<pl.ScanCsvOptions> = {\n    inferSchemaLength: 0,\n    truncateRaggedLines: true,\n  }\n\n  if (resource.encoding) {\n    options.encoding = resource.encoding\n\n    // Polars supports only utf-8 and utf-8-lossy encodings\n    if (options.encoding === \"utf-8\") {\n      options.encoding = \"utf8\"\n    }\n\n    if (options.encoding !== \"utf8\") {\n      throw new Error(`Encoding ${options.encoding} for CSV files is not supported`)\n    }\n  }\n\n  options.skipRows = getRowsToSkip(dialect)\n  options.hasHeader = dialect?.header !== false\n  options.eolChar = dialect?.lineTerminator ?? \"\\n\"\n  options.sep = dialect?.delimiter ?? \",\"\n\n  // TODO: try convincing nodejs-polars to support escapeChar\n  // https://github.com/pola-rs/polars/issues/3074\n  //options.escapeChar = dialect?.escapeChar\n\n  options.quoteChar = dialect?.quoteChar ?? '\"'\n  options.nullValues = dialect?.nullSequence\n\n  // TODO: try convincing nodejs-polars to support doubleQuote\n  //options.doubleQuote = dialect?.doubleQuote ?? true\n\n  // TODO: remove ts-ignore when issues is fixed\n  // https://github.com/pola-rs/nodejs-polars/issues/334\n  // @ts-ignore\n  options.commentPrefix = dialect?.commentChar\n\n  return options\n}\n\nfunction getRowsToSkip(dialect?: Dialect) {\n  const headerRows = getHeaderRows(dialect)\n  return headerRows[0] ? headerRows[0] - 1 : 0\n}\n\nfunction getHeaderRows(dialect?: Dialect) {\n  return dialect?.header !== false ? (dialect?.headerRows ?? [1]) : []\n}\n"]}

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

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