@frictionless-ts/table 1.0.1

package/build/field/checks/minimum.js

@@ -0,0 +1,73 @@
+import * as pl from "nodejs-polars";
+import { evaluateExpression } from "../../helpers.js";
+import { parseDateField } from "../types/date.js";
+import { parseDatetimeField } from "../types/datetime.js";
+import { parseIntegerField } from "../types/integer.js";
+import { parseNumberField } from "../types/number.js";
+import { parseTimeField } from "../types/time.js";
+import { parseYearField } from "../types/year.js";
+import { parseYearmonthField } from "../types/yearmonth.js";
+export function createCheckCellMinimum(options) {
+    return (field, mapping) => {
+        if (field.type !== "integer" &&
+            field.type !== "number" &&
+            field.type !== "date" &&
+            field.type !== "time" &&
+            field.type !== "datetime" &&
+            field.type !== "year" &&
+            field.type !== "yearmonth") {
+            return undefined;
+        }
+        const minimum = options?.isExclusive
+            ? field.constraints?.exclusiveMinimum
+            : field.constraints?.minimum;
+        if (minimum === undefined)
+            return undefined;
+        let isErrorExpr;
+        try {
+            const parsedMinimum = parseConstraint(field, minimum);
+            isErrorExpr = options?.isExclusive
+                ? mapping.target.ltEq(parsedMinimum)
+                : mapping.target.lt(parsedMinimum);
+        }
+        catch (error) {
+            isErrorExpr = pl.pl.lit(true);
+        }
+        const errorTemplate = {
+            type: options?.isExclusive ? "cell/exclusiveMinimum" : "cell/minimum",
+            fieldName: field.name,
+            minimum: String(minimum),
+            rowNumber: 0,
+            cell: "",
+        };
+        return { isErrorExpr, errorTemplate };
+    };
+}
+function parseConstraint(field, value) {
+    if (typeof value !== "string")
+        return value;
+    let expr = pl.pl.lit(value);
+    if (field.type === "integer") {
+        expr = parseIntegerField(field, expr);
+    }
+    else if (field.type === "number") {
+        expr = parseNumberField(field, expr);
+    }
+    else if (field.type === "date") {
+        expr = parseDateField(field, expr);
+    }
+    else if (field.type === "time") {
+        expr = parseTimeField(field, expr);
+    }
+    else if (field.type === "datetime") {
+        expr = parseDatetimeField(field, expr);
+    }
+    else if (field.type === "year") {
+        expr = parseYearField(field, expr);
+    }
+    else if (field.type === "yearmonth") {
+        expr = parseYearmonthField(field, expr);
+    }
+    return evaluateExpression(expr);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/field/checks/minimum.spec.d.ts

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

package/build/field/checks/minimum.spec.js

@@ -0,0 +1,476 @@
+import * as pl from "nodejs-polars";
+import { describe, expect, it } from "vitest";
+import { inspectTable } from "../../table/index.js";
+describe("inspectTable (cell/minimum)", () => {
+    it("should not errors for valid values", async () => {
+        const table = pl
+            .DataFrame({
+            price: [10.5, 20.75, 30.0],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "price",
+                    type: "number",
+                    constraints: { minimum: 5 },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(0);
+    });
+    it("should report an error for invalid values", async () => {
+        const table = pl
+            .DataFrame({
+            temperature: [20.5, 30.0, 40, 3.5],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "temperature",
+                    type: "number",
+                    constraints: { minimum: 10 },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors.filter(e => e.type === "cell/minimum")).toHaveLength(1);
+        expect(errors).toContainEqual({
+            type: "cell/minimum",
+            fieldName: "temperature",
+            minimum: "10",
+            rowNumber: 4,
+            cell: "3.5",
+        });
+    });
+    it("should report an error for invalid values (exclusive)", async () => {
+        const table = pl
+            .DataFrame({
+            temperature: [20.5, 30.0, 10.0, 5.5],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "temperature",
+                    type: "number",
+                    constraints: { exclusiveMinimum: 10 },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors.filter(e => e.type === "cell/exclusiveMinimum")).toHaveLength(2);
+        expect(errors).toContainEqual({
+            type: "cell/exclusiveMinimum",
+            fieldName: "temperature",
+            minimum: "10",
+            rowNumber: 3,
+            cell: "10",
+        });
+        expect(errors).toContainEqual({
+            type: "cell/exclusiveMinimum",
+            fieldName: "temperature",
+            minimum: "10",
+            rowNumber: 4,
+            cell: "5.5",
+        });
+    });
+    it("should handle minimum as string", async () => {
+        const table = pl
+            .DataFrame({
+            price: [10.5, 20.75, 3.0],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "price",
+                    type: "number",
+                    constraints: { minimum: "5" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/minimum",
+                fieldName: "price",
+                minimum: "5",
+                rowNumber: 3,
+                cell: "3",
+            },
+        ]);
+    });
+    it("should handle exclusiveMinimum as string", async () => {
+        const table = pl
+            .DataFrame({
+            temperature: [20.5, 10.0, 5.5],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "temperature",
+                    type: "number",
+                    constraints: { exclusiveMinimum: "10" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/exclusiveMinimum",
+                fieldName: "temperature",
+                minimum: "10",
+                rowNumber: 2,
+                cell: "10",
+            },
+            {
+                type: "cell/exclusiveMinimum",
+                fieldName: "temperature",
+                minimum: "10",
+                rowNumber: 3,
+                cell: "5.5",
+            },
+        ]);
+    });
+    it("should handle minimum as string with groupChar", async () => {
+        const table = pl
+            .DataFrame({
+            price: ["5,000", "10,500", "2,500"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "price",
+                    type: "integer",
+                    groupChar: ",",
+                    constraints: { minimum: "3,000" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/minimum",
+                fieldName: "price",
+                minimum: "3,000",
+                rowNumber: 3,
+                cell: "2,500",
+            },
+        ]);
+    });
+    it("should handle minimum as string with decimalChar", async () => {
+        const table = pl
+            .DataFrame({
+            price: ["5,5", "10,75", "2,3"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "price",
+                    type: "number",
+                    decimalChar: ",",
+                    constraints: { minimum: "3,0" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/minimum",
+                fieldName: "price",
+                minimum: "3,0",
+                rowNumber: 3,
+                cell: "2,3",
+            },
+        ]);
+    });
+    it("should handle minimum as string with groupChar and decimalChar", async () => {
+        const table = pl
+            .DataFrame({
+            price: ["5.000,50", "10.500,75", "2.500,30"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "price",
+                    type: "number",
+                    groupChar: ".",
+                    decimalChar: ",",
+                    constraints: { minimum: "3.000,00" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/minimum",
+                fieldName: "price",
+                minimum: "3.000,00",
+                rowNumber: 3,
+                cell: "2.500,30",
+            },
+        ]);
+    });
+    it("should handle minimum as string with bareNumber false", async () => {
+        const table = pl
+            .DataFrame({
+            price: ["$5.00", "$10.50", "$2.50"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "price",
+                    type: "number",
+                    bareNumber: false,
+                    constraints: { minimum: "$3.00" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/minimum",
+                fieldName: "price",
+                minimum: "$3.00",
+                rowNumber: 3,
+                cell: "$2.50",
+            },
+        ]);
+    });
+    it("should handle minimum for date fields", async () => {
+        const table = pl
+            .DataFrame({
+            date: ["2024-01-15", "2024-02-20", "2024-01-05"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "date",
+                    type: "date",
+                    constraints: { minimum: "2024-01-10" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/minimum",
+                fieldName: "date",
+                minimum: "2024-01-10",
+                rowNumber: 3,
+                cell: "2024-01-05",
+            },
+        ]);
+    });
+    it.skip("should handle minimum for time fields", async () => {
+        const table = pl
+            .DataFrame({
+            time: ["14:30:00", "16:45:00", "12:15:00"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "time",
+                    type: "time",
+                    constraints: { minimum: "13:00:00" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/minimum",
+                fieldName: "time",
+                minimum: "13:00:00",
+                rowNumber: 3,
+                cell: "12:15:00",
+            },
+        ]);
+    });
+    it("should handle minimum for datetime fields", async () => {
+        const table = pl
+            .DataFrame({
+            timestamp: [
+                "2024-01-15T14:30:00",
+                "2024-02-20T08:15:00",
+                "2024-01-10T10:00:00",
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "timestamp",
+                    type: "datetime",
+                    constraints: { minimum: "2024-01-15T00:00:00" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/minimum",
+                fieldName: "timestamp",
+                minimum: "2024-01-15T00:00:00",
+                rowNumber: 3,
+                cell: "2024-01-10T10:00:00",
+            },
+        ]);
+    });
+    it("should handle minimum for date fields with custom format", async () => {
+        const table = pl
+            .DataFrame({
+            date: ["15/01/2024", "20/02/2024", "05/01/2024"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "date",
+                    type: "date",
+                    format: "%d/%m/%Y",
+                    constraints: { minimum: "10/01/2024" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/minimum",
+                fieldName: "date",
+                minimum: "10/01/2024",
+                rowNumber: 3,
+                cell: "05/01/2024",
+            },
+        ]);
+    });
+    it("should handle minimum for year fields", async () => {
+        const table = pl
+            .DataFrame({
+            year: ["2020", "2021", "2018"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "year",
+                    type: "year",
+                    constraints: { minimum: "2019" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/minimum",
+                fieldName: "year",
+                minimum: "2019",
+                rowNumber: 3,
+                cell: "2018",
+            },
+        ]);
+    });
+    it("should handle exclusiveMinimum for year fields", async () => {
+        const table = pl
+            .DataFrame({
+            year: ["2020", "2021", "2019", "2018"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "year",
+                    type: "year",
+                    constraints: { exclusiveMinimum: "2019" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/exclusiveMinimum",
+                fieldName: "year",
+                minimum: "2019",
+                rowNumber: 3,
+                cell: "2019",
+            },
+            {
+                type: "cell/exclusiveMinimum",
+                fieldName: "year",
+                minimum: "2019",
+                rowNumber: 4,
+                cell: "2018",
+            },
+        ]);
+    });
+    it.skip("should handle minimum for yearmonth fields", async () => {
+        const table = pl
+            .DataFrame({
+            yearmonth: ["2024-03", "2024-05", "2024-01"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "yearmonth",
+                    type: "yearmonth",
+                    constraints: { minimum: "2024-02" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/minimum",
+                fieldName: "yearmonth",
+                minimum: "2024-02",
+                rowNumber: 3,
+                cell: "2024-01",
+            },
+        ]);
+    });
+    it.skip("should handle exclusiveMinimum for yearmonth fields", async () => {
+        const table = pl
+            .DataFrame({
+            yearmonth: ["2024-03", "2024-05", "2024-02", "2024-01"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "yearmonth",
+                    type: "yearmonth",
+                    constraints: { exclusiveMinimum: "2024-02" },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/exclusiveMinimum",
+                fieldName: "yearmonth",
+                minimum: "2024-02",
+                rowNumber: 3,
+                cell: "2024-02",
+            },
+            {
+                type: "cell/exclusiveMinimum",
+                fieldName: "yearmonth",
+                minimum: "2024-02",
+                rowNumber: 4,
+                cell: "2024-01",
+            },
+        ]);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"minimum.spec.js","sourceRoot":"","sources":["../../../field/checks/minimum.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(\"inspectTable (cell/minimum)\", () => {\n  it(\"should not errors for valid values\", async () => {\n    const table = pl\n      .DataFrame({\n        price: [10.5, 20.75, 30.0],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"price\",\n          type: \"number\",\n          constraints: { minimum: 5 },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toHaveLength(0)\n  })\n\n  it(\"should report an error for invalid values\", async () => {\n    const table = pl\n      .DataFrame({\n        temperature: [20.5, 30.0, 40, 3.5],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"temperature\",\n          type: \"number\",\n          constraints: { minimum: 10 },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors.filter(e => e.type === \"cell/minimum\")).toHaveLength(1)\n    expect(errors).toContainEqual({\n      type: \"cell/minimum\",\n      fieldName: \"temperature\",\n      minimum: \"10\",\n      rowNumber: 4,\n      cell: \"3.5\",\n    })\n  })\n\n  it(\"should report an error for invalid values (exclusive)\", async () => {\n    const table = pl\n      .DataFrame({\n        temperature: [20.5, 30.0, 10.0, 5.5],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"temperature\",\n          type: \"number\",\n          constraints: { exclusiveMinimum: 10 },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors.filter(e => e.type === \"cell/exclusiveMinimum\")).toHaveLength(\n      2,\n    )\n    expect(errors).toContainEqual({\n      type: \"cell/exclusiveMinimum\",\n      fieldName: \"temperature\",\n      minimum: \"10\",\n      rowNumber: 3,\n      cell: \"10\",\n    })\n    expect(errors).toContainEqual({\n      type: \"cell/exclusiveMinimum\",\n      fieldName: \"temperature\",\n      minimum: \"10\",\n      rowNumber: 4,\n      cell: \"5.5\",\n    })\n  })\n\n  it(\"should handle minimum as string\", async () => {\n    const table = pl\n      .DataFrame({\n        price: [10.5, 20.75, 3.0],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"price\",\n          type: \"number\",\n          constraints: { minimum: \"5\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/minimum\",\n        fieldName: \"price\",\n        minimum: \"5\",\n        rowNumber: 3,\n        cell: \"3\",\n      },\n    ])\n  })\n\n  it(\"should handle exclusiveMinimum as string\", async () => {\n    const table = pl\n      .DataFrame({\n        temperature: [20.5, 10.0, 5.5],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"temperature\",\n          type: \"number\",\n          constraints: { exclusiveMinimum: \"10\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/exclusiveMinimum\",\n        fieldName: \"temperature\",\n        minimum: \"10\",\n        rowNumber: 2,\n        cell: \"10\",\n      },\n      {\n        type: \"cell/exclusiveMinimum\",\n        fieldName: \"temperature\",\n        minimum: \"10\",\n        rowNumber: 3,\n        cell: \"5.5\",\n      },\n    ])\n  })\n\n  it(\"should handle minimum as string with groupChar\", async () => {\n    const table = pl\n      .DataFrame({\n        price: [\"5,000\", \"10,500\", \"2,500\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"price\",\n          type: \"integer\",\n          groupChar: \",\",\n          constraints: { minimum: \"3,000\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/minimum\",\n        fieldName: \"price\",\n        minimum: \"3,000\",\n        rowNumber: 3,\n        cell: \"2,500\",\n      },\n    ])\n  })\n\n  it(\"should handle minimum as string with decimalChar\", async () => {\n    const table = pl\n      .DataFrame({\n        price: [\"5,5\", \"10,75\", \"2,3\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"price\",\n          type: \"number\",\n          decimalChar: \",\",\n          constraints: { minimum: \"3,0\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/minimum\",\n        fieldName: \"price\",\n        minimum: \"3,0\",\n        rowNumber: 3,\n        cell: \"2,3\",\n      },\n    ])\n  })\n\n  it(\"should handle minimum as string with groupChar and decimalChar\", async () => {\n    const table = pl\n      .DataFrame({\n        price: [\"5.000,50\", \"10.500,75\", \"2.500,30\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"price\",\n          type: \"number\",\n          groupChar: \".\",\n          decimalChar: \",\",\n          constraints: { minimum: \"3.000,00\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/minimum\",\n        fieldName: \"price\",\n        minimum: \"3.000,00\",\n        rowNumber: 3,\n        cell: \"2.500,30\",\n      },\n    ])\n  })\n\n  it(\"should handle minimum as string with bareNumber false\", async () => {\n    const table = pl\n      .DataFrame({\n        price: [\"$5.00\", \"$10.50\", \"$2.50\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"price\",\n          type: \"number\",\n          bareNumber: false,\n          constraints: { minimum: \"$3.00\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/minimum\",\n        fieldName: \"price\",\n        minimum: \"$3.00\",\n        rowNumber: 3,\n        cell: \"$2.50\",\n      },\n    ])\n  })\n\n  it(\"should handle minimum for date fields\", async () => {\n    const table = pl\n      .DataFrame({\n        date: [\"2024-01-15\", \"2024-02-20\", \"2024-01-05\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"date\",\n          type: \"date\",\n          constraints: { minimum: \"2024-01-10\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/minimum\",\n        fieldName: \"date\",\n        minimum: \"2024-01-10\",\n        rowNumber: 3,\n        cell: \"2024-01-05\",\n      },\n    ])\n  })\n\n  it.skip(\"should handle minimum for time fields\", async () => {\n    const table = pl\n      .DataFrame({\n        time: [\"14:30:00\", \"16:45:00\", \"12:15:00\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"time\",\n          type: \"time\",\n          constraints: { minimum: \"13:00:00\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/minimum\",\n        fieldName: \"time\",\n        minimum: \"13:00:00\",\n        rowNumber: 3,\n        cell: \"12:15:00\",\n      },\n    ])\n  })\n\n  it(\"should handle minimum for datetime fields\", async () => {\n    const table = pl\n      .DataFrame({\n        timestamp: [\n          \"2024-01-15T14:30:00\",\n          \"2024-02-20T08:15:00\",\n          \"2024-01-10T10:00:00\",\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"timestamp\",\n          type: \"datetime\",\n          constraints: { minimum: \"2024-01-15T00:00:00\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/minimum\",\n        fieldName: \"timestamp\",\n        minimum: \"2024-01-15T00:00:00\",\n        rowNumber: 3,\n        cell: \"2024-01-10T10:00:00\",\n      },\n    ])\n  })\n\n  it(\"should handle minimum for date fields with custom format\", async () => {\n    const table = pl\n      .DataFrame({\n        date: [\"15/01/2024\", \"20/02/2024\", \"05/01/2024\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"date\",\n          type: \"date\",\n          format: \"%d/%m/%Y\",\n          constraints: { minimum: \"10/01/2024\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/minimum\",\n        fieldName: \"date\",\n        minimum: \"10/01/2024\",\n        rowNumber: 3,\n        cell: \"05/01/2024\",\n      },\n    ])\n  })\n\n  it(\"should handle minimum for year fields\", async () => {\n    const table = pl\n      .DataFrame({\n        year: [\"2020\", \"2021\", \"2018\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"year\",\n          type: \"year\",\n          constraints: { minimum: \"2019\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/minimum\",\n        fieldName: \"year\",\n        minimum: \"2019\",\n        rowNumber: 3,\n        cell: \"2018\",\n      },\n    ])\n  })\n\n  it(\"should handle exclusiveMinimum for year fields\", async () => {\n    const table = pl\n      .DataFrame({\n        year: [\"2020\", \"2021\", \"2019\", \"2018\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"year\",\n          type: \"year\",\n          constraints: { exclusiveMinimum: \"2019\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/exclusiveMinimum\",\n        fieldName: \"year\",\n        minimum: \"2019\",\n        rowNumber: 3,\n        cell: \"2019\",\n      },\n      {\n        type: \"cell/exclusiveMinimum\",\n        fieldName: \"year\",\n        minimum: \"2019\",\n        rowNumber: 4,\n        cell: \"2018\",\n      },\n    ])\n  })\n\n  it.skip(\"should handle minimum for yearmonth fields\", async () => {\n    const table = pl\n      .DataFrame({\n        yearmonth: [\"2024-03\", \"2024-05\", \"2024-01\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"yearmonth\",\n          type: \"yearmonth\",\n          constraints: { minimum: \"2024-02\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/minimum\",\n        fieldName: \"yearmonth\",\n        minimum: \"2024-02\",\n        rowNumber: 3,\n        cell: \"2024-01\",\n      },\n    ])\n  })\n\n  it.skip(\"should handle exclusiveMinimum for yearmonth fields\", async () => {\n    const table = pl\n      .DataFrame({\n        yearmonth: [\"2024-03\", \"2024-05\", \"2024-02\", \"2024-01\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"yearmonth\",\n          type: \"yearmonth\",\n          constraints: { exclusiveMinimum: \"2024-02\" },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/exclusiveMinimum\",\n        fieldName: \"yearmonth\",\n        minimum: \"2024-02\",\n        rowNumber: 3,\n        cell: \"2024-02\",\n      },\n      {\n        type: \"cell/exclusiveMinimum\",\n        fieldName: \"yearmonth\",\n        minimum: \"2024-02\",\n        rowNumber: 4,\n        cell: \"2024-01\",\n      },\n    ])\n  })\n})\n"]}

package/build/field/checks/pattern.d.ts

@@ -0,0 +1,7 @@
+import type { Field } from "@frictionless-ts/metadata";
+import type { CellPatternError } from "@frictionless-ts/metadata";
+import type { CellMapping } from "../Mapping.ts";
+export declare function checkCellPattern(field: Field, mapping: CellMapping): {
+    isErrorExpr: import("nodejs-polars").Expr;
+    errorTemplate: CellPatternError;
+} | undefined;

package/build/field/checks/pattern.js

@@ -0,0 +1,17 @@
+export function checkCellPattern(field, mapping) {
+    if (field.type !== "string")
+        return undefined;
+    const pattern = field.constraints?.pattern;
+    if (!pattern)
+        return undefined;
+    const isErrorExpr = mapping.target.str.contains(pattern).not();
+    const errorTemplate = {
+        type: "cell/pattern",
+        fieldName: field.name,
+        pattern: pattern,
+        rowNumber: 0,
+        cell: "",
+    };
+    return { isErrorExpr, errorTemplate };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF0dGVybi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2ZpZWxkL2NoZWNrcy9wYXR0ZXJuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLE1BQU0sVUFBVSxnQkFBZ0IsQ0FBQyxLQUFZLEVBQUUsT0FBb0I7SUFDakUsSUFBSSxLQUFLLENBQUMsSUFBSSxLQUFLLFFBQVE7UUFBRSxPQUFPLFNBQVMsQ0FBQTtJQUU3QyxNQUFNLE9BQU8sR0FBRyxLQUFLLENBQUMsV0FBVyxFQUFFLE9BQU8sQ0FBQTtJQUMxQyxJQUFJLENBQUMsT0FBTztRQUFFLE9BQU8sU0FBUyxDQUFBO0lBRTlCLE1BQU0sV0FBVyxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsQ0FBQyxHQUFHLEVBQUUsQ0FBQTtJQUU5RCxNQUFNLGFBQWEsR0FBcUI7UUFDdEMsSUFBSSxFQUFFLGNBQWM7UUFDcEIsU0FBUyxFQUFFLEtBQUssQ0FBQyxJQUFJO1FBQ3JCLE9BQU8sRUFBRSxPQUFPO1FBQ2hCLFNBQVMsRUFBRSxDQUFDO1FBQ1osSUFBSSxFQUFFLEVBQUU7S0FDVCxDQUFBO0lBRUQsT0FBTyxFQUFFLFdBQVcsRUFBRSxhQUFhLEVBQUUsQ0FBQTtBQUN2QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBGaWVsZCB9IGZyb20gXCJAZnJpY3Rpb25sZXNzLXRzL21ldGFkYXRhXCJcbmltcG9ydCB0eXBlIHsgQ2VsbFBhdHRlcm5FcnJvciB9IGZyb20gXCJAZnJpY3Rpb25sZXNzLXRzL21ldGFkYXRhXCJcbmltcG9ydCB0eXBlIHsgQ2VsbE1hcHBpbmcgfSBmcm9tIFwiLi4vTWFwcGluZy50c1wiXG5cbmV4cG9ydCBmdW5jdGlvbiBjaGVja0NlbGxQYXR0ZXJuKGZpZWxkOiBGaWVsZCwgbWFwcGluZzogQ2VsbE1hcHBpbmcpIHtcbiAgaWYgKGZpZWxkLnR5cGUgIT09IFwic3RyaW5nXCIpIHJldHVybiB1bmRlZmluZWRcblxuICBjb25zdCBwYXR0ZXJuID0gZmllbGQuY29uc3RyYWludHM/LnBhdHRlcm5cbiAgaWYgKCFwYXR0ZXJuKSByZXR1cm4gdW5kZWZpbmVkXG5cbiAgY29uc3QgaXNFcnJvckV4cHIgPSBtYXBwaW5nLnRhcmdldC5zdHIuY29udGFpbnMocGF0dGVybikubm90KClcblxuICBjb25zdCBlcnJvclRlbXBsYXRlOiBDZWxsUGF0dGVybkVycm9yID0ge1xuICAgIHR5cGU6IFwiY2VsbC9wYXR0ZXJuXCIsXG4gICAgZmllbGROYW1lOiBmaWVsZC5uYW1lLFxuICAgIHBhdHRlcm46IHBhdHRlcm4sXG4gICAgcm93TnVtYmVyOiAwLFxuICAgIGNlbGw6IFwiXCIsXG4gIH1cblxuICByZXR1cm4geyBpc0Vycm9yRXhwciwgZXJyb3JUZW1wbGF0ZSB9XG59XG4iXX0=

package/build/field/checks/pattern.spec.d.ts

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