@rjsf/utils 5.13.0 → 5.13.1

package/dist/utils.esm.js

@@ -138,7 +138,7 @@ function deepEquals(a, b) {
 }
 
 // src/schema/getDefaultFormState.ts
-import get6 from "lodash/get";
+import get7 from "lodash/get";
 import isEmpty from "lodash/isEmpty";
 
 // src/findSchemaDefinition.ts
@@ -172,25 +172,58 @@ function findSchemaDefinition($ref, rootSchema = {}) {
 }
 
 // src/schema/getClosestMatchingOption.ts
-import get4 from "lodash/get";
+import get5 from "lodash/get";
 import has2 from "lodash/has";
+import isNumber2 from "lodash/isNumber";
 import isObject2 from "lodash/isObject";
 import isString2 from "lodash/isString";
 import reduce from "lodash/reduce";
 import times2 from "lodash/times";
 
 // src/schema/getMatchingOption.ts
-import get from "lodash/get";
+import get2 from "lodash/get";
 import has from "lodash/has";
+import isNumber from "lodash/isNumber";
+
+// src/getOptionMatchingSimpleDiscriminator.ts
+import get from "lodash/get";
+function getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField) {
+  if (formData && discriminatorField) {
+    const value = get(formData, discriminatorField);
+    if (value === void 0) {
+      return;
+    }
+    for (let i = 0; i < options.length; i++) {
+      const option = options[i];
+      const discriminator = get(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 (isNumber(simpleDiscriminatorMatch)) {
+    return simpleDiscriminatorMatch;
+  }
   for (let i = 0; i < options.length; i++) {
     const option = options[i];
     if (discriminatorField && has(option, [PROPERTIES_KEY, discriminatorField])) {
-      const value = get(formData, discriminatorField);
-      const discriminator = get(option, [PROPERTIES_KEY, discriminatorField], {});
+      const value = get2(formData, discriminatorField);
+      const discriminator = get2(option, [PROPERTIES_KEY, discriminatorField], {});
       if (validator.isValid(discriminator, value, rootSchema)) {
         return i;
       }
@@ -230,18 +263,19 @@ function getFirstMatchingOption(validator, formData, options, rootSchema, discri
 }
 
 // src/schema/retrieveSchema.ts
-import get3 from "lodash/get";
+import get4 from "lodash/get";
+import isEqual from "lodash/isEqual";
 import set from "lodash/set";
 import times from "lodash/times";
 import transform from "lodash/transform";
 import mergeAllOf from "json-schema-merge-allof";
 
 // src/getDiscriminatorFieldFromSchema.ts
-import get2 from "lodash/get";
+import get3 from "lodash/get";
 import isString from "lodash/isString";
 function getDiscriminatorFieldFromSchema(schema) {
   let discriminator;
-  const maybeString = get2(schema, "discriminator.propertyName", void 0);
+  const maybeString = get3(schema, "discriminator.propertyName", void 0);
   if (isString(maybeString)) {
     discriminator = maybeString;
   } else if (maybeString !== void 0) {
@@ -288,8 +322,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;
 }
@@ -314,7 +352,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];
@@ -322,19 +360,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
+        )
       );
     }
   }
@@ -342,7 +387,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) {
@@ -359,40 +404,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 };
   }
@@ -400,16 +477,19 @@ function resolveAllReferences(schema, rootSchema) {
     const updatedProps = transform(
       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 isEqual(schema, resolvedSchema) ? schema : resolvedSchema;
 }
 function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFormData) {
   const schema = {
@@ -426,7 +506,7 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
       if (REF_KEY in schema.additionalProperties) {
         additionalProperties = retrieveSchema(
           validator,
-          { $ref: get3(schema.additionalProperties, [REF_KEY]) },
+          { $ref: get4(schema.additionalProperties, [REF_KEY]) },
           rootSchema,
           formData
         );
@@ -438,25 +518,39 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
           ...schema.additionalProperties
         };
       } else {
-        additionalProperties = { type: guessType(get3(formData, [key])) };
+        additionalProperties = { type: guessType(get4(formData, [key])) };
       }
     } else {
-      additionalProperties = { type: guessType(get3(formData, [key])) };
+      additionalProperties = { type: guessType(get4(formData, [key])) };
     }
     schema.properties[key] = additionalProperties;
     set(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) {
@@ -480,7 +574,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)) {
@@ -492,7 +586,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) {
@@ -502,23 +596,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 && get3(formData, [dependencyKey]) === void 0) {
+    if (!expandAllBranches && get4(formData, [dependencyKey]) === void 0) {
       continue;
     }
     if (resolvedSchema.properties && !(dependencyKey in resolvedSchema.properties)) {
@@ -538,11 +641,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;
@@ -554,13 +666,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;
@@ -572,7 +685,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(
@@ -583,12 +696,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;
@@ -618,7 +732,8 @@ function withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, o
       dependentSchema,
       rootSchema,
       formData,
-      expandAllBranches
+      expandAllBranches,
+      recurseList
     );
     return schemas.map((s2) => mergeSchemas(schema, s2));
   });
