@nolwenture/formik-jsonschema-form 0.26.3 → 0.26.4

package/dist/cjs/utils/__tests/testSchemas.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaWithDependenciesAndOneOf = exports.simpleConditionalSchema = exports.refDefUiSchema = exports.refDefSchema = void 0;
+exports.refDefSchema = {
+    title: "References and Definitions",
+    type: "object",
+    required: ["string"],
+    properties: {
+        name: {
+            $ref: "#/definitions/name",
+        },
+        birthday: {
+            $ref: "#/definitions/birthday",
+        },
+        friendBirthday: {
+            $ref: "#/definitions/birthday",
+        },
+        address: {
+            $ref: "#/definitions/address",
+            required: ["postcode"],
+            default: { country: "US" },
+            properties: {
+                apartmentNumber: { type: "string", title: "Apartment number" },
+            },
+        },
+    },
+    definitions: {
+        name: { type: "string", title: "Name" },
+        birthday: { type: "string", title: "Birthday" },
+        address: {
+            type: "object",
+            title: "Address",
+            required: ["country", "city", "street"],
+            properties: {
+                country: { type: "string", title: "Country" },
+                city: { type: "string", title: "City" },
+                street: { type: "string", title: "Street" },
+                postcode: { type: "string", title: "Postcode" },
+            },
+        },
+    },
+};
+exports.refDefUiSchema = {
+    friendBirthday: { "ui:title": "The birthday of your best friend" },
+    definitions: {
+        birthday: { "ui:field": "DateField" },
+    },
+};
+exports.simpleConditionalSchema = {
+    type: "object",
+    title: "Title",
+    properties: {
+        animal: {
+            type: "string",
+            enum: ["cat", "bird"],
+        },
+    },
+    allOf: [
+        {
+            if: {
+                properties: {
+                    animal: {
+                        const: "cat",
+                    },
+                },
+            },
+            then: {
+                properties: {
+                    food: {
+                        type: "string",
+                        enum: ["meat", "grass", "fish"],
+                    },
+                },
+                required: ["food"],
+            },
+        },
+    ],
+};
+exports.schemaWithDependenciesAndOneOf = {
+    type: "object",
+    properties: {
+        type: { type: "string", enum: ["car", "bike"] },
+    },
+    dependencies: {
+        type: {
+            oneOf: [
+                {
+                    properties: {
+                        type: { enum: ["car"] },
+                        wheels: { type: "number", enum: [4] },
+                    },
+                },
+                {
+                    properties: {
+                        type: { enum: ["bike"] },
+                        wheels: { type: "number", enum: [2] },
+                    },
+                },
+            ],
+        },
+    },
+};

package/dist/cjs/utils/createInitialValues.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInitialValues = createInitialValues;
+const solveReferences_1 = require("./solveReferences");
+function createInitialValues(schema, definitions = {}) {
+    if (!schema || !schema.properties) {
+        return {};
+    }
+    const schemaDefinitions = { ...definitions, ...(schema.definitions ?? {}) };
+    function getValue(schema) {
+        if (schema.properties) {
+            return createInitialValues(schema, schemaDefinitions);
+        }
+        const type = schema.type;
+        switch (type) {
+            case "array":
+                return [];
+            case "number":
+                return 0;
+            // Boolean cannot be true/false by default, since that is a valid value
+            case "boolean":
+            case "null":
+            case "string":
+                return "";
+            default:
+                console.error({ schema });
+                throw new Error(`createInitialValues: Unsupported schema type: ${type}`);
+        }
+    }
+    return Object.keys(schema?.properties).reduce((acc, key) => {
+        const value = schema?.properties?.[key];
+        const solvedValue = (0, solveReferences_1.solveReferences)(value, schemaDefinitions, {}, {});
+        return {
+            ...acc,
+            [key]: getValue(solvedValue.schema),
+        };
+    }, {});
+}

package/dist/cjs/utils/createValidationSchema.js

