@frictionless-ts/table 1.0.1

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

@@ -0,0 +1,393 @@
+import * as pl from "nodejs-polars";
+import { describe, expect, it } from "vitest";
+import { inspectTable } from "../../table/index.js";
+describe("validateObjectField", () => {
+    it("should not errors for valid JSON objects", async () => {
+        const table = pl
+            .DataFrame({
+            metadata: ['{"key":"value"}', '{"num":123}', '{"arr":[1,2,3]}'],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "metadata",
+                    type: "object",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(0);
+    });
+    it("should errors for JSON arrays", async () => {
+        const table = pl
+            .DataFrame({
+            data: ["[1,2,3]", '{"key":"value"}', '["a","b","c"]'],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "data",
+                    type: "object",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/type",
+                fieldName: "data",
+                fieldType: "object",
+                rowNumber: 1,
+                cell: "[1,2,3]",
+            },
+            {
+                type: "cell/type",
+                fieldName: "data",
+                fieldType: "object",
+                rowNumber: 3,
+                cell: '["a","b","c"]',
+            },
+        ]);
+    });
+    it("should not errors for null values", async () => {
+        const table = pl
+            .DataFrame({
+            config: ['{"key":"value"}', null, '{"num":123}'],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "config",
+                    type: "object",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(0);
+    });
+    it("should errors for invalid JSON", async () => {
+        const table = pl
+            .DataFrame({
+            data: ['{"valid":true}', "invalid json", '{"key":"value"}', "{broken}"],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "data",
+                    type: "object",
+                },
+            ],
+        };
+        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: "object",
+            rowNumber: 2,
+            cell: "invalid json",
+        });
+        expect(errors).toContainEqual({
+            type: "cell/type",
+            fieldName: "data",
+            fieldType: "object",
+            rowNumber: 4,
+            cell: "{broken}",
+        });
+    });
+    it("should handle complex nested JSON structures", async () => {
+        const table = pl
+            .DataFrame({
+            complex: [
+                '{"user":{"name":"John","age":30,"tags":["admin","user"]}}',
+                '{"nested":{"deep":{"value":true}}}',
+                '{"array":[{"id":1},{"id":2}]}',
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "complex",
+                    type: "object",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(0);
+    });
+    it("should errors for empty strings", async () => {
+        const table = pl
+            .DataFrame({
+            data: ['{"valid":true}', "", '{"key":"value"}'],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "data",
+                    type: "object",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/type",
+                fieldName: "data",
+                fieldType: "object",
+                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: "object",
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/type",
+                fieldName: "data",
+                fieldType: "object",
+                rowNumber: 1,
+                cell: '"string"',
+            },
+            {
+                type: "cell/type",
+                fieldName: "data",
+                fieldType: "object",
+                rowNumber: 2,
+                cell: "123",
+            },
+            {
+                type: "cell/type",
+                fieldName: "data",
+                fieldType: "object",
+                rowNumber: 3,
+                cell: "true",
+            },
+            {
+                type: "cell/type",
+                fieldName: "data",
+                fieldType: "object",
+                rowNumber: 4,
+                cell: "false",
+            },
+            {
+                type: "cell/type",
+                fieldName: "data",
+                fieldType: "object",
+                rowNumber: 5,
+                cell: "null",
+            },
+        ]);
+    });
+    it("should not errors for objects matching jsonSchema", async () => {
+        const table = pl
+            .DataFrame({
+            user: [
+                '{"name":"John","age":30}',
+                '{"name":"Jane","age":25}',
+                '{"name":"Bob","age":35}',
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "user",
+                    type: "object",
+                    constraints: {
+                        jsonSchema: {
+                            type: "object",
+                            properties: {
+                                name: { type: "string" },
+                                age: { type: "number" },
+                            },
+                            required: ["name", "age"],
+                        },
+                    },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toHaveLength(0);
+    });
+    it("should errors for objects not matching jsonSchema", async () => {
+        const jsonSchema = {
+            type: "object",
+            properties: {
+                name: { type: "string" },
+                age: { type: "number" },
+            },
+            required: ["name", "age"],
+        };
+        const table = pl
+            .DataFrame({
+            user: [
+                '{"name":"John","age":30}',
+                '{"name":"Jane"}',
+                '{"age":25}',
+                '{"name":"Bob","age":"invalid"}',
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "user",
+                    type: "object",
+                    constraints: {
+                        jsonSchema,
+                    },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors.filter(e => e.type === "cell/jsonSchema")).toEqual([
+            {
+                type: "cell/jsonSchema",
+                fieldName: "user",
+                rowNumber: 2,
+                cell: '{"name":"Jane"}',
+                pointer: "",
+                message: "must have required property 'age'",
+            },
+            {
+                type: "cell/jsonSchema",
+                fieldName: "user",
+                rowNumber: 3,
+                cell: '{"age":25}',
+                pointer: "",
+                message: "must have required property 'name'",
+            },
+            {
+                type: "cell/jsonSchema",
+                fieldName: "user",
+                rowNumber: 4,
+                cell: '{"name":"Bob","age":"invalid"}',
+                pointer: "/age",
+                message: "must be number",
+            },
+        ]);
+    });
+    it("should validate complex jsonSchema with nested objects", async () => {
+        const table = pl
+            .DataFrame({
+            config: [
+                '{"database":{"host":"localhost","port":5432},"cache":{"enabled":true}}',
+                '{"database":{"host":"localhost","port":"invalid"},"cache":{"enabled":true}}',
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "config",
+                    type: "object",
+                    constraints: {
+                        jsonSchema: {
+                            type: "object",
+                            properties: {
+                                database: {
+                                    type: "object",
+                                    properties: {
+                                        host: { type: "string" },
+                                        port: { type: "number" },
+                                    },
+                                    required: ["host", "port"],
+                                },
+                                cache: {
+                                    type: "object",
+                                    properties: {
+                                        enabled: { type: "boolean" },
+                                    },
+                                    required: ["enabled"],
+                                },
+                            },
+                            required: ["database", "cache"],
+                        },
+                    },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors).toEqual([
+            {
+                type: "cell/jsonSchema",
+                fieldName: "config",
+                rowNumber: 2,
+                cell: '{"database":{"host":"localhost","port":"invalid"},"cache":{"enabled":true}}',
+                pointer: "/database/port",
+                message: "must be number",
+            },
+        ]);
+    });
+    it("should validate jsonSchema with array properties", async () => {
+        const table = pl
+            .DataFrame({
+            data: [
+                '{"items":[1,2,3],"name":"test"}',
+                '{"items":["not","numbers"],"name":"test"}',
+            ],
+        })
+            .lazy();
+        const schema = {
+            fields: [
+                {
+                    name: "data",
+                    type: "object",
+                    constraints: {
+                        jsonSchema: {
+                            type: "object",
+                            properties: {
+                                items: {
+                                    type: "array",
+                                    items: { type: "number" },
+                                },
+                                name: { type: "string" },
+                            },
+                            required: ["items", "name"],
+                        },
+                    },
+                },
+            ],
+        };
+        const errors = await inspectTable(table, { schema });
+        expect(errors.filter(e => e.type === "cell/jsonSchema")).toEqual([
+            {
+                type: "cell/jsonSchema",
+                fieldName: "data",
+                rowNumber: 2,
+                cell: '{"items":["not","numbers"],"name":"test"}',
+                pointer: "/items/0",
+                message: "must be number",
+            },
+            {
+                type: "cell/jsonSchema",
+                fieldName: "data",
+                rowNumber: 2,
+                cell: '{"items":["not","numbers"],"name":"test"}',
+                pointer: "/items/1",
+                message: "must be number",
+            },
+        ]);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"object.spec.js","sourceRoot":"","sources":["../../../field/types/object.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(\"validateObjectField\", () => {\n  it(\"should not errors for valid JSON objects\", async () => {\n    const table = pl\n      .DataFrame({\n        metadata: ['{\"key\":\"value\"}', '{\"num\":123}', '{\"arr\":[1,2,3]}'],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"metadata\",\n          type: \"object\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toHaveLength(0)\n  })\n\n  it(\"should errors for JSON arrays\", async () => {\n    const table = pl\n      .DataFrame({\n        data: [\"[1,2,3]\", '{\"key\":\"value\"}', '[\"a\",\"b\",\"c\"]'],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"data\",\n          type: \"object\",\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: \"object\",\n        rowNumber: 1,\n        cell: \"[1,2,3]\",\n      },\n      {\n        type: \"cell/type\",\n        fieldName: \"data\",\n        fieldType: \"object\",\n        rowNumber: 3,\n        cell: '[\"a\",\"b\",\"c\"]',\n      },\n    ])\n  })\n\n  it(\"should not errors for null values\", async () => {\n    const table = pl\n      .DataFrame({\n        config: ['{\"key\":\"value\"}', null, '{\"num\":123}'],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"config\",\n          type: \"object\",\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toHaveLength(0)\n  })\n\n  it(\"should errors for invalid JSON\", async () => {\n    const table = pl\n      .DataFrame({\n        data: ['{\"valid\":true}', \"invalid json\", '{\"key\":\"value\"}', \"{broken}\"],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"data\",\n          type: \"object\",\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: \"object\",\n      rowNumber: 2,\n      cell: \"invalid json\",\n    })\n    expect(errors).toContainEqual({\n      type: \"cell/type\",\n      fieldName: \"data\",\n      fieldType: \"object\",\n      rowNumber: 4,\n      cell: \"{broken}\",\n    })\n  })\n\n  it(\"should handle complex nested JSON structures\", async () => {\n    const table = pl\n      .DataFrame({\n        complex: [\n          '{\"user\":{\"name\":\"John\",\"age\":30,\"tags\":[\"admin\",\"user\"]}}',\n          '{\"nested\":{\"deep\":{\"value\":true}}}',\n          '{\"array\":[{\"id\":1},{\"id\":2}]}',\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"complex\",\n          type: \"object\",\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\":true}', \"\", '{\"key\":\"value\"}'],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"data\",\n          type: \"object\",\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: \"object\",\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: \"object\",\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: \"object\",\n        rowNumber: 1,\n        cell: '\"string\"',\n      },\n      {\n        type: \"cell/type\",\n        fieldName: \"data\",\n        fieldType: \"object\",\n        rowNumber: 2,\n        cell: \"123\",\n      },\n      {\n        type: \"cell/type\",\n        fieldName: \"data\",\n        fieldType: \"object\",\n        rowNumber: 3,\n        cell: \"true\",\n      },\n      {\n        type: \"cell/type\",\n        fieldName: \"data\",\n        fieldType: \"object\",\n        rowNumber: 4,\n        cell: \"false\",\n      },\n      {\n        type: \"cell/type\",\n        fieldName: \"data\",\n        fieldType: \"object\",\n        rowNumber: 5,\n        cell: \"null\",\n      },\n    ])\n  })\n\n  it(\"should not errors for objects matching jsonSchema\", async () => {\n    const table = pl\n      .DataFrame({\n        user: [\n          '{\"name\":\"John\",\"age\":30}',\n          '{\"name\":\"Jane\",\"age\":25}',\n          '{\"name\":\"Bob\",\"age\":35}',\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"user\",\n          type: \"object\",\n          constraints: {\n            jsonSchema: {\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    const errors = await inspectTable(table, { schema })\n    expect(errors).toHaveLength(0)\n  })\n\n  it(\"should errors for objects not matching jsonSchema\", async () => {\n    const jsonSchema = {\n      type: \"object\",\n      properties: {\n        name: { type: \"string\" },\n        age: { type: \"number\" },\n      },\n      required: [\"name\", \"age\"],\n    }\n\n    const table = pl\n      .DataFrame({\n        user: [\n          '{\"name\":\"John\",\"age\":30}',\n          '{\"name\":\"Jane\"}',\n          '{\"age\":25}',\n          '{\"name\":\"Bob\",\"age\":\"invalid\"}',\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"user\",\n          type: \"object\",\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: \"user\",\n        rowNumber: 2,\n        cell: '{\"name\":\"Jane\"}',\n        pointer: \"\",\n        message: \"must have required property 'age'\",\n      },\n      {\n        type: \"cell/jsonSchema\",\n        fieldName: \"user\",\n        rowNumber: 3,\n        cell: '{\"age\":25}',\n        pointer: \"\",\n        message: \"must have required property 'name'\",\n      },\n      {\n        type: \"cell/jsonSchema\",\n        fieldName: \"user\",\n        rowNumber: 4,\n        cell: '{\"name\":\"Bob\",\"age\":\"invalid\"}',\n        pointer: \"/age\",\n        message: \"must be number\",\n      },\n    ])\n  })\n\n  it(\"should validate complex jsonSchema with nested objects\", async () => {\n    const table = pl\n      .DataFrame({\n        config: [\n          '{\"database\":{\"host\":\"localhost\",\"port\":5432},\"cache\":{\"enabled\":true}}',\n          '{\"database\":{\"host\":\"localhost\",\"port\":\"invalid\"},\"cache\":{\"enabled\":true}}',\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"config\",\n          type: \"object\",\n          constraints: {\n            jsonSchema: {\n              type: \"object\",\n              properties: {\n                database: {\n                  type: \"object\",\n                  properties: {\n                    host: { type: \"string\" },\n                    port: { type: \"number\" },\n                  },\n                  required: [\"host\", \"port\"],\n                },\n                cache: {\n                  type: \"object\",\n                  properties: {\n                    enabled: { type: \"boolean\" },\n                  },\n                  required: [\"enabled\"],\n                },\n              },\n              required: [\"database\", \"cache\"],\n            },\n          },\n        },\n      ],\n    }\n\n    const errors = await inspectTable(table, { schema })\n    expect(errors).toEqual([\n      {\n        type: \"cell/jsonSchema\",\n        fieldName: \"config\",\n        rowNumber: 2,\n        cell: '{\"database\":{\"host\":\"localhost\",\"port\":\"invalid\"},\"cache\":{\"enabled\":true}}',\n        pointer: \"/database/port\",\n        message: \"must be number\",\n      },\n    ])\n  })\n\n  it(\"should validate jsonSchema with array properties\", async () => {\n    const table = pl\n      .DataFrame({\n        data: [\n          '{\"items\":[1,2,3],\"name\":\"test\"}',\n          '{\"items\":[\"not\",\"numbers\"],\"name\":\"test\"}',\n        ],\n      })\n      .lazy()\n\n    const schema: Schema = {\n      fields: [\n        {\n          name: \"data\",\n          type: \"object\",\n          constraints: {\n            jsonSchema: {\n              type: \"object\",\n              properties: {\n                items: {\n                  type: \"array\",\n                  items: { type: \"number\" },\n                },\n                name: { type: \"string\" },\n              },\n              required: [\"items\", \"name\"],\n            },\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: \"data\",\n        rowNumber: 2,\n        cell: '{\"items\":[\"not\",\"numbers\"],\"name\":\"test\"}',\n        pointer: \"/items/0\",\n        message: \"must be number\",\n      },\n      {\n        type: \"cell/jsonSchema\",\n        fieldName: \"data\",\n        rowNumber: 2,\n        cell: '{\"items\":[\"not\",\"numbers\"],\"name\":\"test\"}',\n        pointer: \"/items/1\",\n        message: \"must be number\",\n      },\n    ])\n  })\n})\n"]}

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

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

package/build/field/types/string.js

@@ -0,0 +1,32 @@
+import * as pl from "nodejs-polars";
+const FORMAT_REGEX = {
+    email: "^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+$",
+    uri: "^[a-zA-Z][a-zA-Z0-9+.-]*:(//([^\\s/]+[^\\s]*|/[^\\s]*)|[^\\s/][^\\s]*)$",
+    binary: "^[A-Za-z0-9+/]*={0,2}$",
+    uuid: "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$",
+};
+// TODO: support categoriesOrder?
+export function parseStringField(field, fieldExpr) {
+    const format = field.format;
+    const flattenCategories = field.categories?.map(it => typeof it === "string" ? it : it.value);
+    if (flattenCategories) {
+        return pl
+            .when(fieldExpr.isIn(flattenCategories))
+            .then(fieldExpr.cast(pl.Categorical))
+            .otherwise(pl.lit(null))
+            .alias(field.name);
+    }
+    if (format) {
+        const regex = FORMAT_REGEX[format];
+        return pl
+            .when(fieldExpr.str.contains(regex))
+            .then(fieldExpr)
+            .otherwise(pl.lit(null))
+            .alias(field.name);
+    }
+    return fieldExpr;
+}
+export function stringifyStringField(_field, fieldExpr) {
+    return fieldExpr;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RyaW5nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vZmllbGQvdHlwZXMvc3RyaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFFLE1BQU0sZUFBZSxDQUFBO0FBRW5DLE1BQU0sWUFBWSxHQUFHO0lBQ25CLEtBQUssRUFDSCx1SUFBdUk7SUFDekksR0FBRyxFQUFFLHlFQUF5RTtJQUM5RSxNQUFNLEVBQUUsd0JBQXdCO0lBQ2hDLElBQUksRUFBRSxnRUFBZ0U7Q0FDOUQsQ0FBQTtBQUVWLGlDQUFpQztBQUNqQyxNQUFNLFVBQVUsZ0JBQWdCLENBQUMsS0FBa0IsRUFBRSxTQUFrQjtJQUNyRSxNQUFNLE1BQU0sR0FBRyxLQUFLLENBQUMsTUFBTSxDQUFBO0lBQzNCLE1BQU0saUJBQWlCLEdBQUcsS0FBSyxDQUFDLFVBQVUsRUFBRSxHQUFHLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FDbkQsT0FBTyxFQUFFLEtBQUssUUFBUSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxLQUFLLENBQ3ZDLENBQUE7SUFFRCxJQUFJLGlCQUFpQixFQUFFLENBQUM7UUFDdEIsT0FBTyxFQUFFO2FBQ04sSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsaUJBQWlCLENBQUMsQ0FBQzthQUN2QyxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsV0FBVyxDQUFDLENBQUM7YUFDcEMsU0FBUyxDQUFDLEVBQUUsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUM7YUFDdkIsS0FBSyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQTtJQUN0QixDQUFDO0lBRUQsSUFBSSxNQUFNLEVBQUUsQ0FBQztRQUNYLE1BQU0sS0FBSyxHQUFHLFlBQVksQ0FBQyxNQUFNLENBQUMsQ0FBQTtRQUNsQyxPQUFPLEVBQUU7YUFDTixJQUFJLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLENBQUM7YUFDbkMsSUFBSSxDQUFDLFNBQVMsQ0FBQzthQUNmLFNBQVMsQ0FBQyxFQUFFLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDO2FBQ3ZCLEtBQUssQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUE7SUFDdEIsQ0FBQztJQUVELE9BQU8sU0FBUyxDQUFBO0FBQ2xCLENBQUM7QUFFRCxNQUFNLFVBQVUsb0JBQW9CLENBQUMsTUFBbUIsRUFBRSxTQUFrQjtJQUMxRSxPQUFPLFNBQVMsQ0FBQTtBQUNsQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBTdHJpbmdGaWVsZCB9IGZyb20gXCJAZnJpY3Rpb25sZXNzLXRzL21ldGFkYXRhXCJcbmltcG9ydCAqIGFzIHBsIGZyb20gXCJub2RlanMtcG9sYXJzXCJcblxuY29uc3QgRk9STUFUX1JFR0VYID0ge1xuICBlbWFpbDpcbiAgICBcIl5bYS16QS1aMC05LiEjJCUmJyorLz0/Xl9ge3x9fi1dK0BbYS16QS1aMC05XSg/OlthLXpBLVowLTktXXswLDYxfVthLXpBLVowLTldKT8oPzpcXFxcLlthLXpBLVowLTldKD86W2EtekEtWjAtOS1dezAsNjF9W2EtekEtWjAtOV0pPykrJFwiLFxuICB1cmk6IFwiXlthLXpBLVpdW2EtekEtWjAtOSsuLV0qOigvLyhbXlxcXFxzL10rW15cXFxcc10qfC9bXlxcXFxzXSopfFteXFxcXHMvXVteXFxcXHNdKikkXCIsXG4gIGJpbmFyeTogXCJeW0EtWmEtejAtOSsvXSo9ezAsMn0kXCIsXG4gIHV1aWQ6IFwiXlswLTlhLWZdezh9LVswLTlhLWZdezR9LVswLTlhLWZdezR9LVswLTlhLWZdezR9LVswLTlhLWZdezEyfSRcIixcbn0gYXMgY29uc3RcblxuLy8gVE9ETzogc3VwcG9ydCBjYXRlZ29yaWVzT3JkZXI/XG5leHBvcnQgZnVuY3Rpb24gcGFyc2VTdHJpbmdGaWVsZChmaWVsZDogU3RyaW5nRmllbGQsIGZpZWxkRXhwcjogcGwuRXhwcikge1xuICBjb25zdCBmb3JtYXQgPSBmaWVsZC5mb3JtYXRcbiAgY29uc3QgZmxhdHRlbkNhdGVnb3JpZXMgPSBmaWVsZC5jYXRlZ29yaWVzPy5tYXAoaXQgPT5cbiAgICB0eXBlb2YgaXQgPT09IFwic3RyaW5nXCIgPyBpdCA6IGl0LnZhbHVlLFxuICApXG5cbiAgaWYgKGZsYXR0ZW5DYXRlZ29yaWVzKSB7XG4gICAgcmV0dXJuIHBsXG4gICAgICAud2hlbihmaWVsZEV4cHIuaXNJbihmbGF0dGVuQ2F0ZWdvcmllcykpXG4gICAgICAudGhlbihmaWVsZEV4cHIuY2FzdChwbC5DYXRlZ29yaWNhbCkpXG4gICAgICAub3RoZXJ3aXNlKHBsLmxpdChudWxsKSlcbiAgICAgIC5hbGlhcyhmaWVsZC5uYW1lKVxuICB9XG5cbiAgaWYgKGZvcm1hdCkge1xuICAgIGNvbnN0IHJlZ2V4ID0gRk9STUFUX1JFR0VYW2Zvcm1hdF1cbiAgICByZXR1cm4gcGxcbiAgICAgIC53aGVuKGZpZWxkRXhwci5zdHIuY29udGFpbnMocmVnZXgpKVxuICAgICAgLnRoZW4oZmllbGRFeHByKVxuICAgICAgLm90aGVyd2lzZShwbC5saXQobnVsbCkpXG4gICAgICAuYWxpYXMoZmllbGQubmFtZSlcbiAgfVxuXG4gIHJldHVybiBmaWVsZEV4cHJcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIHN0cmluZ2lmeVN0cmluZ0ZpZWxkKF9maWVsZDogU3RyaW5nRmllbGQsIGZpZWxkRXhwcjogcGwuRXhwcikge1xuICByZXR1cm4gZmllbGRFeHByXG59XG4iXX0=

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

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