@rjsf/utils 5.0.0-beta.17 → 5.0.0-beta.18

package/dist/utils.esm.js

@@ -3,13 +3,17 @@ import get from 'lodash-es/get';
 import isEmpty from 'lodash-es/isEmpty';
 import jsonpointer from 'jsonpointer';
 import omit from 'lodash-es/omit';
+import has from 'lodash-es/has';
+import isObject$1 from 'lodash-es/isObject';
+import isString from 'lodash-es/isString';
+import reduce from 'lodash-es/reduce';
+import times from 'lodash-es/times';
 import set from 'lodash-es/set';
 import mergeAllOf from 'json-schema-merge-allof';
 import union from 'lodash-es/union';
 import cloneDeep from 'lodash-es/cloneDeep';
 import React from 'react';
 import ReactIs from 'react-is';
-import isString from 'lodash-es/isString';
 
 /** 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.
@@ -290,12 +294,14 @@ function findSchemaDefinition($ref, rootSchema) {
 }
 
 /** Given the `formData` and list of `options`, attempts to find the index of the option that best matches the data.
+ * Deprecated, use `getFirstMatchingOption()` instead.
  *
  * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
  * @param formData - The current formData, if any, used to figure out a match
  * @param options - The list of options to find a matching options from
  * @param rootSchema - The root schema, used to primarily to look up `$ref`s
  * @returns - The index of the matched option or 0 if none is available
+ * @deprecated
  */
 function getMatchingOption(validator, formData, options, rootSchema) {
   // For performance, skip validating subschemas if formData is undefined. We just
@@ -351,6 +357,19 @@ function getMatchingOption(validator, formData, options, rootSchema) {
   return 0;
 }
 
+/** Given the `formData` and list of `options`, attempts to find the index of the first option that matches the data.
+ * Always returns the first option if there is nothing that matches.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param formData - The current formData, if any, used to figure out a match
+ * @param options - The list of options to find a matching options from
+ * @param rootSchema - The root schema, used to primarily to look up `$ref`s
+ * @returns - The index of the first matched option or 0 if none is available
+ */
+function getFirstMatchingOption(validator, formData, options, rootSchema) {
+  return getMatchingOption(validator, formData, options, rootSchema);
+}
+
 /** 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.
  *
@@ -402,6 +421,12 @@ function getSchemaType(schema) {
   if (!type && (schema.properties || schema.additionalProperties)) {
     return "object";
   }
+  if (!type && Array.isArray(schema.oneOf) && schema.oneOf.length) {
+    return getSchemaType(schema.oneOf[0]);
+  }
+  if (!type && Array.isArray(schema.anyOf) && schema.anyOf.length) {
+    return getSchemaType(schema.anyOf[0]);
+  }
   if (Array.isArray(type) && type.length === 2 && type.includes("null")) {
     type = type.find(function (type) {
       return type !== "null";
@@ -410,99 +435,6 @@ function getSchemaType(schema) {
   return type;
 }
 
-/** Detects whether the given `schema` contains fixed items. This is the case when `schema.items` is a non-empty array
- * that only contains objects.
- *
- * @param schema - The schema in which to check for fixed items
- * @returns - True if there are fixed items in the schema, false otherwise
- */
-function isFixedItems(schema) {
-  return Array.isArray(schema.items) && schema.items.length > 0 && schema.items.every(function (item) {
-    return isObject(item);
-  });
-}
-
-/** Merges the `defaults` object of type `T` into the `formData` of type `T`
- *
- * When merging defaults and form data, we want to merge in this specific way:
- * - objects are deeply merged
- * - arrays are merged in such a way that:
- *   - when the array is set in form data, only array entries set in form data
- *     are deeply merged; additional entries from the defaults are ignored
- *   - when the array is not set in form data, the default is copied over
- * - scalars are overwritten/set by form data
- *
- * @param defaults - The defaults to merge
- * @param formData - The form data into which the defaults will be merged
- * @returns - The resulting merged form data with defaults
- */
-function mergeDefaultsWithFormData(defaults, formData) {
-  if (Array.isArray(formData)) {
-    var defaultsArray = Array.isArray(defaults) ? defaults : [];
-    var mapped = formData.map(function (value, idx) {
-      if (defaultsArray[idx]) {
-        return mergeDefaultsWithFormData(defaultsArray[idx], value);
-      }
-      return value;
-    });
-    return mapped;
-  }
-  if (isObject(formData)) {
-    var acc = Object.assign({}, defaults); // Prevent mutation of source object.
-    return Object.keys(formData).reduce(function (acc, key) {
-      acc[key] = mergeDefaultsWithFormData(defaults ? get(defaults, key) : {}, get(formData, key));
-      return acc;
-    }, acc);
-  }
-  return formData;
-}
-
-/** Recursively merge deeply nested objects.
- *
- * @param obj1 - The first object to merge
- * @param obj2 - The second object to merge
- * @param [concatArrays=false] - Optional flag that, when true, will cause arrays to be concatenated. Use
- *          "preventDuplicates" to merge arrays in a manner that prevents any duplicate entries from being merged.
- *          NOTE: Uses shallow comparison for the duplicate checking.
- * @returns - A new object that is the merge of the two given objects
- */
-function mergeObjects(obj1, obj2, concatArrays) {
-  if (concatArrays === void 0) {
-    concatArrays = false;
-  }
-  return Object.keys(obj2).reduce(function (acc, key) {
-    var left = obj1 ? obj1[key] : {},
-      right = obj2[key];
-    if (obj1 && key in obj1 && isObject(right)) {
-      acc[key] = mergeObjects(left, right, concatArrays);
-    } else if (concatArrays && Array.isArray(left) && Array.isArray(right)) {
-      var toMerge = right;
-      if (concatArrays === "preventDuplicates") {
-        toMerge = right.reduce(function (result, value) {
-          if (!left.includes(value)) {
-            result.push(value);
-          }
-          return result;
-        }, []);
-      }
-      acc[key] = left.concat(toMerge);
-    } else {
-      acc[key] = right;
-    }
-    return acc;
-  }, Object.assign({}, obj1)); // Prevent mutation of source object.
-}
-
-/** This function checks if the given `schema` matches a single constant value. This happens when either the schema has
- * an `enum` array with a single value or there is a `const` defined.
- *
- * @param schema - The schema for a field
- * @returns - True if the `schema` has a single constant value, false otherwise
- */
-function isConstant(schema) {
-  return Array.isArray(schema["enum"]) && schema["enum"].length === 1 || CONST_KEY in schema;
-}
-
 /** Recursively merge deeply nested schemas. The difference between `mergeSchemas` and `mergeObjects` is that
  * `mergeSchemas` only concats arrays for values under the 'required' keyword, and when it does, it doesn't include
  * duplicate values.
@@ -539,7 +471,7 @@ var _excluded$1 = ["if", "then", "else"],
  * @param validator - An implementation of the `ValidatorType<T, S>` 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 formData - The current formData to assist retrieving a schema
+ * @param [formData] - The current formData to assist retrieving a schema
  * @returns - A schema with the appropriate condition resolved
  */
 function resolveCondition(validator, schema, rootSchema, formData) {
@@ -627,6 +559,10 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
         }, rootSchema, formData);
       } else if ("type" in schema.additionalProperties) {
         additionalProperties = _extends({}, schema.additionalProperties);
+      } else if (ANY_OF_KEY in schema.additionalProperties || ONE_OF_KEY in schema.additionalProperties) {
+        additionalProperties = _extends({
+          type: "object"
+        }, schema.additionalProperties);
       } else {
         additionalProperties = {
           type: guessType(get(formData, [key]))
@@ -698,9 +634,9 @@ function resolveDependencies(validator, schema, rootSchema, formData) {
     remainingSchema = _objectWithoutPropertiesLoose(schema, _excluded4);
   var resolvedSchema = remainingSchema;
   if (Array.isArray(resolvedSchema.oneOf)) {
-    resolvedSchema = resolvedSchema.oneOf[getMatchingOption(validator, formData, resolvedSchema.oneOf, rootSchema)];
+    resolvedSchema = resolvedSchema.oneOf[getFirstMatchingOption(validator, formData, resolvedSchema.oneOf, rootSchema)];
   } else if (Array.isArray(resolvedSchema.anyOf)) {
-    resolvedSchema = resolvedSchema.anyOf[getMatchingOption(validator, formData, resolvedSchema.anyOf, rootSchema)];
+    resolvedSchema = resolvedSchema.anyOf[getFirstMatchingOption(validator, formData, resolvedSchema.anyOf, rootSchema)];
   }
   return processDependencies(validator, dependencies, resolvedSchema, rootSchema, formData);
 }
@@ -821,6 +757,242 @@ function withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, o
   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
+ * the first item
+ */
+var JUNK_OPTION = {
+  type: "object",
+  properties: {
+    __not_really_there__: {
+      type: "number"
+    }
+  }
+};
+/** Recursive function that calculates the score of a `formData` against the given `schema`. The computation is fairly
+ * simple. Initially the total score is 0. When `schema.properties` object exists, then all the `key/value` pairs within
+ * the object are processed as follows after obtaining the formValue from `formData` using the `key`:
+ * - If the `value` contains a `$ref`, `calculateIndexScore()` is called recursively with the formValue and the new
+ *   schema that is the result of the ref in the schema being resolved and that sub-schema's resulting score is added to
+ *   the total.
+ * - If the `value` contains a `oneOf` and there is a formValue, then score based on the index returned from calling
+ *   `getClosestMatchingOption()` of that oneOf.
+ * - If the type of the `value` is 'object', `calculateIndexScore()` is called recursively with the formValue and the
+ *   `value` itself as the sub-schema, and the score is added to the total.
+ * - If the type of the `value` matches the guessed-type of the `formValue`, the score is incremented by 1, UNLESS the
+ *   value has a `default` or `const`. In those case, if the `default` or `const` and the `formValue` match, the score
+ *   is incremented by another 1 otherwise it is decremented by 1.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param rootSchema - The root JSON schema of the entire form
+ * @param schema - The schema for which the score is being calculated
+ * @param formData - The form data associated with the schema, used to calculate the score
+ * @returns - The score a schema against the formData
+ */
+function calculateIndexScore(validator, rootSchema, schema, formData) {
+  if (formData === void 0) {
+    formData = {};
+  }
+  var totalScore = 0;
+  if (schema) {
+    if (isObject$1(schema.properties)) {
+      totalScore += reduce(schema.properties, function (score, value, key) {
+        var formValue = get(formData, key);
+        if (typeof value === "boolean") {
+          return score;
+        }
+        if (has(value, REF_KEY)) {
+          var newSchema = retrieveSchema(validator, value, rootSchema, formValue);
+          return score + calculateIndexScore(validator, rootSchema, newSchema, formValue || {});
+        }
+        if (has(value, ONE_OF_KEY) && formValue) {
+          return score + getClosestMatchingOption(validator, rootSchema, formValue, get(value, ONE_OF_KEY));
+        }
+        if (value.type === "object") {
+          return score + calculateIndexScore(validator, rootSchema, value, formValue || {});
+        }
+        if (value.type === guessType(formValue)) {
+          // If the types match, then we bump the score by one
+          var newScore = score + 1;
+          if (value["default"]) {
+            // If the schema contains a readonly default value score the value that matches the default higher and
+            // any non-matching value lower
+            newScore += formValue === value["default"] ? 1 : -1;
+          } else if (value["const"]) {
+            // If the schema contains a const value score the value that matches the default higher and
+            // any non-matching value lower
+            newScore += formValue === value["const"] ? 1 : -1;
+          }
+          // TODO eventually, deal with enums/arrays
+          return newScore;
+        }
+        return score;
+      }, 0);
+    } else if (isString(schema.type) && schema.type === guessType(formData)) {
+      totalScore += 1;
+    }
+  }
+  return totalScore;
+}
+/** Determines which of the given `options` provided most closely matches the `formData`. Using
+ * `getFirstMatchingOption()` to match two schemas that differ only by the readOnly, default or const value of a field
+ * based on the `formData` and returns 0 when there is no match. Rather than passing in all the `options` at once to
+ * this utility, instead an array of valid option indexes is created by iterating over the list of options, call
+ * `getFirstMatchingOptions` with a list of one junk option and one good option, seeing if the good option is considered
+ * matched.
+ *
+ * Once the list of valid indexes is created, if there is only one valid index, just return it. Otherwise, if there are
+ * no valid indexes, then fill the valid indexes array with the indexes of all the options. Next, the index of the
+ * option with the highest score is determined by iterating over the list of valid options, calling
+ * `calculateIndexScore()` on each, comparing it against the current best score, and returning the index of the one that
+ * eventually has the best score.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param rootSchema - The root JSON schema of the entire form
+ * @param formData - The form data associated with the schema
+ * @param options - The list of options that can be selected from
+ * @param [selectedOption=-1] - The index of the currently selected option, defaulted to -1 if not specified
+ * @returns - The index of the option that is the closest match to the `formData` or the `selectedOption` if no match
+ */
+function getClosestMatchingOption(validator, rootSchema, formData, options, selectedOption) {
+  if (selectedOption === void 0) {
+    selectedOption = -1;
+  }
+  // Reduce the array of options down to a list of the indexes that are considered matching options
+  var allValidIndexes = options.reduce(function (validList, option, index) {
+    var testOptions = [JUNK_OPTION, option];
+    var match = getFirstMatchingOption(validator, formData, testOptions, rootSchema);
+    // The match is the real option, so add its index to list of valid indexes
+    if (match === 1) {
+      validList.push(index);
+    }
+    return validList;
+  }, []);
+  // There is only one valid index, so return it!
+  if (allValidIndexes.length === 1) {
+    return allValidIndexes[0];
+  }
+  if (!allValidIndexes.length) {
+    // No indexes were valid, so we'll score all the options, add all the indexes
+    times(options.length, function (i) {
+      return allValidIndexes.push(i);
+    });
+  }
+  // Score all the options in the list of valid indexes and return the index with the best score
+  var _allValidIndexes$redu = allValidIndexes.reduce(function (scoreData, index) {
+      var bestScore = scoreData.bestScore;
+      var option = options[index];
+      if (has(option, REF_KEY)) {
+        option = retrieveSchema(validator, option, rootSchema, formData);
+      }
+      var score = calculateIndexScore(validator, rootSchema, option, formData);
+      if (score > bestScore) {
+        return {
+          bestIndex: index,
+          bestScore: score
+        };
+      }
+      return scoreData;
+    }, {
+      bestIndex: selectedOption,
+      bestScore: 0
+    }),
+    bestIndex = _allValidIndexes$redu.bestIndex;
+  return bestIndex;
+}
+
+/** Detects whether the given `schema` contains fixed items. This is the case when `schema.items` is a non-empty array
+ * that only contains objects.
+ *
+ * @param schema - The schema in which to check for fixed items
+ * @returns - True if there are fixed items in the schema, false otherwise
+ */
+function isFixedItems(schema) {
+  return Array.isArray(schema.items) && schema.items.length > 0 && schema.items.every(function (item) {
+    return isObject(item);
+  });
+}
+
+/** Merges the `defaults` object of type `T` into the `formData` of type `T`
+ *
+ * When merging defaults and form data, we want to merge in this specific way:
+ * - objects are deeply merged
+ * - arrays are merged in such a way that:
+ *   - when the array is set in form data, only array entries set in form data
+ *     are deeply merged; additional entries from the defaults are ignored
+ *   - when the array is not set in form data, the default is copied over
+ * - scalars are overwritten/set by form data
+ *
+ * @param [defaults] - The defaults to merge
+ * @param [formData] - The form data into which the defaults will be merged
+ * @returns - The resulting merged form data with defaults
+ */
+function mergeDefaultsWithFormData(defaults, formData) {
+  if (Array.isArray(formData)) {
+    var defaultsArray = Array.isArray(defaults) ? defaults : [];
+    var mapped = formData.map(function (value, idx) {
+      if (defaultsArray[idx]) {
+        return mergeDefaultsWithFormData(defaultsArray[idx], value);
+      }
+      return value;
+    });
+    return mapped;
+  }
+  if (isObject(formData)) {
+    var acc = Object.assign({}, defaults); // Prevent mutation of source object.
+    return Object.keys(formData).reduce(function (acc, key) {
+      acc[key] = mergeDefaultsWithFormData(defaults ? get(defaults, key) : {}, get(formData, key));
+      return acc;
+    }, acc);
+  }
+  return formData;
+}
+
+/** Recursively merge deeply nested objects.
+ *
+ * @param obj1 - The first object to merge
+ * @param obj2 - The second object to merge
+ * @param [concatArrays=false] - Optional flag that, when true, will cause arrays to be concatenated. Use
+ *          "preventDuplicates" to merge arrays in a manner that prevents any duplicate entries from being merged.
+ *          NOTE: Uses shallow comparison for the duplicate checking.
+ * @returns - A new object that is the merge of the two given objects
+ */
+function mergeObjects(obj1, obj2, concatArrays) {
+  if (concatArrays === void 0) {
+    concatArrays = false;
+  }
+  return Object.keys(obj2).reduce(function (acc, key) {
+    var left = obj1 ? obj1[key] : {},
+      right = obj2[key];
+    if (obj1 && key in obj1 && isObject(right)) {
+      acc[key] = mergeObjects(left, right, concatArrays);
+    } else if (concatArrays && Array.isArray(left) && Array.isArray(right)) {
+      var toMerge = right;
+      if (concatArrays === "preventDuplicates") {
+        toMerge = right.reduce(function (result, value) {
+          if (!left.includes(value)) {
+            result.push(value);
+          }
+          return result;
+        }, []);
+      }
+      acc[key] = left.concat(toMerge);
+    } else {
+      acc[key] = right;
+    }
+    return acc;
+  }, Object.assign({}, obj1)); // Prevent mutation of source object.
+}
+
+/** This function checks if the given `schema` matches a single constant value. This happens when either the schema has
+ * an `enum` array with a single value or there is a `const` defined.
+ *
+ * @param schema - The schema for a field
+ * @returns - True if the `schema` has a single constant value, false otherwise
+ */
+function isConstant(schema) {
+  return Array.isArray(schema["enum"]) && schema["enum"].length === 1 || CONST_KEY in schema;
+}
+
 /** Checks to see if the `schema` combination represents a select
  *
  * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
@@ -946,9 +1118,9 @@ function computeDefaults(validator, rawSchema, parentDefaults, rootSchema, rawFo
       return computeDefaults(validator, itemSchema, Array.isArray(parentDefaults) ? parentDefaults[idx] : undefined, rootSchema, formData, includeUndefinedValues);
     });
   } else if (ONE_OF_KEY in schema) {
-    schema = schema.oneOf[getMatchingOption(validator, isEmpty(formData) ? undefined : formData, schema.oneOf, rootSchema)];
+    schema = schema.oneOf[getClosestMatchingOption(validator, rootSchema, isEmpty(formData) ? undefined : formData, schema.oneOf, 0)];
   } else if (ANY_OF_KEY in schema) {
-    schema = schema.anyOf[getMatchingOption(validator, isEmpty(formData) ? undefined : formData, schema.anyOf, rootSchema)];
+    schema = schema.anyOf[getClosestMatchingOption(validator, rootSchema, isEmpty(formData) ? undefined : formData, schema.anyOf, 0)];
   }
   // Not defaults defined for this node, fallback to generic typed ones.
   if (typeof defaults === "undefined") {
@@ -1140,6 +1312,169 @@ function mergeValidationData(validator, validationData, additionalErrorSchema) {
   };
 }
 
+var NO_VALUE = /*#__PURE__*/Symbol("no Value");
+/** Sanitize the `data` associated with the `oldSchema` so it is considered appropriate for the `newSchema`. If the new
+ * schema does not contain any properties, then `undefined` is returned to clear all the form data. Due to the nature
+ * of schemas, this sanitization happens recursively for nested objects of data. Also, any properties in the old schema
+ * that are non-existent in the new schema are set to `undefined`. The data sanitization process has the following flow:
+ *
+ * - If the new schema is an object that contains a `properties` object then:
+ *   - Create a `removeOldSchemaData` object, setting each key in the `oldSchema.properties` having `data` to undefined
+ *   - Create an empty `nestedData` object for use in the key filtering below:
+ *   - Iterate over each key in the `newSchema.properties` as follows:
+ *     - Get the `formValue` of the key from the `data`
+ *     - Get the `oldKeySchema` and `newKeyedSchema` for the key, defaulting to `{}` when it doesn't exist
+ *     - Retrieve the schema for any refs within each `oldKeySchema` and/or `newKeySchema`
+ *     - Get the types of the old and new keyed schemas and if the old doesn't exist or the old & new are the same then:
+ *       - If `removeOldSchemaData` has an entry for the key, delete it since the new schema has the same property
+ *       - If type of the key in the new schema is `object`:
+ *         - Store the value from the recursive `sanitizeDataForNewSchema` call in `nestedData[key]`
+ *       - Otherwise, check for default or const values:
+ *         - Get the old and new `default` values from the schema and check:
+ *           - If the new `default` value does not match the form value:
+ *             - If the old `default` value DOES match the form value, then:
+ *               - Replace `removeOldSchemaData[key]` with the new `default`
+ *               - Otherwise, if the new schema is `readOnly` then replace `removeOldSchemaData[key]` with undefined
+ *         - Get the old and new `const` values from the schema and check:
+ *           - If the new `const` value does not match the form value:
+ *           - If the old `const` value DOES match the form value, then:
+ *             - Replace `removeOldSchemaData[key]` with the new `const`
+ *             - Otherwise, replace `removeOldSchemaData[key]` with undefined
+ *   - Once all keys have been processed, return an object built as follows:
+ *     - `{ ...removeOldSchemaData, ...nestedData, ...pick(data, keysToKeep) }`
+ * - If the new and old schema types are array and the `data` is an array then:
+ *   - If the type of the old and new schema `items` are a non-array objects:
+ *     - Retrieve the schema for any refs within each `oldKeySchema.items` and/or `newKeySchema.items`
+ *     - If the `type`s of both items are the same (or the old does not have a type):
+ *       - If the type is "object", then:
+ *         - For each element in the `data` recursively sanitize the data, stopping at `maxItems` if specified
+ *       - Otherwise, just return the `data` removing any values after `maxItems` if it is set
+ *   - If the type of the old and new schema `items` are booleans of the same value, return `data` as is
+ * - Otherwise return `undefined`
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param rootSchema - The root JSON schema of the entire form
+ * @param [newSchema] - The new schema for which the data is being sanitized
+ * @param [oldSchema] - The old schema from which the data originated
+ * @param [data={}] - The form data associated with the schema, defaulting to an empty object when undefined
+ * @returns - The new form data, with all the fields uniquely associated with the old schema set
+ *      to `undefined`. Will return `undefined` if the new schema is not an object containing properties.
+ */
+function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, data) {
+  if (data === void 0) {
+    data = {};
+  }
+  // By default, we will clear the form data
+  var newFormData;
+  // If the new schema is of type object and that object contains a list of properties
+  if (has(newSchema, PROPERTIES_KEY)) {
+    // Create an object containing root-level keys in the old schema, setting each key to undefined to remove the data
+    var removeOldSchemaData = {};
+    if (has(oldSchema, PROPERTIES_KEY)) {
+      var properties = get(oldSchema, PROPERTIES_KEY, {});
+      Object.keys(properties).forEach(function (key) {
+        if (has(data, key)) {
+          removeOldSchemaData[key] = undefined;
+        }
+      });
+    }
+    var keys = Object.keys(get(newSchema, PROPERTIES_KEY, {}));
+    // Create a place to store nested data that will be a side-effect of the filter
+    var nestedData = {};
+    keys.forEach(function (key) {
+      var formValue = get(data, key);
+      var oldKeyedSchema = get(oldSchema, [PROPERTIES_KEY, key], {});
+      var newKeyedSchema = get(newSchema, [PROPERTIES_KEY, key], {});
+      // Resolve the refs if they exist
+      if (has(oldKeyedSchema, REF_KEY)) {
+        oldKeyedSchema = retrieveSchema(validator, oldKeyedSchema, rootSchema, formValue);
+      }
+      if (has(newKeyedSchema, REF_KEY)) {
+        newKeyedSchema = retrieveSchema(validator, newKeyedSchema, rootSchema, formValue);
+      }
+      // Now get types and see if they are the same
+      var oldSchemaTypeForKey = get(oldKeyedSchema, "type");
+      var newSchemaTypeForKey = get(newKeyedSchema, "type");
+      // Check if the old option has the same key with the same type
+      if (!oldSchemaTypeForKey || oldSchemaTypeForKey === newSchemaTypeForKey) {
+        if (has(removeOldSchemaData, key)) {
+          // SIDE-EFFECT: remove the undefined value for a key that has the same type between the old and new schemas
+          delete removeOldSchemaData[key];
+        }
+        // If it is an object, we'll recurse and store the resulting sanitized data for the key
+        if (newSchemaTypeForKey === "object" || newSchemaTypeForKey === "array" && Array.isArray(formValue)) {
+          // SIDE-EFFECT: process the new schema type of object recursively to save iterations
+          var itemData = sanitizeDataForNewSchema(validator, rootSchema, newKeyedSchema, oldKeyedSchema, formValue);
+          if (itemData !== undefined || newSchemaTypeForKey === "array") {
+            // only put undefined values for the array type and not the object type
+            nestedData[key] = itemData;
+          }
+        } else {
+          // Ok, the non-object types match, let's make sure that a default or a const of a different value is replaced
+          // with the new default or const. This allows the case where two schemas differ that only by the default/const
+          // value to be properly selected
+          var newOptionDefault = get(newKeyedSchema, "default", NO_VALUE);
+          var oldOptionDefault = get(oldKeyedSchema, "default", NO_VALUE);
+          if (newOptionDefault !== NO_VALUE && newOptionDefault !== formValue) {
+            if (oldOptionDefault === formValue) {
+              // If the old default matches the formValue, we'll update the new value to match the new default
+              removeOldSchemaData[key] = newOptionDefault;
+            } else if (get(newKeyedSchema, "readOnly") === true) {
+              // If the new schema has the default set to read-only, treat it like a const and remove the value
+              removeOldSchemaData[key] = undefined;
+            }
+          }
+          var newOptionConst = get(newKeyedSchema, "const", NO_VALUE);
+          var oldOptionConst = get(oldKeyedSchema, "const", NO_VALUE);
+          if (newOptionConst !== NO_VALUE && newOptionConst !== formValue) {
+            // Since this is a const, if the old value matches, replace the value with the new const otherwise clear it
+            removeOldSchemaData[key] = oldOptionConst === formValue ? newOptionConst : undefined;
+          }
+        }
+      }
+    });
+    newFormData = _extends({}, data, removeOldSchemaData, nestedData);
+    // First apply removing the old schema data, then apply the nested data, then apply the old data keys to keep
+  } else if (get(oldSchema, "type") === "array" && get(newSchema, "type") === "array" && Array.isArray(data)) {
+    var oldSchemaItems = get(oldSchema, "items");
+    var newSchemaItems = get(newSchema, "items");
+    // If any of the array types `items` are arrays (remember arrays are objects) then we'll just drop the data
+    // Eventually, we may want to deal with when either of the `items` are arrays since those tuple validations
+    if (typeof oldSchemaItems === "object" && typeof newSchemaItems === "object" && !Array.isArray(oldSchemaItems) && !Array.isArray(newSchemaItems)) {
+      if (has(oldSchemaItems, REF_KEY)) {
+        oldSchemaItems = retrieveSchema(validator, oldSchemaItems, rootSchema, data);
+      }
+      if (has(newSchemaItems, REF_KEY)) {
+        newSchemaItems = retrieveSchema(validator, newSchemaItems, rootSchema, data);
+      }
+      // Now get types and see if they are the same
+      var oldSchemaType = get(oldSchemaItems, "type");
+      var newSchemaType = get(newSchemaItems, "type");
+      // Check if the old option has the same key with the same type
+      if (!oldSchemaType || oldSchemaType === newSchemaType) {
+        var maxItems = get(newSchema, "maxItems", -1);
+        if (newSchemaType === "object") {
+          newFormData = data.reduce(function (newValue, aValue) {
+            var itemValue = sanitizeDataForNewSchema(validator, rootSchema, newSchemaItems, oldSchemaItems, aValue);
+            if (itemValue !== undefined && (maxItems < 0 || newValue.length < maxItems)) {
+              newValue.push(itemValue);
+            }
+            return newValue;
+          }, []);
+        } else {
+          newFormData = maxItems > 0 && data.length > maxItems ? data.slice(0, maxItems) : data;
+        }
+      }
+    } else if (typeof oldSchemaItems === "boolean" && typeof newSchemaItems === "boolean" && oldSchemaItems === newSchemaItems) {
+      // If they are both booleans and have the same value just return the data as is otherwise fall-thru to undefined
+      newFormData = data;
+    }
+    // Also probably want to deal with `prefixItems` as tuples with the latest 2020 draft
+  }
+
+  return newFormData;
+}
+
 /** Generates an `IdSchema` object for the `schema`, recursively
  *
  * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
@@ -1285,11 +1620,37 @@ var SchemaUtils = /*#__PURE__*/function () {
   _proto.getDisplayLabel = function getDisplayLabel$1(schema, uiSchema) {
     return getDisplayLabel(this.validator, schema, uiSchema, this.rootSchema);
   }
+  /** Determines which of the given `options` provided most closely matches the `formData`.
+   * Returns the index of the option that is valid and is the closest match, or 0 if there is no match.
+   *
+   * The closest match is determined using the number of matching properties, and more heavily favors options with
+   * matching readOnly, default, or const values.
+   *
+   * @param formData - The form data associated with the schema
+   * @param options - The list of options that can be selected from
+   * @param [selectedOption] - The index of the currently selected option, defaulted to -1 if not specified
+   * @returns - The index of the option that is the closest match to the `formData` or the `selectedOption` if no match
+   */;
+  _proto.getClosestMatchingOption = function getClosestMatchingOption$1(formData, options, selectedOption) {
+    return getClosestMatchingOption(this.validator, this.rootSchema, formData, options, selectedOption);
+  }
+  /** Given the `formData` and list of `options`, attempts to find the index of the first option that matches the data.
+   * Always returns the first option if there is nothing that matches.
+   *
+   * @param formData - The current formData, if any, used to figure out a match
+   * @param options - The list of options to find a matching options from
+   * @returns - The firstindex of the matched option or 0 if none is available
+   */;
+  _proto.getFirstMatchingOption = function getFirstMatchingOption$1(formData, options) {
+    return getFirstMatchingOption(this.validator, formData, options, this.rootSchema);
+  }
   /** Given the `formData` and list of `options`, attempts to find the index of the option that best matches the data.
+   * Deprecated, use `getFirstMatchingOption()` instead.
    *
    * @param formData - The current formData, if any, onto which to provide any missing defaults
    * @param options - The list of options to find a matching options from
    * @returns - The index of the matched option or 0 if none is available
+   * @deprecated
    */;
   _proto.getMatchingOption = function getMatchingOption$1(formData, options) {
     return getMatchingOption(this.validator, formData, options, this.rootSchema);
@@ -1342,6 +1703,20 @@ var SchemaUtils = /*#__PURE__*/function () {
   _proto.retrieveSchema = function retrieveSchema$1(schema, rawFormData) {
     return retrieveSchema(this.validator, schema, this.rootSchema, rawFormData);
   }
+  /** Sanitize the `data` associated with the `oldSchema` so it is considered appropriate for the `newSchema`. If the
+   * new schema does not contain any properties, then `undefined` is returned to clear all the form data. Due to the
+   * nature of schemas, this sanitization happens recursively for nested objects of data. Also, any properties in the
+   * old schemas that are non-existent in the new schema are set to `undefined`.
+   *
+   * @param [newSchema] - The new schema for which the data is being sanitized
+   * @param [oldSchema] - The old schema from which the data originated
+   * @param [data={}] - The form data associated with the schema, defaulting to an empty object when undefined
+   * @returns - The new form data, with all the fields uniquely associated with the old schema set
+   *      to `undefined`. Will return `undefined` if the new schema is not an object containing properties.
+   */;
+  _proto.sanitizeDataForNewSchema = function sanitizeDataForNewSchema$1(newSchema, oldSchema, data) {
+    return sanitizeDataForNewSchema(this.validator, this.rootSchema, newSchema, oldSchema, data);
+  }
   /** Generates an `IdSchema` object for the `schema`, recursively
    *
    * @param schema - The schema for which the display label flag is desired
@@ -2196,5 +2571,5 @@ function utcToLocal(jsonDate) {
   return yyyy + "-" + MM + "-" + dd + "T" + hh + ":" + mm + ":" + ss + "." + SSS;
 }
 
-export { ADDITIONAL_PROPERTIES_KEY, ADDITIONAL_PROPERTY_FLAG, ALL_OF_KEY, ANY_OF_KEY, CONST_KEY, DEFAULT_KEY, DEFINITIONS_KEY, DEPENDENCIES_KEY, ENUM_KEY, ERRORS_KEY, ErrorSchemaBuilder, ID_KEY, ITEMS_KEY, NAME_KEY, ONE_OF_KEY, PROPERTIES_KEY, REF_KEY, REQUIRED_KEY, RJSF_ADDITONAL_PROPERTIES_FLAG, SUBMIT_BTN_OPTIONS_KEY, UI_FIELD_KEY, UI_OPTIONS_KEY, UI_WIDGET_KEY, allowAdditionalItems, ariaDescribedByIds, asNumber, canExpand, createSchemaUtils, dataURItoBlob, deepEquals, descriptionId, enumOptionsDeselectValue, enumOptionsSelectValue, errorId, examplesId, findSchemaDefinition, getDefaultFormState, getDisplayLabel, getInputProps, getMatchingOption, getSchemaType, getSubmitButtonOptions, getTemplate, getUiOptions, getWidget, guessType, hasWidget, helpId, isConstant, isCustomWidget, isFilesArray, isFixedItems, isMultiSelect, isObject, isSelect, localToUTC, mergeDefaultsWithFormData, mergeObjects, mergeSchemas, mergeValidationData, optionId, optionsList, orderProperties, pad, parseDateString, processSelectValue, rangeSpec, retrieveSchema, schemaRequiresTrueValue, shouldRender, titleId, toConstant, toDateString, toIdSchema, toPathSchema, utcToLocal };
+export { ADDITIONAL_PROPERTIES_KEY, ADDITIONAL_PROPERTY_FLAG, ALL_OF_KEY, ANY_OF_KEY, CONST_KEY, DEFAULT_KEY, DEFINITIONS_KEY, DEPENDENCIES_KEY, ENUM_KEY, ERRORS_KEY, ErrorSchemaBuilder, ID_KEY, ITEMS_KEY, NAME_KEY, ONE_OF_KEY, PROPERTIES_KEY, REF_KEY, REQUIRED_KEY, RJSF_ADDITONAL_PROPERTIES_FLAG, SUBMIT_BTN_OPTIONS_KEY, UI_FIELD_KEY, UI_OPTIONS_KEY, UI_WIDGET_KEY, allowAdditionalItems, ariaDescribedByIds, asNumber, canExpand, createSchemaUtils, dataURItoBlob, deepEquals, descriptionId, enumOptionsDeselectValue, enumOptionsSelectValue, errorId, examplesId, findSchemaDefinition, getClosestMatchingOption, getDefaultFormState, getDisplayLabel, getFirstMatchingOption, getInputProps, getMatchingOption, getSchemaType, getSubmitButtonOptions, getTemplate, getUiOptions, getWidget, guessType, hasWidget, helpId, isConstant, isCustomWidget, isFilesArray, isFixedItems, isMultiSelect, isObject, isSelect, localToUTC, mergeDefaultsWithFormData, mergeObjects, mergeSchemas, mergeValidationData, optionId, optionsList, orderProperties, pad, parseDateString, processSelectValue, rangeSpec, retrieveSchema, sanitizeDataForNewSchema, schemaRequiresTrueValue, shouldRender, titleId, toConstant, toDateString, toIdSchema, toPathSchema, utcToLocal };
 //# sourceMappingURL=utils.esm.js.map