@rjsf/utils 5.13.0 → 5.13.1

package/dist/utils.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('lodash/isPlainObject'), require('lodash/isEqualWith'), require('lodash/get'), require('lodash/isEmpty'), require('jsonpointer'), require('lodash/omit'), require('lodash/has'), require('lodash/isObject'), require('lodash/isString'), require('lodash/reduce'), require('lodash/times'), require('lodash/set'), require('lodash/transform'), require('json-schema-merge-allof'), require('lodash/union'), require('lodash/isEqual'), require('lodash'), require('lodash/cloneDeep'), require('react'), require('react-is'), require('react/jsx-runtime'), require('lodash/toPath'), require('lodash/forEach')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'lodash/isPlainObject', 'lodash/isEqualWith', 'lodash/get', 'lodash/isEmpty', 'jsonpointer', 'lodash/omit', 'lodash/has', 'lodash/isObject', 'lodash/isString', 'lodash/reduce', 'lodash/times', 'lodash/set', 'lodash/transform', 'json-schema-merge-allof', 'lodash/union', 'lodash/isEqual', 'lodash', 'lodash/cloneDeep', 'react', 'react-is', 'react/jsx-runtime', 'lodash/toPath', 'lodash/forEach'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@rjsf/utils"] = {}, global.isPlainObject, global.isEqualWith, global.get7, global.isEmpty, global.jsonpointer, global.omit, global.has3, global.isObject2, global.isString, global.reduce, global.times, global.set3, global.transform, global.mergeAllOf, global.union, global.isEqual3, global.lodash, global.cloneDeep, global.react, global.ReactIs, global.jsxRuntime, global.toPath, global.forEach));
-})(this, (function (exports, isPlainObject, isEqualWith, get7, isEmpty, jsonpointer, omit, has3, isObject2, isString, reduce, times, set3, transform, mergeAllOf, union, isEqual3, lodash, cloneDeep, react, ReactIs, jsxRuntime, toPath, forEach) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('lodash/isPlainObject'), require('lodash/isEqualWith'), require('lodash/get'), require('lodash/isEmpty'), require('jsonpointer'), require('lodash/omit'), require('lodash/has'), require('lodash/isNumber'), require('lodash/isObject'), require('lodash/isString'), require('lodash/reduce'), require('lodash/times'), require('lodash/isEqual'), require('lodash/set'), require('lodash/transform'), require('json-schema-merge-allof'), require('lodash/union'), require('lodash'), require('lodash/cloneDeep'), require('react'), require('react-is'), require('react/jsx-runtime'), require('lodash/toPath'), require('lodash/forEach')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'lodash/isPlainObject', 'lodash/isEqualWith', 'lodash/get', 'lodash/isEmpty', 'jsonpointer', 'lodash/omit', 'lodash/has', 'lodash/isNumber', 'lodash/isObject', 'lodash/isString', 'lodash/reduce', 'lodash/times', 'lodash/isEqual', 'lodash/set', 'lodash/transform', 'json-schema-merge-allof', 'lodash/union', 'lodash', 'lodash/cloneDeep', 'react', 'react-is', 'react/jsx-runtime', 'lodash/toPath', 'lodash/forEach'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@rjsf/utils"] = {}, global.isPlainObject, global.isEqualWith, global.get8, global.isEmpty, global.jsonpointer, global.omit, global.has3, global.isNumber, global.isObject2, global.isString, global.reduce, global.times, global.isEqual4, global.set3, global.transform, global.mergeAllOf, global.union, global.lodash, global.cloneDeep, global.react, global.ReactIs, global.jsxRuntime, global.toPath, global.forEach));
+})(this, (function (exports, isPlainObject, isEqualWith, get8, isEmpty, jsonpointer, omit, has3, isNumber, isObject2, isString, reduce, times, isEqual4, set3, transform, mergeAllOf, union, lodash, cloneDeep, react, ReactIs, jsxRuntime, toPath, forEach) { 'use strict';
 
   // src/isObject.ts
   function isObject(thing) {
@@ -162,15 +162,43 @@
     }
     return current;
   }
+  function getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField) {
+    if (formData && discriminatorField) {
+      const value = get8(formData, discriminatorField);
+      if (value === void 0) {
+        return;
+      }
+      for (let i = 0; i < options.length; i++) {
+        const option = options[i];
+        const discriminator = get8(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 && has3(option, [PROPERTIES_KEY, discriminatorField])) {
-        const value = get7(formData, discriminatorField);
-        const discriminator = get7(option, [PROPERTIES_KEY, discriminatorField], {});
+        const value = get8(formData, discriminatorField);
+        const discriminator = get8(option, [PROPERTIES_KEY, discriminatorField], {});
         if (validator.isValid(discriminator, value, rootSchema)) {
           return i;
         }
@@ -210,7 +238,7 @@
   }
   function getDiscriminatorFieldFromSchema(schema) {
     let discriminator;
-    const maybeString = get7(schema, "discriminator.propertyName", void 0);
+    const maybeString = get8(schema, "discriminator.propertyName", void 0);
     if (isString(maybeString)) {
       discriminator = maybeString;
     } else if (maybeString !== void 0) {
@@ -254,8 +282,12 @@
     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;
   }
@@ -280,7 +312,7 @@
   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];
@@ -288,19 +320,26 @@
     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
+          )
         );
       }
     }
