@nolwenture/formik-jsonschema-form 0.26.8 → 1.0.0-beta.2

package/dist/esm/utils/__tests/deepOverlap.test.js

@@ -1,41 +0,0 @@
-import { deepOverlap } from "../deepOverlap";
-describe("deepOverlap", () => {
-    test("returns true for both empty objects", () => {
-        expect(deepOverlap({}, {})).toBe(true);
-    });
-    test("returns true for identical objects", () => {
-        const obj1 = { a: 1, b: 2 };
-        const obj2 = { a: 1, b: 2 };
-        expect(deepOverlap(obj1, obj2)).toBe(true);
-    });
-    test("returns true for nested objects that are identical", () => {
-        const obj1 = { a: { b: 2 } };
-        const obj2 = { a: { b: 2 } };
-        expect(deepOverlap(obj1, obj2)).toBe(true);
-    });
-    test("handles arrays and non-object types correctly", () => {
-        const obj1 = { a: [1, 2, 3], b: "string", c: true };
-        const obj2 = { a: [1, 2, 3], b: "string", c: true };
-        expect(deepOverlap(obj1, obj2)).toBe(true);
-    });
-    test("returns true for objects with keys in different orders", () => {
-        const obj1 = { a: 1, b: { c: 2 } };
-        const obj2 = { b: { c: 2 }, a: 1 };
-        expect(deepOverlap(obj1, obj2)).toBe(true);
-    });
-    test("returns false for objects with different values", () => {
-        const obj1 = { a: 1 };
-        const obj2 = { a: 2 };
-        expect(deepOverlap(obj1, obj2)).toBe(false);
-    });
-    test("returns false for nested objects that do not overlap", () => {
-        const obj1 = { a: { b: 1 } };
-        const obj2 = { a: { b: 2 } };
-        expect(deepOverlap(obj1, obj2)).toBe(false);
-    });
-    test("returns false when one object is empty", () => {
-        const obj1 = { a: 1 };
-        const obj2 = {};
-        expect(deepOverlap(obj1, obj2)).toBe(false);
-    });
-});

package/dist/esm/utils/__tests/getEnums.test.js

@@ -1,59 +0,0 @@
-import { getEnums } from "../getEnums";
-describe("getEnums", () => {
-    test("returns undefined when no enum types are defined", () => {
-        const result = getEnums({ schema: {} });
-        expect(result).toBeUndefined();
-    });
-    test("throws error when more than one enum type is defined", () => {
-        expect(() => getEnums({ schema: { enum: [], oneOf: [], anyOf: [] } })).toThrow('Only one of "enum", "oneOf" or "anyOf" can be defined!');
-    });
-    test("enum works", () => {
-        const result = getEnums({ schema: { enum: ["one", "two", "three"] } });
-        expect(result).toEqual({
-            type: "select",
-            values: [
-                { const: "one", title: "one" },
-                { const: "two", title: "two" },
-                { const: "three", title: "three" },
-            ],
-        });
-    });
-    test("oneOf works", () => {
-        const result = getEnums({
-            schema: {
-                oneOf: [
-                    { const: "horse", title: "Horse" },
-                    { const: "frog", title: "Frog" },
-                    { const: "bird", title: "Bird" },
-                ],
-            },
-        });
-        expect(result).toEqual({
-            type: "select",
-            values: [
-                { const: "horse", title: "Horse" },
-                { const: "frog", title: "Frog" },
-                { const: "bird", title: "Bird" },
-            ],
-        });
-    });
-    test("anyOf works", () => {
-        const result = getEnums({
-            schema: {
-                anyOf: [
-                    { const: "tangerine", title: "Tangerine" },
-                    { const: "mandarin", title: "Mandarin" },
-                    { const: "bruno", title: "Bruno" },
-                ],
-            },
-        });
-        expect(result).toEqual({
-            type: "multiSelect",
-            values: [
-                { const: "tangerine", title: "Tangerine" },
-                { const: "mandarin", title: "Mandarin" },
-                { const: "bruno", title: "Bruno" },
-            ],
-        });
-    });
-});

package/dist/esm/utils/__tests/getTitleAndDescription.test.js

