@nolwenture/formik-jsonschema-form 2.0.2 → 3.0.0-beta.1

package/dist/cjs/utils/createValidationSchema.js

@@ -1,397 +0,0 @@
-"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 () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __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");
-const DEFAULT_ERROR_MESSAGES = {
-    required: "Required",
-    minLength: (params) => `Must be at least ${params.limit} characters`,
-    maxLength: (params) => `Must be at most ${params.limit} characters`,
-    pattern: "Invalid format",
-    minimum: (params) => `Must be at least ${params.min}`,
-    maximum: (params) => `Must be at most ${params.max}`,
-    exclusiveMinimum: (params) => `Must be more than ${params.min}`,
-    exclusiveMaximum: (params) => `Must be less than ${params.max}`,
-    multipleOf: (params) => `Must be a multiple of ${params.multipleOf}`,
-    minItems: (params) => `Must have at least ${params.min} items`,
-    maxItems: (params) => `Must have at most ${params.max} items`,
-    uniqueItems: "Items must be unique",
-    enum: "Invalid value",
-    const: "Invalid value",
-    notConst: "Invalid value",
-};
-// Difficult to solve
-// @ts-expect-error
-Yup.addMethod(Yup.array, "mixedOf", function ({ itemSchemas, additionalItemSchema }) {
-    return Yup.lazy((value) => {
-        if (value === undefined) {
-            return Yup.mixed().notRequired();
-        }
-        const valueLength = value?.length ?? 0;
-        const numOfAdditionalItems = itemSchemas.length > valueLength ? 0 : valueLength - itemSchemas.length;
-        const additionalSchemas = additionalItemSchema
-            ? Array(numOfAdditionalItems).fill(additionalItemSchema)
-            : Array(numOfAdditionalItems).fill(Yup.mixed());
-        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(schemas, options) {
-    const { schema, uiSchema = {} } = schemas;
-    const { localize, definitions, conditionsContext = {}, condition } = options ?? {};
-    if (!schema?.properties) {
-        return Yup.object().shape({});
-    }
-    const getErrorMessage = (key, fieldUiSchema, params) => {
-        const uiError = fieldUiSchema?.["ui:validation"]?.error?.[key];
-        if (uiError)
-            return uiError;
-        if (localize) {
-            return localize(`validation.error.${key}`, params);
-        }
-        const defaultMsg = DEFAULT_ERROR_MESSAGES[key];
-        return typeof defaultMsg === "function" ? defaultMsg(params) : defaultMsg;
-    };
-    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;
-        const fieldUiSchema = uiSchema?.[key];
-        if (schema.properties) {
-            yupSchema = createValidationSchema({
-                schema,
-                uiSchema: fieldUiSchema
-            }, {
-                localize,
-                definitions: schemaDefinitions,
-                conditionsContext,
-            });
-            type = type ?? "object";
-        }
-        else if (type === "array" && schema.anyOf) {
-            if (!schema.items && !schema.additionalItems) {
-                yupSchema = Yup.array();
-            }
-            else {
-                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, getErrorMessage("required", fieldUiSchema))
-                    : anyOfSchema;
-            }
-        }
-        else if (type === "array") {
-            if (!schema.items && !schema.additionalItems) {
-                yupSchema = Yup.array();
-            }
-            else {
-                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();
-        // Apply JSON Schema validation keywords based on type
-        if (type === "string") {
-            let stringSchema = yupSchema;
-            if (schema.minLength !== undefined) {
-                stringSchema = stringSchema.min(schema.minLength, getErrorMessage("minLength", fieldUiSchema, { limit: schema.minLength }));
-            }
-            if (schema.maxLength !== undefined) {
-                stringSchema = stringSchema.max(schema.maxLength, getErrorMessage("maxLength", fieldUiSchema, { limit: schema.maxLength }));
-            }
-            if (schema.pattern !== undefined) {
-                stringSchema = stringSchema.matches(new RegExp(schema.pattern), getErrorMessage("pattern", fieldUiSchema));
-            }
-            yupSchema = stringSchema;
-        }
-        if (type === "number" || type === "integer") {
-            let numberSchema = yupSchema;
-            if (schema.minimum !== undefined) {
-                numberSchema = numberSchema.min(schema.minimum, getErrorMessage("minimum", fieldUiSchema, { min: schema.minimum }));
-            }
-            if (schema.maximum !== undefined) {
-                numberSchema = numberSchema.max(schema.maximum, getErrorMessage("maximum", fieldUiSchema, { max: schema.maximum }));
-            }
-            if (schema.exclusiveMinimum !== undefined) {
-                numberSchema = numberSchema.moreThan(schema.exclusiveMinimum, getErrorMessage("exclusiveMinimum", fieldUiSchema, { min: schema.exclusiveMinimum }));
-            }
-            if (schema.exclusiveMaximum !== undefined) {
-                numberSchema = numberSchema.lessThan(schema.exclusiveMaximum, getErrorMessage("exclusiveMaximum", fieldUiSchema, { max: schema.exclusiveMaximum }));
-            }
-            if (schema.multipleOf !== undefined) {
-                numberSchema = numberSchema.test("multipleOf", getErrorMessage("multipleOf", fieldUiSchema, { multipleOf: schema.multipleOf }), (value) => value === undefined ||
-                    value === null ||
-                    value % schema.multipleOf === 0);
-            }
-            yupSchema = numberSchema;
-        }
-        if (type === "array") {
-            const applyArrayTests = (s) => {
-                let result = s;
-                if (schema.minItems !== undefined) {
-                    result = result.test("minItems", getErrorMessage("minItems", fieldUiSchema, { min: schema.minItems }), (value) => !value || value.length >= schema.minItems);
-                }
-                if (schema.maxItems !== undefined) {
-                    result = result.test("maxItems", getErrorMessage("maxItems", fieldUiSchema, { max: schema.maxItems }), (value) => !value || value.length <= schema.maxItems);
-                }
-                if (schema.uniqueItems === true) {
-                    result = result.test("uniqueItems", getErrorMessage("uniqueItems", fieldUiSchema), (value) => {
-                        if (!value)
-                            return true;
-                        return new Set(value).size === value.length;
-                    });
-                }
-                return result;
-            };
-            if (yupSchema.test) {
-                yupSchema = applyArrayTests(yupSchema);
-            }
-            else {
-                // It's likely a Lazy schema (from mixedOf). Wrap it to apply tests.
-                const originalLazy = yupSchema;
-                yupSchema = Yup.lazy((value, options) => {
-                    return applyArrayTests(originalLazy.resolve(options));
-                });
-            }
-        }
-        const isOptionEnum = schema.enum !== undefined;
-        const isOptionConst = schema.const !== undefined;
-        if (isOptionEnum || isOptionConst) {
-            // Check for $data reference (cross-field validation)
-            const constValue = schema.const;
-            const isDataRef = typeof constValue === "object" && constValue?.$data;
-            if (isDataRef) {
-                // Cross-field reference: const: { $data: "1/otherFieldName" }
-                // JSON Pointer format: "1/fieldName" means go up 1 level and reference fieldName
-                const dataPath = constValue.$data;
-                const pathParts = dataPath.split("/");
-                const refFieldName = pathParts[pathParts.length - 1]; // Get the field name (last part)
-                yupSchema = yupSchema.oneOf([Yup.ref(refFieldName)], getErrorMessage("const", fieldUiSchema));
-            }
-            else {
-                // Standard const or enum validation
-                const allowedValues = isOptionConst ? [schema.const] : schema.enum;
-                const errorKey = isOptionConst ? "const" : "enum";
-                yupSchema = yupSchema.oneOf(allowedValues, getErrorMessage(errorKey, fieldUiSchema));
-            }
-        }
-        if (schema.not &&
-            typeof schema.not !== "boolean" &&
-            schema.not.const !== undefined) {
-            yupSchema = yupSchema.notOneOf([schema.not.const], getErrorMessage("notConst", fieldUiSchema));
-        }
-        // JSON Schema validation keywords
-        if (isRequired && type !== "array") {
-            yupSchema = yupSchema.required(getErrorMessage("required", fieldUiSchema));
-        }
-        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({
-            schema: solvedSchemas.schema,
-            uiSchema
-        }, {
-            localize,
-            definitions: schemaDefinitions,
-            conditionsContext,
-            condition: conditionalValidation.condition
-        }));
-    }, baseValidationSchema);
-}

package/dist/cjs/utils/deepOverlap.js

@@ -1,18 +0,0 @@
-"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/extractUiSchema.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractUiSchema = void 0;
-const extractUiSchema = (props = {}) => {
-    // props is frozen by React, so it needs to be copied
-    const schema = { ...props };
-    if (schema.props !== undefined) {
-        schema["ui:props"] = {
-            ...(schema["ui:props"] ?? {}),
-            ...(schema.props ?? {}),
-        };
-    }
-    const { "ui:options": options = {}, ...uiSchema } = schema;
-    return {
-        ...Object.keys(uiSchema || {}).reduce((result, key) => ({
-            ...result,
-            [key.replace("ui:", "")]: uiSchema[key],
-        }), {}),
-        ...options,
-    };
-};
-exports.extractUiSchema = extractUiSchema;

package/dist/cjs/utils/getEnums.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSelectedEnum = exports.getEnums = exports.EnumsTypes = void 0;
-var EnumsTypes;
-(function (EnumsTypes) {
-    EnumsTypes["SELECT"] = "select";
-    EnumsTypes["MULTI_SELECT"] = "multiSelect";
-})(EnumsTypes || (exports.EnumsTypes = EnumsTypes = {}));
-//TODO: Add some proper typing
-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: EnumsTypes.SELECT,
-            values: schema.enum.map((option) => ({
-                const: option,
-                title: `${option}`,
-            })),
-        };
-    }
-    if (schema.oneOf) {
-        return {
-            type: EnumsTypes.SELECT,
-            values: schema.oneOf,
-        };
-    }
-    if (schema.anyOf) {
-        return {
-            type: EnumsTypes.MULTI_SELECT,
-            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/getHiddenProperties.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getHiddenProperties = void 0;
-const getHiddenProperties = (order, properties) => {
-    if (!order || order.includes("*")) {
-        return [];
-    }
-    const propertiesInOrder = order.flatMap((entry) => typeof entry === "string" ? entry : entry.fields);
-    return properties.filter((key) => !propertiesInOrder.includes(key));
-};
-exports.getHiddenProperties = getHiddenProperties;

package/dist/cjs/utils/getStyle.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getStyle = getStyle;
-function getStyle(key) {
-    const style = {};
-    if (key === "inline") {
-        style.flexDirection = "row";
-    }
-    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

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDescription = exports.getTitle = void 0;
-const getTitle = ({ title, uiSchema, schema, name, }) => {
-    return uiSchema?.["ui:options"]?.hideTitle
-        ? undefined
-        : 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

@@ -1,60 +0,0 @@
-"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 undefined;
-};
-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/immutablySwapItems.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.immutablySwapItems = immutablySwapItems;
-function immutablySwapItems(items, firstIndex, secondIndex) {
-    const results = items.slice();
-    const firstItem = items[firstIndex];
-    results[firstIndex] = items[secondIndex];
-    results[secondIndex] = firstItem;
-    return results;
-}

package/dist/cjs/utils/index.js

@@ -1,31 +0,0 @@
-"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 });
-__exportStar(require("./deepOverlap"), exports);
-__exportStar(require("./extractUiSchema"), exports);
-__exportStar(require("./getEnums"), exports);
-__exportStar(require("./getHiddenProperties"), 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);
-__exportStar(require("./orderAdditionalProperties"), exports);
-__exportStar(require("./setTitleValues"), exports);
-__exportStar(require("./immutablySwapItems"), exports);