@@ -0,0 +1,239 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createValidationSchema = createValidationSchema;
+const Yup = __importStar(require("yup"));
+const resolveSchema_1 = require("./resolveSchema");
+const solveReferences_1 = require("./solveReferences");
+// Difficult to solve
+// @ts-expect-error
+Yup.addMethod(Yup.array, "mixedOf", function ({ itemSchemas, additionalItemSchema }) {
+    return Yup.lazy((value) => {
+        const valueLength = value?.length ?? 0;
+        const numOfAdditionalItems = itemSchemas.length > valueLength ? 0 : valueLength - itemSchemas.length;
+        const additionalSchemas = additionalItemSchema
+            ? Array(numOfAdditionalItems).fill(additionalItemSchema)
+            : [];
+        return Yup.tuple([...itemSchemas, ...additionalSchemas]).typeError("Required");
+    });
+});
+function getConditionalValidations(schema) {
+    const { dependencies, allOf } = schema;
+    let conditionalValidations = [];
+    if (dependencies) {
+        conditionalValidations = Object.entries(dependencies).reduce((validations, [key, dependency]) => {
+            if (typeof dependency === "boolean" || Array.isArray(dependency)) {
+                return validations;
+            }
+            const oneOf = dependency.oneOf;
+            if (Array.isArray(oneOf)) {
+                oneOf.forEach((oneOfSchema) => {
+                    if (typeof oneOfSchema === "boolean") {
+                        return;
+                    }
+                    const { [key]: propertyToCheck, ...propertiesSansKey } = oneOfSchema.properties ?? {};
+                    // Push validation only if there are additions in schema
+                    if (Object.keys(propertiesSansKey)?.length ||
+                        Object.keys(oneOfSchema).length > 1) {
+                        validations.push({
+                            schema: { ...oneOfSchema, properties: propertiesSansKey },
+                            condition: {
+                                dependentKeys: [key],
+                                conditionFn: (value) => value === (0, resolveSchema_1.resolveOneOfValue)(propertyToCheck),
+                            },
+                        });
+                    }
+                });
+                return validations;
+            }
+            // Depends on presence of `key` property value
+            validations.push({
+                schema: dependency,
+                condition: {
+                    dependentKeys: [key],
+                    conditionFn: (value) => value !== undefined && value !== "",
+                },
+            });
+            return validations;
+        }, conditionalValidations);
+    }
+    if (allOf) {
+        conditionalValidations = allOf.reduce((validations, condition) => {
+            if (typeof condition === "boolean") {
+                return validations;
+            }
+            const { if: expression, then, else: otherwise, ...schemaWithoutCondition } = condition;
+            if (expression &&
+                typeof expression !== "boolean" &&
+                expression.properties) {
+                const keyValueMap = Object.entries(expression.properties).reduce((result, [key, value]) => {
+                    if (typeof value !== "boolean") {
+                        return { ...result, [key]: value.const };
+                    }
+                    return result;
+                }, {});
+                const dependentKeys = Object.keys(keyValueMap);
+                if (then && typeof then !== "boolean") {
+                    validations.push({
+                        schema: then,
+                        condition: {
+                            dependentKeys,
+                            conditionFn: (...args) => args.every((value, index) => keyValueMap[dependentKeys[index]] === value),
+                        },
+                    });
+                }
+                if (otherwise && typeof otherwise !== "boolean") {
+                    validations.push({
+                        schema: otherwise,
+                        condition: {
+                            dependentKeys,
+                            conditionFn: (...args) => args.some((value, index) => keyValueMap[dependentKeys[index]] !== value),
+                        },
+                    });
+                }
+            }
+            else {
+                validations.push({ schema: schemaWithoutCondition });
+            }
+            return validations;
+        }, conditionalValidations);
+    }
+    return conditionalValidations;
+}
+function getYupType(schema) {
+    const type = schema?.type;
+    switch (type) {
+        case "object":
+            return Yup.object();
+        case "array":
+            return Yup.array();
+        case "boolean":
+            return Yup.boolean();
+        case "integer":
+        case "number":
+            return Yup.number();
+        case "null":
+            return Yup.string();
+        case "string":
+            return Yup.string();
+        default:
+            console.error({ schema });
+            throw new Error(`createValidationSchema: Unsupported schema type: ${type}`);
+    }
+}
+function createValidationSchema(schema, definitions = {}, conditionsContext = {}, condition) {
+    if (!schema?.properties) {
+        return Yup.object().shape({});
+    }
+    const schemaDefinitions = {
+        ...definitions,
+        ...(schema.definitions ?? {}),
+    };
+    const requiredFields = schema.required;
+    function getValue(givenSchema, key, required) {
+        const { schema } = (0, solveReferences_1.solveReferences)(givenSchema, schemaDefinitions, {}, {});
+        const isRequired = requiredFields?.includes(key) || required === true;
+        let type = schema.type;
+        let yupSchema;
+        if (schema.properties) {
+            yupSchema = createValidationSchema(schema, schemaDefinitions, conditionsContext);
+            type = type ?? "object";
+        }
+        else if (type === "array" && schema.anyOf) {
+            const anyOf = schema.anyOf;
+            // anyOf is optional, therefore we cannot change it to array.mixedOf() aka tuple
+            const anyOfSchema = Yup.array().of(Yup.lazy(() => {
+                // value has to match with one of the anyOf values in the schema
+                return Yup.mixed().oneOf(anyOf.map((item) => item.const));
+            }));
+            // In case the property is required, there should be at least one item in the array
+            yupSchema = isRequired ? anyOfSchema.min(1, "Required") : anyOfSchema;
+        }
+        else if (type === "array") {
+            const additionalItemSchema = (() => {
+                const additionalItems = schema.additionalItems;
+                if (!additionalItems) {
+                    return undefined;
+                }
+                // Yup.lazy() enables validation for infinitely nested schemas
+                // aka references that refer to themselves or in circular references
+                return Yup.lazy(() => {
+                    return getValue(schema?.additionalItems, "#ignore-this", true);
+                });
+            })();
+            const schemaItems = schema?.items ?? [];
+            const items = Array.isArray(schemaItems) ? schemaItems : [schemaItems];
+            yupSchema = Yup.array().mixedOf({
+                itemSchemas: items.map((item) => getValue(item, "#ignore-this", true)),
+                additionalItemSchema,
+            });
+        }
+        else {
+            yupSchema = getYupType(schema);
+        }
+        if (type === "null")
+            yupSchema.nullable();
+        if (isRequired && type !== "array") {
+            yupSchema = yupSchema.required("Required");
+        }
+        if (!condition) {
+            return yupSchema;
+        }
+        const existing = conditionsContext[key] ?? [];
+        conditionsContext[key] = [...existing, { yupSchema, condition }];
+        // TODO: The latest given type for duplicate field is used.
+        // This might become a problem at some point, but testing has not
+        // shown any problems so far.
+        const yupType = getYupType(schema).when(condition.dependentKeys, {
+            is: condition.conditionFn,
+            then: () => yupSchema,
+        });
+        // If there are existing conditions for the field with same name
+        // for example definition or duplicate field, add those clauses in.
+        // Otherwise the validation would be overwritten by the latest one
+        // breaking the earlier validations.
+        return existing.reduce((result, context) => {
+            const { condition: ctxCondition, yupSchema: ctxYupSchema } = context;
+            return result.when(ctxCondition.dependentKeys, {
+                is: ctxCondition.conditionFn,
+                then: () => ctxYupSchema,
+            });
+        }, yupType);
+    }
+    const baseValidationSchema = Object.keys(schema.properties).reduce((validationSchema, key) => {
+        const value = schema.properties?.[key];
+        return validationSchema.concat(Yup.object().shape({ [key]: getValue(value, key) }));
+    }, Yup.object().shape({}));
+    return getConditionalValidations(schema).reduce((validationSchema, conditionalValidation) => {
+        const solvedSchemas = (0, solveReferences_1.solveReferences)(conditionalValidation.schema, schemaDefinitions, {}, {});
+        /*
+        "Only schemas of the same type can be concatenated. concat is not
+        a "merge" function in the sense that all settings from the provided schema,
+        override ones in the base, including type, presence and nullability."
+        Source: https://github.com/jquense/yup?tab=readme-ov-file#schemaconcatschema-schema-schema
+        */
+        return validationSchema.concat(createValidationSchema(solvedSchemas.schema, schemaDefinitions, conditionsContext, conditionalValidation.condition));
+    }, baseValidationSchema);
+}

