@frictionless-ts/table 1.0.1

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

@@ -0,0 +1,327 @@
+import * as pl from "nodejs-polars";
+import { describe, expect, it } from "vitest";
+import { inspectTable } from "../../table/index.js";
+describe("inspectTable (cell/enum)", () => {
+    it("should not errors for string values that are in the enum", async () => {
+        const table = pl
+            .DataFrame({
+            status: ["pending", "approved", "rejected", "pending"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "status",
+                    type: "string",
+                    constraints: {
+                        enum: ["pending", "approved", "rejected"],
+                    },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(0);
+    });
+    it("should errors for values not in the enum", async () => {
+        const allowedValues = ["pending", "approved", "rejected"];
+        const table = pl
+            .DataFrame({
+            status: ["pending", "approved", "unknown", "cancelled", "rejected"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "status",
+                    type: "string",
+                    constraints: {
+                        enum: allowedValues,
+                    },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors.filter(e => e.type === "cell/enum")).toHaveLength(2);
+        expect(errors).toContainEqual({
+            type: "cell/enum",
+            fieldName: "status",
+            enum: allowedValues,
+            rowNumber: 3,
+            cell: "unknown",
+        });
+        expect(errors).toContainEqual({
+            type: "cell/enum",
+            fieldName: "status",
+            enum: allowedValues,
+            rowNumber: 4,
+            cell: "cancelled",
+        });
+    });
+    it("should handle null values correctly", async () => {
+        const table = pl
+            .DataFrame({
+            status: ["pending", null, "approved", null],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "status",
+                    type: "string",
+                    constraints: {
+                        enum: ["pending", "approved", "rejected"],
+                    },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors.filter(e => e.type === "cell/enum")).toHaveLength(0);
+    });
+    it("should handle case sensitivity correctly", async () => {
+        const allowedValues = ["pending", "approved", "rejected"];
+        const table = pl
+            .DataFrame({
+            status: ["Pending", "APPROVED", "rejected"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "status",
+                    type: "string",
+                    constraints: {
+                        enum: allowedValues,
+                    },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors.filter(e => e.type === "cell/enum")).toHaveLength(2);
+        expect(errors).toContainEqual({
+            type: "cell/enum",
+            fieldName: "status",
+            enum: allowedValues,
+            rowNumber: 1,
+            cell: "Pending",
+        });
+        expect(errors).toContainEqual({
+            type: "cell/enum",
+            fieldName: "status",
+            enum: allowedValues,
+            rowNumber: 2,
+            cell: "APPROVED",
+        });
+    });
+    it("should handle integer enum with string values", async () => {
+        const allowedValues = ["1", "2", "3"];
+        const table = pl
+            .DataFrame({
+            priority: ["1", "2", "5"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "priority",
+                    type: "integer",
+                    constraints: {
+                        enum: allowedValues,
+                    },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/enum",
+                fieldName: "priority",
+                enum: allowedValues,
+                rowNumber: 3,
+                cell: "5",
+            },
+        ]);
+    });
+    it("should handle number enum with string values", async () => {
+        const allowedValues = ["1.5", "2.5", "3.5"];
+        const table = pl
+            .DataFrame({
+            rating: ["1.5", "2.5", "4.5"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "rating",
+                    type: "number",
+                    constraints: {
+                        enum: allowedValues,
+                    },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/enum",
+                fieldName: "rating",
+                enum: allowedValues,
+                rowNumber: 3,
+                cell: "4.5",
+            },
+        ]);
+    });
+    it.skip("should handle date enum with string values", async () => {
+        const allowedValues = ["2024-01-01", "2024-02-01", "2024-03-01"];
+        const table = pl
+            .DataFrame({
+            date: ["2024-01-01", "2024-02-01", "2024-05-01"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "date",
+                    type: "date",
+                    constraints: {
+                        enum: allowedValues,
+                    },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/enum",
+                fieldName: "date",
+                enum: allowedValues,
+                rowNumber: 3,
+                cell: "2024-05-01",
+            },
+        ]);
+    });
+    it.skip("should handle datetime enum with string values", async () => {
+        const allowedValues = [
+            "2024-01-01T10:00:00",
+            "2024-01-01T14:00:00",
+            "2024-01-01T18:00:00",
+        ];
+        const table = pl
+            .DataFrame({
+            timestamp: [
+                "2024-01-01T10:00:00",
+                "2024-01-01T14:00:00",
+                "2024-01-01T20:00:00",
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "timestamp",
+                    type: "datetime",
+                    constraints: {
+                        enum: allowedValues,
+                    },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/enum",
+                fieldName: "timestamp",
+                enum: allowedValues,
+                rowNumber: 3,
+                cell: "2024-01-01T20:00:00",
+            },
+        ]);
+    });
+    it("should handle year enum with string values", async () => {
+        const allowedValues = ["2020", "2021", "2022"];
+        const table = pl
+            .DataFrame({
+            year: ["2020", "2021", "2023"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "year",
+                    type: "year",
+                    constraints: {
+                        enum: allowedValues,
+                    },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/enum",
+                fieldName: "year",
+                enum: allowedValues,
+                rowNumber: 3,
+                cell: "2023",
+            },
+        ]);
+    });
+    it.skip("should handle time enum with string values", async () => {
+        const allowedValues = ["10:00:00", "14:00:00", "18:00:00"];
+        const table = pl
+            .DataFrame({
+            time: ["10:00:00", "14:00:00", "20:00:00"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "time",
+                    type: "time",
+                    constraints: {
+                        enum: allowedValues,
+                    },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/enum",
+                fieldName: "time",
+                enum: allowedValues,
+                rowNumber: 3,
+                cell: "20:00:00",
+            },
+        ]);
+    });
+    it.skip("should handle yearmonth enum with string values", async () => {
+        const allowedValues = ["2024-01", "2024-02", "2024-03"];
+        const table = pl
+            .DataFrame({
+            yearmonth: ["2024-01", "2024-02", "2024-05"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "yearmonth",
+                    type: "yearmonth",
+                    constraints: {
+                        enum: allowedValues,
+                    },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/enum",
+                fieldName: "yearmonth",
+                enum: allowedValues,
+                rowNumber: 3,
+                cell: "2024-05",
+            },
+        ]);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"enum.spec.js","sourceRoot":"","sources":["../../../field/checks/enum.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/enum)\", () => {\n  it(\"should not errors for string values that are in the enum\", async () => {\n    const table = pl\n      .DataFrame({\n        status: [\"pending\", \"approved\", \"rejected\", \"pending\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"status\",\n          type: \"string\",\n          constraints: {\n            enum: [\"pending\", \"approved\", \"rejected\"],\n          },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toHaveLength(0)\n  })\n\n  it(\"should errors for values not in the enum\", async () => {\n    const allowedValues = [\"pending\", \"approved\", \"rejected\"]\n\n    const table = pl\n      .DataFrame({\n        status: [\"pending\", \"approved\", \"unknown\", \"cancelled\", \"rejected\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"status\",\n          type: \"string\",\n          constraints: {\n            enum: allowedValues,\n          },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors.filter(e => e.type === \"cell/enum\")).toHaveLength(2)\n    expect(errors).toContainEqual({\n      type: \"cell/enum\",\n      fieldName: \"status\",\n      enum: allowedValues,\n      rowNumber: 3,\n      cell: \"unknown\",\n    })\n    expect(errors).toContainEqual({\n      type: \"cell/enum\",\n      fieldName: \"status\",\n      enum: allowedValues,\n      rowNumber: 4,\n      cell: \"cancelled\",\n    })\n  })\n\n  it(\"should handle null values correctly\", async () => {\n    const table = pl\n      .DataFrame({\n        status: [\"pending\", null, \"approved\", null],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"status\",\n          type: \"string\",\n          constraints: {\n            enum: [\"pending\", \"approved\", \"rejected\"],\n          },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors.filter(e => e.type === \"cell/enum\")).toHaveLength(0)\n  })\n\n  it(\"should handle case sensitivity correctly\", async () => {\n    const allowedValues = [\"pending\", \"approved\", \"rejected\"]\n\n    const table = pl\n      .DataFrame({\n        status: [\"Pending\", \"APPROVED\", \"rejected\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"status\",\n          type: \"string\",\n          constraints: {\n            enum: allowedValues,\n          },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors.filter(e => e.type === \"cell/enum\")).toHaveLength(2)\n    expect(errors).toContainEqual({\n      type: \"cell/enum\",\n      fieldName: \"status\",\n      enum: allowedValues,\n      rowNumber: 1,\n      cell: \"Pending\",\n    })\n    expect(errors).toContainEqual({\n      type: \"cell/enum\",\n      fieldName: \"status\",\n      enum: allowedValues,\n      rowNumber: 2,\n      cell: \"APPROVED\",\n    })\n  })\n\n  it(\"should handle integer enum with string values\", async () => {\n    const allowedValues = [\"1\", \"2\", \"3\"]\n\n    const table = pl\n      .DataFrame({\n        priority: [\"1\", \"2\", \"5\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"priority\",\n          type: \"integer\",\n          constraints: {\n            enum: allowedValues,\n          },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/enum\",\n        fieldName: \"priority\",\n        enum: allowedValues,\n        rowNumber: 3,\n        cell: \"5\",\n      },\n    ])\n  })\n\n  it(\"should handle number enum with string values\", async () => {\n    const allowedValues = [\"1.5\", \"2.5\", \"3.5\"]\n\n    const table = pl\n      .DataFrame({\n        rating: [\"1.5\", \"2.5\", \"4.5\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"rating\",\n          type: \"number\",\n          constraints: {\n            enum: allowedValues,\n          },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/enum\",\n        fieldName: \"rating\",\n        enum: allowedValues,\n        rowNumber: 3,\n        cell: \"4.5\",\n      },\n    ])\n  })\n\n  it.skip(\"should handle date enum with string values\", async () => {\n    const allowedValues = [\"2024-01-01\", \"2024-02-01\", \"2024-03-01\"]\n\n    const table = pl\n      .DataFrame({\n        date: [\"2024-01-01\", \"2024-02-01\", \"2024-05-01\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"date\",\n          type: \"date\",\n          constraints: {\n            enum: allowedValues,\n          },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/enum\",\n        fieldName: \"date\",\n        enum: allowedValues,\n        rowNumber: 3,\n        cell: \"2024-05-01\",\n      },\n    ])\n  })\n\n  it.skip(\"should handle datetime enum with string values\", async () => {\n    const allowedValues = [\n      \"2024-01-01T10:00:00\",\n      \"2024-01-01T14:00:00\",\n      \"2024-01-01T18:00:00\",\n    ]\n\n    const table = pl\n      .DataFrame({\n        timestamp: [\n          \"2024-01-01T10:00:00\",\n          \"2024-01-01T14:00:00\",\n          \"2024-01-01T20:00:00\",\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"timestamp\",\n          type: \"datetime\",\n          constraints: {\n            enum: allowedValues,\n          },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/enum\",\n        fieldName: \"timestamp\",\n        enum: allowedValues,\n        rowNumber: 3,\n        cell: \"2024-01-01T20:00:00\",\n      },\n    ])\n  })\n\n  it(\"should handle year enum with string values\", async () => {\n    const allowedValues = [\"2020\", \"2021\", \"2022\"]\n\n    const table = pl\n      .DataFrame({\n        year: [\"2020\", \"2021\", \"2023\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"year\",\n          type: \"year\",\n          constraints: {\n            enum: allowedValues,\n          },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/enum\",\n        fieldName: \"year\",\n        enum: allowedValues,\n        rowNumber: 3,\n        cell: \"2023\",\n      },\n    ])\n  })\n\n  it.skip(\"should handle time enum with string values\", async () => {\n    const allowedValues = [\"10:00:00\", \"14:00:00\", \"18:00:00\"]\n\n    const table = pl\n      .DataFrame({\n        time: [\"10:00:00\", \"14:00:00\", \"20:00:00\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"time\",\n          type: \"time\",\n          constraints: {\n            enum: allowedValues,\n          },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/enum\",\n        fieldName: \"time\",\n        enum: allowedValues,\n        rowNumber: 3,\n        cell: \"20:00:00\",\n      },\n    ])\n  })\n\n  it.skip(\"should handle yearmonth enum with string values\", async () => {\n    const allowedValues = [\"2024-01\", \"2024-02\", \"2024-03\"]\n\n    const table = pl\n      .DataFrame({\n        yearmonth: [\"2024-01\", \"2024-02\", \"2024-05\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"yearmonth\",\n          type: \"yearmonth\",\n          constraints: {\n            enum: allowedValues,\n          },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n\n    expect(errors).toEqual([\n      {\n        type: \"cell/enum\",\n        fieldName: \"yearmonth\",\n        enum: allowedValues,\n        rowNumber: 3,\n        cell: \"2024-05\",\n      },\n    ])\n  })\n})\n"]}

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

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

package/build/field/checks/maxLength.js

@@ -0,0 +1,17 @@
+export function checkCellMaxLength(field, mapping) {
+    if (field.type !== "string")
+        return undefined;
+    const maxLength = field.constraints?.maxLength;
+    if (!maxLength)
+        return undefined;
+    const isErrorExpr = mapping.target.str.lengths().gt(maxLength);
+    const errorTemplate = {
+        type: "cell/maxLength",
+        fieldName: field.name,
+        maxLength: maxLength,
+        rowNumber: 0,
+        cell: "",
+    };
+    return { isErrorExpr, errorTemplate };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWF4TGVuZ3RoLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vZmllbGQvY2hlY2tzL21heExlbmd0aC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxNQUFNLFVBQVUsa0JBQWtCLENBQUMsS0FBWSxFQUFFLE9BQW9CO0lBQ25FLElBQUksS0FBSyxDQUFDLElBQUksS0FBSyxRQUFRO1FBQUUsT0FBTyxTQUFTLENBQUE7SUFFN0MsTUFBTSxTQUFTLEdBQUcsS0FBSyxDQUFDLFdBQVcsRUFBRSxTQUFTLENBQUE7SUFDOUMsSUFBSSxDQUFDLFNBQVM7UUFBRSxPQUFPLFNBQVMsQ0FBQTtJQUVoQyxNQUFNLFdBQVcsR0FBRyxPQUFPLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxPQUFPLEVBQUUsQ0FBQyxFQUFFLENBQUMsU0FBUyxDQUFDLENBQUE7SUFFOUQsTUFBTSxhQUFhLEdBQXVCO1FBQ3hDLElBQUksRUFBRSxnQkFBZ0I7UUFDdEIsU0FBUyxFQUFFLEtBQUssQ0FBQyxJQUFJO1FBQ3JCLFNBQVMsRUFBRSxTQUFTO1FBQ3BCLFNBQVMsRUFBRSxDQUFDO1FBQ1osSUFBSSxFQUFFLEVBQUU7S0FDVCxDQUFBO0lBRUQsT0FBTyxFQUFFLFdBQVcsRUFBRSxhQUFhLEVBQUUsQ0FBQTtBQUN2QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBGaWVsZCB9IGZyb20gXCJAZnJpY3Rpb25sZXNzLXRzL21ldGFkYXRhXCJcbmltcG9ydCB0eXBlIHsgQ2VsbE1heExlbmd0aEVycm9yIH0gZnJvbSBcIkBmcmljdGlvbmxlc3MtdHMvbWV0YWRhdGFcIlxuaW1wb3J0IHR5cGUgeyBDZWxsTWFwcGluZyB9IGZyb20gXCIuLi9NYXBwaW5nLnRzXCJcblxuZXhwb3J0IGZ1bmN0aW9uIGNoZWNrQ2VsbE1heExlbmd0aChmaWVsZDogRmllbGQsIG1hcHBpbmc6IENlbGxNYXBwaW5nKSB7XG4gIGlmIChmaWVsZC50eXBlICE9PSBcInN0cmluZ1wiKSByZXR1cm4gdW5kZWZpbmVkXG5cbiAgY29uc3QgbWF4TGVuZ3RoID0gZmllbGQuY29uc3RyYWludHM/Lm1heExlbmd0aFxuICBpZiAoIW1heExlbmd0aCkgcmV0dXJuIHVuZGVmaW5lZFxuXG4gIGNvbnN0IGlzRXJyb3JFeHByID0gbWFwcGluZy50YXJnZXQuc3RyLmxlbmd0aHMoKS5ndChtYXhMZW5ndGgpXG5cbiAgY29uc3QgZXJyb3JUZW1wbGF0ZTogQ2VsbE1heExlbmd0aEVycm9yID0ge1xuICAgIHR5cGU6IFwiY2VsbC9tYXhMZW5ndGhcIixcbiAgICBmaWVsZE5hbWU6IGZpZWxkLm5hbWUsXG4gICAgbWF4TGVuZ3RoOiBtYXhMZW5ndGgsXG4gICAgcm93TnVtYmVyOiAwLFxuICAgIGNlbGw6IFwiXCIsXG4gIH1cblxuICByZXR1cm4geyBpc0Vycm9yRXhwciwgZXJyb3JUZW1wbGF0ZSB9XG59XG4iXX0=

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

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

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

@@ -0,0 +1,49 @@
+import * as pl from "nodejs-polars";
+import { describe, expect, it } from "vitest";
+import { inspectTable } from "../../table/index.js";
+describe("inspectTable (cell/maxLength)", () => {
+    it("should not errors for string values that meet the maxLength constraint", async () => {
+        const table = pl
+            .DataFrame({
+            code: ["A123", "B456", "C789"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "code",
+                    type: "string",
+                    constraints: { maxLength: 4 },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(0);
+    });
+    it("should report an error for strings that are too long", async () => {
+        const table = pl
+            .DataFrame({
+            username: ["bob", "alice", "christopher", "david"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "username",
+                    type: "string",
+                    constraints: { maxLength: 8 },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors.filter(e => e.type === "cell/maxLength")).toHaveLength(1);
+        expect(errors).toContainEqual({
+            type: "cell/maxLength",
+            fieldName: "username",
+            maxLength: 8,
+            rowNumber: 3,
+            cell: "christopher",
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,11 @@
+import type { Field } from "@frictionless-ts/metadata";
+import type { CellExclusiveMaximumError } from "@frictionless-ts/metadata";
+import type { CellMaximumError } from "@frictionless-ts/metadata";
+import * as pl from "nodejs-polars";
+import type { CellMapping } from "../Mapping.ts";
+export declare function createCheckCellMaximum(options?: {
+    isExclusive?: boolean;
+}): (field: Field, mapping: CellMapping) => {
+    isErrorExpr: pl.Expr;
+    errorTemplate: CellMaximumError | CellExclusiveMaximumError;
+} | undefined;

package/build/field/checks/maximum.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 createCheckCellMaximum(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 maximum = options?.isExclusive
+            ? field.constraints?.exclusiveMaximum
+            : field.constraints?.maximum;
+        if (maximum === undefined)
+            return undefined;
+        let isErrorExpr;
+        try {
+            const parsedMaximum = parseConstraint(field, maximum);
+            isErrorExpr = options?.isExclusive
+                ? mapping.target.gtEq(parsedMaximum)
+                : mapping.target.gt(parsedMaximum);
+        }
+        catch (error) {
+            isErrorExpr = pl.pl.lit(true);
+        }
+        const errorTemplate = {
+            type: options?.isExclusive ? "cell/exclusiveMaximum" : "cell/maximum",
+            fieldName: field.name,
+            maximum: String(maximum),
+            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/maximum.spec.d.ts

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