@nolwenture/formik-jsonschema-form 0.26.3 → 0.26.4

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const deepOverlap_1 = require("../deepOverlap");
+describe("deepOverlap", () => {
+    test("returns true for both empty objects", () => {
+        expect((0, deepOverlap_1.deepOverlap)({}, {})).toBe(true);
+    });
+    test("returns true for identical objects", () => {
+        const obj1 = { a: 1, b: 2 };
+        const obj2 = { a: 1, b: 2 };
+        expect((0, deepOverlap_1.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((0, deepOverlap_1.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((0, deepOverlap_1.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((0, deepOverlap_1.deepOverlap)(obj1, obj2)).toBe(true);
+    });
+    test("returns false for objects with different values", () => {
+        const obj1 = { a: 1 };
+        const obj2 = { a: 2 };
+        expect((0, deepOverlap_1.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((0, deepOverlap_1.deepOverlap)(obj1, obj2)).toBe(false);
+    });
+    test("returns false when one object is empty", () => {
+        const obj1 = { a: 1 };
+        const obj2 = {};
+        expect((0, deepOverlap_1.deepOverlap)(obj1, obj2)).toBe(false);
+    });
+});

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getEnums_1 = require("../getEnums");
+describe("getEnums", () => {
+    test("returns undefined when no enum types are defined", () => {
+        const result = (0, getEnums_1.getEnums)({ schema: {} });
+        expect(result).toBeUndefined();
+    });
+    test("throws error when more than one enum type is defined", () => {
+        expect(() => (0, getEnums_1.getEnums)({ schema: { enum: [], oneOf: [], anyOf: [] } })).toThrow('Only one of "enum", "oneOf" or "anyOf" can be defined!');
+    });
+    test("enum works", () => {
+        const result = (0, getEnums_1.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 = (0, getEnums_1.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 = (0, getEnums_1.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/cjs/utils/__tests/getTitleAndDescription.test.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getTitleAndDescription_1 = require("../getTitleAndDescription");
+describe("getTitleAndDescription", () => {
+    describe("getTitle", () => {
+        test("returns title when provided", () => {
+            const title = "Test Title";
+            expect((0, getTitleAndDescription_1.getTitle)({ title })).toBe(title);
+        });
+        test("returns title from uiSchema options when provided", () => {
+            const uiSchema = {
+                "ui:options": { title: "UI Schema Title" },
+            };
+            expect((0, getTitleAndDescription_1.getTitle)({ uiSchema })).toBe("UI Schema Title");
+        });
+        test("returns title from uiSchema title when provided", () => {
+            const uiSchema = { "ui:title": "UI Schema Title" };
+            expect((0, getTitleAndDescription_1.getTitle)({ uiSchema })).toBe("UI Schema Title");
+        });
+        test("returns title from schema when provided", () => {
+            const schema = { title: "Schema Title" };
+            expect((0, getTitleAndDescription_1.getTitle)({ schema })).toBe("Schema Title");
+        });
+        test("returns last part of name when provided", () => {
+            const name = "nested.property";
+            expect((0, getTitleAndDescription_1.getTitle)({ name })).toBe("property");
+        });
+        test("returns undefined when no title is provided", () => {
+            expect((0, getTitleAndDescription_1.getTitle)({})).toBeUndefined();
+        });
+    });
+    describe("getDescription", () => {
+        test("returns description when provided", () => {
+            const description = "Test Description";
+            expect((0, getTitleAndDescription_1.getDescription)({ description })).toBe(description);
+        });
+        test("returns description from uiSchema options when provided", () => {
+            const uiSchema = {
+                "ui:options": { description: "UI Schema Description" },
+            };
+            expect((0, getTitleAndDescription_1.getDescription)({ uiSchema })).toBe("UI Schema Description");
+        });
+        test("returns description from uiSchema description when provided", () => {
+            const uiSchema = { "ui:description": "UI Schema Description" };
+            expect((0, getTitleAndDescription_1.getDescription)({ uiSchema })).toBe("UI Schema Description");
+        });
+        test("returns description from schema when provided", () => {
+            const schema = { description: "Schema Description" };
+            expect((0, getTitleAndDescription_1.getDescription)({ schema })).toBe("Schema Description");
+        });
+        test("returns undefined when no description is provided", () => {
+            expect((0, getTitleAndDescription_1.getDescription)({})).toBeUndefined();
+        });
+    });
+});

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

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

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

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const hasReferences_1 = require("../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((0, hasReferences_1.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((0, hasReferences_1.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((0, hasReferences_1.hasReferences)(schema2)).toEqual(true);
+    });
+});

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mergeSchemas_1 = require("../mergeSchemas");
+describe("mergeSchemas", () => {
+    test("merges simple objects without overlap", () => {
+        const obj1 = { a: 1 };
+        const obj2 = { b: 2 };
+        expect((0, mergeSchemas_1.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((0, mergeSchemas_1.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((0, mergeSchemas_1.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((0, mergeSchemas_1.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((0, mergeSchemas_1.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((0, mergeSchemas_1.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((0, mergeSchemas_1.mergeSchemas)(obj1, obj2)).toEqual({ a: 1 });
+    });
+});

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const orderByUiSchema_1 = require("../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 = (0, orderByUiSchema_1.orderByUiSchema)(emptyOrder, allProperties);
+        expect(orderedProperties).toEqual(undefined);
+    });
+    it("returns only given properties when order includes no asterisk", () => {
+        const orderedProperties = (0, orderByUiSchema_1.orderByUiSchema)(noAsteriskOrder, allProperties);
+        expect(orderedProperties).toEqual(["firstName", "age"]);
+    });
+    it("returns all properties in the given order with asterisk as first element", () => {
+        const orderedProperties = (0, orderByUiSchema_1.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 = (0, orderByUiSchema_1.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 = (0, orderByUiSchema_1.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 = (0, orderByUiSchema_1.orderByUiSchema)(asteriskAsMiddleElement, allProperties);
+        expect(orderedProperties).toEqual([
+            "hobbies",
+            "firstName",
+            "lastName",
+            "age",
+        ]);
+    });
+    it("ignores duplicates in order array to avoid errors", () => {
+        const orderedProperties = (0, orderByUiSchema_1.orderByUiSchema)(orderWithDuplicates, allProperties);
+        expect(orderedProperties).toEqual([
+            "age",
+            "firstName",
+            "hobbies",
+            "lastName",
+        ]);
+    });
+});

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

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resolveSchema_1 = require("../resolveSchema");
+const testSchemas_1 = require("./testSchemas");
+describe("resolveSchema", () => {
+    test("adds conditional properties when condition is met", () => {
+        const value = { animal: "cat" };
+        const resolvedSchema = (0, resolveSchema_1.resolveSchema)(testSchemas_1.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 = (0, resolveSchema_1.resolveSchema)(testSchemas_1.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 = (0, resolveSchema_1.resolveSchema)(testSchemas_1.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 = (0, resolveSchema_1.resolveSchema)(testSchemas_1.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 = (0, resolveSchema_1.resolveSchema)(testSchemas_1.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 = (0, resolveSchema_1.resolveSchema)(testSchemas_1.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 = (0, resolveSchema_1.resolveSchema)(testSchemas_1.schemaWithDependenciesAndOneOf, valueEmpty);
+        expect(resolvedEmptySchema).toEqual([
+            {
+                type: "object",
+                properties: {
+                    type: { type: "string", enum: ["car", "bike"] },
+                },
+            },
+            [],
+        ]);
+    });
+});

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const solveReferences_1 = require("../solveReferences");
+const testSchemas_1 = require("./testSchemas");
+describe("solveReferences", () => {
+    it("should resolve simple references correctly", () => {
+        const schemaSolvedForReferences = (0, solveReferences_1.solveReferences)(testSchemas_1.refDefSchema?.properties?.name, testSchemas_1.refDefSchema.definitions, {}, {});
+        expect(schemaSolvedForReferences).toEqual({
+            schema: {
+                type: "string",
+                title: "Name",
+            },
+            uiSchema: {},
+        });
+    });
+    it("should resolve simple references with uiSchema correctly", () => {
+        const schemaSolvedForReferences = (0, solveReferences_1.solveReferences)(testSchemas_1.refDefSchema?.properties?.birthday, testSchemas_1.refDefSchema.definitions, testSchemas_1.refDefUiSchema.birthday ?? {}, testSchemas_1.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 = (0, solveReferences_1.solveReferences)(testSchemas_1.refDefSchema?.properties?.friendBirthday, testSchemas_1.refDefSchema.definitions, testSchemas_1.refDefUiSchema.friendBirthday ?? {}, testSchemas_1.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 = (0, solveReferences_1.solveReferences)(testSchemas_1.refDefSchema?.properties?.address, testSchemas_1.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: {},
+        });
+    });
+});