@frictionless-ts/metadata 1.0.1

package/build/field/convert/fromDescriptor.spec.js

@@ -0,0 +1,241 @@
+import { describe, expect, it, vi } from "vitest";
+import { convertFieldFromDescriptor } from "./fromDescriptor.js";
+describe("convertFieldFromDescriptor", () => {
+    it("should return a cloned descriptor", () => {
+        const descriptor = { name: "id", type: "string" };
+        const result = convertFieldFromDescriptor(descriptor);
+        expect(result).toEqual(descriptor);
+        expect(result).not.toBe(descriptor);
+    });
+    describe("format conversion", () => {
+        it("should remove fmt: prefix from format", () => {
+            const descriptor = { name: "id", type: "string", format: "fmt:email" };
+            const result = convertFieldFromDescriptor(descriptor);
+            expect(result.format).toBe("email");
+        });
+        it("should preserve format without fmt: prefix", () => {
+            const descriptor = { name: "id", type: "string", format: "email" };
+            const result = convertFieldFromDescriptor(descriptor);
+            expect(result.format).toBe("email");
+        });
+        it("should handle descriptor without format", () => {
+            const descriptor = { name: "id", type: "string" };
+            const result = convertFieldFromDescriptor(descriptor);
+            expect(result.format).toBeUndefined();
+        });
+    });
+    describe("missingValues validation", () => {
+        it("should preserve valid missingValues array", () => {
+            const descriptor = {
+                name: "id",
+                type: "string",
+                missingValues: ["", "NA", "N/A"],
+            };
+            const result = convertFieldFromDescriptor(descriptor);
+            expect(result.missingValues).toEqual(["", "NA", "N/A"]);
+        });
+        it("should remove invalid non-array missingValues and warn", () => {
+            const consoleWarnSpy = vi
+                .spyOn(console, "warn")
+                .mockImplementation(() => { });
+            const descriptor = {
+                name: "id",
+                type: "string",
+                missingValues: "invalid",
+            };
+            const result = convertFieldFromDescriptor(descriptor);
+            expect(result.missingValues).toBeUndefined();
+            expect(consoleWarnSpy).toHaveBeenCalledWith("Ignoring v2.0 incompatible missingValues: invalid");
+            consoleWarnSpy.mockRestore();
+        });
+        it("should handle descriptor without missingValues", () => {
+            const descriptor = { name: "id", type: "string" };
+            const result = convertFieldFromDescriptor(descriptor);
+            expect(result.missingValues).toBeUndefined();
+        });
+    });
+    describe("categories validation", () => {
+        it("should preserve valid categories array", () => {
+            const descriptor = {
+                name: "status",
+                type: "string",
+                categories: ["active", "inactive", "pending"],
+            };
+            const result = convertFieldFromDescriptor(descriptor);
+            expect(result.categories).toEqual(["active", "inactive", "pending"]);
+        });
+        it("should remove invalid non-array categories and warn", () => {
+            const consoleWarnSpy = vi
+                .spyOn(console, "warn")
+                .mockImplementation(() => { });
+            const descriptor = {
+                name: "status",
+                type: "string",
+                categories: "invalid",
+            };
+            const result = convertFieldFromDescriptor(descriptor);
+            expect(result.categories).toBeUndefined();
+            expect(consoleWarnSpy).toHaveBeenCalledWith("Ignoring v2.0 incompatible categories: invalid");
+            consoleWarnSpy.mockRestore();
+        });
+        it("should handle descriptor without categories", () => {
+            const descriptor = { name: "status", type: "string" };
+            const result = convertFieldFromDescriptor(descriptor);
+            expect(result.categories).toBeUndefined();
+        });
+    });
+    describe("categoriesOrdered validation", () => {
+        it("should preserve valid categoriesOrdered boolean", () => {
+            const descriptor = {
+                name: "status",
+                type: "string",
+                categoriesOrdered: true,
+            };
+            const result = convertFieldFromDescriptor(descriptor);
+            expect(result.categoriesOrdered).toBe(true);
+        });
+        it("should remove invalid non-boolean categoriesOrdered and warn", () => {
+            const consoleWarnSpy = vi
+                .spyOn(console, "warn")
+                .mockImplementation(() => { });
+            const descriptor = {
+                name: "status",
+                type: "string",
+                categoriesOrdered: "invalid",
+            };
+            const result = convertFieldFromDescriptor(descriptor);
+            expect(result.categoriesOrdered).toBeUndefined();
+            expect(consoleWarnSpy).toHaveBeenCalledWith("Ignoring v2.0 incompatible categoriesOrdered: invalid");
+            consoleWarnSpy.mockRestore();
+        });
+        it("should handle descriptor without categoriesOrdered", () => {
+            const descriptor = { name: "status", type: "string" };
+            const result = convertFieldFromDescriptor(descriptor);
+            expect(result.categoriesOrdered).toBeUndefined();
+        });
+    });
+    describe("jsonschema validation", () => {
+        it("should preserve valid jsonschema object", () => {
+            const descriptor = {
+                name: "data",
+                type: "object",
+                jsonschema: { type: "object", properties: { id: { type: "number" } } },
+            };
+            const result = convertFieldFromDescriptor(descriptor);
+            expect(result.jsonschema).toEqual({
+                type: "object",
+                properties: { id: { type: "number" } },
+            });
+        });
+        it("should remove invalid non-object jsonschema and warn", () => {
+            const consoleWarnSpy = vi
+                .spyOn(console, "warn")
+                .mockImplementation(() => { });
+            const descriptor = {
+                name: "data",
+                type: "object",
+                jsonschema: "invalid",
+            };
+            const result = convertFieldFromDescriptor(descriptor);
+            expect(result.jsonschema).toBeUndefined();
+            expect(consoleWarnSpy).toHaveBeenCalledWith("Ignoring v2.0 incompatible jsonschema: invalid");
+            consoleWarnSpy.mockRestore();
+        });
+        it("should handle descriptor without jsonschema", () => {
+            const descriptor = { name: "data", type: "object" };
+            const result = convertFieldFromDescriptor(descriptor);
+            expect(result.jsonschema).toBeUndefined();
+        });
+    });
+    describe("combined conversions", () => {
+        it("should apply all conversions together", () => {
+            const consoleWarnSpy = vi
+                .spyOn(console, "warn")
+                .mockImplementation(() => { });
+            const descriptor = {
+                name: "email",
+                type: "string",
+                format: "fmt:email",
+                missingValues: ["", "NA"],
+                categories: ["valid", "invalid"],
+                categoriesOrdered: true,
+                jsonschema: { type: "string", pattern: "^[a-z]+@[a-z]+\\.[a-z]+$" },
+            };
+            const result = convertFieldFromDescriptor(descriptor);
+            expect(result.format).toBe("email");
+            expect(result.missingValues).toEqual(["", "NA"]);
+            expect(result.categories).toEqual(["valid", "invalid"]);
+            expect(result.categoriesOrdered).toBe(true);
+            expect(result.jsonschema).toEqual({
+                type: "string",
+                pattern: "^[a-z]+@[a-z]+\\.[a-z]+$",
+            });
+            expect(consoleWarnSpy).not.toHaveBeenCalled();
+            consoleWarnSpy.mockRestore();
+        });
+        it("should handle multiple invalid properties and warn for each", () => {
+            const consoleWarnSpy = vi
+                .spyOn(console, "warn")
+                .mockImplementation(() => { });
+            const descriptor = {
+                name: "field",
+                type: "string",
+                missingValues: "invalid",
+                categories: 123,
+                categoriesOrdered: "invalid",
+                jsonschema: "invalid",
+            };
+            const result = convertFieldFromDescriptor(descriptor);
+            expect(result.missingValues).toBeUndefined();
+            expect(result.categories).toBeUndefined();
+            expect(result.categoriesOrdered).toBeUndefined();
+            expect(result.jsonschema).toBeUndefined();
+            expect(consoleWarnSpy).toHaveBeenCalledTimes(4);
+            consoleWarnSpy.mockRestore();
+        });
+        it("should handle field with all valid properties", () => {
+            const descriptor = {
+                name: "age",
+                type: "integer",
+                title: "Age",
+                description: "Person's age",
+                format: "fmt:default",
+                example: 25,
+                examples: [18, 25, 30, 45],
+                rdfType: "http://schema.org/age",
+                missingValues: ["", "unknown"],
+                categories: ["young", "middle", "old"],
+                categoriesOrdered: true,
+                jsonschema: { type: "integer", minimum: 0, maximum: 150 },
+                constraints: {
+                    required: true,
+                    minimum: 0,
+                    maximum: 150,
+                },
+            };
+            const result = convertFieldFromDescriptor(descriptor);
+            expect(result.name).toBe("age");
+            expect(result.type).toBe("integer");
+            expect(result.title).toBe("Age");
+            expect(result.description).toBe("Person's age");
+            expect(result.format).toBe("default");
+            expect(result.example).toBe(25);
+            expect(result.examples).toEqual([18, 25, 30, 45]);
+            expect(result.rdfType).toBe("http://schema.org/age");
+            expect(result.missingValues).toEqual(["", "unknown"]);
+            expect(result.categories).toEqual(["young", "middle", "old"]);
+            expect(result.categoriesOrdered).toBe(true);
+            expect(result.jsonschema).toEqual({
+                type: "integer",
+                minimum: 0,
+                maximum: 150,
+            });
+            expect(result.constraints).toEqual({
+                required: true,
+                minimum: 0,
+                maximum: 150,
+            });
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fromDescriptor.spec.js","sourceRoot":"","sources":["../../../field/convert/fromDescriptor.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { describe, expect, it, vi } from \"vitest\"\nimport { convertFieldFromDescriptor } from \"./fromDescriptor.ts\"\n\ndescribe(\"convertFieldFromDescriptor\", () => {\n  it(\"should return a cloned descriptor\", () => {\n    const descriptor = { name: \"id\", type: \"string\" }\n\n    const result = convertFieldFromDescriptor(descriptor)\n\n    expect(result).toEqual(descriptor)\n    expect(result).not.toBe(descriptor)\n  })\n\n  describe(\"format conversion\", () => {\n    it(\"should remove fmt: prefix from format\", () => {\n      const descriptor = { name: \"id\", type: \"string\", format: \"fmt:email\" }\n\n      const result = convertFieldFromDescriptor(descriptor)\n\n      expect(result.format).toBe(\"email\")\n    })\n\n    it(\"should preserve format without fmt: prefix\", () => {\n      const descriptor = { name: \"id\", type: \"string\", format: \"email\" }\n\n      const result = convertFieldFromDescriptor(descriptor)\n\n      expect(result.format).toBe(\"email\")\n    })\n\n    it(\"should handle descriptor without format\", () => {\n      const descriptor = { name: \"id\", type: \"string\" }\n\n      const result = convertFieldFromDescriptor(descriptor)\n\n      expect(result.format).toBeUndefined()\n    })\n  })\n\n  describe(\"missingValues validation\", () => {\n    it(\"should preserve valid missingValues array\", () => {\n      const descriptor = {\n        name: \"id\",\n        type: \"string\",\n        missingValues: [\"\", \"NA\", \"N/A\"],\n      }\n\n      const result = convertFieldFromDescriptor(descriptor)\n\n      expect(result.missingValues).toEqual([\"\", \"NA\", \"N/A\"])\n    })\n\n    it(\"should remove invalid non-array missingValues and warn\", () => {\n      const consoleWarnSpy = vi\n        .spyOn(console, \"warn\")\n        .mockImplementation(() => {})\n      const descriptor = {\n        name: \"id\",\n        type: \"string\",\n        missingValues: \"invalid\",\n      }\n\n      const result = convertFieldFromDescriptor(descriptor)\n\n      expect(result.missingValues).toBeUndefined()\n      expect(consoleWarnSpy).toHaveBeenCalledWith(\n        \"Ignoring v2.0 incompatible missingValues: invalid\",\n      )\n      consoleWarnSpy.mockRestore()\n    })\n\n    it(\"should handle descriptor without missingValues\", () => {\n      const descriptor = { name: \"id\", type: \"string\" }\n\n      const result = convertFieldFromDescriptor(descriptor)\n\n      expect(result.missingValues).toBeUndefined()\n    })\n  })\n\n  describe(\"categories validation\", () => {\n    it(\"should preserve valid categories array\", () => {\n      const descriptor = {\n        name: \"status\",\n        type: \"string\",\n        categories: [\"active\", \"inactive\", \"pending\"],\n      }\n\n      const result = convertFieldFromDescriptor(descriptor)\n\n      expect(result.categories).toEqual([\"active\", \"inactive\", \"pending\"])\n    })\n\n    it(\"should remove invalid non-array categories and warn\", () => {\n      const consoleWarnSpy = vi\n        .spyOn(console, \"warn\")\n        .mockImplementation(() => {})\n      const descriptor = {\n        name: \"status\",\n        type: \"string\",\n        categories: \"invalid\",\n      }\n\n      const result = convertFieldFromDescriptor(descriptor)\n\n      expect(result.categories).toBeUndefined()\n      expect(consoleWarnSpy).toHaveBeenCalledWith(\n        \"Ignoring v2.0 incompatible categories: invalid\",\n      )\n      consoleWarnSpy.mockRestore()\n    })\n\n    it(\"should handle descriptor without categories\", () => {\n      const descriptor = { name: \"status\", type: \"string\" }\n\n      const result = convertFieldFromDescriptor(descriptor)\n\n      expect(result.categories).toBeUndefined()\n    })\n  })\n\n  describe(\"categoriesOrdered validation\", () => {\n    it(\"should preserve valid categoriesOrdered boolean\", () => {\n      const descriptor = {\n        name: \"status\",\n        type: \"string\",\n        categoriesOrdered: true,\n      }\n\n      const result = convertFieldFromDescriptor(descriptor)\n\n      expect(result.categoriesOrdered).toBe(true)\n    })\n\n    it(\"should remove invalid non-boolean categoriesOrdered and warn\", () => {\n      const consoleWarnSpy = vi\n        .spyOn(console, \"warn\")\n        .mockImplementation(() => {})\n      const descriptor = {\n        name: \"status\",\n        type: \"string\",\n        categoriesOrdered: \"invalid\",\n      }\n\n      const result = convertFieldFromDescriptor(descriptor)\n\n      expect(result.categoriesOrdered).toBeUndefined()\n      expect(consoleWarnSpy).toHaveBeenCalledWith(\n        \"Ignoring v2.0 incompatible categoriesOrdered: invalid\",\n      )\n      consoleWarnSpy.mockRestore()\n    })\n\n    it(\"should handle descriptor without categoriesOrdered\", () => {\n      const descriptor = { name: \"status\", type: \"string\" }\n\n      const result = convertFieldFromDescriptor(descriptor)\n\n      expect(result.categoriesOrdered).toBeUndefined()\n    })\n  })\n\n  describe(\"jsonschema validation\", () => {\n    it(\"should preserve valid jsonschema object\", () => {\n      const descriptor = {\n        name: \"data\",\n        type: \"object\",\n        jsonschema: { type: \"object\", properties: { id: { type: \"number\" } } },\n      }\n\n      const result = convertFieldFromDescriptor(descriptor)\n\n      expect(result.jsonschema).toEqual({\n        type: \"object\",\n        properties: { id: { type: \"number\" } },\n      })\n    })\n\n    it(\"should remove invalid non-object jsonschema and warn\", () => {\n      const consoleWarnSpy = vi\n        .spyOn(console, \"warn\")\n        .mockImplementation(() => {})\n      const descriptor = {\n        name: \"data\",\n        type: \"object\",\n        jsonschema: \"invalid\",\n      }\n\n      const result = convertFieldFromDescriptor(descriptor)\n\n      expect(result.jsonschema).toBeUndefined()\n      expect(consoleWarnSpy).toHaveBeenCalledWith(\n        \"Ignoring v2.0 incompatible jsonschema: invalid\",\n      )\n      consoleWarnSpy.mockRestore()\n    })\n\n    it(\"should handle descriptor without jsonschema\", () => {\n      const descriptor = { name: \"data\", type: \"object\" }\n\n      const result = convertFieldFromDescriptor(descriptor)\n\n      expect(result.jsonschema).toBeUndefined()\n    })\n  })\n\n  describe(\"combined conversions\", () => {\n    it(\"should apply all conversions together\", () => {\n      const consoleWarnSpy = vi\n        .spyOn(console, \"warn\")\n        .mockImplementation(() => {})\n      const descriptor = {\n        name: \"email\",\n        type: \"string\",\n        format: \"fmt:email\",\n        missingValues: [\"\", \"NA\"],\n        categories: [\"valid\", \"invalid\"],\n        categoriesOrdered: true,\n        jsonschema: { type: \"string\", pattern: \"^[a-z]+@[a-z]+\\\\.[a-z]+$\" },\n      }\n\n      const result = convertFieldFromDescriptor(descriptor)\n\n      expect(result.format).toBe(\"email\")\n      expect(result.missingValues).toEqual([\"\", \"NA\"])\n      expect(result.categories).toEqual([\"valid\", \"invalid\"])\n      expect(result.categoriesOrdered).toBe(true)\n      expect(result.jsonschema).toEqual({\n        type: \"string\",\n        pattern: \"^[a-z]+@[a-z]+\\\\.[a-z]+$\",\n      })\n      expect(consoleWarnSpy).not.toHaveBeenCalled()\n      consoleWarnSpy.mockRestore()\n    })\n\n    it(\"should handle multiple invalid properties and warn for each\", () => {\n      const consoleWarnSpy = vi\n        .spyOn(console, \"warn\")\n        .mockImplementation(() => {})\n      const descriptor = {\n        name: \"field\",\n        type: \"string\",\n        missingValues: \"invalid\",\n        categories: 123,\n        categoriesOrdered: \"invalid\",\n        jsonschema: \"invalid\",\n      }\n\n      const result = convertFieldFromDescriptor(descriptor)\n\n      expect(result.missingValues).toBeUndefined()\n      expect(result.categories).toBeUndefined()\n      expect(result.categoriesOrdered).toBeUndefined()\n      expect(result.jsonschema).toBeUndefined()\n      expect(consoleWarnSpy).toHaveBeenCalledTimes(4)\n      consoleWarnSpy.mockRestore()\n    })\n\n    it(\"should handle field with all valid properties\", () => {\n      const descriptor = {\n        name: \"age\",\n        type: \"integer\",\n        title: \"Age\",\n        description: \"Person's age\",\n        format: \"fmt:default\",\n        example: 25,\n        examples: [18, 25, 30, 45],\n        rdfType: \"http://schema.org/age\",\n        missingValues: [\"\", \"unknown\"],\n        categories: [\"young\", \"middle\", \"old\"],\n        categoriesOrdered: true,\n        jsonschema: { type: \"integer\", minimum: 0, maximum: 150 },\n        constraints: {\n          required: true,\n          minimum: 0,\n          maximum: 150,\n        },\n      }\n\n      const result = convertFieldFromDescriptor(descriptor)\n\n      expect(result.name).toBe(\"age\")\n      expect(result.type).toBe(\"integer\")\n      expect(result.title).toBe(\"Age\")\n      expect(result.description).toBe(\"Person's age\")\n      expect(result.format).toBe(\"default\")\n      expect(result.example).toBe(25)\n      expect(result.examples).toEqual([18, 25, 30, 45])\n      expect(result.rdfType).toBe(\"http://schema.org/age\")\n      expect(result.missingValues).toEqual([\"\", \"unknown\"])\n      expect(result.categories).toEqual([\"young\", \"middle\", \"old\"])\n      expect(result.categoriesOrdered).toBe(true)\n      expect(result.jsonschema).toEqual({\n        type: \"integer\",\n        minimum: 0,\n        maximum: 150,\n      })\n      expect(result.constraints).toEqual({\n        required: true,\n        minimum: 0,\n        maximum: 150,\n      })\n    })\n  })\n})\n"]}

package/build/field/convert/toDescriptor.d.ts

@@ -0,0 +1,3 @@
+import type { Descriptor } from "../../descriptor/index.ts";
+import type { Field } from "../Field.ts";
+export declare function convertFieldToDescriptor(field: Field): Descriptor;

package/build/field/convert/toDescriptor.js

@@ -0,0 +1,5 @@
+export function convertFieldToDescriptor(field) {
+    field = globalThis.structuredClone(field);
+    return field;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9EZXNjcmlwdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vZmllbGQvY29udmVydC90b0Rlc2NyaXB0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsTUFBTSxVQUFVLHdCQUF3QixDQUFDLEtBQVk7SUFDbkQsS0FBSyxHQUFHLFVBQVUsQ0FBQyxlQUFlLENBQUMsS0FBSyxDQUFDLENBQUE7SUFFekMsT0FBTyxLQUE4QixDQUFBO0FBQ3ZDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IERlc2NyaXB0b3IgfSBmcm9tIFwiLi4vLi4vZGVzY3JpcHRvci9pbmRleC50c1wiXG5pbXBvcnQgdHlwZSB7IEZpZWxkIH0gZnJvbSBcIi4uL0ZpZWxkLnRzXCJcblxuZXhwb3J0IGZ1bmN0aW9uIGNvbnZlcnRGaWVsZFRvRGVzY3JpcHRvcihmaWVsZDogRmllbGQpIHtcbiAgZmllbGQgPSBnbG9iYWxUaGlzLnN0cnVjdHVyZWRDbG9uZShmaWVsZClcblxuICByZXR1cm4gZmllbGQgYXMgdW5rbm93biBhcyBEZXNjcmlwdG9yXG59XG4iXX0=

package/build/field/convert/toDescriptor.spec.d.ts

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

package/build/field/convert/toDescriptor.spec.js

@@ -0,0 +1,291 @@
+import { describe, expect, it } from "vitest";
+import { convertFieldToDescriptor } from "./toDescriptor.js";
+describe("convertFieldToDescriptor", () => {
+    it("should return a cloned descriptor", () => {
+        const field = { name: "id", type: "string" };
+        const result = convertFieldToDescriptor(field);
+        expect(result).toEqual(field);
+        expect(result).not.toBe(field);
+    });
+    it("should convert string field to descriptor", () => {
+        const field = {
+            name: "email",
+            type: "string",
+            format: "email",
+            title: "Email Address",
+            description: "User's email address",
+        };
+        const result = convertFieldToDescriptor(field);
+        expect(result.name).toBe("email");
+        expect(result.type).toBe("string");
+        expect(result.format).toBe("email");
+        expect(result.title).toBe("Email Address");
+        expect(result.description).toBe("User's email address");
+    });
+    it("should convert integer field to descriptor", () => {
+        const field = {
+            name: "age",
+            type: "integer",
+            title: "Age",
+            constraints: {
+                required: true,
+                minimum: 0,
+                maximum: 150,
+            },
+        };
+        const result = convertFieldToDescriptor(field);
+        expect(result.name).toBe("age");
+        expect(result.type).toBe("integer");
+        expect(result.title).toBe("Age");
+        expect(result.constraints).toEqual({
+            required: true,
+            minimum: 0,
+            maximum: 150,
+        });
+    });
+    it("should convert number field to descriptor", () => {
+        const field = {
+            name: "score",
+            type: "number",
+            description: "Test score",
+            constraints: {
+                minimum: 0,
+                maximum: 100,
+            },
+        };
+        const result = convertFieldToDescriptor(field);
+        expect(result.name).toBe("score");
+        expect(result.type).toBe("number");
+        expect(result.description).toBe("Test score");
+        expect(result.constraints).toEqual({
+            minimum: 0,
+            maximum: 100,
+        });
+    });
+    it("should convert boolean field to descriptor", () => {
+        const field = {
+            name: "active",
+            type: "boolean",
+            title: "Active Status",
+        };
+        const result = convertFieldToDescriptor(field);
+        expect(result.name).toBe("active");
+        expect(result.type).toBe("boolean");
+        expect(result.title).toBe("Active Status");
+    });
+    it("should convert date field to descriptor", () => {
+        const field = {
+            name: "birth_date",
+            type: "date",
+            description: "Date of birth",
+        };
+        const result = convertFieldToDescriptor(field);
+        expect(result.name).toBe("birth_date");
+        expect(result.type).toBe("date");
+        expect(result.description).toBe("Date of birth");
+    });
+    it("should convert datetime field to descriptor", () => {
+        const field = {
+            name: "created_at",
+            type: "datetime",
+            title: "Created At",
+        };
+        const result = convertFieldToDescriptor(field);
+        expect(result.name).toBe("created_at");
+        expect(result.type).toBe("datetime");
+        expect(result.title).toBe("Created At");
+    });
+    it("should convert time field to descriptor", () => {
+        const field = {
+            name: "start_time",
+            type: "time",
+        };
+        const result = convertFieldToDescriptor(field);
+        expect(result.name).toBe("start_time");
+        expect(result.type).toBe("time");
+    });
+    it("should convert object field to descriptor", () => {
+        const field = {
+            name: "metadata",
+            type: "object",
+            constraints: {
+                jsonSchema: {
+                    type: "object",
+                    properties: {
+                        id: { type: "number" },
+                        name: { type: "string" },
+                    },
+                },
+            },
+        };
+        const result = convertFieldToDescriptor(field);
+        expect(result.name).toBe("metadata");
+        expect(result.type).toBe("object");
+        expect(result.constraints?.jsonSchema).toEqual({
+            type: "object",
+            properties: {
+                id: { type: "number" },
+                name: { type: "string" },
+            },
+        });
+    });
+    it("should convert array field to descriptor", () => {
+        const field = {
+            name: "tags",
+            type: "array",
+            constraints: {
+                jsonSchema: {
+                    type: "array",
+                    items: { type: "string" },
+                },
+            },
+        };
+        const result = convertFieldToDescriptor(field);
+        expect(result.name).toBe("tags");
+        expect(result.type).toBe("array");
+        expect(result.constraints?.jsonSchema).toEqual({
+            type: "array",
+            items: { type: "string" },
+        });
+    });
+    it("should preserve string field with categories", () => {
+        const field = {
+            name: "status",
+            type: "string",
+            categories: ["active", "inactive", "pending"],
+            categoriesOrdered: true,
+        };
+        const result = convertFieldToDescriptor(field);
+        expect(result.name).toBe("status");
+        expect(result.type).toBe("string");
+        expect(result.categories).toEqual(["active", "inactive", "pending"]);
+        expect(result.categoriesOrdered).toBe(true);
+    });
+    it("should preserve field with missingValues", () => {
+        const field = {
+            name: "value",
+            type: "string",
+            missingValues: ["", "NA", "N/A"],
+        };
+        const result = convertFieldToDescriptor(field);
+        expect(result.name).toBe("value");
+        expect(result.type).toBe("string");
+        expect(result.missingValues).toEqual(["", "NA", "N/A"]);
+    });
+    it("should preserve field with example and examples", () => {
+        const field = {
+            name: "age",
+            type: "integer",
+            example: 25,
+            examples: [18, 25, 30, 45],
+        };
+        const result = convertFieldToDescriptor(field);
+        expect(result.name).toBe("age");
+        expect(result.type).toBe("integer");
+        expect(result.example).toBe(25);
+        expect(result.examples).toEqual([18, 25, 30, 45]);
+    });
+    it("should preserve field with rdfType", () => {
+        const field = {
+            name: "age",
+            type: "integer",
+            rdfType: "http://schema.org/age",
+        };
+        const result = convertFieldToDescriptor(field);
+        expect(result.name).toBe("age");
+        expect(result.type).toBe("integer");
+        expect(result.rdfType).toBe("http://schema.org/age");
+    });
+    it("should convert field with all properties", () => {
+        const field = {
+            name: "email",
+            type: "string",
+            format: "email",
+            title: "Email Address",
+            description: "User's email address",
+            example: "user@example.com",
+            examples: ["user@example.com", "admin@example.org"],
+            rdfType: "http://schema.org/email",
+            missingValues: ["", "none"],
+            categories: ["personal", "work"],
+            categoriesOrdered: false,
+            constraints: {
+                required: true,
+                pattern: "^[a-z]+@[a-z]+\\.[a-z]+$",
+            },
+        };
+        const result = convertFieldToDescriptor(field);
+        expect(result.name).toBe("email");
+        expect(result.type).toBe("string");
+        expect(result.format).toBe("email");
+        expect(result.title).toBe("Email Address");
+        expect(result.description).toBe("User's email address");
+        expect(result.example).toBe("user@example.com");
+        expect(result.examples).toEqual(["user@example.com", "admin@example.org"]);
+        expect(result.rdfType).toBe("http://schema.org/email");
+        expect(result.missingValues).toEqual(["", "none"]);
+        expect(result.categories).toEqual(["personal", "work"]);
+        expect(result.categoriesOrdered).toBe(false);
+        expect(result.constraints).toEqual({
+            required: true,
+            pattern: "^[a-z]+@[a-z]+\\.[a-z]+$",
+        });
+    });
+    it("should convert year field to descriptor", () => {
+        const field = {
+            name: "birth_year",
+            type: "year",
+        };
+        const result = convertFieldToDescriptor(field);
+        expect(result.name).toBe("birth_year");
+        expect(result.type).toBe("year");
+    });
+    it("should convert yearmonth field to descriptor", () => {
+        const field = {
+            name: "start_month",
+            type: "yearmonth",
+        };
+        const result = convertFieldToDescriptor(field);
+        expect(result.name).toBe("start_month");
+        expect(result.type).toBe("yearmonth");
+    });
+    it("should convert duration field to descriptor", () => {
+        const field = {
+            name: "duration",
+            type: "duration",
+        };
+        const result = convertFieldToDescriptor(field);
+        expect(result.name).toBe("duration");
+        expect(result.type).toBe("duration");
+    });
+    it("should convert geopoint field to descriptor", () => {
+        const field = {
+            name: "location",
+            type: "geopoint",
+            format: "default",
+        };
+        const result = convertFieldToDescriptor(field);
+        expect(result.name).toBe("location");
+        expect(result.type).toBe("geopoint");
+        expect(result.format).toBe("default");
+    });
+    it("should convert geojson field to descriptor", () => {
+        const field = {
+            name: "geometry",
+            type: "geojson",
+        };
+        const result = convertFieldToDescriptor(field);
+        expect(result.name).toBe("geometry");
+        expect(result.type).toBe("geojson");
+    });
+    it("should convert any field to descriptor", () => {
+        const field = {
+            name: "data",
+            type: "any",
+        };
+        const result = convertFieldToDescriptor(field);
+        expect(result.name).toBe("data");
+        expect(result.type).toBe("any");
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toDescriptor.spec.js","sourceRoot":"","sources":["../../../field/convert/toDescriptor.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { describe, expect, it } from \"vitest\"\nimport type { Field } from \"../Field.ts\"\nimport { convertFieldToDescriptor } from \"./toDescriptor.ts\"\n\ndescribe(\"convertFieldToDescriptor\", () => {\n  it(\"should return a cloned descriptor\", () => {\n    const field: Field = { name: \"id\", type: \"string\" }\n\n    const result = convertFieldToDescriptor(field)\n\n    expect(result).toEqual(field)\n    expect(result).not.toBe(field)\n  })\n\n  it(\"should convert string field to descriptor\", () => {\n    const field: Field = {\n      name: \"email\",\n      type: \"string\",\n      format: \"email\",\n      title: \"Email Address\",\n      description: \"User's email address\",\n    }\n\n    const result = convertFieldToDescriptor(field)\n\n    expect(result.name).toBe(\"email\")\n    expect(result.type).toBe(\"string\")\n    expect(result.format).toBe(\"email\")\n    expect(result.title).toBe(\"Email Address\")\n    expect(result.description).toBe(\"User's email address\")\n  })\n\n  it(\"should convert integer field to descriptor\", () => {\n    const field: Field = {\n      name: \"age\",\n      type: \"integer\",\n      title: \"Age\",\n      constraints: {\n        required: true,\n        minimum: 0,\n        maximum: 150,\n      },\n    }\n\n    const result = convertFieldToDescriptor(field)\n\n    expect(result.name).toBe(\"age\")\n    expect(result.type).toBe(\"integer\")\n    expect(result.title).toBe(\"Age\")\n    expect(result.constraints).toEqual({\n      required: true,\n      minimum: 0,\n      maximum: 150,\n    })\n  })\n\n  it(\"should convert number field to descriptor\", () => {\n    const field: Field = {\n      name: \"score\",\n      type: \"number\",\n      description: \"Test score\",\n      constraints: {\n        minimum: 0,\n        maximum: 100,\n      },\n    }\n\n    const result = convertFieldToDescriptor(field)\n\n    expect(result.name).toBe(\"score\")\n    expect(result.type).toBe(\"number\")\n    expect(result.description).toBe(\"Test score\")\n    expect(result.constraints).toEqual({\n      minimum: 0,\n      maximum: 100,\n    })\n  })\n\n  it(\"should convert boolean field to descriptor\", () => {\n    const field: Field = {\n      name: \"active\",\n      type: \"boolean\",\n      title: \"Active Status\",\n    }\n\n    const result = convertFieldToDescriptor(field)\n\n    expect(result.name).toBe(\"active\")\n    expect(result.type).toBe(\"boolean\")\n    expect(result.title).toBe(\"Active Status\")\n  })\n\n  it(\"should convert date field to descriptor\", () => {\n    const field: Field = {\n      name: \"birth_date\",\n      type: \"date\",\n      description: \"Date of birth\",\n    }\n\n    const result = convertFieldToDescriptor(field)\n\n    expect(result.name).toBe(\"birth_date\")\n    expect(result.type).toBe(\"date\")\n    expect(result.description).toBe(\"Date of birth\")\n  })\n\n  it(\"should convert datetime field to descriptor\", () => {\n    const field: Field = {\n      name: \"created_at\",\n      type: \"datetime\",\n      title: \"Created At\",\n    }\n\n    const result = convertFieldToDescriptor(field)\n\n    expect(result.name).toBe(\"created_at\")\n    expect(result.type).toBe(\"datetime\")\n    expect(result.title).toBe(\"Created At\")\n  })\n\n  it(\"should convert time field to descriptor\", () => {\n    const field: Field = {\n      name: \"start_time\",\n      type: \"time\",\n    }\n\n    const result = convertFieldToDescriptor(field)\n\n    expect(result.name).toBe(\"start_time\")\n    expect(result.type).toBe(\"time\")\n  })\n\n  it(\"should convert object field to descriptor\", () => {\n    const field: Field = {\n      name: \"metadata\",\n      type: \"object\",\n      constraints: {\n        jsonSchema: {\n          type: \"object\",\n          properties: {\n            id: { type: \"number\" },\n            name: { type: \"string\" },\n          },\n        },\n      },\n    }\n\n    const result = convertFieldToDescriptor(field)\n\n    expect(result.name).toBe(\"metadata\")\n    expect(result.type).toBe(\"object\")\n    expect((result.constraints as any)?.jsonSchema).toEqual({\n      type: \"object\",\n      properties: {\n        id: { type: \"number\" },\n        name: { type: \"string\" },\n      },\n    })\n  })\n\n  it(\"should convert array field to descriptor\", () => {\n    const field: Field = {\n      name: \"tags\",\n      type: \"array\",\n      constraints: {\n        jsonSchema: {\n          type: \"array\",\n          items: { type: \"string\" },\n        },\n      },\n    }\n\n    const result = convertFieldToDescriptor(field)\n\n    expect(result.name).toBe(\"tags\")\n    expect(result.type).toBe(\"array\")\n    expect((result.constraints as any)?.jsonSchema).toEqual({\n      type: \"array\",\n      items: { type: \"string\" },\n    })\n  })\n\n  it(\"should preserve string field with categories\", () => {\n    const field: Field = {\n      name: \"status\",\n      type: \"string\",\n      categories: [\"active\", \"inactive\", \"pending\"],\n      categoriesOrdered: true,\n    }\n\n    const result = convertFieldToDescriptor(field)\n\n    expect(result.name).toBe(\"status\")\n    expect(result.type).toBe(\"string\")\n    expect(result.categories).toEqual([\"active\", \"inactive\", \"pending\"])\n    expect(result.categoriesOrdered).toBe(true)\n  })\n\n  it(\"should preserve field with missingValues\", () => {\n    const field: Field = {\n      name: \"value\",\n      type: \"string\",\n      missingValues: [\"\", \"NA\", \"N/A\"],\n    }\n\n    const result = convertFieldToDescriptor(field)\n\n    expect(result.name).toBe(\"value\")\n    expect(result.type).toBe(\"string\")\n    expect(result.missingValues).toEqual([\"\", \"NA\", \"N/A\"])\n  })\n\n  it(\"should preserve field with example and examples\", () => {\n    const field: Field = {\n      name: \"age\",\n      type: \"integer\",\n      example: 25,\n      examples: [18, 25, 30, 45],\n    }\n\n    const result = convertFieldToDescriptor(field)\n\n    expect(result.name).toBe(\"age\")\n    expect(result.type).toBe(\"integer\")\n    expect(result.example).toBe(25)\n    expect(result.examples).toEqual([18, 25, 30, 45])\n  })\n\n  it(\"should preserve field with rdfType\", () => {\n    const field: Field = {\n      name: \"age\",\n      type: \"integer\",\n      rdfType: \"http://schema.org/age\",\n    }\n\n    const result = convertFieldToDescriptor(field)\n\n    expect(result.name).toBe(\"age\")\n    expect(result.type).toBe(\"integer\")\n    expect(result.rdfType).toBe(\"http://schema.org/age\")\n  })\n\n  it(\"should convert field with all properties\", () => {\n    const field: Field = {\n      name: \"email\",\n      type: \"string\",\n      format: \"email\",\n      title: \"Email Address\",\n      description: \"User's email address\",\n      example: \"user@example.com\",\n      examples: [\"user@example.com\", \"admin@example.org\"],\n      rdfType: \"http://schema.org/email\",\n      missingValues: [\"\", \"none\"],\n      categories: [\"personal\", \"work\"],\n      categoriesOrdered: false,\n      constraints: {\n        required: true,\n        pattern: \"^[a-z]+@[a-z]+\\\\.[a-z]+$\",\n      },\n    }\n\n    const result = convertFieldToDescriptor(field)\n\n    expect(result.name).toBe(\"email\")\n    expect(result.type).toBe(\"string\")\n    expect(result.format).toBe(\"email\")\n    expect(result.title).toBe(\"Email Address\")\n    expect(result.description).toBe(\"User's email address\")\n    expect(result.example).toBe(\"user@example.com\")\n    expect(result.examples).toEqual([\"user@example.com\", \"admin@example.org\"])\n    expect(result.rdfType).toBe(\"http://schema.org/email\")\n    expect(result.missingValues).toEqual([\"\", \"none\"])\n    expect(result.categories).toEqual([\"personal\", \"work\"])\n    expect(result.categoriesOrdered).toBe(false)\n    expect(result.constraints).toEqual({\n      required: true,\n      pattern: \"^[a-z]+@[a-z]+\\\\.[a-z]+$\",\n    })\n  })\n\n  it(\"should convert year field to descriptor\", () => {\n    const field: Field = {\n      name: \"birth_year\",\n      type: \"year\",\n    }\n\n    const result = convertFieldToDescriptor(field)\n\n    expect(result.name).toBe(\"birth_year\")\n    expect(result.type).toBe(\"year\")\n  })\n\n  it(\"should convert yearmonth field to descriptor\", () => {\n    const field: Field = {\n      name: \"start_month\",\n      type: \"yearmonth\",\n    }\n\n    const result = convertFieldToDescriptor(field)\n\n    expect(result.name).toBe(\"start_month\")\n    expect(result.type).toBe(\"yearmonth\")\n  })\n\n  it(\"should convert duration field to descriptor\", () => {\n    const field: Field = {\n      name: \"duration\",\n      type: \"duration\",\n    }\n\n    const result = convertFieldToDescriptor(field)\n\n    expect(result.name).toBe(\"duration\")\n    expect(result.type).toBe(\"duration\")\n  })\n\n  it(\"should convert geopoint field to descriptor\", () => {\n    const field: Field = {\n      name: \"location\",\n      type: \"geopoint\",\n      format: \"default\",\n    }\n\n    const result = convertFieldToDescriptor(field)\n\n    expect(result.name).toBe(\"location\")\n    expect(result.type).toBe(\"geopoint\")\n    expect(result.format).toBe(\"default\")\n  })\n\n  it(\"should convert geojson field to descriptor\", () => {\n    const field: Field = {\n      name: \"geometry\",\n      type: \"geojson\",\n    }\n\n    const result = convertFieldToDescriptor(field)\n\n    expect(result.name).toBe(\"geometry\")\n    expect(result.type).toBe(\"geojson\")\n  })\n\n  it(\"should convert any field to descriptor\", () => {\n    const field: Field = {\n      name: \"data\",\n      type: \"any\",\n    }\n\n    const result = convertFieldToDescriptor(field)\n\n    expect(result.name).toBe(\"data\")\n    expect(result.type).toBe(\"any\")\n  })\n})\n"]}