package/dist/cjs/utils/deepOverlap.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepOverlap = void 0;
+const getTypes_1 = require("./getTypes");
+const deepOverlap = (object1, object2) => {
+    const keys1 = Object.keys(object1);
+    for (const key of keys1) {
+        const val1 = object1[key];
+        const val2 = object2[key];
+        const areObjects = (0, getTypes_1.isObject)(val1) && (0, getTypes_1.isObject)(val2);
+        if ((areObjects && !(0, exports.deepOverlap)(val1, val2)) ||
+            (!areObjects && val1 !== val2)) {
+            return false;
+        }
+    }
+    return true;
+};
+exports.deepOverlap = deepOverlap;

package/dist/cjs/utils/getEnums.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSelectedEnum = exports.getEnums = void 0;
+const getEnums = ({ schema }) => {
+    if (!schema) {
+        return { values: [] };
+    }
+    const numberOfDefined = [schema.enum, schema.oneOf, schema.anyOf].filter((x) => x).length;
+    if (numberOfDefined === 0) {
+        return;
+    }
+    if (numberOfDefined > 1) {
+        throw new Error('Only one of "enum", "oneOf" or "anyOf" can be defined!');
+    }
+    if (schema.enum) {
+        return {
+            type: "select",
+            values: schema.enum.map((option) => ({
+                const: option,
+                title: `${option}`,
+            })),
+        };
+    }
+    if (schema.oneOf) {
+        return {
+            type: "select",
+            values: schema.oneOf,
+        };
+    }
+    if (schema.anyOf) {
+        return {
+            type: "multiSelect",
+            values: schema.anyOf,
+        };
+    }
+};
+exports.getEnums = getEnums;
+const getSelectedEnum = (selected, enums) => {
+    if (Array.isArray(selected)) {
+        const stuff = selected
+            .map((v) => enums?.values.find((e) => e.const === v))
+            .filter((e) => !!e);
+        return stuff.length > 0 ? stuff : undefined;
+    }
+    if (typeof selected === "string" || typeof selected === "number") {
+        return enums?.values.filter((e) => e.const === selected);
+    }
+    return undefined;
+};
+exports.getSelectedEnum = getSelectedEnum;

