@nolwenture/formik-jsonschema-form 0.26.1 → 0.26.3

package/dist/utils/__tests/createValidationSchema.test.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { ageFieldDefinition } from "../../sampleData/ageFieldDefinition";
 import { createValidationSchema } from "../createValidationSchema";
 const exampleSchema = {
@@ -324,7 +315,6 @@ const nestedRequiredConditionalExampleSchema = {
 };
 describe("Create Validation Schema", () => {
     function listErrors(schema, data, definitions) {
-        var _a;
         const yupSchema = createValidationSchema(schema, definitions);
         try {
             // Cannot be strict, since forms always use string based values
@@ -332,10 +322,10 @@ describe("Create Validation Schema", () => {
         }
         catch (err) {
             const error = err;
-            return (_a = error === null || error === void 0 ? void 0 : error.inner) === null || _a === void 0 ? void 0 : _a.map((e, i) => { var _a; return `${e.path}: ${error.errors[i].replace((_a = e === null || e === void 0 ? void 0 : e.path) !== null && _a !== void 0 ? _a : "", "").trim()}`; });
+            return error?.inner?.map((e, i) => `${e.path}: ${error.errors[i].replace(e?.path ?? "", "").trim()}`);
         }
     }
-    it("creates yup validationSchema based on given JSON schema", () => __awaiter(void 0, void 0, void 0, function* () {
+    it("creates yup validationSchema based on given JSON schema", async () => {
         const result = createValidationSchema(exampleSchema);
         const expected = result.isValidSync({
             name: "Jane",
@@ -354,19 +344,19 @@ describe("Create Validation Schema", () => {
             },
         });
         expect(expected).toEqual(true);
-    }));
-    it("throws error when required input is missing", () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it("throws error when required input is missing", async () => {
         const result = createValidationSchema(simpleExampleSchema);
-        yield expect(() => result.validate({
+        await expect(() => result.validate({
             firstName: "Jane",
             lastName: undefined,
             age: 55,
         })).rejects.toThrow("Required");
-    }));
-    it("throws error when given input is not matching defined type", () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it("throws error when given input is not matching defined type", async () => {
         const result = createValidationSchema(simpleExampleSchema);
         // for 'number' type
-        yield expect(() => result.validate({
+        await expect(() => result.validate({
             firstName: "Ella",
             lastName: "Myller",
             age: true,
@@ -374,7 +364,7 @@ describe("Create Validation Schema", () => {
             simpleArray: [],
         }, { strict: true })).rejects.toThrow("age must be a `number` type, but the final value was: `true`.");
         // for 'string' type
-        yield expect(() => result.validate({
+        await expect(() => result.validate({
             firstName: 123,
             lastName: "Myller",
             age: 17,
@@ -382,7 +372,7 @@ describe("Create Validation Schema", () => {
             simpleArray: [],
         }, { strict: true })).rejects.toThrow("firstName must be a `string` type, but the final value was: `123`.");
         // for 'boolean' type
-        yield expect(() => result.validate({
+        await expect(() => result.validate({
             firstName: "Ella",
             lastName: "Myller",
             age: 17,
@@ -390,14 +380,14 @@ describe("Create Validation Schema", () => {
             simpleArray: [],
         }, { strict: true })).rejects.toThrow('drinksCoffee must be a `boolean` type, but the final value was: `"Well, sometimes..."`.');
         // for 'array' type
-        yield expect(() => result.validate({
+        await expect(() => result.validate({
             firstName: "Ella",
             lastName: "Myller",
             age: 17,
             drinksCoffee: false,
             simpleArray: "Hello :)",
         }, { strict: true })).rejects.toThrow("Required");
-    }));
+    });
     describe("Conditionals", () => {
         it("generates validation for dependencies without oneOf", () => {
             const result = createValidationSchema(dependenciesExampleSchema);
@@ -502,7 +492,7 @@ describe("Create Validation Schema", () => {
             expect(firstTrueInvalid3).toEqual(false);
             expect(firstTrueValid).toEqual(true);
         });
-        it("generates validation for if-then", () => __awaiter(void 0, void 0, void 0, function* () {
+        it("generates validation for if-then", async () => {
             const faultyBusiness = listErrors(allOfExample, {
                 customerType: "BUSINESS",
             });
@@ -571,7 +561,7 @@ describe("Create Validation Schema", () => {
             // eslint-disable-next-line
             // @ts-expect-error
             expect(yupSchema.fields.code.deps.length).toEqual(3);
-        }));
+        });
         it("generates validation for conditional objects with nested validations", () => {
             const result = createValidationSchema(nestedRequiredConditionalExampleSchema);
             const isValidWhenConditionNotNet = result.isValidSync({
@@ -599,10 +589,15 @@ describe("Create Validation Schema", () => {
             title: "Array of objects Schema",
             required: ["arrayOfObjects"],
             properties: {
-                arrayOfObjects: Object.assign({ type: "array", title: "A list of fixed items", items }, (additionalItems ? { additionalItems } : {})),
+                arrayOfObjects: {
+                    type: "array",
+                    title: "A list of fixed items",
+                    items,
+                    ...(additionalItems ? { additionalItems } : {}),
+                },
             },
         });
-        it("requires fields with array items and additionalItems", () => __awaiter(void 0, void 0, void 0, function* () {
+        it("requires fields with array items and additionalItems", async () => {
             const arraySchema = createArraySchema({
                 items: [
                     { title: "A string value", type: "string" },
@@ -740,8 +735,8 @@ describe("Create Validation Schema", () => {
                 ],
             });
             expect(correct).toEqual(undefined);
-        }));
-        it("required fields with array items only", () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        it("required fields with array items only", async () => {
             const arraySchema = createArraySchema({
                 items: [
                     { title: "A string value", type: "string" },
@@ -762,8 +757,8 @@ describe("Create Validation Schema", () => {
                 arrayOfObjects: ["name", 123, true, 123.141241],
             });
             expect(coprrecorrect).toEqual(undefined);
-        }));
-        it("requires fields with array items and additionalItems with definitions", () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        it("requires fields with array items and additionalItems with definitions", async () => {
             const arraySchema = {
                 title: "TITLE",
                 properties: {
@@ -814,8 +809,8 @@ describe("Create Validation Schema", () => {
                 ],
             }, definitions);
             expect(correct).toEqual(undefined);
-        }));
-        it("validates anyOf correctly", () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        it("validates anyOf correctly", async () => {
             const optionalInput = listErrors(anyOfExample(), { warningSymbols: [] });
             expect(optionalInput).toEqual(undefined);
             const requiredInput = listErrors(anyOfExample(["warningSymbols"]), {
@@ -841,7 +836,7 @@ describe("Create Validation Schema", () => {
                 warningSymbols: ["GHS01", "GHS05", 7890],
             });
             expect(validInput).toEqual(undefined);
-        }));
+        });
     });
     describe("Infinite loop validation", () => {
         const definitions = {
@@ -873,7 +868,7 @@ describe("Create Validation Schema", () => {
                 },
             },
         };
-        it("does not throw RangeError: Maximum call stack size exceeded", () => __awaiter(void 0, void 0, void 0, function* () {
+        it("does not throw RangeError: Maximum call stack size exceeded", async () => {
             const validInput1 = listErrors(treeSchema, {
                 organization: {
                     name: "Org A",
@@ -944,6 +939,6 @@ describe("Create Validation Schema", () => {
                 },
             }, definitions);
             expect(invalidInput).toEqual(["organization.subOrganizations: Required"]);
-        }));
+        });
     });
 });

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

@@ -2,8 +2,7 @@ import { solveReferences } from "../solveReferences";
 import { refDefSchema, refDefUiSchema } from "./testSchemas";
 describe("solveReferences", () => {
     it("should resolve simple references correctly", () => {
-        var _a;
-        const schemaSolvedForReferences = solveReferences((_a = refDefSchema === null || refDefSchema === void 0 ? void 0 : refDefSchema.properties) === null || _a === void 0 ? void 0 : _a.name, refDefSchema.definitions, {}, {});
+        const schemaSolvedForReferences = solveReferences(refDefSchema?.properties?.name, refDefSchema.definitions, {}, {});
         expect(schemaSolvedForReferences).toEqual({
             schema: {
                 type: "string",
@@ -13,8 +12,7 @@ describe("solveReferences", () => {
         });
     });
     it("should resolve simple references with uiSchema correctly", () => {
-        var _a, _b;
-        const schemaSolvedForReferences = solveReferences((_a = refDefSchema === null || refDefSchema === void 0 ? void 0 : refDefSchema.properties) === null || _a === void 0 ? void 0 : _a.birthday, refDefSchema.definitions, (_b = refDefUiSchema.birthday) !== null && _b !== void 0 ? _b : {}, refDefUiSchema.definitions);
+        const schemaSolvedForReferences = solveReferences(refDefSchema?.properties?.birthday, refDefSchema.definitions, refDefUiSchema.birthday ?? {}, refDefUiSchema.definitions);
         expect(schemaSolvedForReferences).toEqual({
             schema: {
                 type: "string",
@@ -24,8 +22,7 @@ describe("solveReferences", () => {
         });
     });
     it("should override uiSchema settings when key of field is also given outside definitions object of uiSchema", () => {
-        var _a, _b;
-        const schemaSolvedForReferences = solveReferences((_a = refDefSchema === null || refDefSchema === void 0 ? void 0 : refDefSchema.properties) === null || _a === void 0 ? void 0 : _a.friendBirthday, refDefSchema.definitions, (_b = refDefUiSchema.friendBirthday) !== null && _b !== void 0 ? _b : {}, refDefUiSchema.definitions);
+        const schemaSolvedForReferences = solveReferences(refDefSchema?.properties?.friendBirthday, refDefSchema.definitions, refDefUiSchema.friendBirthday ?? {}, refDefUiSchema.definitions);
         expect(schemaSolvedForReferences).toEqual({
             schema: {
                 type: "string",
@@ -38,8 +35,7 @@ describe("solveReferences", () => {
         });
     });
     it("should merge field and definition schema", () => {
-        var _a;
-        const schemaSolvedForReferences = solveReferences((_a = refDefSchema === null || refDefSchema === void 0 ? void 0 : refDefSchema.properties) === null || _a === void 0 ? void 0 : _a.address, refDefSchema.definitions, {}, {});
+        const schemaSolvedForReferences = solveReferences(refDefSchema?.properties?.address, refDefSchema.definitions, {}, {});
         expect(schemaSolvedForReferences).toEqual({
             schema: {
                 type: "object",

package/dist/utils/createInitialValues.js

@@ -1,10 +1,9 @@
 import { solveReferences } from "./solveReferences";
 export function createInitialValues(schema, definitions = {}) {
-    var _a;
     if (!schema || !schema.properties) {
         return {};
     }
-    const schemaDefinitions = Object.assign(Object.assign({}, definitions), ((_a = schema.definitions) !== null && _a !== void 0 ? _a : {}));
+    const schemaDefinitions = { ...definitions, ...(schema.definitions ?? {}) };
     function getValue(schema) {
         if (schema.properties) {
             return createInitialValues(schema, schemaDefinitions);
@@ -21,13 +20,16 @@ export function createInitialValues(schema, definitions = {}) {
             case "string":
                 return "";
             default:
-                throw new Error("Unsupported schema type");
+                console.error({ schema });
+                throw new Error(`createInitialValues: Unsupported schema type: ${type}`);
         }
     }
-    return Object.keys(schema === null || schema === void 0 ? void 0 : schema.properties).reduce((acc, key) => {
-        var _a;
-        const value = (_a = schema === null || schema === void 0 ? void 0 : schema.properties) === null || _a === void 0 ? void 0 : _a[key];
+    return Object.keys(schema?.properties).reduce((acc, key) => {
+        const value = schema?.properties?.[key];
         const solvedValue = solveReferences(value, schemaDefinitions, {}, {});
-        return Object.assign(Object.assign({}, acc), { [key]: getValue(solvedValue.schema) });
+        return {
+            ...acc,
+            [key]: getValue(solvedValue.schema),
+        };
     }, {});
 }

package/dist/utils/createValidationSchema.js

@@ -1,14 +1,3 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 import * as Yup from "yup";
 import { resolveOneOfValue } from "./resolveSchema";
 import { solveReferences } from "./solveReferences";
@@ -16,8 +5,7 @@ import { solveReferences } from "./solveReferences";
 // @ts-expect-error
 Yup.addMethod(Yup.array, "mixedOf", function ({ itemSchemas, additionalItemSchema }) {
     return Yup.lazy((value) => {
-        var _a;
-        const valueLength = (_a = value === null || value === void 0 ? void 0 : value.length) !== null && _a !== void 0 ? _a : 0;
+        const valueLength = value?.length ?? 0;
         const numOfAdditionalItems = itemSchemas.length > valueLength ? 0 : valueLength - itemSchemas.length;
         const additionalSchemas = additionalItemSchema
             ? Array(numOfAdditionalItems).fill(additionalItemSchema)
@@ -36,16 +24,15 @@ function getConditionalValidations(schema) {
             const oneOf = dependency.oneOf;
             if (Array.isArray(oneOf)) {
                 oneOf.forEach((oneOfSchema) => {
-                    var _a, _b;
                     if (typeof oneOfSchema === "boolean") {
                         return;
                     }
-                    const _c = (_a = oneOfSchema.properties) !== null && _a !== void 0 ? _a : {}, _d = key, propertyToCheck = _c[_d], propertiesSansKey = __rest(_c, [typeof _d === "symbol" ? _d : _d + ""]);
+                    const { [key]: propertyToCheck, ...propertiesSansKey } = oneOfSchema.properties ?? {};
                     // Push validation only if there are additions in schema
-                    if (((_b = Object.keys(propertiesSansKey)) === null || _b === void 0 ? void 0 : _b.length) ||
+                    if (Object.keys(propertiesSansKey)?.length ||
                         Object.keys(oneOfSchema).length > 1) {
                         validations.push({
-                            schema: Object.assign(Object.assign({}, oneOfSchema), { properties: propertiesSansKey }),
+                            schema: { ...oneOfSchema, properties: propertiesSansKey },
                             condition: {
                                 dependentKeys: [key],
                                 conditionFn: (value) => value === resolveOneOfValue(propertyToCheck),
@@ -71,13 +58,13 @@ function getConditionalValidations(schema) {
             if (typeof condition === "boolean") {
                 return validations;
             }
-            const { if: expression, then, else: otherwise } = condition, schemaWithoutCondition = __rest(condition, ["if", "then", "else"]);
+            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 Object.assign(Object.assign({}, result), { [key]: value.const });
+                        return { ...result, [key]: value.const };
                     }
                     return result;
                 }, {});
@@ -110,7 +97,7 @@ function getConditionalValidations(schema) {
     return conditionalValidations;
 }
 function getYupType(schema) {
-    const type = schema === null || schema === void 0 ? void 0 : schema.type;
+    const type = schema?.type;
     switch (type) {
         case "object":
             return Yup.object();
@@ -127,25 +114,26 @@ function getYupType(schema) {
             return Yup.string();
         default:
             console.error({ schema });
-            throw new Error(`Unsupported schema type: ${type}`);
+            throw new Error(`createValidationSchema: Unsupported schema type: ${type}`);
     }
 }
 export function createValidationSchema(schema, definitions = {}, conditionsContext = {}, condition) {
-    var _a;
-    if (!(schema === null || schema === void 0 ? void 0 : schema.properties)) {
+    if (!schema?.properties) {
         return Yup.object().shape({});
     }
-    const schemaDefinitions = Object.assign(Object.assign({}, definitions), ((_a = schema.definitions) !== null && _a !== void 0 ? _a : {}));
+    const schemaDefinitions = {
+        ...definitions,
+        ...(schema.definitions ?? {}),
+    };
     const requiredFields = schema.required;
     function getValue(givenSchema, key, required) {
-        var _a, _b;
         const { schema } = solveReferences(givenSchema, schemaDefinitions, {}, {});
-        const isRequired = (requiredFields === null || requiredFields === void 0 ? void 0 : requiredFields.includes(key)) || required === true;
+        const isRequired = requiredFields?.includes(key) || required === true;
         let type = schema.type;
         let yupSchema;
         if (schema.properties) {
             yupSchema = createValidationSchema(schema, schemaDefinitions, conditionsContext);
-            type = type !== null && type !== void 0 ? type : "object";
+            type = type ?? "object";
         }
         else if (type === "array" && schema.anyOf) {
             const anyOf = schema.anyOf;
@@ -166,10 +154,10 @@ export function createValidationSchema(schema, definitions = {}, conditionsConte
                 // Yup.lazy() enables validation for infinitely nested schemas
                 // aka references that refer to themselves or in circular references
                 return Yup.lazy(() => {
-                    return getValue(schema === null || schema === void 0 ? void 0 : schema.additionalItems, "#ignore-this", true);
+                    return getValue(schema?.additionalItems, "#ignore-this", true);
                 });
             })();
-            const schemaItems = (_a = schema === null || schema === void 0 ? void 0 : schema.items) !== null && _a !== void 0 ? _a : [];
+            const schemaItems = schema?.items ?? [];
             const items = Array.isArray(schemaItems) ? schemaItems : [schemaItems];
             yupSchema = Yup.array().mixedOf({
                 itemSchemas: items.map((item) => getValue(item, "#ignore-this", true)),
@@ -187,7 +175,7 @@ export function createValidationSchema(schema, definitions = {}, conditionsConte
         if (!condition) {
             return yupSchema;
         }
-        const existing = (_b = conditionsContext[key]) !== null && _b !== void 0 ? _b : [];
+        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
@@ -209,8 +197,7 @@ export function createValidationSchema(schema, definitions = {}, conditionsConte
         }, yupType);
     }
     const baseValidationSchema = Object.keys(schema.properties).reduce((validationSchema, key) => {
-        var _a;
-        const value = (_a = schema.properties) === null || _a === void 0 ? void 0 : _a[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) => {

package/dist/utils/getEnums.js

@@ -34,12 +34,12 @@ export const getEnums = ({ schema }) => {
 export const getSelectedEnum = (selected, enums) => {
     if (Array.isArray(selected)) {
         const stuff = selected
-            .map((v) => enums === null || enums === void 0 ? void 0 : enums.values.find((e) => e.const === v))
+            .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 === null || enums === void 0 ? void 0 : enums.values.filter((e) => e.const === selected);
+        return enums?.values.filter((e) => e.const === selected);
     }
     return undefined;
 };

package/dist/utils/getTitleAndDescription.js

@@ -1,15 +1,13 @@
 export const getTitle = ({ title, uiSchema, schema, name, }) => {
-    var _a;
     return (title ||
-        ((_a = uiSchema === null || uiSchema === void 0 ? void 0 : uiSchema["ui:options"]) === null || _a === void 0 ? void 0 : _a.title) ||
-        (uiSchema === null || uiSchema === void 0 ? void 0 : uiSchema["ui:title"]) ||
-        (schema === null || schema === void 0 ? void 0 : schema.title) ||
-        (name === null || name === void 0 ? void 0 : name.split(".")[(name === null || name === void 0 ? void 0 : name.split(".").length) - 1]));
+        uiSchema?.["ui:options"]?.title ||
+        uiSchema?.["ui:title"] ||
+        schema?.title ||
+        name?.split(".")[name?.split(".").length - 1]);
 };
 export const getDescription = ({ description, uiSchema, schema, }) => {
-    var _a;
     return (description ||
-        ((_a = uiSchema === null || uiSchema === void 0 ? void 0 : uiSchema["ui:options"]) === null || _a === void 0 ? void 0 : _a.description) ||
-        (uiSchema === null || uiSchema === void 0 ? void 0 : uiSchema["ui:description"]) ||
-        (schema === null || schema === void 0 ? void 0 : schema.description));
+        uiSchema?.["ui:options"]?.description ||
+        uiSchema?.["ui:description"] ||
+        schema?.description);
 };

package/dist/utils/hasReferences.js

@@ -1,10 +1,10 @@
 export function hasReferences(schema) {
-    const properties = schema === null || schema === void 0 ? void 0 : schema.properties;
+    const properties = schema?.properties;
     if (!properties)
         return false;
     return Object.keys(properties).some((key) => {
         const value = properties[key];
-        if (value === null || value === void 0 ? void 0 : value.properties) {
+        if (value?.properties) {
             return hasReferences(value);
         }
         return Object.keys(value).includes("$ref");

package/dist/utils/resolveSchema.js

@@ -1,27 +1,18 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 import { deepOverlap } from "./deepOverlap";
 import { mergeSchemas } from "./mergeSchemas";
 const resolveEquality = (value, expression) => {
     const keyOfValue = Object.keys(value);
     const valueOfValue = Object.values(value);
     const newObject = {
-        properties: keyOfValue.reduce((properties, key, index) => (Object.assign(Object.assign({}, properties), { [key]: { const: valueOfValue[index] } })), {}),
+        properties: keyOfValue.reduce((properties, key, index) => ({
+            ...properties,
+            [key]: { const: valueOfValue[index] },
+        }), {}),
     };
     return deepOverlap(expression, newObject);
 };
 export function resolveOneOfValue(value) {
-    var _a;
-    if (typeof value !== "boolean" && ((_a = value.enum) === null || _a === void 0 ? void 0 : _a[0]) !== undefined) {
+    if (typeof value !== "boolean" && value.enum?.[0] !== undefined) {
         return value.enum[0];
     }
     else if (value === true || value === false) {
@@ -31,22 +22,18 @@ export function resolveOneOfValue(value) {
         return undefined;
 }
 const resolveSelectedOneOfValue = (key, value, oneOf) => {
-    var _a, _b;
-    const update = ((_a = oneOf.find((one) => typeof one !== "boolean" && (one === null || one === void 0 ? void 0 : one.properties)
+    const update = (oneOf.find((one) => typeof one !== "boolean" && one?.properties
         ? resolveOneOfValue(one.properties[key]) === value[key]
-        : false)) !== null && _a !== void 0 ? _a : {});
-    const manipulatedUpdateValue = Object.keys((_b = update.properties) !== null && _b !== void 0 ? _b : {})
+        : false) ?? {});
+    const manipulatedUpdateValue = Object.keys(update.properties ?? {})
         .filter((objKey) => objKey !== key)
         .reduce((newObj, innerKey) => {
-        var _a;
-        newObj[innerKey] = (_a = update.properties) === null || _a === void 0 ? void 0 : _a[innerKey];
+        newObj[innerKey] = update.properties?.[innerKey];
         return newObj;
     }, {});
-    return Object.assign(Object.assign({}, update), { properties: manipulatedUpdateValue });
+    return { ...update, properties: manipulatedUpdateValue };
 };
-export const resolveSchema = (_a, value) => {
-    var _b, _c;
-    var { allOf, dependencies } = _a, schema = __rest(_a, ["allOf", "dependencies"]);
+export const resolveSchema = ({ allOf, dependencies, ...schema }, value) => {
     let schemaCopy = schema;
     let valuesToRemoveDeps = [];
     let valuesToRemoveAllOf = [];
@@ -67,7 +54,7 @@ export const resolveSchema = (_a, value) => {
         }, schemaCopy);
     }
     if (dependencies) {
-        const usedProperties = Object.keys((_b = schemaCopy.properties) !== null && _b !== void 0 ? _b : {});
+        const usedProperties = Object.keys(schemaCopy.properties ?? {});
         Object.keys(value).map((key) => {
             if (!usedProperties.includes(key)) {
                 valuesToRemoveDeps.push(key);
@@ -79,11 +66,10 @@ export const resolveSchema = (_a, value) => {
     }
     if (allOf) {
         const { resolvedSchema, notAddedProperties } = allOf.reduce(({ resolvedSchema, notAddedProperties }, current) => {
-            var _a, _b;
             if (!current || typeof current === "boolean") {
                 return { resolvedSchema, notAddedProperties };
             }
-            const { if: expression, then, else: otherwise } = current, resolvedSchemaLessConditional = __rest(current, ["if", "then", "else"]);
+            const { if: expression, then, else: otherwise, ...resolvedSchemaLessConditional } = current;
             if (!expression || typeof expression === "boolean") {
                 return {
                     resolvedSchema: mergeSchemas(resolvedSchema, resolvedSchemaLessConditional),
@@ -97,7 +83,7 @@ export const resolveSchema = (_a, value) => {
                 if (otherwise && typeof otherwise !== "boolean") {
                     notAddedProperties = [
                         ...notAddedProperties,
-                        ...Object.keys((_a = otherwise.properties) !== null && _a !== void 0 ? _a : {}),
+                        ...Object.keys(otherwise.properties ?? {}),
                     ];
                 }
             }
@@ -105,7 +91,7 @@ export const resolveSchema = (_a, value) => {
                 if (then && typeof then !== "boolean") {
                     notAddedProperties = [
                         ...notAddedProperties,
-                        ...Object.keys((_b = then.properties) !== null && _b !== void 0 ? _b : {}),
+                        ...Object.keys(then.properties ?? {}),
                     ];
                 }
                 if (otherwise && typeof otherwise !== "boolean") {
@@ -115,7 +101,7 @@ export const resolveSchema = (_a, value) => {
             return { resolvedSchema, notAddedProperties };
         }, { resolvedSchema: schemaCopy, notAddedProperties: [] });
         //Values that do not exists due to conditions
-        const usedPropertiesAllOf = Object.keys((_c = resolvedSchema.properties) !== null && _c !== void 0 ? _c : {});
+        const usedPropertiesAllOf = Object.keys(resolvedSchema.properties ?? {});
         valuesToRemoveAllOf = [...new Set([...notAddedProperties])].filter((key) => !usedPropertiesAllOf.includes(key) && typeof value[key] !== "undefined");
         const valuesToRemove = [
             ...new Set([...valuesToRemoveDeps, ...valuesToRemoveAllOf]),

package/dist/utils/solveReferences.js

@@ -1,14 +1,13 @@
 import { mergeSchemas } from "./mergeSchemas";
 export function solveReferences(schema, definitions, uiSchema, uiSchemaDefinitions) {
-    var _a, _b, _c, _d;
     let solvedSchema = schema;
     let solvedUiSchema = uiSchema;
     if (typeof schema === "object" && schema["$ref"] && definitions) {
-        const schemaKey = (_b = (_a = schema["$ref"]) === null || _a === void 0 ? void 0 : _a.substring(14)) !== null && _b !== void 0 ? _b : "";
+        const schemaKey = schema["$ref"]?.substring(14) ?? "";
         // TODO: Should we overwrite rather than merge? Maybe add a flag for choosing the behavior?
-        solvedSchema = mergeSchemas((_c = definitions[schemaKey]) !== null && _c !== void 0 ? _c : {}, schema !== null && schema !== void 0 ? schema : {});
+        solvedSchema = mergeSchemas(definitions[schemaKey] ?? {}, schema ?? {});
         delete solvedSchema.$ref;
-        solvedUiSchema = mergeSchemas((_d = uiSchemaDefinitions === null || uiSchemaDefinitions === void 0 ? void 0 : uiSchemaDefinitions[schemaKey]) !== null && _d !== void 0 ? _d : {}, uiSchema !== null && uiSchema !== void 0 ? uiSchema : {});
+        solvedUiSchema = mergeSchemas(uiSchemaDefinitions?.[schemaKey] ?? {}, uiSchema ?? {});
     }
     return { schema: solvedSchema, uiSchema: solvedUiSchema };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nolwenture/formik-jsonschema-form",
-  "version": "0.26.1",
+  "version": "0.26.3",
   "description": "Formik form generation from json schema",
   "author": "Antti Vikman <antti.vikman@nolwenture.com>",
   "contributors": [
@@ -8,6 +8,14 @@
     "Niko Lintunen <niko.lintunen@nolwenture.com>"
   ],
   "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "package.json",
+    "LICENSE"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nolwenture/formik-jsonschema-form.git"
@@ -20,14 +28,6 @@
     "formik",
     "jsonschema"
   ],
-  "type": "commonjs",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "files": [
-    "dist",
-    "package.json",
-    "LICENSE"
-  ],
   "scripts": {
     "build": "tsc --build",
     "clean": "tsc --build --clean",