@frictionless-ts/table 1.0.1

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

@@ -0,0 +1,24 @@
+import { resolveDialect } from "@frictionless-ts/metadata";
+import { resolveSchema } from "@frictionless-ts/metadata";
+import { getRecordsFromRows } from "../../../data/index.js";
+import { inferSchemaFromTable } from "../../../schema/index.js";
+import { normalizeTable } from "../../../table/index.js";
+import * as pl from "nodejs-polars";
+export async function loadInlineTable(resource, options) {
+    const data = resource.data;
+    if (!Array.isArray(data)) {
+        throw new Error("Resource data is not defined or tabular");
+    }
+    const dialect = await resolveDialect(resource.dialect);
+    const isRows = data.every(row => Array.isArray(row));
+    const records = isRows ? getRecordsFromRows(data, dialect) : data;
+    let table = pl.DataFrame(records).lazy();
+    if (!options?.denormalized) {
+        let schema = await resolveSchema(resource.schema);
+        if (!schema)
+            schema = await inferSchemaFromTable(table, options);
+        table = await normalizeTable(table, schema);
+    }
+    return table;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1,160 @@
+import { describe, expect, it } from "vitest";
+import { loadInlineTable } from "./load.js";
+describe("loadInlineTable", () => {
+    it("should throw on no data", async () => {
+        const resource = { name: "test" };
+        await expect(loadInlineTable(resource)).rejects.toThrow("Resource data is not defined or tabular");
+    });
+    it("should throw on bad data", async () => {
+        const resource = { name: "test", data: "bad" };
+        await expect(loadInlineTable(resource)).rejects.toThrow("Resource data is not defined or tabular");
+    });
+    it("should read arrays", async () => {
+        const resource = {
+            name: "test",
+            type: "table",
+            data: [
+                ["id", "name"],
+                [1, "english"],
+                [2, "中文"],
+            ],
+        };
+        const table = await loadInlineTable(resource);
+        const frame = await table.collect();
+        expect([
+            { id: 1, name: "english" },
+            { id: 2, name: "中文" },
+        ]).toEqual(frame.toRecords());
+    });
+    it("should read objects", async () => {
+        const resource = {
+            name: "test",
+            type: "table",
+            data: [
+                { id: 1, name: "english" },
+                { id: 2, name: "中文" },
+            ],
+            schema: undefined,
+        };
+        // @ts-ignore
+        const table = await loadInlineTable(resource);
+        const frame = await table.collect();
+        expect([
+            { id: 1, name: "english" },
+            { id: 2, name: "中文" },
+        ]).toEqual(frame.toRecords());
+    });
+    it("should handle longer rows", async () => {
+        const resource = {
+            name: "test",
+            type: "table",
+            data: [
+                ["id", "name"],
+                [1, "english"],
+                [2, "中文", "bad"], // extra cell
+            ],
+            schema: {
+                fields: [
+                    { name: "id", type: "integer" },
+                    { name: "name", type: "string" },
+                ],
+            },
+        };
+        // @ts-ignore
+        const table = await loadInlineTable(resource);
+        const frame = await table.collect();
+        expect([
+            { id: 1, name: "english" },
+            { id: 2, name: "中文" },
+        ]).toEqual(frame.toRecords());
+    });
+    it("should handle shorter rows", async () => {
+        const resource = {
+            name: "test",
+            type: "table",
+            data: [
+                ["id", "name"],
+                [1, "english"],
+                [2], // missing cell
+            ],
+            schema: {
+                fields: [
+                    { name: "id", type: "integer" },
+                    { name: "name", type: "string" },
+                ],
+            },
+        };
+        // @ts-ignore
+        const table = await loadInlineTable(resource);
+        const frame = await table.collect();
+        expect([
+            { id: 1, name: "english" },
+            { id: 2, name: null },
+        ]).toEqual(frame.toRecords());
+    });
+    it("should handle various data types", async () => {
+        const resource = {
+            name: "test",
+            type: "table",
+            data: [
+                {
+                    string: "string",
+                    number: 1,
+                    boolean: true,
+                    date: new Date("2025-01-01"),
+                    time: new Date("2025-01-01"),
+                    datetime: new Date("2025-01-01"),
+                },
+            ],
+            schema: undefined,
+        };
+        // @ts-ignore
+        const table = await loadInlineTable(resource);
+        const frame = await table.collect();
+        expect([
+            {
+                string: "string",
+                number: 1,
+                boolean: true,
+                date: new Date("2025-01-01"),
+                time: new Date("2025-01-01"),
+                datetime: new Date("2025-01-01"),
+            },
+        ]).toEqual(frame.toRecords());
+    });
+    it("should handle objects with shorter rows", async () => {
+        const resource = {
+            name: "test",
+            type: "table",
+            data: [{ id: 1, name: "english" }, { id: 2, name: "中文" }, { id: 3 }],
+        };
+        // @ts-ignore
+        const table = await loadInlineTable(resource);
+        const frame = await table.collect();
+        expect([
+            { id: 1, name: "english" },
+            { id: 2, name: "中文" },
+            { id: 3, name: null },
+        ]).toEqual(frame.toRecords());
+    });
+    it("should handle objects with longer rows", async () => {
+        const resource = {
+            name: "test",
+            type: "table",
+            data: [
+                { id: 1, name: "english" },
+                { id: 2, name: "中文" },
+                { id: 3, name: "german", extra: "extra" },
+            ],
+        };
+        // @ts-ignore
+        const table = await loadInlineTable(resource);
+        const frame = await table.collect();
+        expect([
+            { id: 1, name: "english", extra: null },
+            { id: 2, name: "中文", extra: null },
+            { id: 3, name: "german", extra: "extra" },
+        ]).toEqual(frame.toRecords());
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"load.spec.js","sourceRoot":"","sources":["../../../../plugins/inline/table/load.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { describe, expect, it } from \"vitest\"\nimport { loadInlineTable } from \"./load.ts\"\n\ndescribe(\"loadInlineTable\", () => {\n  it(\"should throw on no data\", async () => {\n    const resource = { name: \"test\" }\n\n    await expect(loadInlineTable(resource)).rejects.toThrow(\n      \"Resource data is not defined or tabular\",\n    )\n  })\n\n  it(\"should throw on bad data\", async () => {\n    const resource = { name: \"test\", data: \"bad\" }\n\n    await expect(loadInlineTable(resource)).rejects.toThrow(\n      \"Resource data is not defined or tabular\",\n    )\n  })\n\n  it(\"should read arrays\", async () => {\n    const resource = {\n      name: \"test\",\n      type: \"table\" as const,\n      data: [\n        [\"id\", \"name\"],\n        [1, \"english\"],\n        [2, \"中文\"],\n      ],\n    }\n\n    const table = await loadInlineTable(resource)\n    const frame = await table.collect()\n\n    expect([\n      { id: 1, name: \"english\" },\n      { id: 2, name: \"中文\" },\n    ]).toEqual(frame.toRecords())\n  })\n\n  it(\"should read objects\", async () => {\n    const resource = {\n      name: \"test\",\n      type: \"table\",\n      data: [\n        { id: 1, name: \"english\" },\n        { id: 2, name: \"中文\" },\n      ],\n      schema: undefined,\n    }\n\n    // @ts-ignore\n    const table = await loadInlineTable(resource)\n    const frame = await table.collect()\n\n    expect([\n      { id: 1, name: \"english\" },\n      { id: 2, name: \"中文\" },\n    ]).toEqual(frame.toRecords())\n  })\n\n  it(\"should handle longer rows\", async () => {\n    const resource = {\n      name: \"test\",\n      type: \"table\",\n      data: [\n        [\"id\", \"name\"],\n        [1, \"english\"],\n        [2, \"中文\", \"bad\"], // extra cell\n      ],\n      schema: {\n        fields: [\n          { name: \"id\", type: \"integer\" },\n          { name: \"name\", type: \"string\" },\n        ],\n      },\n    }\n\n    // @ts-ignore\n    const table = await loadInlineTable(resource)\n    const frame = await table.collect()\n\n    expect([\n      { id: 1, name: \"english\" },\n      { id: 2, name: \"中文\" },\n    ]).toEqual(frame.toRecords())\n  })\n\n  it(\"should handle shorter rows\", async () => {\n    const resource = {\n      name: \"test\",\n      type: \"table\",\n      data: [\n        [\"id\", \"name\"],\n        [1, \"english\"],\n        [2], // missing cell\n      ],\n      schema: {\n        fields: [\n          { name: \"id\", type: \"integer\" },\n          { name: \"name\", type: \"string\" },\n        ],\n      },\n    }\n\n    // @ts-ignore\n    const table = await loadInlineTable(resource)\n    const frame = await table.collect()\n\n    expect([\n      { id: 1, name: \"english\" },\n      { id: 2, name: null },\n    ]).toEqual(frame.toRecords())\n  })\n\n  it(\"should handle various data types\", async () => {\n    const resource = {\n      name: \"test\",\n      type: \"table\",\n      data: [\n        {\n          string: \"string\",\n          number: 1,\n          boolean: true,\n          date: new Date(\"2025-01-01\"),\n          time: new Date(\"2025-01-01\"),\n          datetime: new Date(\"2025-01-01\"),\n        },\n      ],\n      schema: undefined,\n    }\n\n    // @ts-ignore\n    const table = await loadInlineTable(resource)\n    const frame = await table.collect()\n\n    expect([\n      {\n        string: \"string\",\n        number: 1,\n        boolean: true,\n        date: new Date(\"2025-01-01\"),\n        time: new Date(\"2025-01-01\"),\n        datetime: new Date(\"2025-01-01\"),\n      },\n    ]).toEqual(frame.toRecords())\n  })\n\n  it(\"should handle objects with shorter rows\", async () => {\n    const resource = {\n      name: \"test\",\n      type: \"table\",\n      data: [{ id: 1, name: \"english\" }, { id: 2, name: \"中文\" }, { id: 3 }],\n    }\n\n    // @ts-ignore\n    const table = await loadInlineTable(resource)\n    const frame = await table.collect()\n\n    expect([\n      { id: 1, name: \"english\" },\n      { id: 2, name: \"中文\" },\n      { id: 3, name: null },\n    ]).toEqual(frame.toRecords())\n  })\n\n  it(\"should handle objects with longer rows\", async () => {\n    const resource = {\n      name: \"test\",\n      type: \"table\",\n      data: [\n        { id: 1, name: \"english\" },\n        { id: 2, name: \"中文\" },\n        { id: 3, name: \"german\", extra: \"extra\" },\n      ],\n    }\n\n    // @ts-ignore\n    const table = await loadInlineTable(resource)\n    const frame = await table.collect()\n\n    expect([\n      { id: 1, name: \"english\", extra: null },\n      { id: 2, name: \"中文\", extra: null },\n      { id: 3, name: \"german\", extra: \"extra\" },\n    ]).toEqual(frame.toRecords())\n  })\n})\n"]}

package/build/plugins/json/buffer/decode.d.ts

@@ -0,0 +1,4 @@
+import type { Buffer } from "node:buffer";
+export declare function decodeJsonBuffer(buffer: Buffer, options: {
+    isLines: boolean;
+}): any;

package/build/plugins/json/buffer/decode.js

@@ -0,0 +1,10 @@
+export function decodeJsonBuffer(buffer, options) {
+    const string = buffer.toString("utf-8");
+    return options.isLines
+        ? string
+            .split("\n")
+            .filter(Boolean)
+            .map(line => JSON.parse(line))
+        : JSON.parse(string);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVjb2RlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGx1Z2lucy9qc29uL2J1ZmZlci9kZWNvZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxVQUFVLGdCQUFnQixDQUM5QixNQUFjLEVBQ2QsT0FBNkI7SUFFN0IsTUFBTSxNQUFNLEdBQUcsTUFBTSxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsQ0FBQTtJQUV2QyxPQUFPLE9BQU8sQ0FBQyxPQUFPO1FBQ3BCLENBQUMsQ0FBQyxNQUFNO2FBQ0gsS0FBSyxDQUFDLElBQUksQ0FBQzthQUNYLE1BQU0sQ0FBQyxPQUFPLENBQUM7YUFDZixHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ2xDLENBQUMsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFBO0FBQ3hCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IEJ1ZmZlciB9IGZyb20gXCJub2RlOmJ1ZmZlclwiXG5cbmV4cG9ydCBmdW5jdGlvbiBkZWNvZGVKc29uQnVmZmVyKFxuICBidWZmZXI6IEJ1ZmZlcixcbiAgb3B0aW9uczogeyBpc0xpbmVzOiBib29sZWFuIH0sXG4pIHtcbiAgY29uc3Qgc3RyaW5nID0gYnVmZmVyLnRvU3RyaW5nKFwidXRmLThcIilcblxuICByZXR1cm4gb3B0aW9ucy5pc0xpbmVzXG4gICAgPyBzdHJpbmdcbiAgICAgICAgLnNwbGl0KFwiXFxuXCIpXG4gICAgICAgIC5maWx0ZXIoQm9vbGVhbilcbiAgICAgICAgLm1hcChsaW5lID0+IEpTT04ucGFyc2UobGluZSkpXG4gICAgOiBKU09OLnBhcnNlKHN0cmluZylcbn1cbiJdfQ==

package/build/plugins/json/buffer/encode.d.ts

@@ -0,0 +1,4 @@
+import { Buffer } from "node:buffer";
+export declare function encodeJsonBuffer(data: any, options: {
+    isLines: boolean;
+}): Buffer<any>;

package/build/plugins/json/buffer/encode.js

@@ -0,0 +1,8 @@
+import { Buffer } from "node:buffer";
+export function encodeJsonBuffer(data, options) {
+    const string = options.isLines
+        ? data.map((line) => JSON.stringify(line)).join("\n")
+        : JSON.stringify(data, null, 2);
+    return Buffer.from(string);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5jb2RlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGx1Z2lucy9qc29uL2J1ZmZlci9lbmNvZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLGFBQWEsQ0FBQTtBQUVwQyxNQUFNLFVBQVUsZ0JBQWdCLENBQUMsSUFBUyxFQUFFLE9BQTZCO0lBQ3ZFLE1BQU0sTUFBTSxHQUFHLE9BQU8sQ0FBQyxPQUFPO1FBQzVCLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsSUFBUyxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQztRQUMxRCxDQUFDLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQyxDQUFBO0lBRWpDLE9BQU8sTUFBTSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQTtBQUM1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQnVmZmVyIH0gZnJvbSBcIm5vZGU6YnVmZmVyXCJcblxuZXhwb3J0IGZ1bmN0aW9uIGVuY29kZUpzb25CdWZmZXIoZGF0YTogYW55LCBvcHRpb25zOiB7IGlzTGluZXM6IGJvb2xlYW4gfSkge1xuICBjb25zdCBzdHJpbmcgPSBvcHRpb25zLmlzTGluZXNcbiAgICA/IGRhdGEubWFwKChsaW5lOiBhbnkpID0+IEpTT04uc3RyaW5naWZ5KGxpbmUpKS5qb2luKFwiXFxuXCIpXG4gICAgOiBKU09OLnN0cmluZ2lmeShkYXRhLCBudWxsLCAyKVxuXG4gIHJldHVybiBCdWZmZXIuZnJvbShzdHJpbmcpXG59XG4iXX0=

package/build/plugins/json/buffer/index.d.ts

@@ -0,0 +1,2 @@
+export { encodeJsonBuffer } from "./encode.ts";
+export { decodeJsonBuffer } from "./decode.ts";

package/build/plugins/json/buffer/index.js

@@ -0,0 +1,3 @@
+export { encodeJsonBuffer } from "./encode.js";
+export { decodeJsonBuffer } from "./decode.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wbHVnaW5zL2pzb24vYnVmZmVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGFBQWEsQ0FBQTtBQUM5QyxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxhQUFhLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBlbmNvZGVKc29uQnVmZmVyIH0gZnJvbSBcIi4vZW5jb2RlLnRzXCJcbmV4cG9ydCB7IGRlY29kZUpzb25CdWZmZXIgfSBmcm9tIFwiLi9kZWNvZGUudHNcIlxuIl19

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

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

package/build/plugins/json/index.js

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

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

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

@@ -0,0 +1,25 @@
+import { inferFormat } from "@frictionless-ts/metadata";
+import { loadJsonTable } from "./table/index.js";
+import { saveJsonTable } from "./table/index.js";
+export class JsonPlugin {
+    async loadTable(resource, options) {
+        const jsonFormat = getJsonFormat(resource);
+        if (!jsonFormat)
+            return undefined;
+        return await loadJsonTable({ ...resource, format: jsonFormat }, options);
+    }
+    async saveTable(table, options) {
+        const { path, format } = options;
+        const jsonFormat = getJsonFormat({ path, format });
+        if (!jsonFormat)
+            return undefined;
+        return await saveJsonTable(table, { ...options, format: jsonFormat });
+    }
+}
+function getJsonFormat(resource) {
+    const format = inferFormat(resource);
+    return format === "json" || format === "jsonl" || format === "ndjson"
+        ? format
+        : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,55 @@
+import { resolveDialect } from "@frictionless-ts/metadata";
+import { resolveSchema } from "@frictionless-ts/metadata";
+import { loadFile, prefetchFiles } from "@frictionless-ts/dataset";
+import { inferSchemaFromTable } from "../../../schema/index.js";
+import { normalizeTable } from "../../../table/index.js";
+import * as pl from "nodejs-polars";
+import { decodeJsonBuffer } from "../buffer/index.js";
+export async function loadJsonTable(resource, options) {
+    const isLines = resource.format === "jsonl" || resource.format === "ndjson";
+    const paths = await prefetchFiles(resource.path);
+    if (!paths.length) {
+        throw new Error("Resource path is not defined");
+    }
+    const dialect = await resolveDialect(resource.dialect);
+    const tables = [];
+    for (const path of paths) {
+        if (isLines && !dialect) {
+            const table = pl.scanJson(path);
+            tables.push(table);
+            continue;
+        }
+        const buffer = await loadFile(path);
+        let data = decodeJsonBuffer(buffer, { isLines });
+        if (dialect) {
+            data = processData(data, dialect);
+        }
+        const table = pl.DataFrame(data).lazy();
+        tables.push(table);
+    }
+    let table = pl.concat(tables);
+    if (!options?.denormalized) {
+        let schema = await resolveSchema(resource.schema);
+        if (!schema)
+            schema = await inferSchemaFromTable(table, options);
+        table = await normalizeTable(table, schema);
+    }
+    return table;
+}
+function processData(data, dialect) {
+    if (dialect.property) {
+        data = data[dialect.property];
+    }
+    if (dialect.itemType === "array") {
+        const keys = data[0];
+        data = data
+            .slice(1)
+            .map((row) => Object.fromEntries(keys.map((key, index) => [key, row[index]])));
+    }
+    if (dialect.itemKeys) {
+        const keys = dialect.itemKeys;
+        data = data.map((row) => Object.fromEntries(keys.map((key) => [key, row[key]])));
+    }
+    return data;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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