@@ -1,53 +0,0 @@
-import { getTitle, getDescription } from "../getTitleAndDescription";
-describe("getTitleAndDescription", () => {
-    describe("getTitle", () => {
-        test("returns title when provided", () => {
-            const title = "Test Title";
-            expect(getTitle({ title })).toBe(title);
-        });
-        test("returns title from uiSchema options when provided", () => {
-            const uiSchema = {
-                "ui:options": { title: "UI Schema Title" },
-            };
-            expect(getTitle({ uiSchema })).toBe("UI Schema Title");
-        });
-        test("returns title from uiSchema title when provided", () => {
-            const uiSchema = { "ui:title": "UI Schema Title" };
-            expect(getTitle({ uiSchema })).toBe("UI Schema Title");
-        });
-        test("returns title from schema when provided", () => {
-            const schema = { title: "Schema Title" };
-            expect(getTitle({ schema })).toBe("Schema Title");
-        });
-        test("returns last part of name when provided", () => {
-            const name = "nested.property";
-            expect(getTitle({ name })).toBe("property");
-        });
-        test("returns undefined when no title is provided", () => {
-            expect(getTitle({})).toBeUndefined();
-        });
-    });
-    describe("getDescription", () => {
-        test("returns description when provided", () => {
-            const description = "Test Description";
-            expect(getDescription({ description })).toBe(description);
-        });
-        test("returns description from uiSchema options when provided", () => {
-            const uiSchema = {
-                "ui:options": { description: "UI Schema Description" },
-            };
-            expect(getDescription({ uiSchema })).toBe("UI Schema Description");
-        });
-        test("returns description from uiSchema description when provided", () => {
-            const uiSchema = { "ui:description": "UI Schema Description" };
-            expect(getDescription({ uiSchema })).toBe("UI Schema Description");
-        });
-        test("returns description from schema when provided", () => {
-            const schema = { description: "Schema Description" };
-            expect(getDescription({ schema })).toBe("Schema Description");
-        });
-        test("returns undefined when no description is provided", () => {
-            expect(getDescription({})).toBeUndefined();
-        });
-    });
-});

package/dist/esm/utils/__tests/getTypes.test.js

@@ -1,62 +0,0 @@
-import { isObject, getDefaultValueForType, guessType, getSchemaType, } from "../getTypes";
-describe("getTypes", () => {
-    describe("isObject", () => {
-        test("returns true for non-null objects", () => {
-            expect(isObject({})).toBe(true);
-            expect(isObject([])).toBe(true);
-        });
-        test("returns false for null", () => {
-            expect(isObject(null)).toBe(false);
-        });
-        test("returns false for non-object types", () => {
-            expect(isObject(42)).toBe(false);
-            expect(isObject("string")).toBe(false);
-        });
-    });
-    describe("getDefaultValueForType", () => {
-        test("returns empty array for 'array' type", () => {
-            expect(getDefaultValueForType("array")).toEqual([]);
-        });
-        test("returns empty object for 'object' type", () => {
-            expect(getDefaultValueForType("object")).toEqual({});
-        });
-        test("returns null for unspecified or complex types", () => {
-            expect(getDefaultValueForType("string")).toBeNull();
-            expect(getDefaultValueForType(["string", "null"])).toBeNull();
-        });
-    });
-    describe("guessType", () => {
-        test("correctly guesses basic types", () => {
-            expect(guessType([])).toBe("array");
-            expect(guessType("test")).toBe("string");
-            expect(guessType(42)).toBe("number");
-            expect(guessType(true)).toBe("boolean");
-            expect(guessType(null)).toBe("null");
-            expect(guessType({})).toBe("object");
-        });
-        test("defaults to 'string' for unrecognized values", () => {
-            expect(guessType(() => { })).toBe("string");
-        });
-    });
-    describe("getSchemaType", () => {
-        test("returns the explicit type if provided", () => {
-            expect(getSchemaType({ type: "number" })).toBe("number");
-        });
-        test("guesses the type based on const values", () => {
-            expect(getSchemaType({ const: 42 })).toBe("number");
-        });
-        test("returns 'string' for enums", () => {
-            expect(getSchemaType({ enum: ["one", "two"] })).toBe("string");
-        });
-        test("returns 'object' for schemas with properties or additionalProperties", () => {
-            expect(getSchemaType({ properties: { a: { type: "number" } } })).toBe("object");
-            expect(getSchemaType({ additionalProperties: { type: "number" } })).toBe("object");
-        });
-        test('handles array types, excluding "null" when paired with another type', () => {
-            expect(getSchemaType({ type: ["number", "null"] })).toBe("number");
-        });
-        test("returns undefined for empty or invalid schemas", () => {
-            expect(getSchemaType({})).toBeUndefined();
-        });
-    });
-});

