frictionless-ts 1.0.1

package/build/schema/infer.spec.js

@@ -0,0 +1,136 @@
+import { writeTempFile } from "@frictionless-ts/dataset";
+import { describe, expect, it } from "vitest";
+import { inferSchema } from "./infer.js";
+describe("inferSchema", () => {
+    it("should infer schema from CSV file", async () => {
+        const csvPath = await writeTempFile("id,name,age\n1,alice,25\n2,bob,30");
+        const resource = { path: csvPath, format: "csv" };
+        const schema = await inferSchema(resource);
+        expect(schema).toBeDefined();
+        expect(schema?.fields).toBeDefined();
+        expect(schema?.fields?.length).toBe(3);
+        expect(schema?.fields?.[0]?.name).toBe("id");
+        expect(schema?.fields?.[1]?.name).toBe("name");
+        expect(schema?.fields?.[2]?.name).toBe("age");
+    });
+    it("should infer field types correctly", async () => {
+        const csvPath = await writeTempFile("id,name,score\n1,alice,95.5\n2,bob,87.3");
+        const resource = { path: csvPath, format: "csv" };
+        const schema = await inferSchema(resource);
+        expect(schema?.fields?.[0]?.type).toBe("integer");
+        expect(schema?.fields?.[1]?.type).toBe("string");
+        expect(schema?.fields?.[2]?.type).toBe("number");
+    });
+    it("should infer schema from inline data", async () => {
+        const resource = {
+            name: "test-resource",
+            type: "table",
+            data: [
+                { id: 1, name: "alice" },
+                { id: 2, name: "bob" },
+            ],
+        };
+        const schema = await inferSchema(resource);
+        expect(schema).toBeDefined();
+        expect(schema?.fields).toBeDefined();
+        expect(schema?.fields?.length).toBe(2);
+        expect(schema?.fields?.[0]?.name).toBe("id");
+        expect(schema?.fields?.[1]?.name).toBe("name");
+    });
+    it("should infer schema with custom delimiter", async () => {
+        const csvPath = await writeTempFile("id|name|value\n1|alice|100\n2|bob|200");
+        const resource = {
+            path: csvPath,
+            format: "csv",
+            dialect: { delimiter: "|" },
+        };
+        const schema = await inferSchema(resource);
+        expect(schema).toBeDefined();
+        expect(schema?.fields).toBeDefined();
+        expect(schema?.fields?.length).toBe(3);
+        expect(schema?.fields?.[0]?.name).toBe("id");
+        expect(schema?.fields?.[1]?.name).toBe("name");
+        expect(schema?.fields?.[2]?.name).toBe("value");
+    });
+    it("should handle boolean fields", async () => {
+        const csvPath = await writeTempFile("id,active\n1,true\n2,false");
+        const resource = { path: csvPath, format: "csv" };
+        const schema = await inferSchema(resource);
+        expect(schema?.fields?.[1]?.type).toBe("boolean");
+    });
+    it("should handle date fields", async () => {
+        const csvPath = await writeTempFile("id,created\n1,2024-01-01\n2,2024-01-02");
+        const resource = { path: csvPath, format: "csv" };
+        const schema = await inferSchema(resource);
+        expect(schema?.fields?.[1]?.type).toBe("date");
+    });
+    it("should handle mixed numeric types", async () => {
+        const csvPath = await writeTempFile("id,value\n1,100\n2,200.5");
+        const resource = { path: csvPath, format: "csv" };
+        const schema = await inferSchema(resource);
+        expect(schema?.fields?.[1]?.type).toBe("string");
+    });
+    it("should infer schema from single row", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice");
+        const resource = { path: csvPath, format: "csv" };
+        const schema = await inferSchema(resource);
+        expect(schema).toBeDefined();
+        expect(schema?.fields).toBeDefined();
+        expect(schema?.fields?.length).toBe(2);
+    });
+    it("should handle empty string values", async () => {
+        const csvPath = await writeTempFile("id,name,email\n1,alice,\n2,bob,bob@example.com");
+        const resource = { path: csvPath, format: "csv" };
+        const schema = await inferSchema(resource);
+        expect(schema).toBeDefined();
+        expect(schema?.fields?.length).toBe(3);
+        expect(schema?.fields?.[2]?.name).toBe("email");
+    });
+    it("should infer schema with sampleRows option", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob\n3,charlie\n4,david\n5,eve");
+        const resource = { path: csvPath, format: "csv" };
+        const schema = await inferSchema(resource, { sampleRows: 2 });
+        expect(schema).toBeDefined();
+        expect(schema?.fields).toBeDefined();
+        expect(schema?.fields?.length).toBe(2);
+    });
+    it("should handle resources with headers only", async () => {
+        const csvPath = await writeTempFile("id,name,age");
+        const resource = { path: csvPath, format: "csv" };
+        const schema = await inferSchema(resource);
+        expect(schema).toBeDefined();
+        expect(schema?.fields).toBeDefined();
+        expect(schema?.fields?.length).toBe(3);
+    });
+    it("should infer schema from complex inline data", async () => {
+        const resource = {
+            name: "test-resource",
+            type: "table",
+            data: [
+                {
+                    id: 1,
+                    name: "alice",
+                    score: 95.5,
+                    active: true,
+                    created: "2024-01-01",
+                },
+                {
+                    id: 2,
+                    name: "bob",
+                    score: 87.3,
+                    active: false,
+                    created: "2024-01-02",
+                },
+            ],
+        };
+        const schema = await inferSchema(resource);
+        expect(schema).toBeDefined();
+        expect(schema?.fields?.length).toBe(5);
+        expect(schema?.fields?.find(f => f.name === "id")?.type).toBe("integer");
+        expect(schema?.fields?.find(f => f.name === "name")?.type).toBe("string");
+        expect(schema?.fields?.find(f => f.name === "score")?.type).toBe("number");
+        expect(schema?.fields?.find(f => f.name === "active")?.type).toBe("boolean");
+        expect(schema?.fields?.find(f => f.name === "created")?.type).toBe("date");
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"infer.spec.js","sourceRoot":"","sources":["../../schema/infer.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { writeTempFile } from \"@frictionless-ts/dataset\"\nimport { describe, expect, it } from \"vitest\"\nimport { inferSchema } from \"./infer.ts\"\n\ndescribe(\"inferSchema\", () => {\n  it(\"should infer schema from CSV file\", async () => {\n    const csvPath = await writeTempFile(\"id,name,age\\n1,alice,25\\n2,bob,30\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const schema = await inferSchema(resource)\n\n    expect(schema).toBeDefined()\n    expect(schema?.fields).toBeDefined()\n    expect(schema?.fields?.length).toBe(3)\n    expect(schema?.fields?.[0]?.name).toBe(\"id\")\n    expect(schema?.fields?.[1]?.name).toBe(\"name\")\n    expect(schema?.fields?.[2]?.name).toBe(\"age\")\n  })\n\n  it(\"should infer field types correctly\", async () => {\n    const csvPath = await writeTempFile(\n      \"id,name,score\\n1,alice,95.5\\n2,bob,87.3\",\n    )\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const schema = await inferSchema(resource)\n\n    expect(schema?.fields?.[0]?.type).toBe(\"integer\")\n    expect(schema?.fields?.[1]?.type).toBe(\"string\")\n    expect(schema?.fields?.[2]?.type).toBe(\"number\")\n  })\n\n  it(\"should infer schema from inline data\", async () => {\n    const resource = {\n      name: \"test-resource\",\n      type: \"table\" as const,\n      data: [\n        { id: 1, name: \"alice\" },\n        { id: 2, name: \"bob\" },\n      ],\n    }\n\n    const schema = await inferSchema(resource)\n\n    expect(schema).toBeDefined()\n    expect(schema?.fields).toBeDefined()\n    expect(schema?.fields?.length).toBe(2)\n    expect(schema?.fields?.[0]?.name).toBe(\"id\")\n    expect(schema?.fields?.[1]?.name).toBe(\"name\")\n  })\n\n  it(\"should infer schema with custom delimiter\", async () => {\n    const csvPath = await writeTempFile(\"id|name|value\\n1|alice|100\\n2|bob|200\")\n    const resource = {\n      path: csvPath,\n      format: \"csv\" as const,\n      dialect: { delimiter: \"|\" },\n    }\n\n    const schema = await inferSchema(resource)\n\n    expect(schema).toBeDefined()\n    expect(schema?.fields).toBeDefined()\n    expect(schema?.fields?.length).toBe(3)\n    expect(schema?.fields?.[0]?.name).toBe(\"id\")\n    expect(schema?.fields?.[1]?.name).toBe(\"name\")\n    expect(schema?.fields?.[2]?.name).toBe(\"value\")\n  })\n\n  it(\"should handle boolean fields\", async () => {\n    const csvPath = await writeTempFile(\"id,active\\n1,true\\n2,false\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const schema = await inferSchema(resource)\n\n    expect(schema?.fields?.[1]?.type).toBe(\"boolean\")\n  })\n\n  it(\"should handle date fields\", async () => {\n    const csvPath = await writeTempFile(\n      \"id,created\\n1,2024-01-01\\n2,2024-01-02\",\n    )\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const schema = await inferSchema(resource)\n\n    expect(schema?.fields?.[1]?.type).toBe(\"date\")\n  })\n\n  it(\"should handle mixed numeric types\", async () => {\n    const csvPath = await writeTempFile(\"id,value\\n1,100\\n2,200.5\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const schema = await inferSchema(resource)\n\n    expect(schema?.fields?.[1]?.type).toBe(\"string\")\n  })\n\n  it(\"should infer schema from single row\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const schema = await inferSchema(resource)\n\n    expect(schema).toBeDefined()\n    expect(schema?.fields).toBeDefined()\n    expect(schema?.fields?.length).toBe(2)\n  })\n\n  it(\"should handle empty string values\", async () => {\n    const csvPath = await writeTempFile(\n      \"id,name,email\\n1,alice,\\n2,bob,bob@example.com\",\n    )\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const schema = await inferSchema(resource)\n\n    expect(schema).toBeDefined()\n    expect(schema?.fields?.length).toBe(3)\n    expect(schema?.fields?.[2]?.name).toBe(\"email\")\n  })\n\n  it(\"should infer schema with sampleRows option\", async () => {\n    const csvPath = await writeTempFile(\n      \"id,name\\n1,alice\\n2,bob\\n3,charlie\\n4,david\\n5,eve\",\n    )\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const schema = await inferSchema(resource, { sampleRows: 2 })\n\n    expect(schema).toBeDefined()\n    expect(schema?.fields).toBeDefined()\n    expect(schema?.fields?.length).toBe(2)\n  })\n\n  it(\"should handle resources with headers only\", async () => {\n    const csvPath = await writeTempFile(\"id,name,age\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const schema = await inferSchema(resource)\n\n    expect(schema).toBeDefined()\n    expect(schema?.fields).toBeDefined()\n    expect(schema?.fields?.length).toBe(3)\n  })\n\n  it(\"should infer schema from complex inline data\", async () => {\n    const resource = {\n      name: \"test-resource\",\n      type: \"table\" as const,\n      data: [\n        {\n          id: 1,\n          name: \"alice\",\n          score: 95.5,\n          active: true,\n          created: \"2024-01-01\",\n        },\n        {\n          id: 2,\n          name: \"bob\",\n          score: 87.3,\n          active: false,\n          created: \"2024-01-02\",\n        },\n      ],\n    }\n\n    const schema = await inferSchema(resource)\n\n    expect(schema).toBeDefined()\n    expect(schema?.fields?.length).toBe(5)\n    expect(schema?.fields?.find(f => f.name === \"id\")?.type).toBe(\"integer\")\n    expect(schema?.fields?.find(f => f.name === \"name\")?.type).toBe(\"string\")\n    expect(schema?.fields?.find(f => f.name === \"score\")?.type).toBe(\"number\")\n    expect(schema?.fields?.find(f => f.name === \"active\")?.type).toBe(\"boolean\")\n    expect(schema?.fields?.find(f => f.name === \"created\")?.type).toBe(\"date\")\n  })\n})\n"]}

package/build/system.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from "./plugin.ts";
+export declare class System {
+    plugins: Plugin[];
+    register(PluginClass: new () => Plugin): void;
+}
+export declare const system: System;

package/build/system.js

@@ -0,0 +1,41 @@
+import { DatabasePlugin } from "@frictionless-ts/database";
+import { CkanPlugin } from "@frictionless-ts/dataset";
+import { DatahubPlugin } from "@frictionless-ts/dataset";
+import { DescriptorPlugin } from "@frictionless-ts/dataset";
+import { FolderPlugin } from "@frictionless-ts/dataset";
+import { GithubPlugin } from "@frictionless-ts/dataset";
+import { ZenodoPlugin } from "@frictionless-ts/dataset";
+import { ZipPlugin } from "@frictionless-ts/dataset";
+import { CsvPlugin } from "@frictionless-ts/table";
+import { ArrowPlugin } from "@frictionless-ts/table";
+import { InlinePlugin } from "@frictionless-ts/table";
+import { JsonPlugin } from "@frictionless-ts/table";
+import { OdsPlugin } from "@frictionless-ts/table";
+import { ParquetPlugin } from "@frictionless-ts/table";
+import { XlsxPlugin } from "@frictionless-ts/table";
+export class System {
+    plugins = [];
+    register(PluginClass) {
+        this.plugins.unshift(new PluginClass());
+    }
+}
+export const system = new System();
+// Dataset
+system.register(CkanPlugin);
+system.register(DatahubPlugin);
+system.register(DescriptorPlugin);
+system.register(GithubPlugin);
+system.register(ZenodoPlugin);
+system.register(FolderPlugin);
+system.register(ZipPlugin);
+// Table
+system.register(ArrowPlugin);
+system.register(CsvPlugin);
+system.register(InlinePlugin);
+system.register(JsonPlugin);
+system.register(OdsPlugin);
+system.register(ParquetPlugin);
+system.register(XlsxPlugin);
+// Mixed
+system.register(DatabasePlugin);
+//# sourceMappingURL=data:application/json;base64,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

package/build/table/index.d.ts

@@ -0,0 +1,3 @@
+export { loadTable } from "./load.ts";
+export { saveTable } from "./save.ts";
+export { validateTable } from "./validate.ts";

package/build/table/index.js

@@ -0,0 +1,4 @@
+export { loadTable } from "./load.js";
+export { saveTable } from "./save.js";
+export { validateTable } from "./validate.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90YWJsZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sV0FBVyxDQUFBO0FBQ3JDLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxXQUFXLENBQUE7QUFDckMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGVBQWUsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IGxvYWRUYWJsZSB9IGZyb20gXCIuL2xvYWQudHNcIlxuZXhwb3J0IHsgc2F2ZVRhYmxlIH0gZnJvbSBcIi4vc2F2ZS50c1wiXG5leHBvcnQgeyB2YWxpZGF0ZVRhYmxlIH0gZnJvbSBcIi4vdmFsaWRhdGUudHNcIlxuIl19

package/build/table/infer.d.ts

@@ -0,0 +1,6 @@
+import type { Resource } from "@frictionless-ts/metadata";
+export declare function inferTable(resource: Partial<Resource>): Promise<{
+    dialect: import("@frictionless-ts/metadata").Dialect;
+    schema: import("@frictionless-ts/metadata").Schema;
+    table: import("@frictionless-ts/table").Table;
+} | undefined>;

package/build/table/infer.js

@@ -0,0 +1,20 @@
+import { resolveDialect, resolveSchema } from "@frictionless-ts/metadata";
+import { inferSchemaFromTable } from "@frictionless-ts/table";
+import { inferDialect } from "../dialect/index.js";
+import { loadTable } from "./load.js";
+export async function inferTable(resource) {
+    let dialect = await resolveDialect(resource.dialect);
+    if (!dialect) {
+        dialect = await inferDialect(resource);
+    }
+    const table = await loadTable({ ...resource, dialect }, { denormalized: true });
+    if (!table) {
+        return undefined;
+    }
+    let schema = await resolveSchema(resource.schema);
+    if (!schema) {
+        schema = await inferSchemaFromTable(table);
+    }
+    return { dialect, schema, table };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/table/infer.spec.d.ts

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

package/build/table/infer.spec.js

@@ -0,0 +1,177 @@
+import { writeTempFile } from "@frictionless-ts/dataset";
+import { describe, expect, it } from "vitest";
+import { inferTable } from "./infer.js";
+describe("inferTable", () => {
+    it("should infer table with dialect and schema from CSV", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob");
+        const resource = { path: csvPath, format: "csv" };
+        const result = await inferTable(resource);
+        expect(result).toBeDefined();
+        expect(result?.dialect).toBeDefined();
+        expect(result?.schema).toBeDefined();
+        expect(result?.table).toBeDefined();
+    });
+    it("should use provided dialect when available", async () => {
+        const csvPath = await writeTempFile("id|name\n1|alice\n2|bob");
+        const resource = {
+            path: csvPath,
+            format: "csv",
+            dialect: { delimiter: "|" },
+        };
+        const result = await inferTable(resource);
+        expect(result).toBeDefined();
+        expect(result?.dialect).toBeDefined();
+        expect(result?.dialect.delimiter).toBe("|");
+        expect(result?.schema).toBeDefined();
+        expect(result?.table).toBeDefined();
+    });
+    it("should use provided schema when available", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,bob");
+        const resource = {
+            path: csvPath,
+            format: "csv",
+            schema: {
+                fields: [
+                    { name: "id", type: "integer" },
+                    { name: "name", type: "string" },
+                ],
+            },
+        };
+        const result = await inferTable(resource);
+        expect(result).toBeDefined();
+        expect(result?.dialect).toBeDefined();
+        expect(result?.schema).toBeDefined();
+        expect(result?.schema.fields).toHaveLength(2);
+        expect(result?.table).toBeDefined();
+    });
+    it("should infer table with custom delimiter", async () => {
+        const csvPath = await writeTempFile("id;name;age\n1;alice;25\n2;bob;30");
+        const resource = {
+            path: csvPath,
+            format: "csv",
+            dialect: { delimiter: ";" },
+        };
+        const result = await inferTable(resource);
+        expect(result).toBeDefined();
+        expect(result?.dialect).toBeDefined();
+        expect(result?.dialect.delimiter).toBe(";");
+        expect(result?.schema).toBeDefined();
+        expect(result?.table).toBeDefined();
+    });
+    it("should infer table from inline data", async () => {
+        const resource = {
+            name: "test-resource",
+            type: "table",
+            data: [
+                { id: 1, name: "alice" },
+                { id: 2, name: "bob" },
+            ],
+        };
+        const result = await inferTable(resource);
+        expect(result).toBeDefined();
+        expect(result?.dialect).toBeDefined();
+        expect(result?.schema).toBeDefined();
+        expect(result?.table).toBeDefined();
+    });
+    it("should infer schema with various data types", async () => {
+        const csvPath = await writeTempFile("id,name,score,active\n1,alice,95.5,true\n2,bob,87.3,false");
+        const resource = { path: csvPath, format: "csv" };
+        const result = await inferTable(resource);
+        expect(result).toBeDefined();
+        expect(result?.schema).toBeDefined();
+        expect(result?.schema.fields).toBeDefined();
+        expect(result?.table).toBeDefined();
+    });
+    it("should infer table with numeric columns", async () => {
+        const csvPath = await writeTempFile("id,score\n1,95.5\n2,87.3\n3,100");
+        const resource = { path: csvPath, format: "csv" };
+        const result = await inferTable(resource);
+        expect(result).toBeDefined();
+        expect(result?.schema).toBeDefined();
+        expect(result?.schema.fields).toBeDefined();
+        expect(result?.table).toBeDefined();
+    });
+    it("should infer table with date columns", async () => {
+        const csvPath = await writeTempFile("id,created\n1,2024-01-01\n2,2024-01-02");
+        const resource = { path: csvPath, format: "csv" };
+        const result = await inferTable(resource);
+        expect(result).toBeDefined();
+        expect(result?.schema).toBeDefined();
+        expect(result?.table).toBeDefined();
+    });
+    it("should infer table with boolean columns", async () => {
+        const csvPath = await writeTempFile("id,active\n1,true\n2,false\n3,true");
+        const resource = { path: csvPath, format: "csv" };
+        const result = await inferTable(resource);
+        expect(result).toBeDefined();
+        expect(result?.schema).toBeDefined();
+        expect(result?.table).toBeDefined();
+    });
+    it("should handle table with quoted fields", async () => {
+        const csvPath = await writeTempFile('id,name,description\n1,"alice","Test, data"\n2,"bob","Normal"');
+        const resource = { path: csvPath, format: "csv" };
+        const result = await inferTable(resource);
+        expect(result).toBeDefined();
+        expect(result?.dialect).toBeDefined();
+        expect(result?.schema).toBeDefined();
+        expect(result?.table).toBeDefined();
+    });
+    it("should infer table with single row", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice");
+        const resource = { path: csvPath, format: "csv" };
+        const result = await inferTable(resource);
+        expect(result).toBeDefined();
+        expect(result?.dialect).toBeDefined();
+        expect(result?.schema).toBeDefined();
+        expect(result?.table).toBeDefined();
+    });
+    it("should infer table with empty values", async () => {
+        const csvPath = await writeTempFile("id,name\n1,alice\n2,");
+        const resource = { path: csvPath, format: "csv" };
+        const result = await inferTable(resource);
+        expect(result).toBeDefined();
+        expect(result?.schema).toBeDefined();
+        expect(result?.table).toBeDefined();
+    });
+    it("should infer table with headers only", async () => {
+        const csvPath = await writeTempFile("id,name,age");
+        const resource = { path: csvPath, format: "csv" };
+        const result = await inferTable(resource);
+        expect(result).toBeDefined();
+    });
+    it("should use both provided dialect and schema", async () => {
+        const csvPath = await writeTempFile("id|name\n1|alice\n2|bob");
+        const resource = {
+            path: csvPath,
+            format: "csv",
+            dialect: { delimiter: "|" },
+            schema: {
+                fields: [
+                    { name: "id", type: "integer" },
+                    { name: "name", type: "string" },
+                ],
+            },
+        };
+        const result = await inferTable(resource);
+        expect(result).toBeDefined();
+        expect(result?.dialect).toBeDefined();
+        expect(result?.dialect.delimiter).toBe("|");
+        expect(result?.schema).toBeDefined();
+        expect(result?.schema.fields).toHaveLength(2);
+        expect(result?.table).toBeDefined();
+    });
+    it("should infer table with tab delimiter", async () => {
+        const csvPath = await writeTempFile("id\tname\n1\talice\n2\tbob");
+        const resource = {
+            path: csvPath,
+            format: "csv",
+            dialect: { delimiter: "\t" },
+        };
+        const result = await inferTable(resource);
+        expect(result).toBeDefined();
+        expect(result?.dialect).toBeDefined();
+        expect(result?.schema).toBeDefined();
+        expect(result?.table).toBeDefined();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"infer.spec.js","sourceRoot":"","sources":["../../table/infer.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { writeTempFile } from \"@frictionless-ts/dataset\"\nimport { describe, expect, it } from \"vitest\"\nimport { inferTable } from \"./infer.ts\"\n\ndescribe(\"inferTable\", () => {\n  it(\"should infer table with dialect and schema from CSV\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,bob\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const result = await inferTable(resource)\n\n    expect(result).toBeDefined()\n    expect(result?.dialect).toBeDefined()\n    expect(result?.schema).toBeDefined()\n    expect(result?.table).toBeDefined()\n  })\n\n  it(\"should use provided dialect when available\", async () => {\n    const csvPath = await writeTempFile(\"id|name\\n1|alice\\n2|bob\")\n    const resource = {\n      path: csvPath,\n      format: \"csv\" as const,\n      dialect: { delimiter: \"|\" },\n    }\n\n    const result = await inferTable(resource)\n\n    expect(result).toBeDefined()\n    expect(result?.dialect).toBeDefined()\n    expect(result?.dialect.delimiter).toBe(\"|\")\n    expect(result?.schema).toBeDefined()\n    expect(result?.table).toBeDefined()\n  })\n\n  it(\"should use provided schema when available\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,bob\")\n    const resource = {\n      path: csvPath,\n      format: \"csv\" as const,\n      schema: {\n        fields: [\n          { name: \"id\", type: \"integer\" as const },\n          { name: \"name\", type: \"string\" as const },\n        ],\n      },\n    }\n\n    const result = await inferTable(resource)\n\n    expect(result).toBeDefined()\n    expect(result?.dialect).toBeDefined()\n    expect(result?.schema).toBeDefined()\n    expect(result?.schema.fields).toHaveLength(2)\n    expect(result?.table).toBeDefined()\n  })\n\n  it(\"should infer table with custom delimiter\", async () => {\n    const csvPath = await writeTempFile(\"id;name;age\\n1;alice;25\\n2;bob;30\")\n    const resource = {\n      path: csvPath,\n      format: \"csv\" as const,\n      dialect: { delimiter: \";\" },\n    }\n\n    const result = await inferTable(resource)\n\n    expect(result).toBeDefined()\n    expect(result?.dialect).toBeDefined()\n    expect(result?.dialect.delimiter).toBe(\";\")\n    expect(result?.schema).toBeDefined()\n    expect(result?.table).toBeDefined()\n  })\n\n  it(\"should infer table from inline data\", async () => {\n    const resource = {\n      name: \"test-resource\",\n      type: \"table\" as const,\n      data: [\n        { id: 1, name: \"alice\" },\n        { id: 2, name: \"bob\" },\n      ],\n    }\n\n    const result = await inferTable(resource)\n\n    expect(result).toBeDefined()\n    expect(result?.dialect).toBeDefined()\n    expect(result?.schema).toBeDefined()\n    expect(result?.table).toBeDefined()\n  })\n\n  it(\"should infer schema with various data types\", async () => {\n    const csvPath = await writeTempFile(\n      \"id,name,score,active\\n1,alice,95.5,true\\n2,bob,87.3,false\",\n    )\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const result = await inferTable(resource)\n\n    expect(result).toBeDefined()\n    expect(result?.schema).toBeDefined()\n    expect(result?.schema.fields).toBeDefined()\n    expect(result?.table).toBeDefined()\n  })\n\n  it(\"should infer table with numeric columns\", async () => {\n    const csvPath = await writeTempFile(\"id,score\\n1,95.5\\n2,87.3\\n3,100\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const result = await inferTable(resource)\n\n    expect(result).toBeDefined()\n    expect(result?.schema).toBeDefined()\n    expect(result?.schema.fields).toBeDefined()\n    expect(result?.table).toBeDefined()\n  })\n\n  it(\"should infer table with date columns\", async () => {\n    const csvPath = await writeTempFile(\n      \"id,created\\n1,2024-01-01\\n2,2024-01-02\",\n    )\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const result = await inferTable(resource)\n\n    expect(result).toBeDefined()\n    expect(result?.schema).toBeDefined()\n    expect(result?.table).toBeDefined()\n  })\n\n  it(\"should infer table with boolean columns\", async () => {\n    const csvPath = await writeTempFile(\"id,active\\n1,true\\n2,false\\n3,true\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const result = await inferTable(resource)\n\n    expect(result).toBeDefined()\n    expect(result?.schema).toBeDefined()\n    expect(result?.table).toBeDefined()\n  })\n\n  it(\"should handle table with quoted fields\", async () => {\n    const csvPath = await writeTempFile(\n      'id,name,description\\n1,\"alice\",\"Test, data\"\\n2,\"bob\",\"Normal\"',\n    )\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const result = await inferTable(resource)\n\n    expect(result).toBeDefined()\n    expect(result?.dialect).toBeDefined()\n    expect(result?.schema).toBeDefined()\n    expect(result?.table).toBeDefined()\n  })\n\n  it(\"should infer table with single row\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const result = await inferTable(resource)\n\n    expect(result).toBeDefined()\n    expect(result?.dialect).toBeDefined()\n    expect(result?.schema).toBeDefined()\n    expect(result?.table).toBeDefined()\n  })\n\n  it(\"should infer table with empty values\", async () => {\n    const csvPath = await writeTempFile(\"id,name\\n1,alice\\n2,\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const result = await inferTable(resource)\n\n    expect(result).toBeDefined()\n    expect(result?.schema).toBeDefined()\n    expect(result?.table).toBeDefined()\n  })\n\n  it(\"should infer table with headers only\", async () => {\n    const csvPath = await writeTempFile(\"id,name,age\")\n    const resource = { path: csvPath, format: \"csv\" as const }\n\n    const result = await inferTable(resource)\n\n    expect(result).toBeDefined()\n  })\n\n  it(\"should use both provided dialect and schema\", async () => {\n    const csvPath = await writeTempFile(\"id|name\\n1|alice\\n2|bob\")\n    const resource = {\n      path: csvPath,\n      format: \"csv\" as const,\n      dialect: { delimiter: \"|\" },\n      schema: {\n        fields: [\n          { name: \"id\", type: \"integer\" as const },\n          { name: \"name\", type: \"string\" as const },\n        ],\n      },\n    }\n\n    const result = await inferTable(resource)\n\n    expect(result).toBeDefined()\n    expect(result?.dialect).toBeDefined()\n    expect(result?.dialect.delimiter).toBe(\"|\")\n    expect(result?.schema).toBeDefined()\n    expect(result?.schema.fields).toHaveLength(2)\n    expect(result?.table).toBeDefined()\n  })\n\n  it(\"should infer table with tab delimiter\", async () => {\n    const csvPath = await writeTempFile(\"id\\tname\\n1\\talice\\n2\\tbob\")\n    const resource = {\n      path: csvPath,\n      format: \"csv\" as const,\n      dialect: { delimiter: \"\\t\" },\n    }\n\n    const result = await inferTable(resource)\n\n    expect(result).toBeDefined()\n    expect(result?.dialect).toBeDefined()\n    expect(result?.schema).toBeDefined()\n    expect(result?.table).toBeDefined()\n  })\n})\n"]}

package/build/table/load.d.ts

@@ -0,0 +1,3 @@
+import type { Resource } from "@frictionless-ts/metadata";
+import type { LoadTableOptions } from "@frictionless-ts/table";
+export declare function loadTable(resource: Partial<Resource>, options?: LoadTableOptions): Promise<import("@frictionless-ts/table").Table | undefined>;

package/build/table/load.js

@@ -0,0 +1,11 @@
+import { system } from "../system.js";
+export async function loadTable(resource, options) {
+    for (const plugin of system.plugins) {
+        const table = await plugin.loadTable?.(resource, options);
+        if (table) {
+            return table;
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RhYmxlL2xvYWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLGNBQWMsQ0FBQTtBQUVyQyxNQUFNLENBQUMsS0FBSyxVQUFVLFNBQVMsQ0FDN0IsUUFBMkIsRUFDM0IsT0FBMEI7SUFFMUIsS0FBSyxNQUFNLE1BQU0sSUFBSSxNQUFNLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDcEMsTUFBTSxLQUFLLEdBQUcsTUFBTSxNQUFNLENBQUMsU0FBUyxFQUFFLENBQUMsUUFBUSxFQUFFLE9BQU8sQ0FBQyxDQUFBO1FBQ3pELElBQUksS0FBSyxFQUFFLENBQUM7WUFDVixPQUFPLEtBQUssQ0FBQTtRQUNkLENBQUM7SUFDSCxDQUFDO0lBRUQsT0FBTyxTQUFTLENBQUE7QUFDbEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgUmVzb3VyY2UgfSBmcm9tIFwiQGZyaWN0aW9ubGVzcy10cy9tZXRhZGF0YVwiXG5pbXBvcnQgdHlwZSB7IExvYWRUYWJsZU9wdGlvbnMgfSBmcm9tIFwiQGZyaWN0aW9ubGVzcy10cy90YWJsZVwiXG5pbXBvcnQgeyBzeXN0ZW0gfSBmcm9tIFwiLi4vc3lzdGVtLnRzXCJcblxuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGxvYWRUYWJsZShcbiAgcmVzb3VyY2U6IFBhcnRpYWw8UmVzb3VyY2U+LFxuICBvcHRpb25zPzogTG9hZFRhYmxlT3B0aW9ucyxcbikge1xuICBmb3IgKGNvbnN0IHBsdWdpbiBvZiBzeXN0ZW0ucGx1Z2lucykge1xuICAgIGNvbnN0IHRhYmxlID0gYXdhaXQgcGx1Z2luLmxvYWRUYWJsZT8uKHJlc291cmNlLCBvcHRpb25zKVxuICAgIGlmICh0YWJsZSkge1xuICAgICAgcmV0dXJuIHRhYmxlXG4gICAgfVxuICB9XG5cbiAgcmV0dXJuIHVuZGVmaW5lZFxufVxuIl19

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

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