@@ -308,7 +347,7 @@
       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) {
@@ -325,40 +364,72 @@
     );
     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 };
     }
@@ -366,16 +437,19 @@
       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 isEqual4(schema, resolvedSchema) ? schema : resolvedSchema;
   }
   function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFormData) {
     const schema = {
@@ -392,7 +466,7 @@
         if (REF_KEY in schema.additionalProperties) {
           additionalProperties = retrieveSchema(
             validator,
-            { $ref: get7(schema.additionalProperties, [REF_KEY]) },
+            { $ref: get8(schema.additionalProperties, [REF_KEY]) },
             rootSchema,
             formData
           );
@@ -404,25 +478,39 @@
             ...schema.additionalProperties
           };
         } else {
-          additionalProperties = { type: guessType(get7(formData, [key])) };
+          additionalProperties = { type: guessType(get8(formData, [key])) };
         }
       } else {
-        additionalProperties = { type: guessType(get7(formData, [key])) };
+        additionalProperties = { type: guessType(get8(formData, [key])) };
       }
       schema.properties[key] = additionalProperties;
       set3(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) {
@@ -446,7 +534,7 @@
       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)) {
@@ -458,7 +546,7 @@
       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) {
@@ -468,23 +556,32 @@
     }
     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 && get7(formData, [dependencyKey]) === void 0) {
+      if (!expandAllBranches && get8(formData, [dependencyKey]) === void 0) {
         continue;
       }
       if (resolvedSchema.properties && !(dependencyKey in resolvedSchema.properties)) {
@@ -504,11 +601,20 @@
           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;
@@ -520,13 +626,14 @@
     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;
@@ -538,7 +645,7 @@
         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(
@@ -549,12 +656,13 @@
           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;
@@ -584,7 +692,8 @@
         dependentSchema,
         rootSchema,
         formData,
-        expandAllBranches
+        expandAllBranches,
+        recurseList
       );
       return schemas.map((s2) => mergeSchemas(schema, s2));
     });