package/dist/cjs/utils/getStyle.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStyle = getStyle;
+function getStyle(key) {
+    const style = {};
+    if (key === "inline") {
+        style.display = "inline-grid";
+    }
+    if (key === "oneColumn") {
+        style.display = "grid";
+    }
+    if (key === "twoColumns") {
+        style.display = "grid";
+        style["gridTemplateColumns"] = "1fr 1fr";
+    }
+    if (key === "threeColumns") {
+        style.display = "grid";
+        style["gridTemplateColumns"] = "1fr 1fr 1fr";
+    }
+    return style;
+}

package/dist/cjs/utils/getTitleAndDescription.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDescription = exports.getTitle = void 0;
+const getTitle = ({ title, uiSchema, schema, name, }) => {
+    return (title ||
+        uiSchema?.["ui:options"]?.title ||
+        uiSchema?.["ui:title"] ||
+        schema?.title ||
+        name?.split(".")[name?.split(".").length - 1]);
+};
+exports.getTitle = getTitle;
+const getDescription = ({ description, uiSchema, schema, }) => {
+    return (description ||
+        uiSchema?.["ui:options"]?.description ||
+        uiSchema?.["ui:description"] ||
+        schema?.description);
+};
+exports.getDescription = getDescription;

package/dist/cjs/utils/getTypes.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchemaType = exports.guessType = exports.getDefaultValueForType = exports.isObject = void 0;
+const isObject = (object) => {
+    return object != null && typeof object === "object";
+};
+exports.isObject = isObject;
+const getDefaultValueForType = (type) => {
+    if (type && !Array.isArray(type)) {
+        if (type === "array")
+            return [];
+        if (type === "object")
+            return {};
+    }
+    return null;
+};
+exports.getDefaultValueForType = getDefaultValueForType;
+const guessType = (value) => {
+    if (Array.isArray(value)) {
+        return "array";
+    }
+    else if (typeof value === "string") {
+        return "string";
+    }
+    else if (value === null) {
+        return "null";
+    }
+    else if (typeof value === "boolean") {
+        return "boolean";
+    }
+    else if (!isNaN(value)) {
+        return "number";
+    }
+    else if (typeof value === "object") {
+        return "object";
+    }
+    // Default to string if we can't figure it out
+    return "string";
+};
+exports.guessType = guessType;
+const getSchemaType = (schema) => {
+    if (!schema) {
+        return undefined;
+    }
+    let { type } = schema;
+    if (!type && schema.const) {
+        return (0, exports.guessType)(schema.const);
+    }
+    if (!type && schema.enum) {
+        return "string";
+    }
+    if (!type && (schema.properties || schema.additionalProperties)) {
+        return "object";
+    }
+    if (type instanceof Array && type.length === 2 && type.includes("null")) {
+        return type.find((type) => type !== "null");
+    }
+    return type;
+};
+exports.getSchemaType = getSchemaType;

