@frictionless-ts/table 1.0.1

package/build/field/types/array.spec.js

@@ -0,0 +1,358 @@
+import * as pl from "nodejs-polars";
+import { describe, expect, it } from "vitest";
+import { inspectTable } from "../../table/index.js";
+describe("validateArrayField", () => {
+    it("should not errors for valid JSON arrays", async () => {
+        const table = pl
+            .DataFrame({
+            tags: ['["tag1","tag2"]', "[1,2,3]", '["a","b","c"]'],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "tags",
+                    type: "array",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(0);
+    });
+    it("should not errors for empty arrays", async () => {
+        const table = pl
+            .DataFrame({
+            items: ["[]", "[]", "[]"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "items",
+                    type: "array",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(0);
+    });
+    it("should not errors for null values", async () => {
+        const table = pl
+            .DataFrame({
+            data: ['["value"]', null, "[1,2,3]"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "data",
+                    type: "array",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(0);
+    });
+    it("should errors for JSON objects", async () => {
+        const table = pl
+            .DataFrame({
+            data: ["[1,2,3]", '{"key":"value"}', '["a","b"]'],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "data",
+                    type: "array",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/type",
+                fieldName: "data",
+                fieldType: "array",
+                rowNumber: 2,
+                cell: '{"key":"value"}',
+            },
+        ]);
+    });
+    it("should errors for invalid JSON", async () => {
+        const table = pl
+            .DataFrame({
+            data: ['["valid"]', "invalid json", "[1,2,3]", "[broken"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "data",
+                    type: "array",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors.filter(e => e.type === "cell/type")).toHaveLength(2);
+        expect(errors).toContainEqual({
+            type: "cell/type",
+            fieldName: "data",
+            fieldType: "array",
+            rowNumber: 2,
+            cell: "invalid json",
+        });
+        expect(errors).toContainEqual({
+            type: "cell/type",
+            fieldName: "data",
+            fieldType: "array",
+            rowNumber: 4,
+            cell: "[broken",
+        });
+    });
+    it("should handle nested arrays", async () => {
+        const table = pl
+            .DataFrame({
+            matrix: ["[[1,2],[3,4]]", "[[5,6],[7,8]]", '[["a","b"],["c","d"]]'],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "matrix",
+                    type: "array",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(0);
+    });
+    it("should errors for empty strings", async () => {
+        const table = pl
+            .DataFrame({
+            data: ['["valid"]', "", "[1,2,3]"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "data",
+                    type: "array",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/type",
+                fieldName: "data",
+                fieldType: "array",
+                rowNumber: 2,
+                cell: "",
+            },
+        ]);
+    });
+    it("should errors for JSON primitives", async () => {
+        const table = pl
+            .DataFrame({
+            data: ['"string"', "123", "true", "false", "null"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "data",
+                    type: "array",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/type",
+                fieldName: "data",
+                fieldType: "array",
+                rowNumber: 1,
+                cell: '"string"',
+            },
+            {
+                type: "cell/type",
+                fieldName: "data",
+                fieldType: "array",
+                rowNumber: 2,
+                cell: "123",
+            },
+            {
+                type: "cell/type",
+                fieldName: "data",
+                fieldType: "array",
+                rowNumber: 3,
+                cell: "true",
+            },
+            {
+                type: "cell/type",
+                fieldName: "data",
+                fieldType: "array",
+                rowNumber: 4,
+                cell: "false",
+            },
+            {
+                type: "cell/type",
+                fieldName: "data",
+                fieldType: "array",
+                rowNumber: 5,
+                cell: "null",
+            },
+        ]);
+    });
+    it("should not errors for arrays matching jsonSchema", async () => {
+        const table = pl
+            .DataFrame({
+            scores: ["[80,90,100]", "[75,85,95]", "[90,95,100]"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "scores",
+                    type: "array",
+                    constraints: {
+                        jsonSchema: {
+                            type: "array",
+                            items: { type: "number" },
+                            minItems: 3,
+                            maxItems: 3,
+                        },
+                    },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(0);
+    });
+    it("should errors for arrays not matching jsonSchema", async () => {
+        const jsonSchema = {
+            type: "array",
+            items: { type: "number" },
+            minItems: 2,
+        };
+        const table = pl
+            .DataFrame({
+            numbers: ["[1,2,3]", '["not","numbers"]', "[1]", "[4,5,6]"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "numbers",
+                    type: "array",
+                    constraints: {
+                        jsonSchema,
+                    },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors.filter(e => e.type === "cell/jsonSchema")).toEqual([
+            {
+                type: "cell/jsonSchema",
+                fieldName: "numbers",
+                rowNumber: 2,
+                cell: '["not","numbers"]',
+                pointer: "/0",
+                message: "must be number",
+            },
+            {
+                type: "cell/jsonSchema",
+                fieldName: "numbers",
+                rowNumber: 2,
+                cell: '["not","numbers"]',
+                pointer: "/1",
+                message: "must be number",
+            },
+            {
+                type: "cell/jsonSchema",
+                fieldName: "numbers",
+                rowNumber: 3,
+                cell: "[1]",
+                pointer: "",
+                message: "must NOT have fewer than 2 items",
+            },
+        ]);
+    });
+    it("should validate complex jsonSchema with array of objects", async () => {
+        const table = pl
+            .DataFrame({
+            users: [
+                '[{"name":"John","age":30},{"name":"Jane","age":25}]',
+                '[{"name":"Bob","age":"invalid"}]',
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "users",
+                    type: "array",
+                    constraints: {
+                        jsonSchema: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    name: { type: "string" },
+                                    age: { type: "number" },
+                                },
+                                required: ["name", "age"],
+                            },
+                        },
+                    },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/jsonSchema",
+                fieldName: "users",
+                rowNumber: 2,
+                cell: '[{"name":"Bob","age":"invalid"}]',
+                pointer: "/0/age",
+                message: "must be number",
+            },
+        ]);
+    });
+    it("should validate jsonSchema with unique items constraint", async () => {
+        const table = pl
+            .DataFrame({
+            tags: ['["unique","values"]', '["duplicate","duplicate"]'],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "tags",
+                    type: "array",
+                    constraints: {
+                        jsonSchema: {
+                            type: "array",
+                            items: { type: "string" },
+                            uniqueItems: true,
+                        },
+                    },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/jsonSchema",
+                fieldName: "tags",
+                rowNumber: 2,
+                cell: '["duplicate","duplicate"]',
+                pointer: "",
+                message: "must NOT have duplicate items (items ## 1 and 0 are identical)",
+            },
+        ]);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"array.spec.js","sourceRoot":"","sources":["../../../field/types/array.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Schema } from \"@frictionless-ts/metadata\"\nimport * as pl from \"nodejs-polars\"\nimport { describe, expect, it } from \"vitest\"\nimport { inspectTable } from \"../../table/index.ts\"\n\ndescribe(\"validateArrayField\", () => {\n  it(\"should not errors for valid JSON arrays\", async () => {\n    const table = pl\n      .DataFrame({\n        tags: ['[\"tag1\",\"tag2\"]', \"[1,2,3]\", '[\"a\",\"b\",\"c\"]'],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"tags\",\n          type: \"array\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toHaveLength(0)\n  })\n\n  it(\"should not errors for empty arrays\", async () => {\n    const table = pl\n      .DataFrame({\n        items: [\"[]\", \"[]\", \"[]\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"items\",\n          type: \"array\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toHaveLength(0)\n  })\n\n  it(\"should not errors for null values\", async () => {\n    const table = pl\n      .DataFrame({\n        data: ['[\"value\"]', null, \"[1,2,3]\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"data\",\n          type: \"array\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toHaveLength(0)\n  })\n\n  it(\"should errors for JSON objects\", async () => {\n    const table = pl\n      .DataFrame({\n        data: [\"[1,2,3]\", '{\"key\":\"value\"}', '[\"a\",\"b\"]'],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"data\",\n          type: \"array\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toEqual([\n      {\n        type: \"cell/type\",\n        fieldName: \"data\",\n        fieldType: \"array\",\n        rowNumber: 2,\n        cell: '{\"key\":\"value\"}',\n      },\n    ])\n  })\n\n  it(\"should errors for invalid JSON\", async () => {\n    const table = pl\n      .DataFrame({\n        data: ['[\"valid\"]', \"invalid json\", \"[1,2,3]\", \"[broken\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"data\",\n          type: \"array\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors.filter(e => e.type === \"cell/type\")).toHaveLength(2)\n    expect(errors).toContainEqual({\n      type: \"cell/type\",\n      fieldName: \"data\",\n      fieldType: \"array\",\n      rowNumber: 2,\n      cell: \"invalid json\",\n    })\n    expect(errors).toContainEqual({\n      type: \"cell/type\",\n      fieldName: \"data\",\n      fieldType: \"array\",\n      rowNumber: 4,\n      cell: \"[broken\",\n    })\n  })\n\n  it(\"should handle nested arrays\", async () => {\n    const table = pl\n      .DataFrame({\n        matrix: [\"[[1,2],[3,4]]\", \"[[5,6],[7,8]]\", '[[\"a\",\"b\"],[\"c\",\"d\"]]'],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"matrix\",\n          type: \"array\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toHaveLength(0)\n  })\n\n  it(\"should errors for empty strings\", async () => {\n    const table = pl\n      .DataFrame({\n        data: ['[\"valid\"]', \"\", \"[1,2,3]\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"data\",\n          type: \"array\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toEqual([\n      {\n        type: \"cell/type\",\n        fieldName: \"data\",\n        fieldType: \"array\",\n        rowNumber: 2,\n        cell: \"\",\n      },\n    ])\n  })\n\n  it(\"should errors for JSON primitives\", async () => {\n    const table = pl\n      .DataFrame({\n        data: ['\"string\"', \"123\", \"true\", \"false\", \"null\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"data\",\n          type: \"array\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toEqual([\n      {\n        type: \"cell/type\",\n        fieldName: \"data\",\n        fieldType: \"array\",\n        rowNumber: 1,\n        cell: '\"string\"',\n      },\n      {\n        type: \"cell/type\",\n        fieldName: \"data\",\n        fieldType: \"array\",\n        rowNumber: 2,\n        cell: \"123\",\n      },\n      {\n        type: \"cell/type\",\n        fieldName: \"data\",\n        fieldType: \"array\",\n        rowNumber: 3,\n        cell: \"true\",\n      },\n      {\n        type: \"cell/type\",\n        fieldName: \"data\",\n        fieldType: \"array\",\n        rowNumber: 4,\n        cell: \"false\",\n      },\n      {\n        type: \"cell/type\",\n        fieldName: \"data\",\n        fieldType: \"array\",\n        rowNumber: 5,\n        cell: \"null\",\n      },\n    ])\n  })\n\n  it(\"should not errors for arrays matching jsonSchema\", async () => {\n    const table = pl\n      .DataFrame({\n        scores: [\"[80,90,100]\", \"[75,85,95]\", \"[90,95,100]\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"scores\",\n          type: \"array\",\n          constraints: {\n            jsonSchema: {\n              type: \"array\",\n              items: { type: \"number\" },\n              minItems: 3,\n              maxItems: 3,\n            },\n          },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toHaveLength(0)\n  })\n\n  it(\"should errors for arrays not matching jsonSchema\", async () => {\n    const jsonSchema = {\n      type: \"array\",\n      items: { type: \"number\" },\n      minItems: 2,\n    }\n\n    const table = pl\n      .DataFrame({\n        numbers: [\"[1,2,3]\", '[\"not\",\"numbers\"]', \"[1]\", \"[4,5,6]\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"numbers\",\n          type: \"array\",\n          constraints: {\n            jsonSchema,\n          },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors.filter(e => e.type === \"cell/jsonSchema\")).toEqual([\n      {\n        type: \"cell/jsonSchema\",\n        fieldName: \"numbers\",\n        rowNumber: 2,\n        cell: '[\"not\",\"numbers\"]',\n        pointer: \"/0\",\n        message: \"must be number\",\n      },\n      {\n        type: \"cell/jsonSchema\",\n        fieldName: \"numbers\",\n        rowNumber: 2,\n        cell: '[\"not\",\"numbers\"]',\n        pointer: \"/1\",\n        message: \"must be number\",\n      },\n      {\n        type: \"cell/jsonSchema\",\n        fieldName: \"numbers\",\n        rowNumber: 3,\n        cell: \"[1]\",\n        pointer: \"\",\n        message: \"must NOT have fewer than 2 items\",\n      },\n    ])\n  })\n\n  it(\"should validate complex jsonSchema with array of objects\", async () => {\n    const table = pl\n      .DataFrame({\n        users: [\n          '[{\"name\":\"John\",\"age\":30},{\"name\":\"Jane\",\"age\":25}]',\n          '[{\"name\":\"Bob\",\"age\":\"invalid\"}]',\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"users\",\n          type: \"array\",\n          constraints: {\n            jsonSchema: {\n              type: \"array\",\n              items: {\n                type: \"object\",\n                properties: {\n                  name: { type: \"string\" },\n                  age: { type: \"number\" },\n                },\n                required: [\"name\", \"age\"],\n              },\n            },\n          },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toEqual([\n      {\n        type: \"cell/jsonSchema\",\n        fieldName: \"users\",\n        rowNumber: 2,\n        cell: '[{\"name\":\"Bob\",\"age\":\"invalid\"}]',\n        pointer: \"/0/age\",\n        message: \"must be number\",\n      },\n    ])\n  })\n\n  it(\"should validate jsonSchema with unique items constraint\", async () => {\n    const table = pl\n      .DataFrame({\n        tags: ['[\"unique\",\"values\"]', '[\"duplicate\",\"duplicate\"]'],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"tags\",\n          type: \"array\",\n          constraints: {\n            jsonSchema: {\n              type: \"array\",\n              items: { type: \"string\" },\n              uniqueItems: true,\n            },\n          },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toEqual([\n      {\n        type: \"cell/jsonSchema\",\n        fieldName: \"tags\",\n        rowNumber: 2,\n        cell: '[\"duplicate\",\"duplicate\"]',\n        pointer: \"\",\n        message:\n          \"must NOT have duplicate items (items ## 1 and 0 are identical)\",\n      },\n    ])\n  })\n})\n"]}

package/build/field/types/boolean.d.ts

@@ -0,0 +1,4 @@
+import type { BooleanField } from "@frictionless-ts/metadata";
+import * as pl from "nodejs-polars";
+export declare function parseBooleanField(field: BooleanField, fieldExpr: pl.Expr): pl.Expr;
+export declare function stringifyBooleanField(field: BooleanField, fieldExpr: pl.Expr): pl.Expr;

package/build/field/types/boolean.js

@@ -0,0 +1,31 @@
+import * as pl from "nodejs-polars";
+const DEFAULT_TRUE_VALUES = ["true", "True", "TRUE", "1"];
+const DEFAULT_FALSE_VALUES = ["false", "False", "FALSE", "0"];
+export function parseBooleanField(field, fieldExpr) {
+    const trueValues = field.trueValues ?? DEFAULT_TRUE_VALUES;
+    const falseValues = field.falseValues ?? DEFAULT_FALSE_VALUES;
+    for (const value of trueValues)
+        fieldExpr = fieldExpr.replace(value, "1");
+    for (const value of falseValues)
+        fieldExpr = fieldExpr.replace(value, "0");
+    fieldExpr = fieldExpr.cast(pl.Int8);
+    return pl
+        .when(fieldExpr.eq(1))
+        .then(pl.lit(true))
+        .when(fieldExpr.eq(0))
+        .then(pl.lit(false))
+        .otherwise(pl.lit(null))
+        .alias(field.name);
+}
+const DEFAULT_TRUE_VALUE = "true";
+const DEFAULT_FALSE_VALUE = "false";
+export function stringifyBooleanField(field, fieldExpr) {
+    const trueValue = field.trueValues?.[0] ?? DEFAULT_TRUE_VALUE;
+    const falseValue = field.falseValues?.[0] ?? DEFAULT_FALSE_VALUE;
+    return pl
+        .when(fieldExpr.eq(pl.lit(true)))
+        .then(pl.lit(trueValue))
+        .otherwise(pl.lit(falseValue))
+        .alias(field.name);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/field/types/boolean.spec.d.ts

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

package/build/field/types/boolean.spec.js

@@ -0,0 +1,76 @@
+import * as pl from "nodejs-polars";
+import { describe, expect, it } from "vitest";
+import { normalizeTable } from "../../table/index.js";
+import { denormalizeTable } from "../../table/index.js";
+describe("parseBooleanField", () => {
+    it.each([
+        // Default true values
+        ["true", true, {}],
+        ["True", true, {}],
+        ["TRUE", true, {}],
+        ["1", true, {}],
+        // Default false values
+        ["false", false, {}],
+        ["False", false, {}],
+        ["FALSE", false, {}],
+        ["0", false, {}],
+        // Invalid values
+        ["", null, {}],
+        ["invalid", null, {}],
+        ["truthy", null, {}],
+        ["falsy", null, {}],
+        ["2", null, {}],
+        ["-100", null, {}],
+        ["t", null, {}],
+        ["f", null, {}],
+        ["3.14", null, {}],
+        // Custom true values
+        ["Y", true, { trueValues: ["Y", "y", "yes"] }],
+        ["y", true, { trueValues: ["Y", "y", "yes"] }],
+        ["yes", true, { trueValues: ["Y", "y", "yes"] }],
+        ["true", null, { trueValues: ["Y", "y", "yes"] }],
+        // Custom false values
+        ["N", false, { falseValues: ["N", "n", "no"] }],
+        ["n", false, { falseValues: ["N", "n", "no"] }],
+        ["no", false, { falseValues: ["N", "n", "no"] }],
+        ["false", null, { falseValues: ["N", "n", "no"] }],
+        // Custom true and false values
+        ["oui", true, { trueValues: ["oui", "si"], falseValues: ["non", "no"] }],
+        ["si", true, { trueValues: ["oui", "si"], falseValues: ["non", "no"] }],
+        ["non", false, { trueValues: ["oui", "si"], falseValues: ["non", "no"] }],
+        ["no", false, { trueValues: ["oui", "si"], falseValues: ["non", "no"] }],
+    ])("%s -> %s %o", async (cell, value, options) => {
+        const table = pl.DataFrame([pl.Series("name", [cell], pl.String)]).lazy();
+        const schema = {
+            fields: [{ name: "name", type: "boolean", ...options }],
+        };
+        const result = await normalizeTable(table, schema);
+        const frame = await result.collect();
+        expect(frame.toRecords()[0]?.name).toEqual(value);
+    });
+});
+describe("stringifyBooleanField", () => {
+    it.each([
+        // Default values
+        [true, "true", {}],
+        [false, "false", {}],
+        // Custom true values
+        [true, "Y", { trueValues: ["Y", "y", "yes"] }],
+        [false, "false", { trueValues: ["Y", "y", "yes"] }],
+        // Custom false values
+        [true, "true", { falseValues: ["N", "n", "no"] }],
+        [false, "N", { falseValues: ["N", "n", "no"] }],
+        // Custom true and false values
+        [true, "oui", { trueValues: ["oui", "si"], falseValues: ["non", "no"] }],
+        [false, "non", { trueValues: ["oui", "si"], falseValues: ["non", "no"] }],
+    ])("%s -> %s %o", async (value, expected, options) => {
+        const table = pl.DataFrame([pl.Series("name", [value], pl.Bool)]).lazy();
+        const schema = {
+            fields: [{ name: "name", type: "boolean", ...options }],
+        };
+        const result = await denormalizeTable(table, schema);
+        const frame = await result.collect();
+        expect(frame.toRecords()[0]?.name).toEqual(expected);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"boolean.spec.js","sourceRoot":"","sources":["../../../field/types/boolean.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import * as pl from \"nodejs-polars\"\nimport { describe, expect, it } from \"vitest\"\nimport { normalizeTable } from \"../../table/index.ts\"\nimport { denormalizeTable } from \"../../table/index.ts\"\n\ndescribe(\"parseBooleanField\", () => {\n  it.each([\n    // Default true values\n    [\"true\", true, {}],\n    [\"True\", true, {}],\n    [\"TRUE\", true, {}],\n    [\"1\", true, {}],\n\n    // Default false values\n    [\"false\", false, {}],\n    [\"False\", false, {}],\n    [\"FALSE\", false, {}],\n    [\"0\", false, {}],\n\n    // Invalid values\n    [\"\", null, {}],\n    [\"invalid\", null, {}],\n    [\"truthy\", null, {}],\n    [\"falsy\", null, {}],\n    [\"2\", null, {}],\n    [\"-100\", null, {}],\n    [\"t\", null, {}],\n    [\"f\", null, {}],\n    [\"3.14\", null, {}],\n\n    // Custom true values\n    [\"Y\", true, { trueValues: [\"Y\", \"y\", \"yes\"] }],\n    [\"y\", true, { trueValues: [\"Y\", \"y\", \"yes\"] }],\n    [\"yes\", true, { trueValues: [\"Y\", \"y\", \"yes\"] }],\n    [\"true\", null, { trueValues: [\"Y\", \"y\", \"yes\"] }],\n\n    // Custom false values\n    [\"N\", false, { falseValues: [\"N\", \"n\", \"no\"] }],\n    [\"n\", false, { falseValues: [\"N\", \"n\", \"no\"] }],\n    [\"no\", false, { falseValues: [\"N\", \"n\", \"no\"] }],\n    [\"false\", null, { falseValues: [\"N\", \"n\", \"no\"] }],\n\n    // Custom true and false values\n    [\"oui\", true, { trueValues: [\"oui\", \"si\"], falseValues: [\"non\", \"no\"] }],\n    [\"si\", true, { trueValues: [\"oui\", \"si\"], falseValues: [\"non\", \"no\"] }],\n    [\"non\", false, { trueValues: [\"oui\", \"si\"], falseValues: [\"non\", \"no\"] }],\n    [\"no\", false, { trueValues: [\"oui\", \"si\"], falseValues: [\"non\", \"no\"] }],\n  ])(\"%s -> %s %o\", async (cell, value, options) => {\n    const table = pl.DataFrame([pl.Series(\"name\", [cell], pl.String)]).lazy()\n\n    const schema = {\n      fields: [{ name: \"name\", type: \"boolean\" as const, ...options }],\n    }\n\n    const result = await normalizeTable(table, schema)\n    const frame = await result.collect()\n\n    expect(frame.toRecords()[0]?.name).toEqual(value)\n  })\n})\n\ndescribe(\"stringifyBooleanField\", () => {\n  it.each([\n    // Default values\n    [true, \"true\", {}],\n    [false, \"false\", {}],\n\n    // Custom true values\n    [true, \"Y\", { trueValues: [\"Y\", \"y\", \"yes\"] }],\n    [false, \"false\", { trueValues: [\"Y\", \"y\", \"yes\"] }],\n\n    // Custom false values\n    [true, \"true\", { falseValues: [\"N\", \"n\", \"no\"] }],\n    [false, \"N\", { falseValues: [\"N\", \"n\", \"no\"] }],\n\n    // Custom true and false values\n    [true, \"oui\", { trueValues: [\"oui\", \"si\"], falseValues: [\"non\", \"no\"] }],\n    [false, \"non\", { trueValues: [\"oui\", \"si\"], falseValues: [\"non\", \"no\"] }],\n  ])(\"%s -> %s %o\", async (value, expected, options) => {\n    const table = pl.DataFrame([pl.Series(\"name\", [value], pl.Bool)]).lazy()\n\n    const schema = {\n      fields: [{ name: \"name\", type: \"boolean\" as const, ...options }],\n    }\n\n    const result = await denormalizeTable(table, schema)\n    const frame = await result.collect()\n\n    expect(frame.toRecords()[0]?.name).toEqual(expected)\n  })\n})\n"]}

package/build/field/types/date.d.ts

@@ -0,0 +1,4 @@
+import type { DateField } from "@frictionless-ts/metadata";
+import * as pl from "nodejs-polars";
+export declare function parseDateField(field: DateField, fieldExpr: pl.Expr): pl.Expr;
+export declare function stringifyDateField(field: DateField, fieldExpr: pl.Expr): pl.Expr;

package/build/field/types/date.js

@@ -0,0 +1,14 @@
+import * as pl from "nodejs-polars";
+const DEFAULT_FORMAT = "%Y-%m-%d";
+export function parseDateField(field, fieldExpr) {
+    let format = DEFAULT_FORMAT;
+    if (field.format && field.format !== "default" && field.format !== "any") {
+        format = field.format;
+    }
+    return fieldExpr.str.strptime(pl.Date, format);
+}
+export function stringifyDateField(field, fieldExpr) {
+    const format = field.format ?? DEFAULT_FORMAT;
+    return fieldExpr.date.strftime(format);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2ZpZWxkL3R5cGVzL2RhdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxLQUFLLEVBQUUsTUFBTSxlQUFlLENBQUE7QUFFbkMsTUFBTSxjQUFjLEdBQUcsVUFBVSxDQUFBO0FBRWpDLE1BQU0sVUFBVSxjQUFjLENBQUMsS0FBZ0IsRUFBRSxTQUFrQjtJQUNqRSxJQUFJLE1BQU0sR0FBRyxjQUFjLENBQUE7SUFDM0IsSUFBSSxLQUFLLENBQUMsTUFBTSxJQUFJLEtBQUssQ0FBQyxNQUFNLEtBQUssU0FBUyxJQUFJLEtBQUssQ0FBQyxNQUFNLEtBQUssS0FBSyxFQUFFLENBQUM7UUFDekUsTUFBTSxHQUFHLEtBQUssQ0FBQyxNQUFNLENBQUE7SUFDdkIsQ0FBQztJQUVELE9BQU8sU0FBUyxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDLElBQUksRUFBRSxNQUFNLENBQUMsQ0FBQTtBQUNoRCxDQUFDO0FBRUQsTUFBTSxVQUFVLGtCQUFrQixDQUFDLEtBQWdCLEVBQUUsU0FBa0I7SUFDckUsTUFBTSxNQUFNLEdBQUcsS0FBSyxDQUFDLE1BQU0sSUFBSSxjQUFjLENBQUE7SUFFN0MsT0FBTyxTQUFTLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsQ0FBQTtBQUN4QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBEYXRlRmllbGQgfSBmcm9tIFwiQGZyaWN0aW9ubGVzcy10cy9tZXRhZGF0YVwiXG5pbXBvcnQgKiBhcyBwbCBmcm9tIFwibm9kZWpzLXBvbGFyc1wiXG5cbmNvbnN0IERFRkFVTFRfRk9STUFUID0gXCIlWS0lbS0lZFwiXG5cbmV4cG9ydCBmdW5jdGlvbiBwYXJzZURhdGVGaWVsZChmaWVsZDogRGF0ZUZpZWxkLCBmaWVsZEV4cHI6IHBsLkV4cHIpIHtcbiAgbGV0IGZvcm1hdCA9IERFRkFVTFRfRk9STUFUXG4gIGlmIChmaWVsZC5mb3JtYXQgJiYgZmllbGQuZm9ybWF0ICE9PSBcImRlZmF1bHRcIiAmJiBmaWVsZC5mb3JtYXQgIT09IFwiYW55XCIpIHtcbiAgICBmb3JtYXQgPSBmaWVsZC5mb3JtYXRcbiAgfVxuXG4gIHJldHVybiBmaWVsZEV4cHIuc3RyLnN0cnB0aW1lKHBsLkRhdGUsIGZvcm1hdClcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIHN0cmluZ2lmeURhdGVGaWVsZChmaWVsZDogRGF0ZUZpZWxkLCBmaWVsZEV4cHI6IHBsLkV4cHIpIHtcbiAgY29uc3QgZm9ybWF0ID0gZmllbGQuZm9ybWF0ID8/IERFRkFVTFRfRk9STUFUXG5cbiAgcmV0dXJuIGZpZWxkRXhwci5kYXRlLnN0cmZ0aW1lKGZvcm1hdClcbn1cbiJdfQ==

package/build/field/types/date.spec.d.ts

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

package/build/field/types/date.spec.js

@@ -0,0 +1,52 @@
+import * as pl from "nodejs-polars";
+import { describe, expect, it } from "vitest";
+import { normalizeTable } from "../../table/index.js";
+import { denormalizeTable } from "../../table/index.js";
+describe("parseDateField", () => {
+    it.each([
+        // Default format
+        ["2019-01-01", new Date(Date.UTC(2019, 0, 1)), {}],
+        ["10th Jan 1969", null, {}],
+        ["invalid", null, {}],
+        ["", null, {}],
+        // Custom format
+        ["21/11/2006", new Date(Date.UTC(2006, 10, 21)), { format: "%d/%m/%Y" }],
+        [
+            "21/11/06 16:30",
+            new Date(Date.UTC(2006, 10, 21)),
+            { format: "%d/%m/%y" },
+        ],
+        ["invalid", null, { format: "%d/%m/%y" }],
+        ["", null, { format: "%d/%m/%y" }],
+        ["2006/11/21", new Date(Date.UTC(2006, 10, 21)), { format: "%Y/%m/%d" }],
+        // Invalid format
+        ["21/11/06", null, { format: "invalid" }],
+    ])("%s -> %s %o", async (cell, expected, options) => {
+        const table = pl.DataFrame([pl.Series("name", [cell], pl.String)]).lazy();
+        const schema = {
+            fields: [{ name: "name", type: "date", ...options }],
+        };
+        const result = await normalizeTable(table, schema);
+        const frame = await result.collect();
+        expect(frame.toRecords()[0]?.name).toEqual(expected);
+    });
+});
+describe("stringifyDateField", () => {
+    it.each([
+        // Default format
+        [new Date(Date.UTC(2019, 0, 1)), "2019-01-01", {}],
+        [new Date(Date.UTC(2006, 10, 21)), "2006-11-21", {}],
+        // Custom format
+        [new Date(Date.UTC(2006, 10, 21)), "21/11/2006", { format: "%d/%m/%Y" }],
+        [new Date(Date.UTC(2006, 10, 21)), "2006/11/21", { format: "%Y/%m/%d" }],
+    ])("%s -> %s %o", async (value, expected, options) => {
+        const table = pl.DataFrame([pl.Series("name", [value], pl.Date)]).lazy();
+        const schema = {
+            fields: [{ name: "name", type: "date", ...options }],
+        };
+        const result = await denormalizeTable(table, schema);
+        const frame = await result.collect();
+        expect(frame.toRecords()[0]?.name).toEqual(expected);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/field/types/datetime.d.ts

@@ -0,0 +1,4 @@
+import type { DatetimeField } from "@frictionless-ts/metadata";
+import * as pl from "nodejs-polars";
+export declare function parseDatetimeField(field: DatetimeField, fieldExpr: pl.Expr): pl.Expr;
+export declare function stringifyDatetimeField(field: DatetimeField, fieldExpr: pl.Expr): pl.Expr;