@rjsf/utils 5.6.2 → 5.7.0

package/dist/utils.umd.development.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('lodash-es/isPlainObject'), require('lodash-es/isEqualWith'), require('lodash-es/get'), require('lodash-es/isEmpty'), require('jsonpointer'), require('lodash-es/omit'), require('lodash-es/has'), require('lodash-es/isObject'), require('lodash-es/isString'), require('lodash-es/reduce'), require('lodash-es/times'), require('lodash-es/set'), require('json-schema-merge-allof'), require('lodash-es/union'), require('lodash-es/isEqual'), require('lodash-es/cloneDeep'), require('react/jsx-runtime'), require('react'), require('react-is'), require('lodash-es/toPath')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'lodash-es/isPlainObject', 'lodash-es/isEqualWith', 'lodash-es/get', 'lodash-es/isEmpty', 'jsonpointer', 'lodash-es/omit', 'lodash-es/has', 'lodash-es/isObject', 'lodash-es/isString', 'lodash-es/reduce', 'lodash-es/times', 'lodash-es/set', 'json-schema-merge-allof', 'lodash-es/union', 'lodash-es/isEqual', 'lodash-es/cloneDeep', 'react/jsx-runtime', 'react', 'react-is', 'lodash-es/toPath'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@rjsf/utils"] = {}, global.isPlainObject, global.isEqualWith, global.get, global.isEmpty, global.jsonpointer, global.omit, global.has, global.isObject$1, global.isString, global.reduce, global.times, global.set, global.mergeAllOf, global.union, global.isEqual, global.cloneDeep, global.jsxRuntime, global.React, global.ReactIs, global.toPath));
-})(this, (function (exports, isPlainObject, isEqualWith, get, isEmpty, jsonpointer, omit, has, isObject$1, isString, reduce, times, set, mergeAllOf, union, isEqual, cloneDeep, jsxRuntime, react, ReactIs, toPath) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('lodash-es/isPlainObject'), require('lodash-es/isEqualWith'), require('lodash-es/get'), require('lodash-es/isEmpty'), require('jsonpointer'), require('lodash-es/omit'), require('lodash-es/has'), require('lodash-es/isObject'), require('lodash-es/isString'), require('lodash-es/reduce'), require('lodash-es/times'), require('lodash-es/set'), require('json-schema-merge-allof'), require('lodash-es/union'), require('lodash-es/isEqual'), require('lodash-es/cloneDeep'), require('react/jsx-runtime'), require('react'), require('react-is'), require('lodash-es/toPath'), require('lodash-es/forEach')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'lodash-es/isPlainObject', 'lodash-es/isEqualWith', 'lodash-es/get', 'lodash-es/isEmpty', 'jsonpointer', 'lodash-es/omit', 'lodash-es/has', 'lodash-es/isObject', 'lodash-es/isString', 'lodash-es/reduce', 'lodash-es/times', 'lodash-es/set', 'json-schema-merge-allof', 'lodash-es/union', 'lodash-es/isEqual', 'lodash-es/cloneDeep', 'react/jsx-runtime', 'react', 'react-is', 'lodash-es/toPath', 'lodash-es/forEach'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@rjsf/utils"] = {}, global.isPlainObject, global.isEqualWith, global.get, global.isEmpty, global.jsonpointer, global.omit, global.has, global.isObject$1, global.isString, global.reduce, global.times, global.set, global.mergeAllOf, global.union, global.isEqual, global.cloneDeep, global.jsxRuntime, global.React, global.ReactIs, global.toPath, global.forEach));
+})(this, (function (exports, isPlainObject, isEqualWith, get, isEmpty, jsonpointer, omit, has, isObject$1, isString, reduce, times, set, mergeAllOf, union, isEqual, cloneDeep, jsxRuntime, react, ReactIs, toPath, forEach) { 'use strict';
 
   function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -24,6 +24,7 @@
   var cloneDeep__default = /*#__PURE__*/_interopDefaultLegacy(cloneDeep);
   var ReactIs__default = /*#__PURE__*/_interopDefaultLegacy(ReactIs);
   var toPath__default = /*#__PURE__*/_interopDefaultLegacy(toPath);
+  var forEach__default = /*#__PURE__*/_interopDefaultLegacy(forEach);
 
   /** Determines whether a `thing` is an object for the purposes of RSJF. In this case, `thing` is an object if it has
    * the type `object` but is NOT null, an array or a File.
@@ -167,6 +168,7 @@
   var ENUM_KEY = 'enum';
   var ERRORS_KEY = '__errors';
   var ID_KEY = '$id';
+  var IF_KEY = 'if';
   var ITEMS_KEY = 'items';
   var NAME_KEY = '$name';
   var ONE_OF_KEY = 'oneOf';
@@ -424,6 +426,23 @@
     return getMatchingOption(validator, formData, options, rootSchema, discriminatorField);
   }
 
+  /** Returns the `discriminator.propertyName` when defined in the `schema` if it is a string. A warning is generated when
+   * it is not a string. Returns `undefined` when a valid discriminator is not present.
+   *
+   * @param schema - The schema from which the discriminator is potentially obtained
+   * @returns - The `discriminator.propertyName` if it exists in the schema, otherwise `undefined`
+   */
+  function getDiscriminatorFieldFromSchema(schema) {
+    var discriminator;
+    var maybeString = get__default["default"](schema, 'discriminator.propertyName', undefined);
+    if (isString__default["default"](maybeString)) {
+      discriminator = maybeString;
+    } else if (maybeString !== undefined) {
+      console.warn("Expecting discriminator to be a string, got \"" + typeof maybeString + "\" instead");
+    }
+    return discriminator;
+  }
+
   /** Given a specific `value` attempts to guess the type of a schema element. In the case where we have to implicitly
    *  create a schema, it is useful to know what type to use based on the data we are defining.
    *
@@ -513,82 +532,164 @@
     _excluded3 = ["allOf"],
     _excluded4 = ["dependencies"],
     _excluded5 = ["oneOf"];
+  /** Retrieves an expanded schema that has had all of its conditions, additional properties, references and dependencies
+   * resolved and merged into the `schema` given a `validator`, `rootSchema` and `rawFormData` that is used to do the
+   * potentially recursive resolution.
+   *
+   * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+   * @param schema - The schema for which retrieving a schema is desired
+   * @param [rootSchema={}] - The root schema that will be forwarded to all the APIs
+   * @param [rawFormData] - The current formData, if any, to assist retrieving a schema
+   * @returns - The schema having its conditions, additional properties, references and dependencies resolved
+   */
+  function retrieveSchema(validator, schema, rootSchema, rawFormData) {
+    if (rootSchema === void 0) {
+      rootSchema = {};
+    }
+    return retrieveSchemaInternal(validator, schema, rootSchema, rawFormData)[0];
+  }
   /** Resolves a conditional block (if/else/then) by removing the condition and merging the appropriate conditional branch
-   * with the rest of the schema
+   * with the rest of the schema. If `expandAllBranches` is true, then the `retrieveSchemaInteral()` results for both
+   * conditions will be returned.
    *
-   * @param validator - An implementation of the `ValidatorType<T, S>` interface that is used to detect valid schema conditions
+   * @param validator - An implementation of the `ValidatorType` interface that is used to detect valid schema conditions
    * @param schema - The schema for which resolving a condition is desired
    * @param rootSchema - The root schema that will be forwarded to all the APIs
+   * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and
+   *          dependencies as a list of schemas
    * @param [formData] - The current formData to assist retrieving a schema
-   * @returns - A schema with the appropriate condition resolved
+   * @returns - A list of schemas with the appropriate conditions resolved, possibly with all branches expanded
    */
-  function resolveCondition(validator, schema, rootSchema, formData) {
+  function resolveCondition(validator, schema, rootSchema, expandAllBranches, formData) {
     var expression = schema["if"],
       then = schema.then,
       otherwise = schema["else"],
       resolvedSchemaLessConditional = _objectWithoutPropertiesLoose(schema, _excluded$1);
-    var conditionalSchema = validator.isValid(expression, formData, rootSchema) ? then : otherwise;
-    if (conditionalSchema && typeof conditionalSchema !== 'boolean') {
-      return retrieveSchema(validator, mergeSchemas(resolvedSchemaLessConditional, retrieveSchema(validator, conditionalSchema, rootSchema, formData)), rootSchema, formData);
+    var conditionValue = validator.isValid(expression, formData, rootSchema);
+    var resolvedSchemas = [resolvedSchemaLessConditional];
+    var schemas = [];
+    if (expandAllBranches) {
+      if (then && typeof then !== 'boolean') {
+        schemas = schemas.concat(retrieveSchemaInternal(validator, then, rootSchema, formData, expandAllBranches));
+      }
+      if (otherwise && typeof otherwise !== 'boolean') {
+        schemas = schemas.concat(retrieveSchemaInternal(validator, otherwise, rootSchema, formData, expandAllBranches));
+      }
+    } else {
+      var conditionalSchema = conditionValue ? then : otherwise;
+      if (conditionalSchema && typeof conditionalSchema !== 'boolean') {
+        schemas = schemas.concat(retrieveSchemaInternal(validator, conditionalSchema, rootSchema, formData, expandAllBranches));
+      }
+    }
+    if (schemas.length) {
+      resolvedSchemas = schemas.map(function (s) {
+        return mergeSchemas(resolvedSchemaLessConditional, s);
+      });
     }
-    return retrieveSchema(validator, resolvedSchemaLessConditional, rootSchema, formData);
+    return resolvedSchemas.flatMap(function (s) {
+      return retrieveSchemaInternal(validator, s, rootSchema, formData, expandAllBranches);
+    });
+  }
+  /** Given a list of lists of allOf, anyOf or oneOf values, create a list of lists of all permutations of the values. The
+   * `listOfLists` is expected to be all resolved values of the 1st...nth schemas within an `allOf`, `anyOf` or `oneOf`.
+   * From those lists, build a matrix for each `xxxOf` where there is more than one schema for a row in the list of lists.
+   *
+   * For example:
+   * - If there are three xxxOf rows (A, B, C) and they have been resolved such that there is only one A, two B and three
+   *   C schemas then:
+   *   - The permutation for the first row is `[[A]]`
+   *   - The permutations for the second row are `[[A,B1], [A,B2]]`
+   *   - The permutations for the third row are `[[A,B1,C1], [A,B1,C2], [A,B1,C3], [A,B2,C1], [A,B2,C2], [A,B2,C3]]`
+   *
+   * @param listOfLists - The list of lists of elements that represent the allOf, anyOf or oneOf resolved values in order
+   * @returns - The list of all permutations of schemas for a set of `xxxOf`s
+   */
+  function getAllPermutationsOfXxxOf(listOfLists) {
+    var allPermutations = listOfLists.reduce(function (permutations, list) {
+      // When there are more than one set of schemas for a row, duplicate the set of permutations and add in the values
+      if (list.length > 1) {
+        return list.flatMap(function (element) {
+          return times__default["default"](permutations.length, function (i) {
+            return [].concat(permutations[i]).concat(element);
+          });
+        });
+      }
+      // Otherwise just push in the single value into the current set of permutations
+      permutations.forEach(function (permutation) {
+        return permutation.push(list[0]);
+      });
+      return permutations;
+    }, [[]] // Start with an empty list
+    );
+
+    return allPermutations;
   }
-  /** Resolves references and dependencies within a schema and its 'allOf' children.
-   * Called internally by retrieveSchema.
+  /** Resolves references and dependencies within a schema and its 'allOf' children. Passes the `expandAllBranches` flag
+   * down to the `retrieveSchemaInternal()`, `resolveReference()` and `resolveDependencies()` helper calls. If
+   * `expandAllBranches` is true, then all possible dependencies and/or allOf branches are returned.
    *
-   * @param validator - An implementation of the `ValidatorType<T, S>` interface that will be forwarded to all the APIs
+   * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
    * @param schema - The schema for which resolving a schema is desired
-   * @param [rootSchema={}] - The root schema that will be forwarded to all the APIs
+   * @param rootSchema - The root schema that will be forwarded to all the APIs
+   * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies
+   *          as a list of schemas
    * @param [formData] - The current formData, if any, to assist retrieving a schema
-   * @returns - The schema having its references and dependencies resolved
+   * @returns - The list of schemas having its references, dependencies and allOf schemas resolved
    */
-  function resolveSchema(validator, schema, rootSchema, formData) {
-    if (rootSchema === void 0) {
-      rootSchema = {};
-    }
+  function resolveSchema(validator, schema, rootSchema, expandAllBranches, formData) {
     if (REF_KEY in schema) {
-      return resolveReference(validator, schema, rootSchema, formData);
+      return resolveReference(validator, schema, rootSchema, expandAllBranches, formData);
     }
     if (DEPENDENCIES_KEY in schema) {
-      var resolvedSchema = resolveDependencies(validator, schema, rootSchema, formData);
-      return retrieveSchema(validator, resolvedSchema, rootSchema, formData);
+      var resolvedSchemas = resolveDependencies(validator, schema, rootSchema, expandAllBranches, formData);
+      return resolvedSchemas.flatMap(function (s) {
+        return retrieveSchemaInternal(validator, s, rootSchema, formData, expandAllBranches);
+      });
     }
-    if (ALL_OF_KEY in schema) {
-      return _extends({}, schema, {
-        allOf: schema.allOf.map(function (allOfSubschema) {
-          return retrieveSchema(validator, allOfSubschema, rootSchema, formData);
-        })
+    if (ALL_OF_KEY in schema && Array.isArray(schema.allOf)) {
+      var allOfSchemaElements = schema.allOf.map(function (allOfSubschema) {
+        return retrieveSchemaInternal(validator, allOfSubschema, rootSchema, formData, expandAllBranches);
+      });
+      var allPermutations = getAllPermutationsOfXxxOf(allOfSchemaElements);
+      return allPermutations.map(function (permutation) {
+        return _extends({}, schema, {
+          allOf: permutation
+        });
       });
     }
-    // No $ref or dependencies attribute found, returning the original schema.
-    return schema;
+    // No $ref or dependencies or allOf attribute was found, returning the original schema.
+    return [schema];
   }
-  /** Resolves references within a schema and its 'allOf' children.
+  /** Resolves references within a schema and then returns the `retrieveSchemaInternal()` of the resolved schema. Passes
+   * the `expandAllBranches` flag down to the `retrieveSchemaInternal()` helper call.
    *
-   * @param validator - An implementation of the `ValidatorType<T, S>` interface that will be forwarded to all the APIs
+   * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
    * @param schema - The schema for which resolving a reference is desired
    * @param rootSchema - The root schema that will be forwarded to all the APIs
+   * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies
+   *          as a list of schemas
    * @param [formData] - The current formData, if any, to assist retrieving a schema
-   * @returns - The schema having its references resolved
+   * @returns - The list schemas retrieved after having all references resolved
    */
-  function resolveReference(validator, schema, rootSchema, formData) {
-    // Retrieve the referenced schema definition.
-    var $refSchema = findSchemaDefinition(schema.$ref, rootSchema);
+  function resolveReference(validator, schema, rootSchema, expandAllBranches, formData) {
     // Drop the $ref property of the source schema.
-    var localSchema = _objectWithoutPropertiesLoose(schema, _excluded2);
+    var $ref = schema.$ref,
+      localSchema = _objectWithoutPropertiesLoose(schema, _excluded2);
+    // Retrieve the referenced schema definition.
+    var refSchema = findSchemaDefinition($ref, rootSchema);
     // Update referenced schema definition with local schema properties.
-    return retrieveSchema(validator, _extends({}, $refSchema, localSchema), rootSchema, formData);
+    return retrieveSchemaInternal(validator, _extends({}, refSchema, localSchema), rootSchema, formData, expandAllBranches);
   }
   /** Creates new 'properties' items for each key in the `formData`
    *
-   * @param validator - An implementation of the `ValidatorType<T, S>` interface that will be used when necessary
+   * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
    * @param theSchema - The schema for which the existing additional properties is desired
    * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s * @param validator
    * @param [aFormData] - The current formData, if any, to assist retrieving a schema
    * @returns - The updated schema with additional properties stubbed
    */
   function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFormData) {
-    // Clone the schema so we don't ruin the consumer's original
+    // Clone the schema so that we don't ruin the consumer's original
     var schema = _extends({}, theSchema, {
       properties: _extends({}, theSchema.properties)
     });
@@ -628,98 +729,155 @@
     });
     return schema;
   }
-  /** Retrieves an expanded schema that has had all of its conditions, additional properties, references and dependencies
-   * resolved and merged into the `schema` given a `validator`, `rootSchema` and `rawFormData` that is used to do the
-   * potentially recursive resolution.
+  /** Internal handler that retrieves an expanded schema that has had all of its conditions, additional properties,
+   * references and dependencies resolved and merged into the `schema` given a `validator`, `rootSchema` and `rawFormData`
+   * that is used to do the potentially recursive resolution. If `expandAllBranches` is true, then all possible branches
+   * of the schema and its references, conditions and dependencies are returned.
    *
-   * @param validator - An implementation of the `ValidatorType<T, S>` interface that will be forwarded to all the APIs
+   * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
    * @param schema - The schema for which retrieving a schema is desired
-   * @param [rootSchema={}] - The root schema that will be forwarded to all the APIs
+   * @param rootSchema - The root schema that will be forwarded to all the APIs
    * @param [rawFormData] - The current formData, if any, to assist retrieving a schema
-   * @returns - The schema having its conditions, additional properties, references and dependencies resolved
+   * @param [expandAllBranches=false] - Flag, if true, will return all possible branches of conditions, any/oneOf and
+   *          dependencies as a list of schemas
+   * @returns - The schema(s) resulting from having its conditions, additional properties, references and dependencies
+   *          resolved. Multiple schemas may be returned if `expandAllBranches` is true.
    */
-  function retrieveSchema(validator, schema, rootSchema, rawFormData) {
-    if (rootSchema === void 0) {
-      rootSchema = {};
+  function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expandAllBranches) {
+    if (expandAllBranches === void 0) {
+      expandAllBranches = false;
     }
     if (!isObject(schema)) {
-      return {};
+      return [{}];
     }
-    var resolvedSchema = resolveSchema(validator, schema, rootSchema, rawFormData);
-    if ('if' in schema) {
-      return resolveCondition(validator, schema, rootSchema, rawFormData);
-    }
-    var formData = rawFormData || {};
-    if (ALL_OF_KEY in schema) {
-      try {
-        resolvedSchema = mergeAllOf__default["default"](resolvedSchema, {
-          deep: false
-        });
-      } catch (e) {
-        console.warn('could not merge subschemas in allOf:\n', e);
-        var _resolvedSchema = resolvedSchema,
-          resolvedSchemaWithoutAllOf = _objectWithoutPropertiesLoose(_resolvedSchema, _excluded3);
-        return resolvedSchemaWithoutAllOf;
+    var resolvedSchemas = resolveSchema(validator, schema, rootSchema, expandAllBranches, rawFormData);
+    return resolvedSchemas.flatMap(function (s) {
+      var resolvedSchema = s;
+      if (IF_KEY in resolvedSchema) {
+        return resolveCondition(validator, resolvedSchema, rootSchema, expandAllBranches, rawFormData);
       }
+      if (ALL_OF_KEY in schema) {
+        try {
+          resolvedSchema = mergeAllOf__default["default"](s, {
+            deep: false
+          });
+        } catch (e) {
+          console.warn('could not merge subschemas in allOf:\n', e);
+          var _resolvedSchema = resolvedSchema,
+            resolvedSchemaWithoutAllOf = _objectWithoutPropertiesLoose(_resolvedSchema, _excluded3);
+          return resolvedSchemaWithoutAllOf;
+        }
+      }
+      var hasAdditionalProperties = ADDITIONAL_PROPERTIES_KEY in resolvedSchema && resolvedSchema.additionalProperties !== false;
+      if (hasAdditionalProperties) {
+        return stubExistingAdditionalProperties(validator, resolvedSchema, rootSchema, rawFormData);
+      }
+      return resolvedSchema;
+    });
+  }
+  /** Resolves an `anyOf` or `oneOf` within a schema (if present) to the list of schemas returned from
+   * `retrieveSchemaInternal()` for the best matching option. If `expandAllBranches` is true, then a list of schemas for ALL
+   * options are retrieved and returned.
+   *
+   * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+   * @param schema - The schema for which retrieving a schema is desired
+   * @param rootSchema - The root schema that will be forwarded to all the APIs
+   * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies
+   *          as a list of schemas
+   * @param [rawFormData] - The current formData, if any, to assist retrieving a schema, defaults to an empty object
+   * @returns - Either an array containing the best matching option or all options if `expandAllBranches` is true
+   */
+  function resolveAnyOrOneOfSchemas(validator, schema, rootSchema, expandAllBranches, rawFormData) {
+    var anyOrOneOf;
+    if (Array.isArray(schema.oneOf)) {
+      anyOrOneOf = schema.oneOf;
+    } else if (Array.isArray(schema.anyOf)) {
+      anyOrOneOf = schema.anyOf;
+    }
+    if (anyOrOneOf) {
+      // Ensure that during expand all branches we pass an object rather than undefined so that all options are interrogated
+      var formData = rawFormData === undefined && expandAllBranches ? {} : rawFormData;
+      var discriminator = getDiscriminatorFieldFromSchema(schema);
+      anyOrOneOf = anyOrOneOf.map(function (s) {
+        if (REF_KEY in s) {
+          // For this ref situation, don't expand all branches and just pick the first/only schema result
+          return resolveReference(validator, s, rootSchema, false, formData)[0];
+        }
+        return s;
+      });
+      // Call this to trigger the set of isValid() calls that the schema parser will need
+      var option = getFirstMatchingOption(validator, formData, anyOrOneOf, rootSchema, discriminator);
+      if (expandAllBranches) {
+        return anyOrOneOf;
+      }
+      schema = anyOrOneOf[option];
     }
-    var hasAdditionalProperties = ADDITIONAL_PROPERTIES_KEY in resolvedSchema && resolvedSchema.additionalProperties !== false;
-    if (hasAdditionalProperties) {
-      return stubExistingAdditionalProperties(validator, resolvedSchema, rootSchema, formData);
-    }
-    return resolvedSchema;
+    return [schema];
   }
-  /** Resolves dependencies within a schema and its 'allOf' children.
+  /** Resolves dependencies within a schema and its 'anyOf/oneOf' children. Passes the `expandAllBranches` flag down to
+   * the `resolveAnyOrOneOfSchema()` and `processDependencies()` helper calls.
    *
-   * @param validator - An implementation of the `ValidatorType<T, S>` interface that will be forwarded to all the APIs
+   * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
    * @param schema - The schema for which resolving a dependency is desired
    * @param rootSchema - The root schema that will be forwarded to all the APIs
+   * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies
+   *          as a list of schemas
    * @param [formData] - The current formData, if any, to assist retrieving a schema
-   * @returns - The schema with its dependencies resolved
+   * @returns - The list of schemas with their dependencies resolved
    */
-  function resolveDependencies(validator, schema, rootSchema, formData) {
+  function resolveDependencies(validator, schema, rootSchema, expandAllBranches, formData) {
     // Drop the dependencies from the source schema.
     var dependencies = schema.dependencies,
       remainingSchema = _objectWithoutPropertiesLoose(schema, _excluded4);
-    var resolvedSchema = remainingSchema;
-    if (Array.isArray(resolvedSchema.oneOf)) {
-      resolvedSchema = resolvedSchema.oneOf[getFirstMatchingOption(validator, formData, resolvedSchema.oneOf, rootSchema)];
-    } else if (Array.isArray(resolvedSchema.anyOf)) {
-      resolvedSchema = resolvedSchema.anyOf[getFirstMatchingOption(validator, formData, resolvedSchema.anyOf, rootSchema)];
-    }
-    return processDependencies(validator, dependencies, resolvedSchema, rootSchema, formData);
+    var resolvedSchemas = resolveAnyOrOneOfSchemas(validator, remainingSchema, rootSchema, expandAllBranches, formData);
+    return resolvedSchemas.flatMap(function (resolvedSchema) {
+      return processDependencies(validator, dependencies, resolvedSchema, rootSchema, expandAllBranches, formData);
+    });
   }
-  /** Processes all the `dependencies` recursively into the `resolvedSchema` as needed
+  /** Processes all the `dependencies` recursively into the list of `resolvedSchema`s as needed. Passes the
+   * `expandAllBranches` flag down to the `withDependentSchema()` and the recursive `processDependencies()` helper calls.
    *
-   * @param validator - An implementation of the `ValidatorType<T, S>` interface that will be forwarded to all the APIs
+   * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
    * @param dependencies - The set of dependencies that needs to be processed
    * @param resolvedSchema - The schema for which processing dependencies is desired
    * @param rootSchema - The root schema that will be forwarded to all the APIs
+   * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies
+   *          as a list of schemas
    * @param [formData] - The current formData, if any, to assist retrieving a schema
    * @returns - The schema with the `dependencies` resolved into it
    */
-  function processDependencies(validator, dependencies, resolvedSchema, rootSchema, formData) {
-    var schema = resolvedSchema;
+  function processDependencies(validator, dependencies, resolvedSchema, rootSchema, expandAllBranches, formData) {
+    var schemas = [resolvedSchema];
     // Process dependencies updating the local schema properties as appropriate.
-    for (var dependencyKey in dependencies) {
+    var _loop = function _loop() {
       // Skip this dependency if its trigger property is not present.
-      if (get__default["default"](formData, [dependencyKey]) === undefined) {
-        continue;
+      if (!expandAllBranches && get__default["default"](formData, [dependencyKey]) === undefined) {
+        return "continue";
       }
       // Skip this dependency if it is not included in the schema (such as when dependencyKey is itself a hidden dependency.)
-      if (schema.properties && !(dependencyKey in schema.properties)) {
-        continue;
+      if (resolvedSchema.properties && !(dependencyKey in resolvedSchema.properties)) {
+        return "continue";
       }
       var _splitKeyElementFromO = splitKeyElementFromObject(dependencyKey, dependencies),
         remainingDependencies = _splitKeyElementFromO[0],
         dependencyValue = _splitKeyElementFromO[1];
       if (Array.isArray(dependencyValue)) {
-        schema = withDependentProperties(schema, dependencyValue);
+        schemas[0] = withDependentProperties(resolvedSchema, dependencyValue);
       } else if (isObject(dependencyValue)) {
-        schema = withDependentSchema(validator, schema, rootSchema, dependencyKey, dependencyValue, formData);
+        schemas = withDependentSchema(validator, resolvedSchema, rootSchema, dependencyKey, dependencyValue, expandAllBranches, formData);
       }
-      return processDependencies(validator, remainingDependencies, schema, rootSchema, formData);
+      return {
+        v: schemas.flatMap(function (schema) {
+          return processDependencies(validator, remainingDependencies, schema, rootSchema, expandAllBranches, formData);
+        })
+      };
+    };
+    for (var dependencyKey in dependencies) {
+      var _ret = _loop();
+      if (_ret === "continue") continue;
+      if (typeof _ret === "object") return _ret.v;
     }
-    return schema;
+    return schemas;
   }
   /** Updates a schema with additionally required properties added
    *
@@ -736,45 +894,57 @@
       required: required
     });
   }
-  /** Merges a dependent schema into the `schema` dealing with oneOfs and references
+  /** Merges a dependent schema into the `schema` dealing with oneOfs and references. Passes the `expandAllBranches` flag
+   * down to the `retrieveSchemaInternal()`, `resolveReference()` and `withExactlyOneSubschema()` helper calls.
    *
-   * @param validator - An implementation of the `ValidatorType<T, S>` interface that will be forwarded to all the APIs
+   * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
    * @param schema - The schema for which resolving a dependent schema is desired
    * @param rootSchema - The root schema that will be forwarded to all the APIs
    * @param dependencyKey - The key name of the dependency
    * @param dependencyValue - The potentially dependent schema
-   * @param formData- The current formData to assist retrieving a schema
-   * @returns - The schema with the dependent schema resolved into it
-   */
-  function withDependentSchema(validator, schema, rootSchema, dependencyKey, dependencyValue, formData) {
-    var _retrieveSchema = retrieveSchema(validator, dependencyValue, rootSchema, formData),
-      oneOf = _retrieveSchema.oneOf,
-      dependentSchema = _objectWithoutPropertiesLoose(_retrieveSchema, _excluded5);
-    schema = mergeSchemas(schema, dependentSchema);
-    // Since it does not contain oneOf, we return the original schema.
-    if (oneOf === undefined) {
-      return schema;
-    }
-    // Resolve $refs inside oneOf.
-    var resolvedOneOf = oneOf.map(function (subschema) {
-      if (typeof subschema === 'boolean' || !(REF_KEY in subschema)) {
-        return subschema;
+   * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies
+   *          as a list of schemas
+   * @param [formData]- The current formData to assist retrieving a schema
+   * @returns - The list of schemas with the dependent schema resolved into them
+   */
+  function withDependentSchema(validator, schema, rootSchema, dependencyKey, dependencyValue, expandAllBranches, formData) {
+    var dependentSchemas = retrieveSchemaInternal(validator, dependencyValue, rootSchema, formData, expandAllBranches);
+    return dependentSchemas.flatMap(function (dependent) {
+      var oneOf = dependent.oneOf,
+        dependentSchema = _objectWithoutPropertiesLoose(dependent, _excluded5);
+      schema = mergeSchemas(schema, dependentSchema);
+      // Since it does not contain oneOf, we return the original schema.
+      if (oneOf === undefined) {
+        return schema;
       }
-      return resolveReference(validator, subschema, rootSchema, formData);
+      // Resolve $refs inside oneOf.
+      var resolvedOneOfs = oneOf.map(function (subschema) {
+        if (typeof subschema === 'boolean' || !(REF_KEY in subschema)) {
+          return [subschema];
+        }
+        return resolveReference(validator, subschema, rootSchema, expandAllBranches, formData);
+      });
+      var allPermutations = getAllPermutationsOfXxxOf(resolvedOneOfs);
+      return allPermutations.flatMap(function (resolvedOneOf) {
+        return withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, resolvedOneOf, expandAllBranches, formData);
+      });
     });
-    return withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, resolvedOneOf, formData);
   }
-  /** Returns a `schema` with the best choice from the `oneOf` options merged into it
+  /** Returns a list of `schema`s with the best choice from the `oneOf` options merged into it. If `expandAllBranches` is
+   * true, then a list of schemas for ALL options are retrieved and returned. Passes the `expandAllBranches` flag down to
+   * the `retrieveSchemaInternal()` helper call.
    *
-   * @param validator - An implementation of the `ValidatorType<T, S>` interface that will be used to validate oneOf options
+   * @param validator - An implementation of the `ValidatorType` interface that will be used to validate oneOf options
    * @param schema - The schema for which resolving a oneOf subschema is desired
    * @param rootSchema - The root schema that will be forwarded to all the APIs
    * @param dependencyKey - The key name of the oneOf dependency
    * @param oneOf - The list of schemas representing the oneOf options
+   * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies
+   *          as a list of schemas
    * @param [formData] - The current formData to assist retrieving a schema
-   * @returns  The schema with the best choice of oneOf schemas merged into
+   * @returns - Either an array containing the best matching option or all options if `expandAllBranches` is true
    */
-  function withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, oneOf, formData) {
+  function withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, oneOf, expandAllBranches, formData) {
     var validSubschemas = oneOf.filter(function (subschema) {
       if (typeof subschema === 'boolean' || !subschema || !subschema.properties) {
         return false;
@@ -786,21 +956,26 @@
           type: 'object',
           properties: (_properties = {}, _properties[dependencyKey] = conditionPropertySchema, _properties)
         };
-        return validator.isValid(conditionSchema, formData, rootSchema);
+        return validator.isValid(conditionSchema, formData, rootSchema) || expandAllBranches;
       }
       return false;
     });
-    if (validSubschemas.length !== 1) {
+    if (!expandAllBranches && validSubschemas.length !== 1) {
       console.warn("ignoring oneOf in dependencies because there isn't exactly one subschema that is valid");
-      return schema;
-    }
-    var subschema = validSubschemas[0];
-    var _splitKeyElementFromO2 = splitKeyElementFromObject(dependencyKey, subschema.properties),
-      dependentSubschema = _splitKeyElementFromO2[0];
-    var dependentSchema = _extends({}, subschema, {
-      properties: dependentSubschema
+      return [schema];
+    }
+    return validSubschemas.flatMap(function (s) {
+      var subschema = s;
+      var _splitKeyElementFromO2 = splitKeyElementFromObject(dependencyKey, subschema.properties),
+        dependentSubschema = _splitKeyElementFromO2[0];
+      var dependentSchema = _extends({}, subschema, {
+        properties: dependentSubschema
+      });
+      var schemas = retrieveSchemaInternal(validator, dependentSchema, rootSchema, formData, expandAllBranches);
+      return schemas.map(function (s) {
+        return mergeSchemas(schema, s);
+      });
     });
-    return mergeSchemas(schema, retrieveSchema(validator, dependentSchema, rootSchema, formData));
   }
 
   /** A junk option used to determine when the getFirstMatchingOption call really matches an option rather than returning
@@ -1124,10 +1299,11 @@
     }
     return {};
   }
-  /** Either add `computedDefault` at `key` into `obj` or not add it based on its value and the value of
-   * `includeUndefinedValues`. Generally undefined `computedDefault` values are added only when `includeUndefinedValues`
-   * is either true or "excludeObjectChildren". If `includeUndefinedValues` is false, then non-undefined and
-   * non-empty-object values will be added.
+  /** Either add `computedDefault` at `key` into `obj` or not add it based on its value, the value of
+   * `includeUndefinedValues`, the value of `emptyObjectFields` and if its parent field is required. Generally undefined
+   * `computedDefault` values are added only when `includeUndefinedValues` is either true/"excludeObjectChildren". If `
+   * includeUndefinedValues` is false and `emptyObjectFields` is not "skipDefaults", then non-undefined and non-empty-object
+   * values will be added based on certain conditions.
    *
    * @param obj - The object into which the computed default may be added
    * @param key - The key into the object at which the computed default may be added
@@ -1137,22 +1313,38 @@
    *          false when computing defaults for any nested object properties. If "allowEmptyObject", prevents undefined
    *          values in this object while allow the object itself to be empty and passing `includeUndefinedValues` as
    *          false when computing defaults for any nested object properties.
+   * @param isParentRequired - The optional boolean that indicates whether the parent field is required
    * @param requiredFields - The list of fields that are required
+   * @param experimental_defaultFormStateBehavior - Optional configuration object, if provided, allows users to override
+   *        default form state behavior
    */
-  function maybeAddDefaultToObject(obj, key, computedDefault, includeUndefinedValues, requiredFields) {
+  function maybeAddDefaultToObject(obj, key, computedDefault, includeUndefinedValues, isParentRequired, requiredFields, experimental_defaultFormStateBehavior) {
     if (requiredFields === void 0) {
       requiredFields = [];
     }
+    if (experimental_defaultFormStateBehavior === void 0) {
+      experimental_defaultFormStateBehavior = {};
+    }
+    var _experimental_default = experimental_defaultFormStateBehavior,
+      _experimental_default2 = _experimental_default.emptyObjectFields,
+      emptyObjectFields = _experimental_default2 === void 0 ? 'populateAllDefaults' : _experimental_default2;
     if (includeUndefinedValues) {
       obj[key] = computedDefault;
-    } else if (isObject(computedDefault)) {
-      // Store computedDefault if it's a non-empty object (e.g. not {})
-      if (!isEmpty__default["default"](computedDefault) || requiredFields.includes(key)) {
+    } else if (emptyObjectFields !== 'skipDefaults') {
+      if (isObject(computedDefault)) {
+        // Store computedDefault if it's a non-empty object(e.g. not {}) and satisfies certain conditions
+        // Condition 1: If computedDefault is not empty or if the key is a required field
+        // Condition 2: If the parent object is required or emptyObjectFields is not 'populateRequiredDefaults'
+        if ((!isEmpty__default["default"](computedDefault) || requiredFields.includes(key)) && (isParentRequired || emptyObjectFields !== 'populateRequiredDefaults')) {
+          obj[key] = computedDefault;
+        }
+      } else if (
+      // Store computedDefault if it's a defined primitive (e.g., true) and satisfies certain conditions
+      // Condition 1: computedDefault is not undefined
+      // Condition 2: If emptyObjectFields is 'populateAllDefaults' or if the key is a required field
+      computedDefault !== undefined && (emptyObjectFields === 'populateAllDefaults' || requiredFields.includes(key))) {
         obj[key] = computedDefault;
       }
-    } else if (computedDefault !== undefined) {
-      // Store computedDefault if it's a defined primitive (e.g. true)
-      obj[key] = computedDefault;
     }
   }
   /** Computes the defaults for the current `schema` given the `rawFormData` and `parentDefaults` if any. This drills into
@@ -1160,29 +1352,39 @@
    *
    * @param validator - an implementation of the `ValidatorType` interface that will be used when necessary
    * @param rawSchema - The schema for which the default state is desired
-   * @param [parentDefaults] - Any defaults provided by the parent field in the schema
-   * @param [rootSchema] - The options root schema, used to primarily to look up `$ref`s
-   * @param [rawFormData] - The current formData, if any, onto which to provide any missing defaults
-   * @param [includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults.
+   * @param [props] - Optional props for this function
+   * @param [props.parentDefaults] - Any defaults provided by the parent field in the schema
+   * @param [props.rootSchema] - The options root schema, used to primarily to look up `$ref`s
+   * @param [props.rawFormData] - The current formData, if any, onto which to provide any missing defaults
+   * @param [props.includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults.
    *          If "excludeObjectChildren", cause undefined values for this object and pass `includeUndefinedValues` as
    *          false when computing defaults for any nested object properties.
-   * @param [_recurseList=[]] - The list of ref names currently being recursed, used to prevent infinite recursion
+   * @param [props._recurseList=[]] - The list of ref names currently being recursed, used to prevent infinite recursion
+   * @param [props.experimental_defaultFormStateBehavior] Optional configuration object, if provided, allows users to override default form state behavior
+   * @param [props.required] - Optional flag, if true, indicates this schema was required in the parent schema.
    * @returns - The resulting `formData` with all the defaults provided
    */
-  function computeDefaults(validator, rawSchema, parentDefaults, rootSchema, rawFormData, includeUndefinedValues, _recurseList) {
-    if (rootSchema === void 0) {
-      rootSchema = {};
-    }
-    if (includeUndefinedValues === void 0) {
-      includeUndefinedValues = false;
-    }
-    if (_recurseList === void 0) {
-      _recurseList = [];
-    }
+  function computeDefaults(validator, rawSchema, _temp) {
+    var _ref = _temp === void 0 ? {} : _temp,
+      parentDefaults = _ref.parentDefaults,
+      rawFormData = _ref.rawFormData,
+      _ref$rootSchema = _ref.rootSchema,
+      rootSchema = _ref$rootSchema === void 0 ? {} : _ref$rootSchema,
+      _ref$includeUndefined = _ref.includeUndefinedValues,
+      includeUndefinedValues = _ref$includeUndefined === void 0 ? false : _ref$includeUndefined,
+      _ref$_recurseList = _ref._recurseList,
+      _recurseList = _ref$_recurseList === void 0 ? [] : _ref$_recurseList,
+      _ref$experimental_def = _ref.experimental_defaultFormStateBehavior,
+      experimental_defaultFormStateBehavior = _ref$experimental_def === void 0 ? undefined : _ref$experimental_def,
+      _ref$required = _ref.required,
+      required = _ref$required === void 0 ? false : _ref$required;
     var formData = isObject(rawFormData) ? rawFormData : {};
     var schema = isObject(rawSchema) ? rawSchema : {};
     // Compute the defaults recursively: give highest priority to deepest nodes.
     var defaults = parentDefaults;
+    // If we get a new schema, then we need to recompute defaults again for the new schema found.
+    var schemaToCompute = null;
+    var updatedRecurseList = _recurseList;
     if (isObject(defaults) && isObject(schema["default"])) {
       // For object defaults, only override parent defaults that are defined in
       // schema.default.
@@ -1193,40 +1395,68 @@
       var refName = schema[REF_KEY];
       // Use referenced schema defaults for this node.
       if (!_recurseList.includes(refName)) {
-        var refSchema = findSchemaDefinition(refName, rootSchema);
-        return computeDefaults(validator, refSchema, defaults, rootSchema, formData, includeUndefinedValues, _recurseList.concat(refName));
+        updatedRecurseList = _recurseList.concat(refName);
+        schemaToCompute = findSchemaDefinition(refName, rootSchema);
       }
     } else if (DEPENDENCIES_KEY in schema) {
-      var resolvedSchema = resolveDependencies(validator, schema, rootSchema, formData);
-      return computeDefaults(validator, resolvedSchema, defaults, rootSchema, formData, includeUndefinedValues, _recurseList);
+      var resolvedSchema = resolveDependencies(validator, schema, rootSchema, false, formData);
+      schemaToCompute = resolvedSchema[0]; // pick the first element from resolve dependencies
     } else if (isFixedItems(schema)) {
       defaults = schema.items.map(function (itemSchema, idx) {
-        return computeDefaults(validator, itemSchema, Array.isArray(parentDefaults) ? parentDefaults[idx] : undefined, rootSchema, formData, includeUndefinedValues, _recurseList);
+        return computeDefaults(validator, itemSchema, {
+          rootSchema: rootSchema,
+          includeUndefinedValues: includeUndefinedValues,
+          _recurseList: _recurseList,
+          experimental_defaultFormStateBehavior: experimental_defaultFormStateBehavior,
+          parentDefaults: Array.isArray(parentDefaults) ? parentDefaults[idx] : undefined,
+          rawFormData: formData
+        });
       });
     } else if (ONE_OF_KEY in schema) {
       if (schema.oneOf.length === 0) {
         return undefined;
       }
-      schema = schema.oneOf[getClosestMatchingOption(validator, rootSchema, isEmpty__default["default"](formData) ? undefined : formData, schema.oneOf, 0)];
+      var discriminator = getDiscriminatorFieldFromSchema(schema);
+      schemaToCompute = schema.oneOf[getClosestMatchingOption(validator, rootSchema, isEmpty__default["default"](formData) ? undefined : formData, schema.oneOf, 0, discriminator)];
     } else if (ANY_OF_KEY in schema) {
       if (schema.anyOf.length === 0) {
         return undefined;
       }
-      schema = schema.anyOf[getClosestMatchingOption(validator, rootSchema, isEmpty__default["default"](formData) ? undefined : formData, schema.anyOf, 0)];
+      var _discriminator = getDiscriminatorFieldFromSchema(schema);
+      schemaToCompute = schema.anyOf[getClosestMatchingOption(validator, rootSchema, isEmpty__default["default"](formData) ? undefined : formData, schema.anyOf, 0, _discriminator)];
+    }
+    if (schemaToCompute) {
+      return computeDefaults(validator, schemaToCompute, {
+        rootSchema: rootSchema,
+        includeUndefinedValues: includeUndefinedValues,
+        _recurseList: updatedRecurseList,
+        experimental_defaultFormStateBehavior: experimental_defaultFormStateBehavior,
+        parentDefaults: defaults,
+        rawFormData: formData
+      });
     }
-    // Not defaults defined for this node, fallback to generic typed ones.
-    if (typeof defaults === 'undefined') {
+    // No defaults defined for this node, fallback to generic typed ones.
+    if (defaults === undefined) {
       defaults = schema["default"];
     }
     switch (getSchemaType(schema)) {
-      // We need to recur for object schema inner default values.
+      // We need to recurse for object schema inner default values.
       case 'object':
         {
           var objectDefaults = Object.keys(schema.properties || {}).reduce(function (acc, key) {
+            var _schema$required;
             // Compute the defaults for this node, with the parent defaults we might
             // have from a previous run: defaults[key].
-            var computedDefault = computeDefaults(validator, get__default["default"](schema, [PROPERTIES_KEY, key]), get__default["default"](defaults, [key]), rootSchema, get__default["default"](formData, [key]), includeUndefinedValues === true, _recurseList);
-            maybeAddDefaultToObject(acc, key, computedDefault, includeUndefinedValues, schema.required);
+            var computedDefault = computeDefaults(validator, get__default["default"](schema, [PROPERTIES_KEY, key]), {
+              rootSchema: rootSchema,
+              _recurseList: _recurseList,
+              experimental_defaultFormStateBehavior: experimental_defaultFormStateBehavior,
+              includeUndefinedValues: includeUndefinedValues === true,
+              parentDefaults: get__default["default"](defaults, [key]),
+              rawFormData: get__default["default"](formData, [key]),
+              required: (_schema$required = schema.required) === null || _schema$required === void 0 ? void 0 : _schema$required.includes(key)
+            });
+            maybeAddDefaultToObject(acc, key, computedDefault, includeUndefinedValues, required, schema.required, experimental_defaultFormStateBehavior);
             return acc;
           }, {});
           if (schema.additionalProperties) {
@@ -1240,49 +1470,82 @@
                 return keys.add(key);
               });
             }
+            var formDataRequired;
             if (isObject(formData)) {
+              formDataRequired = [];
               Object.keys(formData).filter(function (key) {
                 return !schema.properties || !schema.properties[key];
               }).forEach(function (key) {
-                return keys.add(key);
+                keys.add(key);
+                formDataRequired.push(key);
               });
             }
             keys.forEach(function (key) {
-              var computedDefault = computeDefaults(validator, additionalPropertiesSchema, get__default["default"](defaults, [key]), rootSchema, get__default["default"](formData, [key]), includeUndefinedValues === true, _recurseList);
-              maybeAddDefaultToObject(objectDefaults, key, computedDefault, includeUndefinedValues);
+              var _schema$required2;
+              var computedDefault = computeDefaults(validator, additionalPropertiesSchema, {
+                rootSchema: rootSchema,
+                _recurseList: _recurseList,
+                experimental_defaultFormStateBehavior: experimental_defaultFormStateBehavior,
+                includeUndefinedValues: includeUndefinedValues === true,
+                parentDefaults: get__default["default"](defaults, [key]),
+                rawFormData: get__default["default"](formData, [key]),
+                required: (_schema$required2 = schema.required) === null || _schema$required2 === void 0 ? void 0 : _schema$required2.includes(key)
+              });
+              // Since these are additional properties we don’t need to add the `experimental_defaultFormStateBehavior` prop
+              maybeAddDefaultToObject(objectDefaults, key, computedDefault, includeUndefinedValues, required, formDataRequired);
             });
           }
           return objectDefaults;
         }
       case 'array':
-        // Inject defaults into existing array defaults
-        if (Array.isArray(defaults)) {
-          defaults = defaults.map(function (item, idx) {
-            var schemaItem = getInnerSchemaForArrayItem(schema, AdditionalItemsHandling.Fallback, idx);
-            return computeDefaults(validator, schemaItem, item, rootSchema, undefined, undefined, _recurseList);
-          });
-        }
-        // Deeply inject defaults into already existing form data
-        if (Array.isArray(rawFormData)) {
-          var schemaItem = getInnerSchemaForArrayItem(schema);
-          defaults = rawFormData.map(function (item, idx) {
-            return computeDefaults(validator, schemaItem, get__default["default"](defaults, [idx]), rootSchema, item, undefined, _recurseList);
-          });
-        }
-        if (schema.minItems) {
-          if (!isMultiSelect(validator, schema, rootSchema)) {
-            var defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
-            if (schema.minItems > defaultsLength) {
-              var defaultEntries = defaults || [];
-              // populate the array with the defaults
-              var fillerSchema = getInnerSchemaForArrayItem(schema, AdditionalItemsHandling.Invert);
-              var fillerDefault = fillerSchema["default"];
-              var fillerEntries = new Array(schema.minItems - defaultsLength).fill(computeDefaults(validator, fillerSchema, fillerDefault, rootSchema, undefined, undefined, _recurseList));
-              // then fill up the rest with either the item default or empty, up to minItems
-              return defaultEntries.concat(fillerEntries);
-            }
+        {
+          // Inject defaults into existing array defaults
+          if (Array.isArray(defaults)) {
+            defaults = defaults.map(function (item, idx) {
+              var schemaItem = getInnerSchemaForArrayItem(schema, AdditionalItemsHandling.Fallback, idx);
+              return computeDefaults(validator, schemaItem, {
+                rootSchema: rootSchema,
+                _recurseList: _recurseList,
+                experimental_defaultFormStateBehavior: experimental_defaultFormStateBehavior,
+                parentDefaults: item
+              });
+            });
           }
-          return defaults ? defaults : [];
+          // Deeply inject defaults into already existing form data
+          if (Array.isArray(rawFormData)) {
+            var schemaItem = getInnerSchemaForArrayItem(schema);
+            defaults = rawFormData.map(function (item, idx) {
+              return computeDefaults(validator, schemaItem, {
+                rootSchema: rootSchema,
+                _recurseList: _recurseList,
+                experimental_defaultFormStateBehavior: experimental_defaultFormStateBehavior,
+                rawFormData: item,
+                parentDefaults: get__default["default"](defaults, [idx])
+              });
+            });
+          }
+          var ignoreMinItemsFlagSet = (experimental_defaultFormStateBehavior === null || experimental_defaultFormStateBehavior === void 0 ? void 0 : experimental_defaultFormStateBehavior.arrayMinItems) === 'requiredOnly';
+          if (ignoreMinItemsFlagSet && !required) {
+            // If no form data exists or defaults are set leave the field empty/non-existent, otherwise
+            // return form data/defaults
+            return defaults ? defaults : undefined;
+          }
+          var defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
+          if (!schema.minItems || isMultiSelect(validator, schema, rootSchema) || schema.minItems <= defaultsLength) {
+            return defaults ? defaults : [];
+          }
+          var defaultEntries = defaults || [];
+          var fillerSchema = getInnerSchemaForArrayItem(schema, AdditionalItemsHandling.Invert);
+          var fillerDefault = fillerSchema["default"];
+          // Calculate filler entries for remaining items (minItems - existing raw data/defaults)
+          var fillerEntries = new Array(schema.minItems - defaultsLength).fill(computeDefaults(validator, fillerSchema, {
+            parentDefaults: fillerDefault,
+            rootSchema: rootSchema,
+            _recurseList: _recurseList,
+            experimental_defaultFormStateBehavior: experimental_defaultFormStateBehavior
+          }));
+          // then fill up the rest with either the item default or empty, up to minItems
+          return defaultEntries.concat(fillerEntries);
         }
     }
     return defaults;
@@ -1297,9 +1560,10 @@
    * @param [includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults.
    *          If "excludeObjectChildren", cause undefined values for this object and pass `includeUndefinedValues` as
    *          false when computing defaults for any nested object properties.
+   * @param [experimental_defaultFormStateBehavior] Optional configuration object, if provided, allows users to override default form state behavior
    * @returns - The resulting `formData` with all the defaults provided
    */
-  function getDefaultFormState(validator, theSchema, formData, rootSchema, includeUndefinedValues) {
+  function getDefaultFormState(validator, theSchema, formData, rootSchema, includeUndefinedValues, experimental_defaultFormStateBehavior) {
     if (includeUndefinedValues === void 0) {
       includeUndefinedValues = false;
     }
@@ -1307,8 +1571,13 @@
       throw new Error('Invalid schema: ' + theSchema);
     }
     var schema = retrieveSchema(validator, theSchema, rootSchema, formData);
-    var defaults = computeDefaults(validator, schema, undefined, rootSchema, formData, includeUndefinedValues);
-    if (typeof formData === 'undefined' || formData === null || typeof formData === 'number' && isNaN(formData)) {
+    var defaults = computeDefaults(validator, schema, {
+      rootSchema: rootSchema,
+      includeUndefinedValues: includeUndefinedValues,
+      experimental_defaultFormStateBehavior: experimental_defaultFormStateBehavior,
+      rawFormData: formData
+    });
+    if (formData === undefined || formData === null || typeof formData === 'number' && isNaN(formData)) {
       // No form data? Use schema defaults.
       return defaults;
     }
@@ -1678,15 +1947,12 @@
       }
     }
     var pathSchema = (_pathSchema = {}, _pathSchema[NAME_KEY] = name.replace(/^\./, ''), _pathSchema);
-    if (ONE_OF_KEY in schema) {
-      var index = getClosestMatchingOption(validator, rootSchema, formData, schema.oneOf, 0);
-      var _schema2 = schema.oneOf[index];
-      return toPathSchemaInternal(validator, _schema2, name, rootSchema, formData, _recurseList);
-    }
-    if (ANY_OF_KEY in schema) {
-      var _index = getClosestMatchingOption(validator, rootSchema, formData, schema.anyOf, 0);
-      var _schema3 = schema.anyOf[_index];
-      return toPathSchemaInternal(validator, _schema3, name, rootSchema, formData, _recurseList);
+    if (ONE_OF_KEY in schema || ANY_OF_KEY in schema) {
+      var xxxOf = ONE_OF_KEY in schema ? schema.oneOf : schema.anyOf;
+      var discriminator = getDiscriminatorFieldFromSchema(schema);
+      var index = getClosestMatchingOption(validator, rootSchema, formData, xxxOf, 0, discriminator);
+      var _schema2 = xxxOf[index];
+      pathSchema = _extends({}, pathSchema, toPathSchemaInternal(validator, _schema2, name, rootSchema, formData, _recurseList));
     }
     if (ADDITIONAL_PROPERTIES_KEY in schema && schema[ADDITIONAL_PROPERTIES_KEY] !== false) {
       set__default["default"](pathSchema, RJSF_ADDITONAL_PROPERTIES_FLAG, true);
@@ -1723,8 +1989,8 @@
   }
 
   /** The `SchemaUtils` class provides a wrapper around the publicly exported APIs in the `utils/schema` directory such
-   * that one does not have to explicitly pass the `validator` or `rootSchema` to each method. Since both the `validator`
-   * and `rootSchema` generally does not change across a `Form`, this allows for providing a simplified set of APIs to the
+   * that one does not have to explicitly pass the `validator`, `rootSchema`, or `experimental_defaultFormStateBehavior` to each method.
+   * Since these generally do not change across a `Form`, this allows for providing a simplified set of APIs to the
    * `@rjsf/core` components and the various themes as well. This class implements the `SchemaUtilsType` interface.
    */
   var SchemaUtils = /*#__PURE__*/function () {
@@ -1732,12 +1998,15 @@
      *
      * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
      * @param rootSchema - The root schema that will be forwarded to all the APIs
+     * @param experimental_defaultFormStateBehavior - Configuration flags to allow users to override default form state behavior
      */
-    function SchemaUtils(validator, rootSchema) {
+    function SchemaUtils(validator, rootSchema, experimental_defaultFormStateBehavior) {
       this.rootSchema = void 0;
       this.validator = void 0;
+      this.experimental_defaultFormStateBehavior = void 0;
       this.rootSchema = rootSchema;
       this.validator = validator;
+      this.experimental_defaultFormStateBehavior = experimental_defaultFormStateBehavior;
     }
     /** Returns the `ValidatorType` in the `SchemaUtilsType`
      *
@@ -1753,13 +2022,17 @@
      *
      * @param validator - An implementation of the `ValidatorType` interface that will be compared against the current one
      * @param rootSchema - The root schema that will be compared against the current one
+     * @param [experimental_defaultFormStateBehavior] Optional configuration object, if provided, allows users to override default form state behavior
      * @returns - True if the `SchemaUtilsType` differs from the given `validator` or `rootSchema`
      */;
-    _proto.doesSchemaUtilsDiffer = function doesSchemaUtilsDiffer(validator, rootSchema) {
+    _proto.doesSchemaUtilsDiffer = function doesSchemaUtilsDiffer(validator, rootSchema, experimental_defaultFormStateBehavior) {
+      if (experimental_defaultFormStateBehavior === void 0) {
+        experimental_defaultFormStateBehavior = {};
+      }
       if (!validator || !rootSchema) {
         return false;
       }
-      return this.validator !== validator || !deepEquals(this.rootSchema, rootSchema);
+      return this.validator !== validator || !deepEquals(this.rootSchema, rootSchema) || !deepEquals(this.experimental_defaultFormStateBehavior, experimental_defaultFormStateBehavior);
     }
     /** Returns the superset of `formData` that includes the given set updated to include any missing fields that have
      * computed to have defaults provided in the `schema`.
@@ -1775,7 +2048,7 @@
       if (includeUndefinedValues === void 0) {
         includeUndefinedValues = false;
       }
-      return getDefaultFormState(this.validator, schema, formData, this.rootSchema, includeUndefinedValues);
+      return getDefaultFormState(this.validator, schema, formData, this.rootSchema, includeUndefinedValues, this.experimental_defaultFormStateBehavior);
     }
     /** Determines whether the combination of `schema` and `uiSchema` properties indicates that the label for the `schema`
      * should be displayed in a UI.
@@ -1928,10 +2201,14 @@
    *
    * @param validator - an implementation of the `ValidatorType` interface that will be forwarded to all the APIs
    * @param rootSchema - The root schema that will be forwarded to all the APIs
+   * @param [experimental_defaultFormStateBehavior] Optional configuration object, if provided, allows users to override default form state behavior
    * @returns - An implementation of a `SchemaUtilsType` interface
    */
-  function createSchemaUtils(validator, rootSchema) {
-    return new SchemaUtils(validator, rootSchema);
+  function createSchemaUtils(validator, rootSchema, experimental_defaultFormStateBehavior) {
+    if (experimental_defaultFormStateBehavior === void 0) {
+      experimental_defaultFormStateBehavior = {};
+    }
+    return new SchemaUtils(validator, rootSchema, experimental_defaultFormStateBehavior);
   }
 
   /** Given the `FileReader.readAsDataURL()` based `dataURI` extracts that data into an actual Blob along with the name
@@ -2486,6 +2763,32 @@
     throw new Error("No widget '" + widget + "' for type '" + type + "'");
   }
 
+  /** JS has no built-in hashing function, so rolling our own
+   *  based on Java's hashing fn:
+   *  http://www.java2s.com/example/nodejs-utility-method/string-hash/hashcode-4dc2b.html
+   *
+   * @param string - The string for which to get the hash
+   * @returns - The resulting hash of the string in hex format
+   */
+  function hashString(string) {
+    var hash = 0;
+    for (var i = 0; i < string.length; i += 1) {
+      var chr = string.charCodeAt(i);
+      hash = (hash << 5) - hash + chr;
+      hash = hash & hash; // Convert to 32bit integer
+    }
+
+    return hash.toString(16);
+  }
+  /** Stringifies the schema and returns the hash of the resulting string.
+   *
+   * @param schema - The schema for which the hash is desired
+   * @returns - The string obtained from the hash of the stringified schema
+   */
+  function hashForSchema(schema) {
+    return hashString(JSON.stringify(schema));
+  }
+
   /** Detects whether the `widget` exists for the `schema` with the associated `registryWidgets` and returns true if it
    * does, or false if it doesn't.
    *
@@ -3089,6 +3392,141 @@
     TranslatableString["FilesInfo"] = "<strong>%1</strong> (%2, %3 bytes)";
   })(exports.TranslatableString || (exports.TranslatableString = {}));
 
+  /** An implementation of the `ValidatorType` interface that is designed for use in capturing schemas used by the
+   * `isValid()` function. The rest of the implementation of the interface throws errors when it is attempted to be used.
+   * An instance of the object allows the caller to capture the schemas used in calls to the `isValid()` function. These
+   * captured schema, along with the root schema used to construct the object are stored in the map of schemas keyed by
+   * the hashed value of the schema. NOTE: After hashing the schema, an $id with the hash value is added to the
+   * schema IF that schema doesn't already have an $id, prior to putting the schema into the map.
+   */
+  var ParserValidator = /*#__PURE__*/function () {
+    /** Construct the ParserValidator for the given `rootSchema`. This `rootSchema` will be stashed in the `schemaMap`
+     * first.
+     *
+     * @param rootSchema - The root schema against which this validator will be executed
+     */
+    function ParserValidator(rootSchema) {
+      /** The rootSchema provided during construction of the class */
+      this.rootSchema = void 0;
+      /** The map of schemas encountered by the ParserValidator */
+      this.schemaMap = {};
+      this.rootSchema = rootSchema;
+      this.addSchema(rootSchema, hashForSchema(rootSchema));
+    }
+    /** Adds the given `schema` to the `schemaMap` keyed by the `hash` or `ID_KEY` if present on the `schema`. If the
+     * schema does not have an `ID_KEY`, then the `hash` will be added as the `ID_KEY` to allow the schema to be
+     * associated with it's `hash` for future use (by a schema compiler).
+     *
+     * @param schema - The schema which is to be added to the map
+     * @param hash - The hash value at which to map the schema
+     */
+    var _proto = ParserValidator.prototype;
+    _proto.addSchema = function addSchema(schema, hash) {
+      var _extends2;
+      var key = get__default["default"](schema, ID_KEY, hash);
+      var identifiedSchema = _extends({}, schema, (_extends2 = {}, _extends2[ID_KEY] = key, _extends2));
+      var existing = this.schemaMap[key];
+      if (!existing) {
+        this.schemaMap[key] = identifiedSchema;
+      } else if (!isEqual__default["default"](existing, identifiedSchema)) {
+        console.error('existing schema:', JSON.stringify(existing, null, 2));
+        console.error('new schema:', JSON.stringify(identifiedSchema, null, 2));
+        throw new Error("Two different schemas exist with the same key " + key + "! What a bad coincidence. If possible, try adding an $id to one of the schemas");
+      }
+    }
+    /** Returns the current `schemaMap` to the caller
+     */;
+    _proto.getSchemaMap = function getSchemaMap() {
+      return this.schemaMap;
+    }
+    /** Implements the `ValidatorType` `isValid()` method to capture the `schema` in the `schemaMap`. Throws an error when
+     * the `rootSchema` is not the same as the root schema provided during construction.
+     *
+     * @param schema - The schema to record in the `schemaMap`
+     * @param _formData - The formData parameter that is ignored
+     * @param rootSchema - The root schema associated with the schema
+     * @throws - Error when the given `rootSchema` differs from the root schema provided during construction
+     */;
+    _proto.isValid = function isValid(schema, _formData, rootSchema) {
+      if (!isEqual__default["default"](rootSchema, this.rootSchema)) {
+        throw new Error('Unexpectedly calling isValid() with a rootSchema that differs from the construction rootSchema');
+      }
+      this.addSchema(schema, hashForSchema(schema));
+      return false;
+    }
+    /** Implements the `ValidatorType` `rawValidation()` method to throw an error since it is never supposed to be called
+     *
+     * @param _schema - The schema parameter that is ignored
+     * @param _formData - The formData parameter that is ignored
+     */;
+    _proto.rawValidation = function rawValidation(_schema, _formData) {
+      throw new Error('Unexpectedly calling the `rawValidation()` method during schema parsing');
+    }
+    /** Implements the `ValidatorType` `toErrorList()` method to throw an error since it is never supposed to be called
+     *
+     * @param _errorSchema - The error schema parameter that is ignored
+     * @param _fieldPath - The field path parameter that is ignored
+     */;
+    _proto.toErrorList = function toErrorList(_errorSchema, _fieldPath) {
+      throw new Error('Unexpectedly calling the `toErrorList()` method during schema parsing');
+    }
+    /** Implements the `ValidatorType` `validateFormData()` method to throw an error since it is never supposed to be
+     * called
+     *
+     * @param _formData - The formData parameter that is ignored
+     * @param _schema - The schema parameter that is ignored
+     * @param _customValidate - The customValidate parameter that is ignored
+     * @param _transformErrors - The transformErrors parameter that is ignored
+     * @param _uiSchema - The uiSchema parameter that is ignored
+     */;
+    _proto.validateFormData = function validateFormData(_formData, _schema, _customValidate, _transformErrors, _uiSchema) {
+      throw new Error('Unexpectedly calling the `validateFormData()` method during schema parsing');
+    };
+    return ParserValidator;
+  }();
+
+  /** Recursive function used to parse the given `schema` belonging to the `rootSchema`. The `validator` is used to
+   * capture the sub-schemas that the `isValid()` function is called with. For each schema returned by the
+   * `retrieveSchemaInternal()`, the `resolveAnyOrOneOfSchemas()` function is called. For each of the schemas returned
+   * from THAT call have `properties`, then each of the sub-schema property objects are then recursively parsed.
+   *
+   * @param validator - The `ParserValidator` implementation used to capture `isValid()` calls during parsing
+   * @param recurseList - The list of schemas returned from the `retrieveSchemaInternal`, preventing infinite recursion
+   * @param rootSchema - The root schema from which the schema parsing began
+   * @param schema - The current schema element being parsed
+   */
+  function parseSchema(validator, recurseList, rootSchema, schema) {
+    var schemas = retrieveSchemaInternal(validator, schema, rootSchema, undefined, true);
+    schemas.forEach(function (schema) {
+      var sameSchemaIndex = recurseList.findIndex(function (item) {
+        return isEqual__default["default"](item, schema);
+      });
+      if (sameSchemaIndex === -1) {
+        recurseList.push(schema);
+        var allOptions = resolveAnyOrOneOfSchemas(validator, schema, rootSchema, true);
+        allOptions.forEach(function (s) {
+          if (PROPERTIES_KEY in s && s[PROPERTIES_KEY]) {
+            forEach__default["default"](schema[PROPERTIES_KEY], function (value) {
+              parseSchema(validator, recurseList, rootSchema, value);
+            });
+          }
+        });
+      }
+    });
+  }
+  /** Parses the given `rootSchema` to extract out all the sub-schemas that maybe contained within it. Returns a map of
+   * the hash of the schema to schema/sub-schema.
+   *
+   * @param rootSchema - The root schema to parse for sub-schemas used by `isValid()` calls
+   * @returns - The `SchemaMap` of all schemas that were parsed
+   */
+  function schemaParser(rootSchema) {
+    var validator = new ParserValidator(rootSchema);
+    var recurseList = [];
+    parseSchema(validator, recurseList, rootSchema, rootSchema);
+    return validator.getSchemaMap();
+  }
+
   exports.ADDITIONAL_PROPERTIES_KEY = ADDITIONAL_PROPERTIES_KEY;
   exports.ADDITIONAL_PROPERTY_FLAG = ADDITIONAL_PROPERTY_FLAG;
   exports.ALL_OF_KEY = ALL_OF_KEY;
@@ -3101,6 +3539,7 @@
   exports.ERRORS_KEY = ERRORS_KEY;
   exports.ErrorSchemaBuilder = ErrorSchemaBuilder;
   exports.ID_KEY = ID_KEY;
+  exports.IF_KEY = IF_KEY;
   exports.ITEMS_KEY = ITEMS_KEY;
   exports.NAME_KEY = NAME_KEY;
   exports.ONE_OF_KEY = ONE_OF_KEY;
@@ -3134,6 +3573,7 @@
   exports.findSchemaDefinition = findSchemaDefinition;
   exports.getClosestMatchingOption = getClosestMatchingOption;
   exports.getDefaultFormState = getDefaultFormState;
+  exports.getDiscriminatorFieldFromSchema = getDiscriminatorFieldFromSchema;
   exports.getDisplayLabel = getDisplayLabel;
   exports.getFirstMatchingOption = getFirstMatchingOption;
   exports.getInputProps = getInputProps;
@@ -3145,6 +3585,7 @@
   exports.getWidget = getWidget;
   exports.guessType = guessType;
   exports.hasWidget = hasWidget;
+  exports.hashForSchema = hashForSchema;
   exports.helpId = helpId;
   exports.isConstant = isConstant;
   exports.isCustomWidget = isCustomWidget;
@@ -3168,6 +3609,7 @@
   exports.replaceStringParameters = replaceStringParameters;
   exports.retrieveSchema = retrieveSchema;
   exports.sanitizeDataForNewSchema = sanitizeDataForNewSchema;
+  exports.schemaParser = schemaParser;
   exports.schemaRequiresTrueValue = schemaRequiresTrueValue;
   exports.shouldRender = shouldRender;
   exports.titleId = titleId;