@@ -607,7 +716,7 @@
         totalScore += reduce(
           schema.properties,
           (score, value, key) => {
-            const formValue = get7(formData, key);
+            const formValue = get8(formData, key);
             if (typeof value === "boolean") {
               return score;
             }
@@ -622,7 +731,7 @@
                 validator,
                 rootSchema,
                 formValue,
-                get7(value, key2),
+                get8(value, key2),
                 -1,
                 discriminator
               );
@@ -651,8 +760,12 @@
   }
   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 (isNumber(simpleDiscriminatorMatch)) {
+      return simpleDiscriminatorMatch;
+    }
     const allValidIndexes = resolvedOptions.reduce((validList, option, index) => {
       const testOptions = [JUNK_OPTION, option];
       const match = getFirstMatchingOption(validator, formData, testOptions, rootSchema, discriminatorField);
@@ -709,8 +822,8 @@
       const acc = Object.assign({}, defaults);
       return Object.keys(formData).reduce((acc2, key) => {
         acc2[key] = mergeDefaultsWithFormData(
-          defaults ? get7(defaults, key) : {},
-          get7(formData, key),
+          defaults ? get8(defaults, key) : {},
+          get8(formData, key),
           mergeExtraArrayDefaults
         );
         return acc2;
@@ -831,7 +944,7 @@
         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(
@@ -893,13 +1006,13 @@
     switch (getSchemaType(schema)) {
       case "object": {
         const objectDefaults = Object.keys(schema.properties || {}).reduce((acc, key) => {
-          const computedDefault = computeDefaults(validator, get7(schema, [PROPERTIES_KEY, key]), {
+          const computedDefault = computeDefaults(validator, get8(schema, [PROPERTIES_KEY, key]), {
             rootSchema,
             _recurseList,
             experimental_defaultFormStateBehavior,
             includeUndefinedValues: includeUndefinedValues === true,
-            parentDefaults: get7(defaults, [key]),
-            rawFormData: get7(formData, [key]),
+            parentDefaults: get8(defaults, [key]),
+            rawFormData: get8(formData, [key]),
             required: schema.required?.includes(key)
           });
           maybeAddDefaultToObject(
@@ -919,22 +1032,19 @@
           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: get7(defaults, [key]),
-              rawFormData: get7(formData, [key]),
+              parentDefaults: get8(defaults, [key]),
+              rawFormData: get8(formData, [key]),
               required: schema.required?.includes(key)
             });
             maybeAddDefaultToObject(
@@ -975,7 +1085,7 @@
                 _recurseList,
                 experimental_defaultFormStateBehavior,
                 rawFormData: item,
-                parentDefaults: get7(defaults, [idx]),
+                parentDefaults: get8(defaults, [idx]),
                 required
               });
             });
@@ -1092,27 +1202,27 @@
     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];
@@ -1129,17 +1239,17 @@
               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;
             }
@@ -1151,9 +1261,9 @@
         ...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);
@@ -1161,10 +1271,10 @@
         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(
@@ -1192,7 +1302,7 @@
   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) => isEqual3(item, _schema));
+      const sameSchemaIndex = _recurseList.findIndex((item) => isEqual4(item, _schema));
       if (sameSchemaIndex === -1) {
         return toIdSchemaInternal(
           validator,
@@ -1206,10 +1316,10 @@
         );
       }
     }
-    if (ITEMS_KEY in schema && !get7(schema, [ITEMS_KEY, REF_KEY])) {
+    if (ITEMS_KEY in schema && !get8(schema, [ITEMS_KEY, REF_KEY])) {
       return toIdSchemaInternal(
         validator,
-        get7(schema, ITEMS_KEY),
+        get8(schema, ITEMS_KEY),
         idPrefix,
         idSeparator,
         id,
@@ -1222,7 +1332,7 @@
     const idSchema = { $id };
     if (getSchemaType(schema) === "object" && PROPERTIES_KEY in schema) {
       for (const name in schema.properties) {
-        const field = get7(schema, [PROPERTIES_KEY, name]);
+        const field = get8(schema, [PROPERTIES_KEY, name]);
         const fieldId = idSchema[ID_KEY] + idSeparator + name;
         idSchema[name] = toIdSchemaInternal(
           validator,
@@ -1233,7 +1343,7 @@
           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
-          get7(formData, [name]),
+          get8(formData, [name]),
           _recurseList
         );
       }
@@ -1246,7 +1356,7 @@
   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) => isEqual3(item, _schema));
+      const sameSchemaIndex = _recurseList.findIndex((item) => isEqual4(item, _schema));
       if (sameSchemaIndex === -1) {
         return toPathSchemaInternal(
           validator,
@@ -1287,7 +1397,7 @@
       });
     } else if (PROPERTIES_KEY in schema) {
       for (const property in schema.properties) {
-        const field = get7(schema, [PROPERTIES_KEY, property]);
+        const field = get8(schema, [PROPERTIES_KEY, property]);
         pathSchema[property] = toPathSchemaInternal(
           validator,
           field,
@@ -1295,7 +1405,7 @@
           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
-          get7(formData, [property]),
+          get8(formData, [property]),
           _recurseList
         );
       }
@@ -1573,15 +1683,15 @@
   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;
   }
   function enumOptionsIsSelected(value, selected) {
     if (Array.isArray(selected)) {
-      return selected.some((sel) => isEqual3(sel, value));
+      return selected.some((sel) => isEqual4(sel, value));
     }
-    return isEqual3(selected, value);
+    return isEqual4(selected, value);
   }
 
   // src/enumOptionsIndexForValue.ts
@@ -1628,7 +1738,7 @@
      */
     getOrCreateErrorBlock(pathOfError) {
       const hasPath = Array.isArray(pathOfError) && pathOfError.length > 0 || typeof pathOfError === "string";
-      let errorBlock = hasPath ? get7(this.errorSchema, pathOfError) : this.errorSchema;
+      let errorBlock = hasPath ? get8(this.errorSchema, pathOfError) : this.errorSchema;
       if (!errorBlock && pathOfError) {
         errorBlock = {};
         set3(this.errorSchema, pathOfError, errorBlock);
@@ -1654,7 +1764,7 @@
      */
     addErrors(errorOrList, pathOfError) {
       const errorBlock = this.getOrCreateErrorBlock(pathOfError);
-      let errorsList = get7(errorBlock, ERRORS_KEY);
+      let errorsList = get8(errorBlock, ERRORS_KEY);
       if (!Array.isArray(errorsList)) {
         errorsList = [];
         errorBlock[ERRORS_KEY] = errorsList;
@@ -1818,7 +1928,7 @@
     }
   };
   function mergeWidgetOptions(AWidget) {
-    let MergedWidget = get7(AWidget, "MergedWidget");
+    let MergedWidget = get8(AWidget, "MergedWidget");
     if (!MergedWidget) {
       const defaultOptions = AWidget.defaultProps && AWidget.defaultProps.options || {};
       MergedWidget = ({ options, ...props }) => {
@@ -2222,12 +2332,12 @@
      * @param hash - The hash value at which to map the schema
      */
     addSchema(schema, hash) {
-      const key = get7(schema, ID_KEY, hash);
+      const key = get8(schema, ID_KEY, hash);
       const identifiedSchema = { ...schema, [ID_KEY]: key };
       const existing = this.schemaMap[key];
       if (!existing) {
         this.schemaMap[key] = identifiedSchema;
-      } else if (!isEqual3(existing, identifiedSchema)) {
+      } else if (!isEqual4(existing, identifiedSchema)) {
         console.error("existing schema:", JSON.stringify(existing, null, 2));
         console.error("new schema:", JSON.stringify(identifiedSchema, null, 2));
         throw new Error(
@@ -2249,7 +2359,7 @@
      * @throws - Error when the given `rootSchema` differs from the root schema provided during construction
      */
     isValid(schema, _formData, rootSchema) {
-      if (!isEqual3(rootSchema, this.rootSchema)) {
+      if (!isEqual4(rootSchema, this.rootSchema)) {
         throw new Error("Unexpectedly calling isValid() with a rootSchema that differs from the construction rootSchema");
       }
       this.addSchema(schema, hashForSchema(schema));
@@ -2287,12 +2397,13 @@
 
   // 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) => isEqual3(item, schema2));
+      const sameSchemaIndex = recurseList.findIndex((item) => isEqual4(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) => {
@@ -2366,6 +2477,7 @@
   exports.getFirstMatchingOption = getFirstMatchingOption;
   exports.getInputProps = getInputProps;
   exports.getMatchingOption = getMatchingOption;
+  exports.getOptionMatchingSimpleDiscriminator = getOptionMatchingSimpleDiscriminator;
   exports.getSchemaType = getSchemaType;
   exports.getSubmitButtonOptions = getSubmitButtonOptions;
   exports.getTemplate = getTemplate;