@rjsf/utils 5.12.1 → 5.13.1

package/dist/index.js

@@ -83,6 +83,7 @@ __export(src_exports, {
   getFirstMatchingOption: () => getFirstMatchingOption,
   getInputProps: () => getInputProps,
   getMatchingOption: () => getMatchingOption,
+  getOptionMatchingSimpleDiscriminator: () => getOptionMatchingSimpleDiscriminator,
   getSchemaType: () => getSchemaType,
   getSubmitButtonOptions: () => getSubmitButtonOptions,
   getTemplate: () => getTemplate,
@@ -271,7 +272,7 @@ function deepEquals(a, b) {
 }
 
 // src/schema/getDefaultFormState.ts
-var import_get6 = __toESM(require("lodash/get"));
+var import_get7 = __toESM(require("lodash/get"));
 var import_isEmpty = __toESM(require("lodash/isEmpty"));
 
 // src/findSchemaDefinition.ts
@@ -305,25 +306,58 @@ function findSchemaDefinition($ref, rootSchema = {}) {
 }
 
 // src/schema/getClosestMatchingOption.ts
-var import_get4 = __toESM(require("lodash/get"));
+var import_get5 = __toESM(require("lodash/get"));
 var import_has2 = __toESM(require("lodash/has"));
+var import_isNumber2 = __toESM(require("lodash/isNumber"));
 var import_isObject5 = __toESM(require("lodash/isObject"));
 var import_isString2 = __toESM(require("lodash/isString"));
 var import_reduce = __toESM(require("lodash/reduce"));
 var import_times2 = __toESM(require("lodash/times"));
 
 // src/schema/getMatchingOption.ts
-var import_get = __toESM(require("lodash/get"));
+var import_get2 = __toESM(require("lodash/get"));
 var import_has = __toESM(require("lodash/has"));
+var import_isNumber = __toESM(require("lodash/isNumber"));
+
+// src/getOptionMatchingSimpleDiscriminator.ts
+var import_get = __toESM(require("lodash/get"));
+function getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField) {
+  if (formData && discriminatorField) {
+    const value = (0, import_get.default)(formData, discriminatorField);
+    if (value === void 0) {
+      return;
+    }
+    for (let i = 0; i < options.length; i++) {
+      const option = options[i];
+      const discriminator = (0, import_get.default)(option, [PROPERTIES_KEY, discriminatorField], {});
+      if (discriminator.type === "object" || discriminator.type === "array") {
+        continue;
+      }
+      if (discriminator.const === value) {
+        return i;
+      }
+      if (discriminator.enum?.includes(value)) {
+        return i;
+      }
+    }
+  }
+  return;
+}
+
+// src/schema/getMatchingOption.ts
 function getMatchingOption(validator, formData, options, rootSchema, discriminatorField) {
   if (formData === void 0) {
     return 0;
   }
+  const simpleDiscriminatorMatch = getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField);
+  if ((0, import_isNumber.default)(simpleDiscriminatorMatch)) {
+    return simpleDiscriminatorMatch;
+  }
   for (let i = 0; i < options.length; i++) {
     const option = options[i];
     if (discriminatorField && (0, import_has.default)(option, [PROPERTIES_KEY, discriminatorField])) {
-      const value = (0, import_get.default)(formData, discriminatorField);
-      const discriminator = (0, import_get.default)(option, [PROPERTIES_KEY, discriminatorField], {});
+      const value = (0, import_get2.default)(formData, discriminatorField);
+      const discriminator = (0, import_get2.default)(option, [PROPERTIES_KEY, discriminatorField], {});
       if (validator.isValid(discriminator, value, rootSchema)) {
         return i;
       }
@@ -363,18 +397,19 @@ function getFirstMatchingOption(validator, formData, options, rootSchema, discri
 }
 
 // src/schema/retrieveSchema.ts
-var import_get3 = __toESM(require("lodash/get"));
+var import_get4 = __toESM(require("lodash/get"));
+var import_isEqual = __toESM(require("lodash/isEqual"));
 var import_set = __toESM(require("lodash/set"));
 var import_times = __toESM(require("lodash/times"));
 var import_transform = __toESM(require("lodash/transform"));
 var import_json_schema_merge_allof = __toESM(require("json-schema-merge-allof"));
 
 // src/getDiscriminatorFieldFromSchema.ts
-var import_get2 = __toESM(require("lodash/get"));
+var import_get3 = __toESM(require("lodash/get"));
 var import_isString = __toESM(require("lodash/isString"));
 function getDiscriminatorFieldFromSchema(schema) {
   let discriminator;
-  const maybeString = (0, import_get2.default)(schema, "discriminator.propertyName", void 0);
+  const maybeString = (0, import_get3.default)(schema, "discriminator.propertyName", void 0);
   if ((0, import_isString.default)(maybeString)) {
     discriminator = maybeString;
   } else if (maybeString !== void 0) {
@@ -421,8 +456,12 @@ function getSchemaType(schema) {
   if (!type && (schema.properties || schema.additionalProperties)) {
     return "object";
   }
-  if (Array.isArray(type) && type.length === 2 && type.includes("null")) {
-    type = type.find((type2) => type2 !== "null");
+  if (Array.isArray(type)) {
+    if (type.length === 2 && type.includes("null")) {
+      type = type.find((type2) => type2 !== "null");
+    } else {
+      type = type[0];
+    }
   }
   return type;
 }
@@ -447,7 +486,7 @@ function mergeSchemas(obj1, obj2) {
 function retrieveSchema(validator, schema, rootSchema = {}, rawFormData) {
   return retrieveSchemaInternal(validator, schema, rootSchema, rawFormData)[0];
 }
-function resolveCondition(validator, schema, rootSchema, expandAllBranches, formData) {
+function resolveCondition(validator, schema, rootSchema, expandAllBranches, recurseList, formData) {
   const { if: expression, then, else: otherwise, ...resolvedSchemaLessConditional } = schema;
   const conditionValue = validator.isValid(expression, formData || {}, rootSchema);
   let resolvedSchemas = [resolvedSchemaLessConditional];
@@ -455,19 +494,26 @@ function resolveCondition(validator, schema, rootSchema, expandAllBranches, form
   if (expandAllBranches) {
     if (then && typeof then !== "boolean") {
       schemas = schemas.concat(
-        retrieveSchemaInternal(validator, then, rootSchema, formData, expandAllBranches)
+        retrieveSchemaInternal(validator, then, rootSchema, formData, expandAllBranches, recurseList)
       );
     }
     if (otherwise && typeof otherwise !== "boolean") {
       schemas = schemas.concat(
-        retrieveSchemaInternal(validator, otherwise, rootSchema, formData, expandAllBranches)
+        retrieveSchemaInternal(validator, otherwise, rootSchema, formData, expandAllBranches, recurseList)
       );
     }
   } else {
     const conditionalSchema = conditionValue ? then : otherwise;
     if (conditionalSchema && typeof conditionalSchema !== "boolean") {
       schemas = schemas.concat(
-        retrieveSchemaInternal(validator, conditionalSchema, rootSchema, formData, expandAllBranches)
+        retrieveSchemaInternal(
+          validator,
+          conditionalSchema,
+          rootSchema,
+          formData,
+          expandAllBranches,
+          recurseList
+        )
       );
     }
   }
@@ -475,7 +521,7 @@ function resolveCondition(validator, schema, rootSchema, expandAllBranches, form
     resolvedSchemas = schemas.map((s) => mergeSchemas(resolvedSchemaLessConditional, s));
   }
   return resolvedSchemas.flatMap(
-    (s) => retrieveSchemaInternal(validator, s, rootSchema, formData, expandAllBranches)
+    (s) => retrieveSchemaInternal(validator, s, rootSchema, formData, expandAllBranches, recurseList)
   );
 }
 function getAllPermutationsOfXxxOf(listOfLists) {
@@ -492,40 +538,72 @@ function getAllPermutationsOfXxxOf(listOfLists) {
   );
   return allPermutations;
 }
-function resolveSchema(validator, schema, rootSchema, expandAllBranches, formData) {
-  if (REF_KEY in schema) {
-    return resolveReference(validator, schema, rootSchema, expandAllBranches, formData);
+function resolveSchema(validator, schema, rootSchema, expandAllBranches, recurseList, formData) {
+  const updatedSchemas = resolveReference(
+    validator,
+    schema,
+    rootSchema,
+    expandAllBranches,
+    recurseList,
+    formData
+  );
+  if (updatedSchemas.length > 1 || updatedSchemas[0] !== schema) {
+    return updatedSchemas;
   }
   if (DEPENDENCIES_KEY in schema) {
-    const resolvedSchemas = resolveDependencies(validator, schema, rootSchema, expandAllBranches, formData);
+    const resolvedSchemas = resolveDependencies(
+      validator,
+      schema,
+      rootSchema,
+      expandAllBranches,
+      recurseList,
+      formData
+    );
     return resolvedSchemas.flatMap((s) => {
-      return retrieveSchemaInternal(validator, s, rootSchema, formData, expandAllBranches);
+      return retrieveSchemaInternal(validator, s, rootSchema, formData, expandAllBranches, recurseList);
     });
   }
   if (ALL_OF_KEY in schema && Array.isArray(schema.allOf)) {
     const allOfSchemaElements = schema.allOf.map(
-      (allOfSubschema) => retrieveSchemaInternal(validator, allOfSubschema, rootSchema, formData, expandAllBranches)
+      (allOfSubschema) => retrieveSchemaInternal(
+        validator,
+        allOfSubschema,
+        rootSchema,
+        formData,
+        expandAllBranches,
+        recurseList
+      )
     );
     const allPermutations = getAllPermutationsOfXxxOf(allOfSchemaElements);
     return allPermutations.map((permutation) => ({ ...schema, allOf: permutation }));
   }
   return [schema];
 }
-function resolveReference(validator, schema, rootSchema, expandAllBranches, formData) {
-  const { $ref, ...localSchema } = schema;
-  const refSchema = findSchemaDefinition($ref, rootSchema);
-  return retrieveSchemaInternal(
-    validator,
-    { ...refSchema, ...localSchema },
-    rootSchema,
-    formData,
-    expandAllBranches
-  );
+function resolveReference(validator, schema, rootSchema, expandAllBranches, recurseList, formData) {
+  const updatedSchema = resolveAllReferences(schema, rootSchema, recurseList);
+  if (updatedSchema !== schema) {
+    return retrieveSchemaInternal(
+      validator,
+      updatedSchema,
+      rootSchema,
+      formData,
+      expandAllBranches,
+      recurseList
+    );
+  }
+  return [schema];
 }
-function resolveAllReferences(schema, rootSchema) {
+function resolveAllReferences(schema, rootSchema, recurseList) {
+  if (!isObject(schema)) {
+    return schema;
+  }
   let resolvedSchema = schema;
   if (REF_KEY in resolvedSchema) {
     const { $ref, ...localSchema } = resolvedSchema;
+    if (recurseList.includes($ref)) {
+      return resolvedSchema;
+    }
+    recurseList.push($ref);
     const refSchema = findSchemaDefinition($ref, rootSchema);
     resolvedSchema = { ...refSchema, ...localSchema };
   }
@@ -533,16 +611,19 @@ function resolveAllReferences(schema, rootSchema) {
     const updatedProps = (0, import_transform.default)(
       resolvedSchema[PROPERTIES_KEY],
       (result, value, key) => {
-        result[key] = resolveAllReferences(value, rootSchema);
+        result[key] = resolveAllReferences(value, rootSchema, recurseList);
       },
       {}
     );
     resolvedSchema = { ...resolvedSchema, [PROPERTIES_KEY]: updatedProps };
   }
   if (ITEMS_KEY in resolvedSchema && !Array.isArray(resolvedSchema.items) && typeof resolvedSchema.items !== "boolean") {
-    resolvedSchema = { ...resolvedSchema, items: resolveAllReferences(resolvedSchema.items, rootSchema) };
+    resolvedSchema = {
+      ...resolvedSchema,
+      items: resolveAllReferences(resolvedSchema.items, rootSchema, recurseList)
+    };
   }
-  return resolvedSchema;
+  return (0, import_isEqual.default)(schema, resolvedSchema) ? schema : resolvedSchema;
 }
 function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFormData) {
   const schema = {
@@ -559,7 +640,7 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
       if (REF_KEY in schema.additionalProperties) {
         additionalProperties = retrieveSchema(
           validator,
-          { $ref: (0, import_get3.default)(schema.additionalProperties, [REF_KEY]) },
+          { $ref: (0, import_get4.default)(schema.additionalProperties, [REF_KEY]) },
           rootSchema,
           formData
         );
@@ -571,25 +652,39 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
           ...schema.additionalProperties
         };
       } else {
-        additionalProperties = { type: guessType((0, import_get3.default)(formData, [key])) };
+        additionalProperties = { type: guessType((0, import_get4.default)(formData, [key])) };
       }
     } else {
-      additionalProperties = { type: guessType((0, import_get3.default)(formData, [key])) };
+      additionalProperties = { type: guessType((0, import_get4.default)(formData, [key])) };
     }
     schema.properties[key] = additionalProperties;
     (0, import_set.default)(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
   });
   return schema;
 }
-function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expandAllBranches = false) {
+function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expandAllBranches = false, recurseList = []) {
   if (!isObject(schema)) {
     return [{}];
   }
-  const resolvedSchemas = resolveSchema(validator, schema, rootSchema, expandAllBranches, rawFormData);
+  const resolvedSchemas = resolveSchema(
+    validator,
+    schema,
+    rootSchema,
+    expandAllBranches,
+    recurseList,
+    rawFormData
+  );
   return resolvedSchemas.flatMap((s) => {
     let resolvedSchema = s;
     if (IF_KEY in resolvedSchema) {
-      return resolveCondition(validator, resolvedSchema, rootSchema, expandAllBranches, rawFormData);
+      return resolveCondition(
+        validator,
+        resolvedSchema,
+        rootSchema,
+        expandAllBranches,
+        recurseList,
+        rawFormData
+      );
     }
     if (ALL_OF_KEY in resolvedSchema) {
       if (expandAllBranches) {
@@ -613,7 +708,7 @@ function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expa
     return resolvedSchema;
   });
 }
-function resolveAnyOrOneOfSchemas(validator, schema, rootSchema, expandAllBranches, rawFormData) {
+function resolveAnyOrOneOfSchemas(validator, schema, rootSchema, expandAllBranches, recurseList, rawFormData) {
   let anyOrOneOf;
   const { oneOf, anyOf, ...remaining } = schema;
   if (Array.isArray(oneOf)) {
@@ -625,7 +720,7 @@ function resolveAnyOrOneOfSchemas(validator, schema, rootSchema, expandAllBranch
     const formData = rawFormData === void 0 && expandAllBranches ? {} : rawFormData;
     const discriminator = getDiscriminatorFieldFromSchema(schema);
     anyOrOneOf = anyOrOneOf.map((s) => {
-      return resolveAllReferences(s, rootSchema);
+      return resolveAllReferences(s, rootSchema, recurseList);
     });
     const option = getFirstMatchingOption(validator, formData, anyOrOneOf, rootSchema, discriminator);
     if (expandAllBranches) {
@@ -635,23 +730,32 @@ function resolveAnyOrOneOfSchemas(validator, schema, rootSchema, expandAllBranch
   }
   return [schema];
 }
-function resolveDependencies(validator, schema, rootSchema, expandAllBranches, formData) {
+function resolveDependencies(validator, schema, rootSchema, expandAllBranches, recurseList, formData) {
   const { dependencies, ...remainingSchema } = schema;
   const resolvedSchemas = resolveAnyOrOneOfSchemas(
     validator,
     remainingSchema,
     rootSchema,
     expandAllBranches,
+    recurseList,
     formData
   );
   return resolvedSchemas.flatMap(
-    (resolvedSchema) => processDependencies(validator, dependencies, resolvedSchema, rootSchema, expandAllBranches, formData)
+    (resolvedSchema) => processDependencies(
+      validator,
+      dependencies,
+      resolvedSchema,
+      rootSchema,
+      expandAllBranches,
+      recurseList,
+      formData
+    )
   );
 }
-function processDependencies(validator, dependencies, resolvedSchema, rootSchema, expandAllBranches, formData) {
+function processDependencies(validator, dependencies, resolvedSchema, rootSchema, expandAllBranches, recurseList, formData) {
   let schemas = [resolvedSchema];
   for (const dependencyKey in dependencies) {
-    if (!expandAllBranches && (0, import_get3.default)(formData, [dependencyKey]) === void 0) {
+    if (!expandAllBranches && (0, import_get4.default)(formData, [dependencyKey]) === void 0) {
       continue;
     }
     if (resolvedSchema.properties && !(dependencyKey in resolvedSchema.properties)) {
@@ -671,11 +775,20 @@ function processDependencies(validator, dependencies, resolvedSchema, rootSchema
         dependencyKey,
         dependencyValue,
         expandAllBranches,
+        recurseList,
         formData
       );
     }
     return schemas.flatMap(
-      (schema) => processDependencies(validator, remainingDependencies, schema, rootSchema, expandAllBranches, formData)
+      (schema) => processDependencies(
+        validator,
+        remainingDependencies,
+        schema,
+        rootSchema,
+        expandAllBranches,
+        recurseList,
+        formData
+      )
     );
   }
   return schemas;
@@ -687,13 +800,14 @@ function withDependentProperties(schema, additionallyRequired) {
   const required = Array.isArray(schema.required) ? Array.from(/* @__PURE__ */ new Set([...schema.required, ...additionallyRequired])) : additionallyRequired;
   return { ...schema, required };
 }
-function withDependentSchema(validator, schema, rootSchema, dependencyKey, dependencyValue, expandAllBranches, formData) {
+function withDependentSchema(validator, schema, rootSchema, dependencyKey, dependencyValue, expandAllBranches, recurseList, formData) {
   const dependentSchemas = retrieveSchemaInternal(
     validator,
     dependencyValue,
     rootSchema,
     formData,
-    expandAllBranches
+    expandAllBranches,
+    recurseList
   );
   return dependentSchemas.flatMap((dependent) => {
     const { oneOf, ...dependentSchema } = dependent;
@@ -705,7 +819,7 @@ function withDependentSchema(validator, schema, rootSchema, dependencyKey, depen
       if (typeof subschema === "boolean" || !(REF_KEY in subschema)) {
         return [subschema];
       }
-      return resolveReference(validator, subschema, rootSchema, expandAllBranches, formData);
+      return resolveReference(validator, subschema, rootSchema, expandAllBranches, recurseList, formData);
     });
     const allPermutations = getAllPermutationsOfXxxOf(resolvedOneOfs);
     return allPermutations.flatMap(
@@ -716,12 +830,13 @@ function withDependentSchema(validator, schema, rootSchema, dependencyKey, depen
         dependencyKey,
         resolvedOneOf,
         expandAllBranches,
+        recurseList,
         formData
       )
     );
   });
 }
-function withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, oneOf, expandAllBranches, formData) {
+function withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, oneOf, expandAllBranches, recurseList, formData) {
   const validSubschemas = oneOf.filter((subschema) => {
     if (typeof subschema === "boolean" || !subschema || !subschema.properties) {
       return false;
@@ -751,7 +866,8 @@ function withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, o
       dependentSchema,
       rootSchema,
       formData,
-      expandAllBranches
+      expandAllBranches,
+      recurseList
     );
     return schemas.map((s2) => mergeSchemas(schema, s2));
   });
@@ -774,7 +890,7 @@ function calculateIndexScore(validator, rootSchema, schema, formData = {}) {
       totalScore += (0, import_reduce.default)(
         schema.properties,
         (score, value, key) => {
-          const formValue = (0, import_get4.default)(formData, key);
+          const formValue = (0, import_get5.default)(formData, key);
           if (typeof value === "boolean") {
             return score;
           }
@@ -789,7 +905,7 @@ function calculateIndexScore(validator, rootSchema, schema, formData = {}) {
               validator,
               rootSchema,
               formValue,
-              (0, import_get4.default)(value, key2),
+              (0, import_get5.default)(value, key2),
               -1,
               discriminator
             );
@@ -818,8 +934,12 @@ function calculateIndexScore(validator, rootSchema, schema, formData = {}) {
 }
 function getClosestMatchingOption(validator, rootSchema, formData, options, selectedOption = -1, discriminatorField) {
   const resolvedOptions = options.map((option) => {
-    return resolveAllReferences(option, rootSchema);
+    return resolveAllReferences(option, rootSchema, []);
   });
+  const simpleDiscriminatorMatch = getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField);
+  if ((0, import_isNumber2.default)(simpleDiscriminatorMatch)) {
+    return simpleDiscriminatorMatch;
+  }
   const allValidIndexes = resolvedOptions.reduce((validList, option, index) => {
     const testOptions = [JUNK_OPTION, option];
     const match = getFirstMatchingOption(validator, formData, testOptions, rootSchema, discriminatorField);
@@ -860,7 +980,7 @@ function isFixedItems(schema) {
 }
 
 // src/mergeDefaultsWithFormData.ts
-var import_get5 = __toESM(require("lodash/get"));
+var import_get6 = __toESM(require("lodash/get"));
 function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults = false) {
   if (Array.isArray(formData)) {
     const defaultsArray = Array.isArray(defaults) ? defaults : [];
@@ -879,8 +999,8 @@ function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults =
     const acc = Object.assign({}, defaults);
     return Object.keys(formData).reduce((acc2, key) => {
       acc2[key] = mergeDefaultsWithFormData(
-        defaults ? (0, import_get5.default)(defaults, key) : {},
-        (0, import_get5.default)(formData, key),
+        defaults ? (0, import_get6.default)(defaults, key) : {},
+        (0, import_get6.default)(formData, key),
         mergeExtraArrayDefaults
       );
       return acc2;
@@ -1001,7 +1121,7 @@ function computeDefaults(validator, rawSchema, {
       schemaToCompute = findSchemaDefinition(refName, rootSchema);
     }
   } else if (DEPENDENCIES_KEY in schema) {
-    const resolvedSchema = resolveDependencies(validator, schema, rootSchema, false, formData);
+    const resolvedSchema = resolveDependencies(validator, schema, rootSchema, false, [], formData);
     schemaToCompute = resolvedSchema[0];
   } else if (isFixedItems(schema)) {
     defaults = schema.items.map(
@@ -1063,13 +1183,13 @@ function computeDefaults(validator, rawSchema, {
   switch (getSchemaType(schema)) {
     case "object": {
       const objectDefaults = Object.keys(schema.properties || {}).reduce((acc, key) => {
-        const computedDefault = computeDefaults(validator, (0, import_get6.default)(schema, [PROPERTIES_KEY, key]), {
+        const computedDefault = computeDefaults(validator, (0, import_get7.default)(schema, [PROPERTIES_KEY, key]), {
           rootSchema,
           _recurseList,
           experimental_defaultFormStateBehavior,
           includeUndefinedValues: includeUndefinedValues === true,
-          parentDefaults: (0, import_get6.default)(defaults, [key]),
-          rawFormData: (0, import_get6.default)(formData, [key]),
+          parentDefaults: (0, import_get7.default)(defaults, [key]),
+          rawFormData: (0, import_get7.default)(formData, [key]),
           required: schema.required?.includes(key)
         });
         maybeAddDefaultToObject(
@@ -1089,22 +1209,19 @@ function computeDefaults(validator, rawSchema, {
         if (isObject(defaults)) {
           Object.keys(defaults).filter((key) => !schema.properties || !schema.properties[key]).forEach((key) => keys.add(key));
         }
-        let formDataRequired;
-        if (isObject(formData)) {
-          formDataRequired = [];
-          Object.keys(formData).filter((key) => !schema.properties || !schema.properties[key]).forEach((key) => {
-            keys.add(key);
-            formDataRequired.push(key);
-          });
-        }
+        const formDataRequired = [];
+        Object.keys(formData).filter((key) => !schema.properties || !schema.properties[key]).forEach((key) => {
+          keys.add(key);
+          formDataRequired.push(key);
+        });
         keys.forEach((key) => {
           const computedDefault = computeDefaults(validator, additionalPropertiesSchema, {
             rootSchema,
             _recurseList,
             experimental_defaultFormStateBehavior,
             includeUndefinedValues: includeUndefinedValues === true,
-            parentDefaults: (0, import_get6.default)(defaults, [key]),
-            rawFormData: (0, import_get6.default)(formData, [key]),
+            parentDefaults: (0, import_get7.default)(defaults, [key]),
+            rawFormData: (0, import_get7.default)(formData, [key]),
             required: schema.required?.includes(key)
           });
           maybeAddDefaultToObject(
@@ -1145,7 +1262,7 @@ function computeDefaults(validator, rawSchema, {
               _recurseList,
               experimental_defaultFormStateBehavior,
               rawFormData: item,
-              parentDefaults: (0, import_get6.default)(defaults, [idx]),
+              parentDefaults: (0, import_get7.default)(defaults, [idx]),
               required
             });
           });
@@ -1261,7 +1378,7 @@ function mergeValidationData(validator, validationData, additionalErrorSchema) {
 }
 
 // src/schema/sanitizeDataForNewSchema.ts
-var import_get7 = __toESM(require("lodash/get"));
+var import_get8 = __toESM(require("lodash/get"));
 var import_has3 = __toESM(require("lodash/has"));
 var NO_VALUE = Symbol("no Value");
 function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, data = {}) {
@@ -1269,27 +1386,27 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
   if ((0, import_has3.default)(newSchema, PROPERTIES_KEY)) {
     const removeOldSchemaData = {};
     if ((0, import_has3.default)(oldSchema, PROPERTIES_KEY)) {
-      const properties = (0, import_get7.default)(oldSchema, PROPERTIES_KEY, {});
+      const properties = (0, import_get8.default)(oldSchema, PROPERTIES_KEY, {});
       Object.keys(properties).forEach((key) => {
         if ((0, import_has3.default)(data, key)) {
           removeOldSchemaData[key] = void 0;
         }
       });
     }
-    const keys = Object.keys((0, import_get7.default)(newSchema, PROPERTIES_KEY, {}));
+    const keys = Object.keys((0, import_get8.default)(newSchema, PROPERTIES_KEY, {}));
     const nestedData = {};
     keys.forEach((key) => {
-      const formValue = (0, import_get7.default)(data, key);
-      let oldKeyedSchema = (0, import_get7.default)(oldSchema, [PROPERTIES_KEY, key], {});
-      let newKeyedSchema = (0, import_get7.default)(newSchema, [PROPERTIES_KEY, key], {});
+      const formValue = (0, import_get8.default)(data, key);
+      let oldKeyedSchema = (0, import_get8.default)(oldSchema, [PROPERTIES_KEY, key], {});
+      let newKeyedSchema = (0, import_get8.default)(newSchema, [PROPERTIES_KEY, key], {});
       if ((0, import_has3.default)(oldKeyedSchema, REF_KEY)) {
         oldKeyedSchema = retrieveSchema(validator, oldKeyedSchema, rootSchema, formValue);
       }
       if ((0, import_has3.default)(newKeyedSchema, REF_KEY)) {
         newKeyedSchema = retrieveSchema(validator, newKeyedSchema, rootSchema, formValue);
       }
-      const oldSchemaTypeForKey = (0, import_get7.default)(oldKeyedSchema, "type");
-      const newSchemaTypeForKey = (0, import_get7.default)(newKeyedSchema, "type");
+      const oldSchemaTypeForKey = (0, import_get8.default)(oldKeyedSchema, "type");
+      const newSchemaTypeForKey = (0, import_get8.default)(newKeyedSchema, "type");
       if (!oldSchemaTypeForKey || oldSchemaTypeForKey === newSchemaTypeForKey) {
         if ((0, import_has3.default)(removeOldSchemaData, key)) {
           delete removeOldSchemaData[key];
@@ -1306,17 +1423,17 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
             nestedData[key] = itemData;
           }
         } else {
-          const newOptionDefault = (0, import_get7.default)(newKeyedSchema, "default", NO_VALUE);
-          const oldOptionDefault = (0, import_get7.default)(oldKeyedSchema, "default", NO_VALUE);
+          const newOptionDefault = (0, import_get8.default)(newKeyedSchema, "default", NO_VALUE);
+          const oldOptionDefault = (0, import_get8.default)(oldKeyedSchema, "default", NO_VALUE);
           if (newOptionDefault !== NO_VALUE && newOptionDefault !== formValue) {
             if (oldOptionDefault === formValue) {
               removeOldSchemaData[key] = newOptionDefault;
-            } else if ((0, import_get7.default)(newKeyedSchema, "readOnly") === true) {
+            } else if ((0, import_get8.default)(newKeyedSchema, "readOnly") === true) {
               removeOldSchemaData[key] = void 0;
             }
           }
-          const newOptionConst = (0, import_get7.default)(newKeyedSchema, "const", NO_VALUE);
-          const oldOptionConst = (0, import_get7.default)(oldKeyedSchema, "const", NO_VALUE);
+          const newOptionConst = (0, import_get8.default)(newKeyedSchema, "const", NO_VALUE);
+          const oldOptionConst = (0, import_get8.default)(oldKeyedSchema, "const", NO_VALUE);
           if (newOptionConst !== NO_VALUE && newOptionConst !== formValue) {
             removeOldSchemaData[key] = oldOptionConst === formValue ? newOptionConst : void 0;
           }
@@ -1328,9 +1445,9 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
       ...removeOldSchemaData,
       ...nestedData
     };
-  } else if ((0, import_get7.default)(oldSchema, "type") === "array" && (0, import_get7.default)(newSchema, "type") === "array" && Array.isArray(data)) {
-    let oldSchemaItems = (0, import_get7.default)(oldSchema, "items");
-    let newSchemaItems = (0, import_get7.default)(newSchema, "items");
+  } else if ((0, import_get8.default)(oldSchema, "type") === "array" && (0, import_get8.default)(newSchema, "type") === "array" && Array.isArray(data)) {
+    let oldSchemaItems = (0, import_get8.default)(oldSchema, "items");
+    let newSchemaItems = (0, import_get8.default)(newSchema, "items");
     if (typeof oldSchemaItems === "object" && typeof newSchemaItems === "object" && !Array.isArray(oldSchemaItems) && !Array.isArray(newSchemaItems)) {
       if ((0, import_has3.default)(oldSchemaItems, REF_KEY)) {
         oldSchemaItems = retrieveSchema(validator, oldSchemaItems, rootSchema, data);
@@ -1338,10 +1455,10 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
       if ((0, import_has3.default)(newSchemaItems, REF_KEY)) {
         newSchemaItems = retrieveSchema(validator, newSchemaItems, rootSchema, data);
       }
-      const oldSchemaType = (0, import_get7.default)(oldSchemaItems, "type");
-      const newSchemaType = (0, import_get7.default)(newSchemaItems, "type");
+      const oldSchemaType = (0, import_get8.default)(oldSchemaItems, "type");
+      const newSchemaType = (0, import_get8.default)(newSchemaItems, "type");
       if (!oldSchemaType || oldSchemaType === newSchemaType) {
-        const maxItems = (0, import_get7.default)(newSchema, "maxItems", -1);
+        const maxItems = (0, import_get8.default)(newSchema, "maxItems", -1);
         if (newSchemaType === "object") {
           newFormData = data.reduce((newValue, aValue) => {
             const itemValue = sanitizeDataForNewSchema(
@@ -1368,12 +1485,12 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
 }
 
 // src/schema/toIdSchema.ts
-var import_get8 = __toESM(require("lodash/get"));
-var import_isEqual = __toESM(require("lodash/isEqual"));
+var import_get9 = __toESM(require("lodash/get"));
+var import_isEqual2 = __toESM(require("lodash/isEqual"));
 function toIdSchemaInternal(validator, schema, idPrefix, idSeparator, id, rootSchema, formData, _recurseList = []) {
   if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
     const _schema = retrieveSchema(validator, schema, rootSchema, formData);
-    const sameSchemaIndex = _recurseList.findIndex((item) => (0, import_isEqual.default)(item, _schema));
+    const sameSchemaIndex = _recurseList.findIndex((item) => (0, import_isEqual2.default)(item, _schema));
     if (sameSchemaIndex === -1) {
       return toIdSchemaInternal(
         validator,
@@ -1387,10 +1504,10 @@ function toIdSchemaInternal(validator, schema, idPrefix, idSeparator, id, rootSc
       );
     }
   }
-  if (ITEMS_KEY in schema && !(0, import_get8.default)(schema, [ITEMS_KEY, REF_KEY])) {
+  if (ITEMS_KEY in schema && !(0, import_get9.default)(schema, [ITEMS_KEY, REF_KEY])) {
     return toIdSchemaInternal(
       validator,
-      (0, import_get8.default)(schema, ITEMS_KEY),
+      (0, import_get9.default)(schema, ITEMS_KEY),
       idPrefix,
       idSeparator,
       id,
@@ -1403,7 +1520,7 @@ function toIdSchemaInternal(validator, schema, idPrefix, idSeparator, id, rootSc
   const idSchema = { $id };
   if (getSchemaType(schema) === "object" && PROPERTIES_KEY in schema) {
     for (const name in schema.properties) {
-      const field = (0, import_get8.default)(schema, [PROPERTIES_KEY, name]);
+      const field = (0, import_get9.default)(schema, [PROPERTIES_KEY, name]);
       const fieldId = idSchema[ID_KEY] + idSeparator + name;
       idSchema[name] = toIdSchemaInternal(
         validator,
@@ -1414,7 +1531,7 @@ function toIdSchemaInternal(validator, schema, idPrefix, idSeparator, id, rootSc
         rootSchema,
         // It's possible that formData is not an object -- this can happen if an
         // array item has just been added, but not populated with data yet
-        (0, import_get8.default)(formData, [name]),
+        (0, import_get9.default)(formData, [name]),
         _recurseList
       );
     }
@@ -1426,13 +1543,13 @@ function toIdSchema(validator, schema, id, rootSchema, formData, idPrefix = "roo
 }
 
 // src/schema/toPathSchema.ts
-var import_get9 = __toESM(require("lodash/get"));
-var import_isEqual2 = __toESM(require("lodash/isEqual"));
+var import_get10 = __toESM(require("lodash/get"));
+var import_isEqual3 = __toESM(require("lodash/isEqual"));
 var import_set2 = __toESM(require("lodash/set"));
 function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _recurseList = []) {
   if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
     const _schema = retrieveSchema(validator, schema, rootSchema, formData);
-    const sameSchemaIndex = _recurseList.findIndex((item) => (0, import_isEqual2.default)(item, _schema));
+    const sameSchemaIndex = _recurseList.findIndex((item) => (0, import_isEqual3.default)(item, _schema));
     if (sameSchemaIndex === -1) {
       return toPathSchemaInternal(
         validator,
@@ -1473,7 +1590,7 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
     });
   } else if (PROPERTIES_KEY in schema) {
     for (const property in schema.properties) {
-      const field = (0, import_get9.default)(schema, [PROPERTIES_KEY, property]);
+      const field = (0, import_get10.default)(schema, [PROPERTIES_KEY, property]);
       pathSchema[property] = toPathSchemaInternal(
         validator,
         field,
@@ -1481,7 +1598,7 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
         rootSchema,
         // It's possible that formData is not an object -- this can happen if an
         // array item has just been added, but not populated with data yet
-        (0, import_get9.default)(formData, [property]),
+        (0, import_get10.default)(formData, [property]),
         _recurseList
       );
     }
@@ -1746,7 +1863,7 @@ function englishStringTranslator(stringToTranslate, params) {
 }
 
 // src/enumOptionsDeselectValue.ts
-var import_isEqual3 = __toESM(require("lodash/isEqual"));
+var import_isEqual4 = __toESM(require("lodash/isEqual"));
 
 // src/enumOptionsValueForIndex.ts
 function enumOptionsValueForIndex(valueIndex, allEnumOptions = [], emptyValue) {
@@ -1762,18 +1879,18 @@ function enumOptionsValueForIndex(valueIndex, allEnumOptions = [], emptyValue) {
 function enumOptionsDeselectValue(valueIndex, selected, allEnumOptions = []) {
   const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
   if (Array.isArray(selected)) {
-    return selected.filter((v) => !(0, import_isEqual3.default)(v, value));
+    return selected.filter((v) => !(0, import_isEqual4.default)(v, value));
   }
-  return (0, import_isEqual3.default)(value, selected) ? void 0 : selected;
+  return (0, import_isEqual4.default)(value, selected) ? void 0 : selected;
 }
 
 // src/enumOptionsIsSelected.ts
-var import_isEqual4 = __toESM(require("lodash/isEqual"));
+var import_isEqual5 = __toESM(require("lodash/isEqual"));
 function enumOptionsIsSelected(value, selected) {
   if (Array.isArray(selected)) {
-    return selected.some((sel) => (0, import_isEqual4.default)(sel, value));
+    return selected.some((sel) => (0, import_isEqual5.default)(sel, value));
   }
-  return (0, import_isEqual4.default)(selected, value);
+  return (0, import_isEqual5.default)(selected, value);
 }
 
 // src/enumOptionsIndexForValue.ts
@@ -1800,7 +1917,7 @@ function enumOptionsSelectValue(valueIndex, selected, allEnumOptions = []) {
 
 // src/ErrorSchemaBuilder.ts
 var import_cloneDeep = __toESM(require("lodash/cloneDeep"));
-var import_get10 = __toESM(require("lodash/get"));
+var import_get11 = __toESM(require("lodash/get"));
 var import_set3 = __toESM(require("lodash/set"));
 var ErrorSchemaBuilder = class {
   /** Construct an `ErrorSchemaBuilder` with an optional initial set of errors in an `ErrorSchema`.
@@ -1828,7 +1945,7 @@ var ErrorSchemaBuilder = class {
    */
   getOrCreateErrorBlock(pathOfError) {
     const hasPath = Array.isArray(pathOfError) && pathOfError.length > 0 || typeof pathOfError === "string";
-    let errorBlock = hasPath ? (0, import_get10.default)(this.errorSchema, pathOfError) : this.errorSchema;
+    let errorBlock = hasPath ? (0, import_get11.default)(this.errorSchema, pathOfError) : this.errorSchema;
     if (!errorBlock && pathOfError) {
       errorBlock = {};
       (0, import_set3.default)(this.errorSchema, pathOfError, errorBlock);
@@ -1854,7 +1971,7 @@ var ErrorSchemaBuilder = class {
    */
   addErrors(errorOrList, pathOfError) {
     const errorBlock = this.getOrCreateErrorBlock(pathOfError);
-    let errorsList = (0, import_get10.default)(errorBlock, ERRORS_KEY);
+    let errorsList = (0, import_get11.default)(errorBlock, ERRORS_KEY);
     if (!Array.isArray(errorsList)) {
       errorsList = [];
       errorBlock[ERRORS_KEY] = errorsList;
@@ -1969,7 +2086,7 @@ function getTemplate(name, registry, uiOptions = {}) {
 // src/getWidget.tsx
 var import_react = require("react");
 var import_react_is = __toESM(require("react-is"));
-var import_get11 = __toESM(require("lodash/get"));
+var import_get12 = __toESM(require("lodash/get"));
 var import_set4 = __toESM(require("lodash/set"));
 var import_jsx_runtime = require("react/jsx-runtime");
 var widgetMap = {
@@ -2025,7 +2142,7 @@ var widgetMap = {
   }
 };
 function mergeWidgetOptions(AWidget) {
-  let MergedWidget = (0, import_get11.default)(AWidget, "MergedWidget");
+  let MergedWidget = (0, import_get12.default)(AWidget, "MergedWidget");
   if (!MergedWidget) {
     const defaultOptions = AWidget.defaultProps && AWidget.defaultProps.options || {};
     MergedWidget = ({ options, ...props }) => {
@@ -2430,11 +2547,11 @@ var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
 
 // src/parser/schemaParser.ts
 var import_forEach = __toESM(require("lodash/forEach"));
-var import_isEqual6 = __toESM(require("lodash/isEqual"));
+var import_isEqual7 = __toESM(require("lodash/isEqual"));
 
 // src/parser/ParserValidator.ts
-var import_get12 = __toESM(require("lodash/get"));
-var import_isEqual5 = __toESM(require("lodash/isEqual"));
+var import_get13 = __toESM(require("lodash/get"));
+var import_isEqual6 = __toESM(require("lodash/isEqual"));
 var ParserValidator = class {
   /** Construct the ParserValidator for the given `rootSchema`. This `rootSchema` will be stashed in the `schemaMap`
    * first.
@@ -2455,12 +2572,12 @@ var ParserValidator = class {
    * @param hash - The hash value at which to map the schema
    */
   addSchema(schema, hash) {
-    const key = (0, import_get12.default)(schema, ID_KEY, hash);
+    const key = (0, import_get13.default)(schema, ID_KEY, hash);
     const identifiedSchema = { ...schema, [ID_KEY]: key };
     const existing = this.schemaMap[key];
     if (!existing) {
       this.schemaMap[key] = identifiedSchema;
-    } else if (!(0, import_isEqual5.default)(existing, identifiedSchema)) {
+    } else if (!(0, import_isEqual6.default)(existing, identifiedSchema)) {
       console.error("existing schema:", JSON.stringify(existing, null, 2));
       console.error("new schema:", JSON.stringify(identifiedSchema, null, 2));
       throw new Error(
@@ -2482,7 +2599,7 @@ var ParserValidator = class {
    * @throws - Error when the given `rootSchema` differs from the root schema provided during construction
    */
   isValid(schema, _formData, rootSchema) {
-    if (!(0, import_isEqual5.default)(rootSchema, this.rootSchema)) {
+    if (!(0, import_isEqual6.default)(rootSchema, this.rootSchema)) {
       throw new Error("Unexpectedly calling isValid() with a rootSchema that differs from the construction rootSchema");
     }
     this.addSchema(schema, hashForSchema(schema));
@@ -2520,12 +2637,13 @@ var ParserValidator = class {
 
 // src/parser/schemaParser.ts
 function parseSchema(validator, recurseList, rootSchema, schema) {
-  const schemas = retrieveSchemaInternal(validator, schema, rootSchema, void 0, true);
+  const recurseRefs = [];
+  const schemas = retrieveSchemaInternal(validator, schema, rootSchema, void 0, true, recurseRefs);
   schemas.forEach((schema2) => {
-    const sameSchemaIndex = recurseList.findIndex((item) => (0, import_isEqual6.default)(item, schema2));
+    const sameSchemaIndex = recurseList.findIndex((item) => (0, import_isEqual7.default)(item, schema2));
     if (sameSchemaIndex === -1) {
       recurseList.push(schema2);
-      const allOptions = resolveAnyOrOneOfSchemas(validator, schema2, rootSchema, true);
+      const allOptions = resolveAnyOrOneOfSchemas(validator, schema2, rootSchema, true, recurseRefs);
       allOptions.forEach((s) => {
         if (PROPERTIES_KEY in s && s[PROPERTIES_KEY]) {
           (0, import_forEach.default)(schema2[PROPERTIES_KEY], (value) => {