package/dist/cjs/utils/hasReferences.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasReferences = hasReferences;
+function hasReferences(schema) {
+    const properties = schema?.properties;
+    if (!properties)
+        return false;
+    return Object.keys(properties).some((key) => {
+        const value = properties[key];
+        if (value?.properties) {
+            return hasReferences(value);
+        }
+        return Object.keys(value).includes("$ref");
+    });
+}

package/dist/cjs/utils/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warnFromUnsupportedKeys = void 0;
+__exportStar(require("./deepOverlap"), exports);
+__exportStar(require("./getEnums"), exports);
+__exportStar(require("./getTitleAndDescription"), exports);
+__exportStar(require("./getTypes"), exports);
+__exportStar(require("./mergeSchemas"), exports);
+__exportStar(require("./resolveSchema"), exports);
+__exportStar(require("./solveReferences"), exports);
+__exportStar(require("./createInitialValues"), exports);
+__exportStar(require("./createValidationSchema"), exports);
+__exportStar(require("./orderByUiSchema"), exports);
+//TODO: REMOVE WHEN ALL SUPPORTED
+const warnFromUnsupportedKeys = (componentName, data, supportedKeys) => {
+    Object.keys(data).forEach((key) => {
+        if (!supportedKeys.includes(key)) {
+            console.warn(`Component "${componentName}" does not support (yet) key "${key}"`);
+        }
+    });
+};
+exports.warnFromUnsupportedKeys = warnFromUnsupportedKeys;

package/dist/cjs/utils/mergeSchemas.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeSchemas = void 0;
+const getTypes_1 = require("./getTypes");
+const mergeSchemas = (obj1, obj2) => {
+    const acc = Object.assign({}, obj1); // Prevent mutation of source object.
+    return Object.keys(obj2).reduce((acc, key) => {
+        const left = obj1 ? obj1[key] : {}, right = obj2[key];
+        if (obj1 &&
+            key in obj1 &&
+            typeof right === "object" &&
+            !Array.isArray(right)) {
+            acc[key] = (0, exports.mergeSchemas)(left, right);
+        }
+        else if (obj1 &&
+            obj2 &&
+            ((0, getTypes_1.getSchemaType)(obj1) === "object" || (0, getTypes_1.getSchemaType)(obj2) === "object") &&
+            key === "required" &&
+            Array.isArray(left) &&
+            Array.isArray(right)) {
+            // Don't include duplicate values when merging 'required' fields.
+            acc[key] = [...new Set([...left, ...right])];
+        }
+        else {
+            acc[key] = right;
+        }
+        return acc;
+    }, acc);
+};
+exports.mergeSchemas = mergeSchemas;

package/dist/cjs/utils/orderByUiSchema.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.orderByUiSchema = orderByUiSchema;
+function orderByUiSchema(order, allProperties) {
+    if (order !== undefined && allProperties !== undefined) {
+        if (order.includes("*")) {
+            return orderWithAsterisk(order, allProperties);
+        }
+        else {
+            return order;
+        }
+    }
+    return undefined;
+}
+function orderWithAsterisk(order, allProperties) {
+    const orderWithoutDuplicates = [...new Set(order)];
+    const finalOrderedArray = [];
+    orderWithoutDuplicates.forEach((element) => {
+        if (element === "*") {
+            const propertiesWithoutOrder = allProperties.filter((prop) => !orderWithoutDuplicates.includes(prop));
+            finalOrderedArray.push(...propertiesWithoutOrder);
+        }
+        else {
+            finalOrderedArray.push(element);
+        }
+    });
+    return finalOrderedArray;
+}