package/dist/esm/utils/__tests/hasReferences.test.js

@@ -1,100 +0,0 @@
-import { hasReferences } from "../hasReferences";
-describe("hasReferences", () => {
-    it("returns false if no references are found", () => {
-        const schema = {
-            title: "Deep object",
-            properties: {
-                value: { type: "number" },
-                level1: {
-                    title: "Level1",
-                    properties: {
-                        value: { type: "number" },
-                        level2: {
-                            title: "Level2",
-                            properties: {
-                                value: { type: "number" },
-                                level3: {
-                                    title: "Level3",
-                                    properties: {
-                                        value: { type: "number" },
-                                        level4: {
-                                            title: "Level4",
-                                            properties: {
-                                                value: { type: "number" },
-                                            },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        };
-        expect(hasReferences(schema)).toEqual(false);
-    });
-    it("returns true if any references are found", () => {
-        const schema = {
-            title: "Deep object",
-            properties: {
-                value: { type: "number" },
-                level1: {
-                    title: "Level1",
-                    properties: {
-                        value: { type: "number" },
-                        level2: {
-                            title: "Level2",
-                            properties: {
-                                value: { type: "number" },
-                                level3: {
-                                    title: "Level3",
-                                    properties: {
-                                        value: { type: "number" },
-                                        level4: {
-                                            title: "Level4",
-                                            properties: {
-                                                value: { $ref: "#/definitions/organization" },
-                                            },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        };
-        expect(hasReferences(schema)).toEqual(true);
-        const schema2 = {
-            title: "Deep object",
-            properties: {
-                value: { type: "number" },
-                level1: {
-                    title: "Level1",
-                    properties: {
-                        value: { type: "number" },
-                        level2: {
-                            title: "Level2",
-                            properties: {
-                                value: { $ref: "#/definitions/organization" },
-                                level3: {
-                                    title: "Level3",
-                                    properties: {
-                                        value: { type: "number" },
-                                        level4: {
-                                            title: "Level4",
-                                            properties: {
-                                                value: { type: "number" },
-                                            },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        };
-        expect(hasReferences(schema2)).toEqual(true);
-    });
-});

package/dist/esm/utils/__tests/mergeSchemas.test.js

@@ -1,40 +0,0 @@
-import { mergeSchemas } from "../mergeSchemas";
-describe("mergeSchemas", () => {
-    test("merges simple objects without overlap", () => {
-        const obj1 = { a: 1 };
-        const obj2 = { b: 2 };
-        expect(mergeSchemas(obj1, obj2)).toEqual({ a: 1, b: 2 });
-    });
-    test("merges objects with nested objects", () => {
-        const obj1 = { a: { b: 1 } };
-        const obj2 = { a: { c: 2 }, d: 3 };
-        expect(mergeSchemas(obj1, obj2)).toEqual({ a: { b: 1, c: 2 }, d: 3 });
-    });
-    test("handles merging with overlapping keys", () => {
-        const obj1 = { a: 1, b: 2 };
-        const obj2 = { a: 3, c: 4 };
-        expect(mergeSchemas(obj1, obj2)).toEqual({ a: 3, b: 2, c: 4 });
-    });
-    test("merges schemas with arrays (ensuring arrays are replaced, not merged)", () => {
-        const obj1 = { a: [1, 2], b: "string" };
-        const obj2 = { a: [3, 4] };
-        expect(mergeSchemas(obj1, obj2)).toEqual({ a: [3, 4], b: "string" });
-    });
-    test("deep merges nested objects", () => {
-        const obj1 = { a: { b: { c: 1 } } };
-        const obj2 = { a: { b: { d: 2 }, e: 3 } };
-        expect(mergeSchemas(obj1, obj2)).toEqual({
-            a: { b: { c: 1, d: 2 }, e: 3 },
-        });
-    });
-    test("retains the more specific type when merging schemas with different types", () => {
-        const obj1 = { type: ["null", "number"] };
-        const obj2 = { type: "number" };
-        expect(mergeSchemas(obj1, obj2)).toEqual({ type: "number" });
-    });
-    test("returns the second object if the first one is null or undefined", () => {
-        const obj1 = null;
-        const obj2 = { a: 1 };
-        expect(mergeSchemas(obj1, obj2)).toEqual({ a: 1 });
-    });
-});

package/dist/esm/utils/__tests/orderByUiSchema.test.js

@@ -1,63 +0,0 @@
-import { orderByUiSchema } from "../orderByUiSchema";
-const allProperties = ["firstName", "lastName", "age", "hobbies"];
-const emptyOrder = undefined;
-const noAsteriskOrder = ["firstName", "age"];
-const asteriskAsFirstElement = ["*", "firstName"];
-const asteriskAsLastElement = ["age", "*"];
-const asteriskAsMiddleElement = ["hobbies", "*", "age"];
-const orderWithDuplicates = ["age", "*", "age", "*", "lastName"];
-describe("orderByUiSchema", () => {
-    it("returns empty array when ui:order is not given", () => {
-        const orderedProperties = orderByUiSchema(emptyOrder, allProperties);
-        expect(orderedProperties).toEqual(undefined);
-    });
-    it("returns only given properties when order includes no asterisk", () => {
-        const orderedProperties = orderByUiSchema(noAsteriskOrder, allProperties);
-        expect(orderedProperties).toEqual(["firstName", "age"]);
-    });
-    it("returns all properties in the given order with asterisk as first element", () => {
-        const orderedProperties = orderByUiSchema(asteriskAsFirstElement, allProperties);
-        expect(orderedProperties).toEqual([
-            "lastName",
-            "age",
-            "hobbies",
-            "firstName",
-        ]);
-    });
-    it("returns all properties in the given order with asterisk as last element", () => {
-        const orderedProperties = orderByUiSchema(asteriskAsLastElement, allProperties);
-        expect(orderedProperties).toEqual([
-            "age",
-            "firstName",
-            "lastName",
-            "hobbies",
-        ]);
-    });
-    it("returns all properties in the given order with asterisk as middle element", () => {
-        const orderedProperties = orderByUiSchema(asteriskAsMiddleElement, allProperties);
-        expect(orderedProperties).toEqual([
-            "hobbies",
-            "firstName",
-            "lastName",
-            "age",
-        ]);
-    });
-    it("returns all properties in the given order with asterisk as middle element", () => {
-        const orderedProperties = orderByUiSchema(asteriskAsMiddleElement, allProperties);
-        expect(orderedProperties).toEqual([
-            "hobbies",
-            "firstName",
-            "lastName",
-            "age",
-        ]);
-    });
-    it("ignores duplicates in order array to avoid errors", () => {
-        const orderedProperties = orderByUiSchema(orderWithDuplicates, allProperties);
-        expect(orderedProperties).toEqual([
-            "age",
-            "firstName",
-            "hobbies",
-            "lastName",
-        ]);
-    });
-});

package/dist/esm/utils/__tests/resolveSchema.test.js

@@ -1,116 +0,0 @@
-import { resolveSchema } from "../resolveSchema";
-import { schemaWithDependenciesAndOneOf, simpleConditionalSchema, } from "./testSchemas";
-describe("resolveSchema", () => {
-    test("adds conditional properties when condition is met", () => {
-        const value = { animal: "cat" };
-        const resolvedSchema = resolveSchema(simpleConditionalSchema, value);
-        expect(resolvedSchema).toEqual([
-            {
-                type: "object",
-                title: "Title",
-                properties: {
-                    animal: {
-                        type: "string",
-                        enum: ["cat", "bird"],
-                    },
-                    food: {
-                        type: "string",
-                        enum: ["meat", "grass", "fish"],
-                    },
-                },
-                required: ["food"],
-            },
-            [],
-        ]);
-    });
-    test("does not add conditional properties when condition is not met", () => {
-        const value = { animal: "bird" };
-        const resolvedSchema = resolveSchema(simpleConditionalSchema, value);
-        expect(resolvedSchema).toEqual([
-            {
-                type: "object",
-                title: "Title",
-                properties: {
-                    animal: {
-                        type: "string",
-                        enum: ["cat", "bird"],
-                    },
-                },
-            },
-            [],
-        ]);
-    });
-    test("does not add conditional properties when no value is provided", () => {
-        const value = {};
-        const resolvedSchema = resolveSchema(simpleConditionalSchema, value);
-        expect(resolvedSchema).toEqual([
-            {
-                type: "object",
-                title: "Title",
-                properties: {
-                    animal: {
-                        type: "string",
-                        enum: ["cat", "bird"],
-                    },
-                },
-            },
-            [],
-        ]);
-    });
-    test("with value changed", () => {
-        const value = { animal: "bird", food: "meat" };
-        const resolvedSchema = resolveSchema(simpleConditionalSchema, value);
-        expect(resolvedSchema).toEqual([
-            {
-                type: "object",
-                title: "Title",
-                properties: {
-                    animal: {
-                        type: "string",
-                        enum: ["cat", "bird"],
-                    },
-                },
-            },
-            ["food"],
-        ]);
-    });
-    test("selects the correct oneOf schema based on the type dependency", () => {
-        const valueCar = { type: "car" };
-        const resolvedCarSchema = resolveSchema(schemaWithDependenciesAndOneOf, valueCar);
-        expect(resolvedCarSchema).toEqual([
-            {
-                type: "object",
-                properties: {
-                    type: { type: "string", enum: ["car", "bike"] },
-                    wheels: { type: "number", enum: [4] },
-                },
-            },
-            [],
-        ]);
-        const valueBike = { type: "bike" };
-        const resolvedBikeSchema = resolveSchema(schemaWithDependenciesAndOneOf, valueBike);
-        expect(resolvedBikeSchema).toEqual([
-            {
-                type: "object",
-                properties: {
-                    type: { type: "string", enum: ["car", "bike"] },
-                    wheels: { type: "number", enum: [2] },
-                },
-            },
-            [],
-        ]);
-    });
-    test("handles missing dependencies", () => {
-        const valueEmpty = {};
-        const resolvedEmptySchema = resolveSchema(schemaWithDependenciesAndOneOf, valueEmpty);
-        expect(resolvedEmptySchema).toEqual([
-            {
-                type: "object",
-                properties: {
-                    type: { type: "string", enum: ["car", "bike"] },
-                },
-            },
-            [],
-        ]);
-    });
-});

package/dist/esm/utils/__tests/solveReferences.test.js

@@ -1,56 +0,0 @@
-import { solveReferences } from "../solveReferences";
-import { refDefSchema, refDefUiSchema } from "./testSchemas";
-describe("solveReferences", () => {
-    it("should resolve simple references correctly", () => {
-        const schemaSolvedForReferences = solveReferences(refDefSchema?.properties?.name, refDefSchema.definitions, {}, {});
-        expect(schemaSolvedForReferences).toEqual({
-            schema: {
-                type: "string",
-                title: "Name",
-            },
-            uiSchema: {},
-        });
-    });
-    it("should resolve simple references with uiSchema correctly", () => {
-        const schemaSolvedForReferences = solveReferences(refDefSchema?.properties?.birthday, refDefSchema.definitions, refDefUiSchema.birthday ?? {}, refDefUiSchema.definitions);
-        expect(schemaSolvedForReferences).toEqual({
-            schema: {
-                type: "string",
-                title: "Birthday",
-            },
-            uiSchema: { "ui:field": "DateField" },
-        });
-    });
-    it("should override uiSchema settings when key of field is also given outside definitions object of uiSchema", () => {
-        const schemaSolvedForReferences = solveReferences(refDefSchema?.properties?.friendBirthday, refDefSchema.definitions, refDefUiSchema.friendBirthday ?? {}, refDefUiSchema.definitions);
-        expect(schemaSolvedForReferences).toEqual({
-            schema: {
-                type: "string",
-                title: "Birthday", //this is the original title that comes from the definitions, but is getting overridden
-            },
-            uiSchema: {
-                "ui:field": "DateField",
-                "ui:title": "The birthday of your best friend", //this is the title that will be displayed as field title
-            },
-        });
-    });
-    it("should merge field and definition schema", () => {
-        const schemaSolvedForReferences = solveReferences(refDefSchema?.properties?.address, refDefSchema.definitions, {}, {});
-        expect(schemaSolvedForReferences).toEqual({
-            schema: {
-                type: "object",
-                title: "Address",
-                required: ["country", "city", "street", "postcode"],
-                default: { country: "US" },
-                properties: {
-                    country: { type: "string", title: "Country" },
-                    city: { type: "string", title: "City" },
-                    street: { type: "string", title: "Street" },
-                    postcode: { type: "string", title: "Postcode" },
-                    apartmentNumber: { type: "string", title: "Apartment number" },
-                },
-            },
-            uiSchema: {},
-        });
-    });
-});