@@ -641,7 +756,7 @@ function calculateIndexScore(validator, rootSchema, schema, formData = {}) {
       totalScore += reduce(
         schema.properties,
         (score, value, key) => {
-          const formValue = get4(formData, key);
+          const formValue = get5(formData, key);
           if (typeof value === "boolean") {
             return score;
           }
@@ -656,7 +771,7 @@ function calculateIndexScore(validator, rootSchema, schema, formData = {}) {
               validator,
               rootSchema,
               formValue,
-              get4(value, key2),
+              get5(value, key2),
               -1,
               discriminator
             );
@@ -685,8 +800,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 (isNumber2(simpleDiscriminatorMatch)) {
+    return simpleDiscriminatorMatch;
+  }
   const allValidIndexes = resolvedOptions.reduce((validList, option, index) => {
     const testOptions = [JUNK_OPTION, option];
     const match = getFirstMatchingOption(validator, formData, testOptions, rootSchema, discriminatorField);
@@ -727,7 +846,7 @@ function isFixedItems(schema) {
 }
 
 // src/mergeDefaultsWithFormData.ts
-import get5 from "lodash/get";
+import get6 from "lodash/get";
 function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults = false) {
   if (Array.isArray(formData)) {
     const defaultsArray = Array.isArray(defaults) ? defaults : [];
@@ -746,8 +865,8 @@ function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults =
     const acc = Object.assign({}, defaults);
     return Object.keys(formData).reduce((acc2, key) => {
       acc2[key] = mergeDefaultsWithFormData(
-        defaults ? get5(defaults, key) : {},
-        get5(formData, key),
+        defaults ? get6(defaults, key) : {},
+        get6(formData, key),
         mergeExtraArrayDefaults
       );
       return acc2;
@@ -868,7 +987,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(
@@ -930,13 +1049,13 @@ function computeDefaults(validator, rawSchema, {
   switch (getSchemaType(schema)) {
     case "object": {
       const objectDefaults = Object.keys(schema.properties || {}).reduce((acc, key) => {
-        const computedDefault = computeDefaults(validator, get6(schema, [PROPERTIES_KEY, key]), {
+        const computedDefault = computeDefaults(validator, get7(schema, [PROPERTIES_KEY, key]), {
           rootSchema,
           _recurseList,
           experimental_defaultFormStateBehavior,
           includeUndefinedValues: includeUndefinedValues === true,
-          parentDefaults: get6(defaults, [key]),
-          rawFormData: get6(formData, [key]),
+          parentDefaults: get7(defaults, [key]),
+          rawFormData: get7(formData, [key]),
           required: schema.required?.includes(key)
         });
         maybeAddDefaultToObject(
@@ -956,22 +1075,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: get6(defaults, [key]),
-            rawFormData: get6(formData, [key]),
+            parentDefaults: get7(defaults, [key]),
+            rawFormData: get7(formData, [key]),
             required: schema.required?.includes(key)
           });
           maybeAddDefaultToObject(
@@ -1012,7 +1128,7 @@ function computeDefaults(validator, rawSchema, {
               _recurseList,
               experimental_defaultFormStateBehavior,
               rawFormData: item,
-              parentDefaults: get6(defaults, [idx]),
+              parentDefaults: get7(defaults, [idx]),
               required
             });
           });
@@ -1128,7 +1244,7 @@ function mergeValidationData(validator, validationData, additionalErrorSchema) {
 }
 
 // src/schema/sanitizeDataForNewSchema.ts
-import get7 from "lodash/get";
+import get8 from "lodash/get";
 import has3 from "lodash/has";
 var NO_VALUE = Symbol("no Value");
 function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, data = {}) {
@@ -1136,27 +1252,27 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
   if (has3(newSchema, PROPERTIES_KEY)) {
     const removeOldSchemaData = {};
     if (has3(oldSchema, PROPERTIES_KEY)) {
-      const properties = get7(oldSchema, PROPERTIES_KEY, {});
+      const properties = get8(oldSchema, PROPERTIES_KEY, {});
       Object.keys(properties).forEach((key) => {
         if (has3(data, key)) {
           removeOldSchemaData[key] = void 0;
         }
       });
     }
-    const keys = Object.keys(get7(newSchema, PROPERTIES_KEY, {}));
+    const keys = Object.keys(get8(newSchema, PROPERTIES_KEY, {}));
     const nestedData = {};
     keys.forEach((key) => {
-      const formValue = get7(data, key);
-      let oldKeyedSchema = get7(oldSchema, [PROPERTIES_KEY, key], {});
-      let newKeyedSchema = get7(newSchema, [PROPERTIES_KEY, key], {});
+      const formValue = get8(data, key);
+      let oldKeyedSchema = get8(oldSchema, [PROPERTIES_KEY, key], {});
+      let newKeyedSchema = get8(newSchema, [PROPERTIES_KEY, key], {});
       if (has3(oldKeyedSchema, REF_KEY)) {
         oldKeyedSchema = retrieveSchema(validator, oldKeyedSchema, rootSchema, formValue);
       }
       if (has3(newKeyedSchema, REF_KEY)) {
         newKeyedSchema = retrieveSchema(validator, newKeyedSchema, rootSchema, formValue);
       }
-      const oldSchemaTypeForKey = get7(oldKeyedSchema, "type");
-      const newSchemaTypeForKey = get7(newKeyedSchema, "type");
+      const oldSchemaTypeForKey = get8(oldKeyedSchema, "type");
+      const newSchemaTypeForKey = get8(newKeyedSchema, "type");
       if (!oldSchemaTypeForKey || oldSchemaTypeForKey === newSchemaTypeForKey) {
         if (has3(removeOldSchemaData, key)) {
           delete removeOldSchemaData[key];
@@ -1173,17 +1289,17 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
             nestedData[key] = itemData;
           }
         } else {
-          const newOptionDefault = get7(newKeyedSchema, "default", NO_VALUE);
-          const oldOptionDefault = get7(oldKeyedSchema, "default", NO_VALUE);
+          const newOptionDefault = get8(newKeyedSchema, "default", NO_VALUE);
+          const oldOptionDefault = get8(oldKeyedSchema, "default", NO_VALUE);
           if (newOptionDefault !== NO_VALUE && newOptionDefault !== formValue) {
             if (oldOptionDefault === formValue) {
               removeOldSchemaData[key] = newOptionDefault;
-            } else if (get7(newKeyedSchema, "readOnly") === true) {
+            } else if (get8(newKeyedSchema, "readOnly") === true) {
               removeOldSchemaData[key] = void 0;
             }
           }
-          const newOptionConst = get7(newKeyedSchema, "const", NO_VALUE);
-          const oldOptionConst = get7(oldKeyedSchema, "const", NO_VALUE);
+          const newOptionConst = get8(newKeyedSchema, "const", NO_VALUE);
+          const oldOptionConst = get8(oldKeyedSchema, "const", NO_VALUE);
           if (newOptionConst !== NO_VALUE && newOptionConst !== formValue) {
             removeOldSchemaData[key] = oldOptionConst === formValue ? newOptionConst : void 0;
           }
@@ -1195,9 +1311,9 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
       ...removeOldSchemaData,
       ...nestedData
     };
-  } else if (get7(oldSchema, "type") === "array" && get7(newSchema, "type") === "array" && Array.isArray(data)) {
-    let oldSchemaItems = get7(oldSchema, "items");
-    let newSchemaItems = get7(newSchema, "items");
+  } else if (get8(oldSchema, "type") === "array" && get8(newSchema, "type") === "array" && Array.isArray(data)) {
+    let oldSchemaItems = get8(oldSchema, "items");
+    let newSchemaItems = get8(newSchema, "items");
     if (typeof oldSchemaItems === "object" && typeof newSchemaItems === "object" && !Array.isArray(oldSchemaItems) && !Array.isArray(newSchemaItems)) {
       if (has3(oldSchemaItems, REF_KEY)) {
         oldSchemaItems = retrieveSchema(validator, oldSchemaItems, rootSchema, data);
@@ -1205,10 +1321,10 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
       if (has3(newSchemaItems, REF_KEY)) {
         newSchemaItems = retrieveSchema(validator, newSchemaItems, rootSchema, data);
       }
-      const oldSchemaType = get7(oldSchemaItems, "type");
-      const newSchemaType = get7(newSchemaItems, "type");
+      const oldSchemaType = get8(oldSchemaItems, "type");
+      const newSchemaType = get8(newSchemaItems, "type");
       if (!oldSchemaType || oldSchemaType === newSchemaType) {
-        const maxItems = get7(newSchema, "maxItems", -1);
+        const maxItems = get8(newSchema, "maxItems", -1);
         if (newSchemaType === "object") {
           newFormData = data.reduce((newValue, aValue) => {
             const itemValue = sanitizeDataForNewSchema(
@@ -1235,12 +1351,12 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
 }
 
 // src/schema/toIdSchema.ts
-import get8 from "lodash/get";
-import isEqual from "lodash/isEqual";
+import get9 from "lodash/get";
+import isEqual2 from "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) => isEqual(item, _schema));
+    const sameSchemaIndex = _recurseList.findIndex((item) => isEqual2(item, _schema));
     if (sameSchemaIndex === -1) {
       return toIdSchemaInternal(
         validator,
@@ -1254,10 +1370,10 @@ function toIdSchemaInternal(validator, schema, idPrefix, idSeparator, id, rootSc
       );
     }
   }
-  if (ITEMS_KEY in schema && !get8(schema, [ITEMS_KEY, REF_KEY])) {
+  if (ITEMS_KEY in schema && !get9(schema, [ITEMS_KEY, REF_KEY])) {
     return toIdSchemaInternal(
       validator,
-      get8(schema, ITEMS_KEY),
+      get9(schema, ITEMS_KEY),
       idPrefix,
       idSeparator,
       id,
@@ -1270,7 +1386,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 = get8(schema, [PROPERTIES_KEY, name]);
+      const field = get9(schema, [PROPERTIES_KEY, name]);
       const fieldId = idSchema[ID_KEY] + idSeparator + name;
       idSchema[name] = toIdSchemaInternal(
         validator,
@@ -1281,7 +1397,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
-        get8(formData, [name]),
+        get9(formData, [name]),
         _recurseList
       );
     }
@@ -1293,13 +1409,13 @@ function toIdSchema(validator, schema, id, rootSchema, formData, idPrefix = "roo
 }
 
 // src/schema/toPathSchema.ts
-import get9 from "lodash/get";
-import isEqual2 from "lodash/isEqual";
+import get10 from "lodash/get";
+import isEqual3 from "lodash/isEqual";
 import set2 from "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) => isEqual2(item, _schema));
+    const sameSchemaIndex = _recurseList.findIndex((item) => isEqual3(item, _schema));
     if (sameSchemaIndex === -1) {
       return toPathSchemaInternal(
         validator,
@@ -1340,7 +1456,7 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
     });
   } else if (PROPERTIES_KEY in schema) {
     for (const property in schema.properties) {
-      const field = get9(schema, [PROPERTIES_KEY, property]);
+      const field = get10(schema, [PROPERTIES_KEY, property]);
       pathSchema[property] = toPathSchemaInternal(
         validator,
         field,
@@ -1348,7 +1464,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
-        get9(formData, [property]),
+        get10(formData, [property]),
         _recurseList
       );
     }
@@ -1613,7 +1729,7 @@ function englishStringTranslator(stringToTranslate, params) {
 }
 
 // src/enumOptionsDeselectValue.ts
-import isEqual3 from "lodash/isEqual";
+import isEqual4 from "lodash/isEqual";
 
 // src/enumOptionsValueForIndex.ts
 function enumOptionsValueForIndex(valueIndex, allEnumOptions = [], emptyValue) {
@@ -1629,18 +1745,18 @@ function enumOptionsValueForIndex(valueIndex, allEnumOptions = [], emptyValue) {
 function enumOptionsDeselectValue(valueIndex, selected, allEnumOptions = []) {
   const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
   if (Array.isArray(selected)) {
-    return selected.filter((v) => !isEqual3(v, value));
+    return selected.filter((v) => !isEqual4(v, value));
   }
-  return isEqual3(value, selected) ? void 0 : selected;
+  return isEqual4(value, selected) ? void 0 : selected;
 }
 
 // src/enumOptionsIsSelected.ts
-import isEqual4 from "lodash/isEqual";
+import isEqual5 from "lodash/isEqual";
 function enumOptionsIsSelected(value, selected) {
   if (Array.isArray(selected)) {
-    return selected.some((sel) => isEqual4(sel, value));
+    return selected.some((sel) => isEqual5(sel, value));
   }
-  return isEqual4(selected, value);
+  return isEqual5(selected, value);
 }
 
 // src/enumOptionsIndexForValue.ts
@@ -1667,7 +1783,7 @@ function enumOptionsSelectValue(valueIndex, selected, allEnumOptions = []) {
 
 // src/ErrorSchemaBuilder.ts
 import cloneDeep from "lodash/cloneDeep";
-import get10 from "lodash/get";
+import get11 from "lodash/get";
 import set3 from "lodash/set";
 var ErrorSchemaBuilder = class {
   /** Construct an `ErrorSchemaBuilder` with an optional initial set of errors in an `ErrorSchema`.
@@ -1695,7 +1811,7 @@ var ErrorSchemaBuilder = class {
    */
   getOrCreateErrorBlock(pathOfError) {
     const hasPath = Array.isArray(pathOfError) && pathOfError.length > 0 || typeof pathOfError === "string";
-    let errorBlock = hasPath ? get10(this.errorSchema, pathOfError) : this.errorSchema;
+    let errorBlock = hasPath ? get11(this.errorSchema, pathOfError) : this.errorSchema;
     if (!errorBlock && pathOfError) {
       errorBlock = {};
       set3(this.errorSchema, pathOfError, errorBlock);
@@ -1721,7 +1837,7 @@ var ErrorSchemaBuilder = class {
    */
   addErrors(errorOrList, pathOfError) {
     const errorBlock = this.getOrCreateErrorBlock(pathOfError);
-    let errorsList = get10(errorBlock, ERRORS_KEY);
+    let errorsList = get11(errorBlock, ERRORS_KEY);
     if (!Array.isArray(errorsList)) {
       errorsList = [];
       errorBlock[ERRORS_KEY] = errorsList;
@@ -1836,7 +1952,7 @@ function getTemplate(name, registry, uiOptions = {}) {
 // src/getWidget.tsx
 import { createElement } from "react";
 import ReactIs from "react-is";
-import get11 from "lodash/get";
+import get12 from "lodash/get";
 import set4 from "lodash/set";
 import { jsx } from "react/jsx-runtime";
 var widgetMap = {
@@ -1892,7 +2008,7 @@ var widgetMap = {
   }
 };
 function mergeWidgetOptions(AWidget) {
-  let MergedWidget = get11(AWidget, "MergedWidget");
+  let MergedWidget = get12(AWidget, "MergedWidget");
   if (!MergedWidget) {
     const defaultOptions = AWidget.defaultProps && AWidget.defaultProps.options || {};
     MergedWidget = ({ options, ...props }) => {
@@ -2297,11 +2413,11 @@ var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
 
 // src/parser/schemaParser.ts
 import forEach from "lodash/forEach";
-import isEqual6 from "lodash/isEqual";
+import isEqual7 from "lodash/isEqual";
 
 // src/parser/ParserValidator.ts
-import get12 from "lodash/get";
-import isEqual5 from "lodash/isEqual";
+import get13 from "lodash/get";
+import isEqual6 from "lodash/isEqual";
 var ParserValidator = class {
   /** Construct the ParserValidator for the given `rootSchema`. This `rootSchema` will be stashed in the `schemaMap`
    * first.
@@ -2322,12 +2438,12 @@ var ParserValidator = class {
    * @param hash - The hash value at which to map the schema
    */
   addSchema(schema, hash) {
-    const key = get12(schema, ID_KEY, hash);
+    const key = get13(schema, ID_KEY, hash);
     const identifiedSchema = { ...schema, [ID_KEY]: key };
     const existing = this.schemaMap[key];
     if (!existing) {
       this.schemaMap[key] = identifiedSchema;
-    } else if (!isEqual5(existing, identifiedSchema)) {
+    } else if (!isEqual6(existing, identifiedSchema)) {
       console.error("existing schema:", JSON.stringify(existing, null, 2));
       console.error("new schema:", JSON.stringify(identifiedSchema, null, 2));
       throw new Error(
@@ -2349,7 +2465,7 @@ var ParserValidator = class {
    * @throws - Error when the given `rootSchema` differs from the root schema provided during construction
    */
   isValid(schema, _formData, rootSchema) {
-    if (!isEqual5(rootSchema, this.rootSchema)) {
+    if (!isEqual6(rootSchema, this.rootSchema)) {
       throw new Error("Unexpectedly calling isValid() with a rootSchema that differs from the construction rootSchema");
     }
     this.addSchema(schema, hashForSchema(schema));
@@ -2387,12 +2503,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) => isEqual6(item, schema2));
+    const sameSchemaIndex = recurseList.findIndex((item) => isEqual7(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]) {
           forEach(schema2[PROPERTIES_KEY], (value) => {
@@ -2466,6 +2583,7 @@ export {
   getFirstMatchingOption,
   getInputProps,
   getMatchingOption,
+  getOptionMatchingSimpleDiscriminator,
   getSchemaType,
   getSubmitButtonOptions,
   getTemplate,