@rjsf/utils 5.0.0-beta.11 → 5.0.0-beta.13

package/dist/utils.cjs.development.js

@@ -36,7 +36,6 @@ function isObject(thing) {
   if (typeof File !== "undefined" && thing instanceof File) {
     return false;
   }
-
   return typeof thing === "object" && thing !== null && !Array.isArray(thing);
 }
 
@@ -46,12 +45,10 @@ function isObject(thing) {
  * @param schema - The schema object to check
  * @returns - True if additional items is allowed, otherwise false
  */
-
 function allowAdditionalItems(schema) {
   if (schema.additionalItems === true) {
     console.warn("additionalItems=true is currently not supported");
   }
-
   return isObject(schema.additionalItems);
 }
 
@@ -68,29 +65,24 @@ function asNumber(value) {
   if (value === "") {
     return undefined;
   }
-
   if (value === null) {
     return null;
   }
-
   if (/\.$/.test(value)) {
     // '3.' can't really be considered a number even if it parses in js. The
     // user is most likely entering a float.
     return value;
   }
-
   if (/\.0$/.test(value)) {
     // we need to return this as a string here, to allow for input like 3.07
     return value;
   }
-
   if (/\.\d*0$/.test(value)) {
     // It's a number, that's cool - but we need it as a string so it doesn't screw
     // with the user when entering dollar amounts or other values (such as those with
     // specific precision or number of significant digits)
     return value;
   }
-
   const n = Number(value);
   const valid = typeof n === "number" && !Number.isNaN(n);
   return valid ? n : value;
@@ -128,29 +120,26 @@ const UI_OPTIONS_KEY = "ui:options";
  * stripped off.
  *
  * @param [uiSchema={}] - The UI Schema from which to get any `ui:xxx` options
- * @returns - An object containing all of the `ui:xxx` options with the stripped off
+ * @returns - An object containing all the `ui:xxx` options with the stripped off
  */
-
 function getUiOptions(uiSchema) {
   if (uiSchema === void 0) {
     uiSchema = {};
   }
-
   return Object.keys(uiSchema).filter(key => key.indexOf("ui:") === 0).reduce((options, key) => {
     const value = uiSchema[key];
-
     if (key === UI_WIDGET_KEY && isObject(value)) {
       console.error("Setting options via ui:widget object is no longer supported, use ui:options instead");
       return options;
     }
-
     if (key === UI_OPTIONS_KEY && isObject(value)) {
-      return { ...options,
+      return {
+        ...options,
         ...value
       };
     }
-
-    return { ...options,
+    return {
+      ...options,
       [key.substring(3)]: value
     };
   }, {});
@@ -165,30 +154,24 @@ function getUiOptions(uiSchema) {
  * @param [formData] - The formData for the field
  * @returns - True if the schema element has additionalProperties, is expandable, and not at the maxProperties limit
  */
-
 function canExpand(schema, uiSchema, formData) {
   if (uiSchema === void 0) {
     uiSchema = {};
   }
-
   if (!schema.additionalProperties) {
     return false;
   }
-
   const {
     expandable = true
   } = getUiOptions(uiSchema);
-
   if (expandable === false) {
     return expandable;
-  } // if ui:options.expandable was not explicitly set to false, we can add
+  }
+  // if ui:options.expandable was not explicitly set to false, we can add
   // another property if we have not exceeded maxProperties yet
-
-
   if (schema.maxProperties !== undefined && formData) {
     return Object.keys(formData).length < schema.maxProperties;
   }
-
   return true;
 }
 
@@ -199,7 +182,6 @@ function canExpand(schema, uiSchema, formData) {
  * @param b - The second element to compare
  * @returns - True if the `a` and `b` are deeply equal, false otherwise
  */
-
 function deepEquals(a, b) {
   return isEqualWith__default["default"](a, b, (obj, other) => {
     if (typeof obj === "function" && typeof other === "function") {
@@ -207,7 +189,6 @@ function deepEquals(a, b) {
       // see https://github.com/rjsf-team/react-jsonschema-form/issues/255
       return true;
     }
-
     return undefined; // fallback to default isEquals behavior
   });
 }
@@ -220,7 +201,6 @@ function deepEquals(a, b) {
  * @returns - An array with the first value being the object minus the `key` element and the second element being the
  *      value from `object[key]`
  */
-
 function splitKeyElementFromObject(key, object) {
   const value = object[key];
   const remaining = omit__default["default"](object, [key]);
@@ -235,40 +215,32 @@ function splitKeyElementFromObject(key, object) {
  * @returns - The sub-schema within the `rootSchema` which matches the `$ref` if it exists
  * @throws - Error indicating that no schema for that reference exists
  */
-
 function findSchemaDefinition($ref, rootSchema) {
   if (rootSchema === void 0) {
     rootSchema = {};
   }
-
   let ref = $ref || "";
-
   if (ref.startsWith("#")) {
     // Decode URI fragment representation.
     ref = decodeURIComponent(ref.substring(1));
   } else {
-    throw new Error("Could not find a definition for " + $ref + ".");
+    throw new Error(`Could not find a definition for ${$ref}.`);
   }
-
   const current = jsonpointer__default["default"].get(rootSchema, ref);
-
   if (current === undefined) {
-    throw new Error("Could not find a definition for " + $ref + ".");
+    throw new Error(`Could not find a definition for ${$ref}.`);
   }
-
   if (current[REF_KEY]) {
     const [remaining, theRef] = splitKeyElementFromObject(REF_KEY, current);
     const subSchema = findSchemaDefinition(theRef, rootSchema);
-
     if (Object.keys(remaining).length > 0) {
-      return { ...remaining,
+      return {
+        ...remaining,
         ...subSchema
       };
     }
-
     return subSchema;
   }
-
   return current;
 }
 
@@ -286,16 +258,15 @@ function getMatchingOption(validator, formData, options, rootSchema) {
   if (formData === undefined) {
     return 0;
   }
-
   for (let i = 0; i < options.length; i++) {
-    const option = options[i]; // If the schema describes an object then we need to add slightly more
+    const option = options[i];
+    // If the schema describes an object then we need to add slightly more
     // strict matching to the schema, because unless the schema uses the
     // "requires" keyword, an object will match the schema as long as it
     // doesn't have matching keys with a conflicting type. To do this we use an
     // "anyOf" with an array of requires. This augmentation expresses that the
     // schema should match if any of the keys in the schema are present on the
     // object and pass validation.
-
     if (option.properties) {
       // Create an "anyOf" schema that requires at least one of the keys in the
       // "properties" object
@@ -304,30 +275,27 @@ function getMatchingOption(validator, formData, options, rootSchema) {
           required: [key]
         }))
       };
-      let augmentedSchema; // If the "anyOf" keyword already exists, wrap the augmentation in an "allOf"
-
+      let augmentedSchema;
+      // If the "anyOf" keyword already exists, wrap the augmentation in an "allOf"
       if (option.anyOf) {
         // Create a shallow clone of the option
-        const { ...shallowClone
+        const {
+          ...shallowClone
         } = option;
-
         if (!shallowClone.allOf) {
           shallowClone.allOf = [];
         } else {
           // If "allOf" already exists, shallow clone the array
           shallowClone.allOf = shallowClone.allOf.slice();
         }
-
         shallowClone.allOf.push(requiresAnyOf);
         augmentedSchema = shallowClone;
       } else {
         augmentedSchema = Object.assign({}, option, requiresAnyOf);
-      } // Remove the "required" field as it's likely that not all fields have
+      }
+      // Remove the "required" field as it's likely that not all fields have
       // been filled in yet, which will mean that the schema is not valid
-
-
       delete augmentedSchema.required;
-
       if (validator.isValid(augmentedSchema, formData, rootSchema)) {
         return i;
       }
@@ -335,7 +303,6 @@ function getMatchingOption(validator, formData, options, rootSchema) {
       return i;
     }
   }
-
   return 0;
 }
 
@@ -349,28 +316,22 @@ function guessType(value) {
   if (Array.isArray(value)) {
     return "array";
   }
-
   if (typeof value === "string") {
     return "string";
   }
-
   if (value == null) {
     return "null";
   }
-
   if (typeof value === "boolean") {
     return "boolean";
   }
-
   if (!isNaN(value)) {
     return "number";
   }
-
   if (typeof value === "object") {
     return "object";
-  } // Default to string if we can't figure it out
-
-
+  }
+  // Default to string if we can't figure it out
   return "string";
 }
 
@@ -385,28 +346,22 @@ function guessType(value) {
  * @param schema - The schema for which to get the type
  * @returns - The type of the schema
  */
-
 function getSchemaType(schema) {
   let {
     type
   } = schema;
-
   if (!type && schema.const) {
     return guessType(schema.const);
   }
-
   if (!type && schema.enum) {
     return "string";
   }
-
   if (!type && (schema.properties || schema.additionalProperties)) {
     return "object";
   }
-
   if (Array.isArray(type) && type.length === 2 && type.includes("null")) {
     type = type.find(type => type !== "null");
   }
-
   return type;
 }
 
@@ -416,7 +371,6 @@ function getSchemaType(schema) {
  * @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(item => isObject(item));
 }
@@ -435,7 +389,6 @@ function isFixedItems(schema) {
  * @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)) {
     const defaultsArray = Array.isArray(defaults) ? defaults : [];
@@ -443,22 +396,17 @@ function mergeDefaultsWithFormData(defaults, formData) {
       if (defaultsArray[idx]) {
         return mergeDefaultsWithFormData(defaultsArray[idx], value);
       }
-
       return value;
     });
     return mapped;
   }
-
   if (isObject(formData)) {
-    // eslint-disable-next-line no-unused-vars
     const acc = Object.assign({}, defaults); // Prevent mutation of source object.
-
     return Object.keys(formData).reduce((acc, key) => {
       acc[key] = mergeDefaultsWithFormData(defaults ? get__default["default"](defaults, key) : {}, get__default["default"](formData, key));
       return acc;
     }, acc);
   }
-
   return formData;
 }
 
@@ -469,16 +417,13 @@ function mergeDefaultsWithFormData(defaults, formData) {
  * @param [concatArrays=false] - Optional flag that, when true, will cause arrays to be concatenated
  * @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((acc, key) => {
     const left = obj1 ? obj1[key] : {},
-          right = obj2[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)) {
@@ -486,7 +431,6 @@ function mergeObjects(obj1, obj2, concatArrays) {
     } else {
       acc[key] = right;
     }
-
     return acc;
   }, Object.assign({}, obj1)); // Prevent mutation of source object.
 }
@@ -497,7 +441,6 @@ function mergeObjects(obj1, obj2, concatArrays) {
  * @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;
 }
@@ -510,14 +453,11 @@ function isConstant(schema) {
  * @param obj2 - The second schema object to merge
  * @returns - The merged schema object
  */
-
 function mergeSchemas(obj1, obj2) {
   const acc = Object.assign({}, obj1); // Prevent mutation of source object.
-
   return Object.keys(obj2).reduce((acc, key) => {
     const left = obj1 ? obj1[key] : {},
-          right = obj2[key];
-
+      right = obj2[key];
     if (obj1 && key in obj1 && isObject(right)) {
       acc[key] = mergeSchemas(left, right);
     } else if (obj1 && obj2 && (getSchemaType(obj1) === "object" || getSchemaType(obj2) === "object") && key === REQUIRED_KEY && Array.isArray(left) && Array.isArray(right)) {
@@ -526,7 +466,6 @@ function mergeSchemas(obj1, obj2) {
     } else {
       acc[key] = right;
     }
-
     return acc;
   }, acc);
 }
@@ -534,13 +473,12 @@ function mergeSchemas(obj1, obj2) {
 /** Resolves a conditional block (if/else/then) by removing the condition and merging the appropriate conditional branch
  * with the rest of the schema
  *
- * @param validator - An implementation of the `ValidatorType` interface that is used to detect valid schema conditions
+ * @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
  * @returns - A schema with the appropriate condition resolved
  */
-
 function resolveCondition(validator, schema, rootSchema, formData) {
   const {
     if: expression,
@@ -549,100 +487,94 @@ function resolveCondition(validator, schema, rootSchema, formData) {
     ...resolvedSchemaLessConditional
   } = schema;
   const 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);
   }
-
   return retrieveSchema(validator, resolvedSchemaLessConditional, rootSchema, formData);
 }
 /** Resolves references and dependencies within a schema and its 'allOf' children.
  * Called internally by retrieveSchema.
  *
- * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+ * @param validator - An implementation of the `ValidatorType<T, S>` 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 [formData] - The current formData, if any, to assist retrieving a schema
  * @returns - The schema having its references and dependencies resolved
  */
-
 function resolveSchema(validator, schema, rootSchema, formData) {
   if (rootSchema === void 0) {
     rootSchema = {};
   }
-
   if (REF_KEY in schema) {
     return resolveReference(validator, schema, rootSchema, formData);
   }
-
   if (DEPENDENCIES_KEY in schema) {
     const resolvedSchema = resolveDependencies(validator, schema, rootSchema, formData);
     return retrieveSchema(validator, resolvedSchema, rootSchema, formData);
   }
-
   if (ALL_OF_KEY in schema) {
-    return { ...schema,
+    return {
+      ...schema,
       allOf: schema.allOf.map(allOfSubschema => retrieveSchema(validator, allOfSubschema, rootSchema, formData))
     };
-  } // No $ref or dependencies attribute found, returning the original schema.
-
-
+  }
+  // No $ref or dependencies attribute found, returning the original schema.
   return schema;
 }
 /** Resolves references within a schema and its 'allOf' children.
  *
- * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+ * @param validator - An implementation of the `ValidatorType<T, S>` 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 [formData] - The current formData, if any, to assist retrieving a schema
  * @returns - The schema having its references resolved
  */
-
 function resolveReference(validator, schema, rootSchema, formData) {
   // Retrieve the referenced schema definition.
-  const $refSchema = findSchemaDefinition(schema.$ref, rootSchema); // Drop the $ref property of the source schema.
-
+  const $refSchema = findSchemaDefinition(schema.$ref, rootSchema);
+  // Drop the $ref property of the source schema.
   const {
     $ref,
     ...localSchema
-  } = schema; // Update referenced schema definition with local schema properties.
-
-  return retrieveSchema(validator, { ...$refSchema,
+  } = schema;
+  // Update referenced schema definition with local schema properties.
+  return retrieveSchema(validator, {
+    ...$refSchema,
     ...localSchema
   }, rootSchema, formData);
 }
 /** Creates new 'properties' items for each key in the `formData`
  *
- * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param validator - An implementation of the `ValidatorType<T, S>` 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
-  const schema = { ...theSchema,
-    properties: { ...theSchema.properties
+  const schema = {
+    ...theSchema,
+    properties: {
+      ...theSchema.properties
     }
-  }; // make sure formData is an object
-
+  };
+  // make sure formData is an object
   const formData = aFormData && isObject(aFormData) ? aFormData : {};
   Object.keys(formData).forEach(key => {
     if (key in schema.properties) {
       // No need to stub, our schema already has the property
       return;
     }
-
     let additionalProperties = {};
-
     if (typeof schema.additionalProperties !== "boolean") {
       if (REF_KEY in schema.additionalProperties) {
         additionalProperties = retrieveSchema(validator, {
           $ref: get__default["default"](schema.additionalProperties, [REF_KEY])
         }, rootSchema, formData);
       } else if ("type" in schema.additionalProperties) {
-        additionalProperties = { ...schema.additionalProperties
+        additionalProperties = {
+          ...schema.additionalProperties
         };
       } else {
         additionalProperties = {
@@ -653,11 +585,10 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
       additionalProperties = {
         type: guessType(get__default["default"](formData, [key]))
       };
-    } // The type of our new key should match the additionalProperties value;
-
-
-    schema.properties[key] = additionalProperties; // Set our additional property flag so we know it was dynamically added
-
+    }
+    // The type of our new key should match the additionalProperties value;
+    schema.properties[key] = additionalProperties;
+    // Set our additional property flag so we know it was dynamically added
     set__default["default"](schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
   });
   return schema;
@@ -666,31 +597,26 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
  * 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 validator - An implementation of the `ValidatorType<T, S>` 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 = {};
   }
-
   if (!isObject(schema)) {
     return {};
   }
-
   let resolvedSchema = resolveSchema(validator, schema, rootSchema, rawFormData);
-
   if ("if" in schema) {
     return resolveCondition(validator, schema, rootSchema, rawFormData);
   }
-
-  const formData = rawFormData || {}; // For each level of the dependency, we need to recursively determine the appropriate resolved schema given the current state of formData.
+  const formData = rawFormData || {};
+  // For each level of the dependency, we need to recursively determine the appropriate resolved schema given the current state of formData.
   // Otherwise, nested allOf subschemas will not be correctly displayed.
-
   if (resolvedSchema.properties) {
     const properties = {};
     Object.entries(resolvedSchema.properties).forEach(entries => {
@@ -700,18 +626,18 @@ function retrieveSchema(validator, schema, rootSchema, rawFormData) {
       const propData = isObject(rawPropData) ? rawPropData : {};
       const resolvedPropSchema = retrieveSchema(validator, propSchema, rootSchema, propData);
       properties[propName] = resolvedPropSchema;
-
       if (propSchema !== resolvedPropSchema && resolvedSchema.properties !== properties) {
-        resolvedSchema = { ...resolvedSchema,
+        resolvedSchema = {
+          ...resolvedSchema,
           properties
         };
       }
     });
   }
-
   if (ALL_OF_KEY in schema) {
     try {
-      resolvedSchema = mergeAllOf__default["default"]({ ...resolvedSchema,
+      resolvedSchema = mergeAllOf__default["default"]({
+        ...resolvedSchema,
         allOf: resolvedSchema.allOf
       });
     } catch (e) {
@@ -723,24 +649,20 @@ function retrieveSchema(validator, schema, rootSchema, rawFormData) {
       return resolvedSchemaWithoutAllOf;
     }
   }
-
   const hasAdditionalProperties = ADDITIONAL_PROPERTIES_KEY in resolvedSchema && resolvedSchema.additionalProperties !== false;
-
   if (hasAdditionalProperties) {
     return stubExistingAdditionalProperties(validator, resolvedSchema, rootSchema, formData);
   }
-
   return resolvedSchema;
 }
 /** Resolves dependencies within a schema and its 'allOf' children.
  *
- * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+ * @param validator - An implementation of the `ValidatorType<T, S>` 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 [formData] - The current formData, if any, to assist retrieving a schema
  * @returns - The schema with its dependencies resolved
  */
-
 function resolveDependencies(validator, schema, rootSchema, formData) {
   // Drop the dependencies from the source schema.
   const {
@@ -748,50 +670,42 @@ function resolveDependencies(validator, schema, rootSchema, formData) {
     ...remainingSchema
   } = schema;
   let resolvedSchema = remainingSchema;
-
   if (Array.isArray(resolvedSchema.oneOf)) {
     resolvedSchema = resolvedSchema.oneOf[getMatchingOption(validator, formData, resolvedSchema.oneOf, rootSchema)];
   } else if (Array.isArray(resolvedSchema.anyOf)) {
     resolvedSchema = resolvedSchema.anyOf[getMatchingOption(validator, formData, resolvedSchema.anyOf, rootSchema)];
   }
-
   return processDependencies(validator, dependencies, resolvedSchema, rootSchema, formData);
 }
 /** Processes all the `dependencies` recursively into the `resolvedSchema` as needed
  *
- * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+ * @param validator - An implementation of the `ValidatorType<T, S>` 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 [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) {
-  let schema = resolvedSchema; // Process dependencies updating the local schema properties as appropriate.
-
+  let schema = resolvedSchema;
+  // Process dependencies updating the local schema properties as appropriate.
   for (const dependencyKey in dependencies) {
     // Skip this dependency if its trigger property is not present.
     if (get__default["default"](formData, [dependencyKey]) === undefined) {
       continue;
-    } // Skip this dependency if it is not included in the schema (such as when dependencyKey is itself a hidden dependency.)
-
-
+    }
+    // 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;
     }
-
     const [remainingDependencies, dependencyValue] = splitKeyElementFromObject(dependencyKey, dependencies);
-
     if (Array.isArray(dependencyValue)) {
       schema = withDependentProperties(schema, dependencyValue);
     } else if (isObject(dependencyValue)) {
       schema = withDependentSchema(validator, schema, rootSchema, dependencyKey, dependencyValue, formData);
     }
-
     return processDependencies(validator, remainingDependencies, schema, rootSchema, formData);
   }
-
   return schema;
 }
 /** Updates a schema with additionally required properties added
@@ -800,20 +714,19 @@ function processDependencies(validator, dependencies, resolvedSchema, rootSchema
  * @param [additionallyRequired] - An optional array of additionally required names
  * @returns - The schema with the additional required values merged in
  */
-
 function withDependentProperties(schema, additionallyRequired) {
   if (!additionallyRequired) {
     return schema;
   }
-
   const required = Array.isArray(schema.required) ? Array.from(new Set([...schema.required, ...additionallyRequired])) : additionallyRequired;
-  return { ...schema,
+  return {
+    ...schema,
     required: required
   };
 }
 /** Merges a dependent schema into the `schema` dealing with oneOfs and references
  *
- * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+ * @param validator - An implementation of the `ValidatorType<T, S>` 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
@@ -821,49 +734,43 @@ function withDependentProperties(schema, additionallyRequired) {
  * @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) {
   const {
     oneOf,
     ...dependentSchema
   } = retrieveSchema(validator, dependencyValue, rootSchema, formData);
-  schema = mergeSchemas(schema, dependentSchema); // Since it does not contain oneOf, we return the original schema.
-
+  schema = mergeSchemas(schema, dependentSchema);
+  // Since it does not contain oneOf, we return the original schema.
   if (oneOf === undefined) {
     return schema;
-  } // Resolve $refs inside oneOf.
-
-
+  }
+  // Resolve $refs inside oneOf.
   const resolvedOneOf = oneOf.map(subschema => {
     if (typeof subschema === "boolean" || !(REF_KEY in subschema)) {
       return subschema;
     }
-
     return resolveReference(validator, subschema, rootSchema, formData);
   });
   return withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, resolvedOneOf, formData);
 }
 /** Returns a `schema` with the best choice from the `oneOf` options merged into it
  *
- * @param validator - An implementation of the `ValidatorType` interface that will be used to validate oneOf options
+ * @param validator - An implementation of the `ValidatorType<T, S>` 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 [formData] - The current formData to assist retrieving a schema
- * @returns  The schema with best choice of oneOf schemas merged into
+ * @returns  The schema with the best choice of oneOf schemas merged into
  */
-
 function withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, oneOf, formData) {
   const validSubschemas = oneOf.filter(subschema => {
-    if (typeof subschema === "boolean" || !subschema.properties) {
+    if (typeof subschema === "boolean" || !subschema || !subschema.properties) {
       return false;
     }
-
     const {
       [dependencyKey]: conditionPropertySchema
     } = subschema.properties;
-
     if (conditionPropertySchema) {
       const conditionSchema = {
         type: "object",
@@ -876,18 +783,16 @@ function withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, o
       } = validator.validateFormData(formData, conditionSchema);
       return errors.length === 0;
     }
-
     return false;
   });
-
   if (validSubschemas.length !== 1) {
     console.warn("ignoring oneOf in dependencies because there isn't exactly one subschema that is valid");
     return schema;
   }
-
   const subschema = validSubschemas[0];
   const [dependentSubschema] = splitKeyElementFromObject(dependencyKey, subschema.properties);
-  const dependentSchema = { ...subschema,
+  const dependentSchema = {
+    ...subschema,
     properties: dependentSubschema
   };
   return mergeSchemas(schema, retrieveSchema(validator, dependentSchema, rootSchema, formData));
@@ -900,23 +805,18 @@ function withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, o
  * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
  * @returns - True if schema contains a select, otherwise false
  */
-
 function isSelect(validator, theSchema, rootSchema) {
   if (rootSchema === void 0) {
     rootSchema = {};
   }
-
   const schema = retrieveSchema(validator, theSchema, rootSchema, undefined);
   const altSchemas = schema.oneOf || schema.anyOf;
-
   if (Array.isArray(schema.enum)) {
     return true;
   }
-
   if (Array.isArray(altSchemas)) {
     return altSchemas.every(altSchemas => typeof altSchemas !== "boolean" && isConstant(altSchemas));
   }
-
   return false;
 }
 
@@ -927,20 +827,16 @@ function isSelect(validator, theSchema, rootSchema) {
  * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
  * @returns - True if schema contains a multi-select, otherwise false
  */
-
 function isMultiSelect(validator, schema, rootSchema) {
   if (!schema.uniqueItems || !schema.items || typeof schema.items === "boolean") {
     return false;
   }
-
   return isSelect(validator, schema.items, rootSchema);
 }
 
 /** Enum that indicates how `schema.additionalItems` should be handled by the `getInnerSchemaForArrayItem()` function.
  */
-
 var AdditionalItemsHandling;
-
 (function (AdditionalItemsHandling) {
   AdditionalItemsHandling[AdditionalItemsHandling["Ignore"] = 0] = "Ignore";
   AdditionalItemsHandling[AdditionalItemsHandling["Invert"] = 1] = "Invert";
@@ -961,21 +857,16 @@ var AdditionalItemsHandling;
  * @param [idx=-1] - Index, if non-negative, will be used to return the idx-th element in a `schema.items` array
  * @returns - The best fit schema object from the `schema` given the `additionalItems` and `idx` modifiers
  */
-
-
 function getInnerSchemaForArrayItem(schema, additionalItems, idx) {
   if (additionalItems === void 0) {
     additionalItems = AdditionalItemsHandling.Ignore;
   }
-
   if (idx === void 0) {
     idx = -1;
   }
-
   if (idx >= 0) {
     if (Array.isArray(schema.items) && idx < schema.items.length) {
       const item = schema.items[idx];
-
       if (typeof item !== "boolean") {
         return item;
       }
@@ -983,11 +874,9 @@ function getInnerSchemaForArrayItem(schema, additionalItems, idx) {
   } else if (schema.items && !Array.isArray(schema.items) && typeof schema.items !== "boolean") {
     return schema.items;
   }
-
   if (additionalItems !== AdditionalItemsHandling.Ignore && isObject(schema.additionalItems)) {
     return schema.additionalItems;
   }
-
   return {};
 }
 /** Computes the defaults for the current `schema` given the `rawFormData` and `parentDefaults` if any. This drills into
@@ -1001,20 +890,16 @@ function getInnerSchemaForArrayItem(schema, additionalItems, idx) {
  * @param [includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults
  * @returns - The resulting `formData` with all the defaults provided
  */
-
 function computeDefaults(validator, schema, parentDefaults, rootSchema, rawFormData, includeUndefinedValues) {
   if (rootSchema === void 0) {
     rootSchema = {};
   }
-
   if (includeUndefinedValues === void 0) {
     includeUndefinedValues = false;
   }
-
-  const formData = isObject(rawFormData) ? rawFormData : {}; // Compute the defaults recursively: give highest priority to deepest nodes.
-
+  const formData = isObject(rawFormData) ? rawFormData : {};
+  // Compute the defaults recursively: give highest priority to deepest nodes.
   let defaults = parentDefaults;
-
   if (isObject(defaults) && isObject(schema.default)) {
     // For object defaults, only override parent defaults that are defined in
     // schema.default.
@@ -1034,13 +919,11 @@ function computeDefaults(validator, schema, parentDefaults, rootSchema, rawFormD
     schema = schema.oneOf[getMatchingOption(validator, isEmpty__default["default"](formData) ? undefined : formData, schema.oneOf, rootSchema)];
   } else if (ANY_OF_KEY in schema) {
     schema = schema.anyOf[getMatchingOption(validator, isEmpty__default["default"](formData) ? undefined : formData, schema.anyOf, rootSchema)];
-  } // Not defaults defined for this node, fallback to generic typed ones.
-
-
+  }
+  // Not defaults defined for this node, fallback to generic typed ones.
   if (typeof defaults === "undefined") {
     defaults = schema.default;
   }
-
   switch (getSchemaType(schema)) {
     // We need to recur for object schema inner default values.
     case "object":
@@ -1048,14 +931,11 @@ function computeDefaults(validator, schema, parentDefaults, rootSchema, rawFormD
         // Compute the defaults for this node, with the parent defaults we might
         // have from a previous run: defaults[key].
         const computedDefault = computeDefaults(validator, get__default["default"](schema, [PROPERTIES_KEY, key]), get__default["default"](defaults, [key]), rootSchema, get__default["default"](formData, [key]), includeUndefinedValues);
-
         if (includeUndefinedValues || computedDefault !== undefined) {
           acc[key] = computedDefault;
         }
-
         return acc;
       }, {});
-
     case "array":
       // Inject defaults into existing array defaults
       if (Array.isArray(defaults)) {
@@ -1063,36 +943,30 @@ function computeDefaults(validator, schema, parentDefaults, rootSchema, rawFormD
           const schemaItem = getInnerSchemaForArrayItem(schema, AdditionalItemsHandling.Fallback, idx);
           return computeDefaults(validator, schemaItem, item, rootSchema);
         });
-      } // Deeply inject defaults into already existing form data
-
-
+      }
+      // Deeply inject defaults into already existing form data
       if (Array.isArray(rawFormData)) {
         const schemaItem = getInnerSchemaForArrayItem(schema);
         defaults = rawFormData.map((item, idx) => {
           return computeDefaults(validator, schemaItem, get__default["default"](defaults, [idx]), rootSchema, item);
         });
       }
-
       if (schema.minItems) {
         if (!isMultiSelect(validator, schema, rootSchema)) {
           const defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
-
           if (schema.minItems > defaultsLength) {
-            const defaultEntries = defaults || []; // populate the array with the defaults
-
+            const defaultEntries = defaults || [];
+            // populate the array with the defaults
             const fillerSchema = getInnerSchemaForArrayItem(schema, AdditionalItemsHandling.Invert);
             const fillerDefault = fillerSchema.default;
-            const fillerEntries = new Array(schema.minItems - defaultsLength).fill(computeDefaults(validator, fillerSchema, fillerDefault, rootSchema)); // then fill up the rest with either the item default or empty, up to minItems
-
+            const fillerEntries = new Array(schema.minItems - defaultsLength).fill(computeDefaults(validator, fillerSchema, fillerDefault, rootSchema));
+            // then fill up the rest with either the item default or empty, up to minItems
             return defaultEntries.concat(fillerEntries);
           }
         }
-
         return defaults ? defaults : [];
       }
-
   }
-
   return defaults;
 }
 /** Returns the superset of `formData` that includes the given set updated to include any missing fields that have
@@ -1105,32 +979,25 @@ function computeDefaults(validator, schema, parentDefaults, rootSchema, rawFormD
  * @param [includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults
  * @returns - The resulting `formData` with all the defaults provided
  */
-
 function getDefaultFormState(validator, theSchema, formData, rootSchema, includeUndefinedValues) {
   if (includeUndefinedValues === void 0) {
     includeUndefinedValues = false;
   }
-
   if (!isObject(theSchema)) {
     throw new Error("Invalid schema: " + theSchema);
   }
-
   const schema = retrieveSchema(validator, theSchema, rootSchema, formData);
   const defaults = computeDefaults(validator, schema, undefined, rootSchema, formData, includeUndefinedValues);
-
   if (typeof formData === "undefined" || formData === null || typeof formData === "number" && isNaN(formData)) {
     // No form data? Use schema defaults.
     return defaults;
   }
-
   if (isObject(formData)) {
     return mergeDefaultsWithFormData(defaults, formData);
   }
-
   if (Array.isArray(formData)) {
     return mergeDefaultsWithFormData(defaults, formData);
   }
-
   return formData;
 }
 
@@ -1139,13 +1006,12 @@ function getDefaultFormState(validator, theSchema, formData, rootSchema, include
  * @param uiSchema - The UI Schema from which to detect if it is customized
  * @returns - True if the `uiSchema` describes a custom widget, false otherwise
  */
-
 function isCustomWidget(uiSchema) {
   if (uiSchema === void 0) {
     uiSchema = {};
   }
-
-  return (// TODO: Remove the `&& uiSchema['ui:widget'] !== 'hidden'` once we support hidden widgets for arrays.
+  return (
+    // TODO: Remove the `&& uiSchema['ui:widget'] !== 'hidden'` once we support hidden widgets for arrays.
     // https://react-jsonschema-form.readthedocs.io/en/latest/usage/widgets/#hidden-widgets
     "widget" in getUiOptions(uiSchema) && getUiOptions(uiSchema)["widget"] !== "hidden"
   );
@@ -1159,21 +1025,17 @@ function isCustomWidget(uiSchema) {
  * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
  * @returns - True if schema/uiSchema contains an array of files, otherwise false
  */
-
 function isFilesArray(validator, schema, uiSchema, rootSchema) {
   if (uiSchema === void 0) {
     uiSchema = {};
   }
-
   if (uiSchema[UI_WIDGET_KEY] === "files") {
     return true;
   }
-
   if (schema.items) {
     const itemsSchema = retrieveSchema(validator, schema.items, rootSchema);
     return itemsSchema.type === "string" && itemsSchema.format === "data-url";
   }
-
   return false;
 }
 
@@ -1186,35 +1048,28 @@ function isFilesArray(validator, schema, uiSchema, rootSchema) {
  * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
  * @returns - True if the label should be displayed or false if it should not
  */
-
 function getDisplayLabel(validator, schema, uiSchema, rootSchema) {
   if (uiSchema === void 0) {
     uiSchema = {};
   }
-
   const uiOptions = getUiOptions(uiSchema);
   const {
     label = true
   } = uiOptions;
   let displayLabel = !!label;
   const schemaType = getSchemaType(schema);
-
   if (schemaType === "array") {
     displayLabel = isMultiSelect(validator, schema, rootSchema) || isFilesArray(validator, schema, uiSchema, rootSchema) || isCustomWidget(uiSchema);
   }
-
   if (schemaType === "object") {
     displayLabel = false;
   }
-
   if (schemaType === "boolean" && !uiSchema[UI_WIDGET_KEY]) {
     displayLabel = false;
   }
-
   if (uiSchema[UI_FIELD_KEY]) {
     displayLabel = false;
   }
-
   return displayLabel;
 }
 
@@ -1228,24 +1083,20 @@ function getDisplayLabel(validator, schema, uiSchema, rootSchema) {
  * @param [additionalErrorSchema] - The additional set of errors in an `ErrorSchema`
  * @returns - The `validationData` with the additional errors from `additionalErrorSchema` merged into it, if provided.
  */
-
 function mergeValidationData(validator, validationData, additionalErrorSchema) {
   if (!additionalErrorSchema) {
     return validationData;
   }
-
   const {
     errors: oldErrors,
     errorSchema: oldErrorSchema
   } = validationData;
   let errors = validator.toErrorList(additionalErrorSchema);
   let errorSchema = additionalErrorSchema;
-
   if (!isEmpty__default["default"](oldErrorSchema)) {
     errorSchema = mergeObjects(oldErrorSchema, additionalErrorSchema, true);
     errors = [...oldErrors].concat(errors);
   }
-
   return {
     errorSchema,
     errors
@@ -1263,41 +1114,34 @@ function mergeValidationData(validator, validationData, additionalErrorSchema) {
  * @param [idSeparator='_'] - The separator to use for the path segments in the id
  * @returns - The `IdSchema` object for the `schema`
  */
-
 function toIdSchema(validator, schema, id, rootSchema, formData, idPrefix, idSeparator) {
   if (idPrefix === void 0) {
     idPrefix = "root";
   }
-
   if (idSeparator === void 0) {
     idSeparator = "_";
   }
-
   if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
     const _schema = retrieveSchema(validator, schema, rootSchema, formData);
-
     return toIdSchema(validator, _schema, id, rootSchema, formData, idPrefix, idSeparator);
   }
-
   if (ITEMS_KEY in schema && !get__default["default"](schema, [ITEMS_KEY, REF_KEY])) {
     return toIdSchema(validator, get__default["default"](schema, ITEMS_KEY), id, rootSchema, formData, idPrefix, idSeparator);
   }
-
   const $id = id || idPrefix;
   const idSchema = {
     $id
   };
-
   if (schema.type === "object" && PROPERTIES_KEY in schema) {
     for (const name in schema.properties) {
       const field = get__default["default"](schema, [PROPERTIES_KEY, name]);
       const fieldId = idSchema[ID_KEY] + idSeparator + name;
-      idSchema[name] = toIdSchema(validator, isObject(field) ? field : {}, fieldId, rootSchema, // It's possible that formData is not an object -- this can happen if an
+      idSchema[name] = toIdSchema(validator, isObject(field) ? field : {}, fieldId, rootSchema,
+      // It's possible that formData is not an object -- this can happen if an
       // array item has just been added, but not populated with data yet
       get__default["default"](formData, [name]), idPrefix, idSeparator);
     }
   }
-
   return idSchema;
 }
 
@@ -1310,39 +1154,33 @@ function toIdSchema(validator, schema, id, rootSchema, formData, idPrefix, idSep
  * @param [formData] - The current formData, if any, to assist retrieving a schema
  * @returns - The `PathSchema` object for the `schema`
  */
-
 function toPathSchema(validator, schema, name, rootSchema, formData) {
   if (name === void 0) {
     name = "";
   }
-
   if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
     const _schema = retrieveSchema(validator, schema, rootSchema, formData);
-
     return toPathSchema(validator, _schema, name, rootSchema, formData);
   }
-
   const pathSchema = {
     [NAME_KEY]: name.replace(/^\./, "")
   };
-
   if (ADDITIONAL_PROPERTIES_KEY in schema && schema[ADDITIONAL_PROPERTIES_KEY] === true) {
     set__default["default"](pathSchema, RJSF_ADDITONAL_PROPERTIES_FLAG, true);
   }
-
   if (ITEMS_KEY in schema && Array.isArray(formData)) {
     formData.forEach((element, i) => {
-      pathSchema[i] = toPathSchema(validator, schema.items, name + "." + i, rootSchema, element);
+      pathSchema[i] = toPathSchema(validator, schema.items, `${name}.${i}`, rootSchema, element);
     });
   } else if (PROPERTIES_KEY in schema) {
     for (const property in schema.properties) {
       const field = get__default["default"](schema, [PROPERTIES_KEY, property]);
-      pathSchema[property] = toPathSchema(validator, field, name + "." + property, rootSchema, // It's possible that formData is not an object -- this can happen if an
+      pathSchema[property] = toPathSchema(validator, field, `${name}.${property}`, rootSchema,
+      // It's possible that formData is not an object -- this can happen if an
       // array item has just been added, but not populated with data yet
       get__default["default"](formData, [property]));
     }
   }
-
   return pathSchema;
 }
 
@@ -1351,7 +1189,6 @@ function toPathSchema(validator, schema, name, rootSchema, formData) {
  * and `rootSchema` generally does 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.
  */
-
 class SchemaUtils {
   /** Constructs the `SchemaUtils` instance with the given `validator` and `rootSchema` stored as instance variables
    *
@@ -1368,8 +1205,6 @@ class SchemaUtils {
    *
    * @returns - The `ValidatorType`
    */
-
-
   getValidator() {
     return this.validator;
   }
@@ -1381,13 +1216,10 @@ class SchemaUtils {
    * @param rootSchema - The root schema that will be compared against the current one
    * @returns - True if the `SchemaUtilsType` differs from the given `validator` or `rootSchema`
    */
-
-
   doesSchemaUtilsDiffer(validator, rootSchema) {
     if (!validator || !rootSchema) {
       return false;
     }
-
     return this.validator !== validator || !deepEquals(this.rootSchema, rootSchema);
   }
   /** Returns the superset of `formData` that includes the given set updated to include any missing fields that have
@@ -1398,13 +1230,10 @@ class SchemaUtils {
    * @param [includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults
    * @returns - The resulting `formData` with all the defaults provided
    */
-
-
   getDefaultFormState(schema, formData, includeUndefinedValues) {
     if (includeUndefinedValues === void 0) {
       includeUndefinedValues = false;
     }
-
     return getDefaultFormState(this.validator, schema, formData, this.rootSchema, includeUndefinedValues);
   }
   /** Determines whether the combination of `schema` and `uiSchema` properties indicates that the label for the `schema`
@@ -1414,8 +1243,6 @@ class SchemaUtils {
    * @param [uiSchema] - The UI schema from which to derive potentially displayable information
    * @returns - True if the label should be displayed or false if it should not
    */
-
-
   getDisplayLabel(schema, uiSchema) {
     return getDisplayLabel(this.validator, schema, uiSchema, this.rootSchema);
   }
@@ -1425,8 +1252,6 @@ class SchemaUtils {
    * @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
    */
-
-
   getMatchingOption(formData, options) {
     return getMatchingOption(this.validator, formData, options, this.rootSchema);
   }
@@ -1436,8 +1261,6 @@ class SchemaUtils {
    * @param [uiSchema] - The UI schema from which to check the widget
    * @returns - True if schema/uiSchema contains an array of files, otherwise false
    */
-
-
   isFilesArray(schema, uiSchema) {
     return isFilesArray(this.validator, schema, uiSchema, this.rootSchema);
   }
@@ -1446,8 +1269,6 @@ class SchemaUtils {
    * @param schema - The schema for which check for a multi-select flag is desired
    * @returns - True if schema contains a multi-select, otherwise false
    */
-
-
   isMultiSelect(schema) {
     return isMultiSelect(this.validator, schema, this.rootSchema);
   }
@@ -1456,8 +1277,6 @@ class SchemaUtils {
    * @param schema - The schema for which check for a select flag is desired
    * @returns - True if schema contains a select, otherwise false
    */
-
-
   isSelect(schema) {
     return isSelect(this.validator, schema, this.rootSchema);
   }
@@ -1470,8 +1289,6 @@ class SchemaUtils {
    * @param [additionalErrorSchema] - The additional set of errors
    * @returns - The `validationData` with the additional errors from `additionalErrorSchema` merged into it, if provided.
    */
-
-
   mergeValidationData(validationData, additionalErrorSchema) {
     return mergeValidationData(this.validator, validationData, additionalErrorSchema);
   }
@@ -1483,8 +1300,6 @@ class SchemaUtils {
    * @param [rawFormData] - The current formData, if any, to assist retrieving a schema
    * @returns - The schema having its conditions, additional properties, references and dependencies resolved
    */
-
-
   retrieveSchema(schema, rawFormData) {
     return retrieveSchema(this.validator, schema, this.rootSchema, rawFormData);
   }
@@ -1497,17 +1312,13 @@ class SchemaUtils {
    * @param [idSeparator='_'] - The separator to use for the path segments in the id
    * @returns - The `IdSchema` object for the `schema`
    */
-
-
   toIdSchema(schema, id, formData, idPrefix, idSeparator) {
     if (idPrefix === void 0) {
       idPrefix = "root";
     }
-
     if (idSeparator === void 0) {
       idSeparator = "_";
     }
-
     return toIdSchema(this.validator, schema, id, this.rootSchema, formData, idPrefix, idSeparator);
   }
   /** Generates an `PathSchema` object for the `schema`, recursively
@@ -1517,12 +1328,9 @@ class SchemaUtils {
    * @param [formData] - The current formData, if any, onto which to provide any missing defaults
    * @returns - The `PathSchema` object for the `schema`
    */
-
-
   toPathSchema(schema, name, formData) {
     return toPathSchema(this.validator, schema, name, this.rootSchema, formData);
   }
-
 }
 /** Creates a `SchemaUtilsType` interface that is based around the given `validator` and `rootSchema` parameters. The
  * resulting interface implementation will forward the `validator` and `rootSchema` to all the wrapped APIs.
@@ -1531,8 +1339,6 @@ class SchemaUtils {
  * @param rootSchema - The root schema that will be forwarded to all the APIs
  * @returns - An implementation of a `SchemaUtilsType` interface
  */
-
-
 function createSchemaUtils(validator, rootSchema) {
   return new SchemaUtils(validator, rootSchema);
 }
@@ -1545,35 +1351,31 @@ function createSchemaUtils(validator, rootSchema) {
  */
 function dataURItoBlob(dataURI) {
   // Split metadata from data
-  const splitted = dataURI.split(","); // Split params
-
-  const params = splitted[0].split(";"); // Get mime-type from params
-
-  const type = params[0].replace("data:", ""); // Filter the name property from params
-
+  const splitted = dataURI.split(",");
+  // Split params
+  const params = splitted[0].split(";");
+  // Get mime-type from params
+  const type = params[0].replace("data:", "");
+  // Filter the name property from params
   const properties = params.filter(param => {
     return param.split("=")[0] === "name";
-  }); // Look for the name and use unknown if no name property.
-
+  });
+  // Look for the name and use unknown if no name property.
   let name;
-
   if (properties.length !== 1) {
     name = "unknown";
   } else {
     // Because we filtered out the other property,
     // we only have the name case here.
     name = properties[0].split("=")[1];
-  } // Built the Uint8Array Blob parameter from the base64 string.
-
-
+  }
+  // Built the Uint8Array Blob parameter from the base64 string.
   const binary = atob(splitted[1]);
   const array = [];
-
   for (let i = 0; i < binary.length; i++) {
     array.push(binary.charCodeAt(i));
-  } // Create the blob object
-
-
+  }
+  // Create the blob object
   const blob = new window.Blob([new Uint8Array(array)], {
     type
   });
@@ -1591,19 +1393,15 @@ function dataURItoBlob(dataURI) {
  */
 function rangeSpec(schema) {
   const spec = {};
-
   if (schema.multipleOf) {
     spec.step = schema.multipleOf;
   }
-
   if (schema.minimum || schema.minimum === 0) {
     spec.min = schema.minimum;
   }
-
   if (schema.maximum || schema.maximum === 0) {
     spec.max = schema.maximum;
   }
-
   return spec;
 }
 
@@ -1615,53 +1413,47 @@ function rangeSpec(schema) {
  * @param [autoDefaultStepAny=true] - Determines whether to auto-default step=any when the type is number and no step
  * @returns - The extracted `InputPropsType` object
  */
-
 function getInputProps(schema, defaultType, options, autoDefaultStepAny) {
   if (options === void 0) {
     options = {};
   }
-
   if (autoDefaultStepAny === void 0) {
     autoDefaultStepAny = true;
   }
-
   const inputProps = {
     type: defaultType || "text",
     ...rangeSpec(schema)
-  }; // If options.inputType is set use that as the input type
-
+  };
+  // If options.inputType is set use that as the input type
   if (options.inputType) {
     inputProps.type = options.inputType;
   } else if (!defaultType) {
     // If the schema is of type number or integer, set the input type to number
     if (schema.type === "number") {
-      inputProps.type = "number"; // Only add step if one isn't already defined and we are auto-defaulting the "any" step
-
+      inputProps.type = "number";
+      // Only add step if one isn't already defined and we are auto-defaulting the "any" step
       if (autoDefaultStepAny && inputProps.step === undefined) {
         // Setting step to 'any' fixes a bug in Safari where decimals are not
         // allowed in number inputs
         inputProps.step = "any";
       }
     } else if (schema.type === "integer") {
-      inputProps.type = "number"; // Only add step if one isn't already defined
-
+      inputProps.type = "number";
+      // Only add step if one isn't already defined
       if (inputProps.step === undefined) {
         // Since this is integer, you always want to step up or down in multiples of 1
         inputProps.step = 1;
       }
     }
   }
-
   if (options.autocomplete) {
     inputProps.autoComplete = options.autocomplete;
   }
-
   return inputProps;
 }
 
 /** The default submit button options, exported for testing purposes
  */
-
 const DEFAULT_OPTIONS = {
   props: {
     disabled: false
@@ -1674,21 +1466,18 @@ const DEFAULT_OPTIONS = {
  * @param [uiSchema={}] - the UI Schema from which to extract submit button props
  * @returns - The merging of the `DEFAULT_OPTIONS` with any custom ones
  */
-
 function getSubmitButtonOptions(uiSchema) {
   if (uiSchema === void 0) {
     uiSchema = {};
   }
-
   const uiOptions = getUiOptions(uiSchema);
-
   if (uiOptions && uiOptions[SUBMIT_BTN_OPTIONS_KEY]) {
     const options = uiOptions[SUBMIT_BTN_OPTIONS_KEY];
-    return { ...DEFAULT_OPTIONS,
+    return {
+      ...DEFAULT_OPTIONS,
       ...options
     };
   }
-
   return DEFAULT_OPTIONS;
 }
 
@@ -1704,16 +1493,14 @@ function getTemplate(name, registry, uiOptions) {
   if (uiOptions === void 0) {
     uiOptions = {};
   }
-
   const {
     templates
   } = registry;
-
   if (name === "ButtonTemplates") {
     return templates[name];
   }
-
-  return (// Evaluating uiOptions[name] results in TS2590: Expression produces a union type that is too complex to represent
+  return (
+    // Evaluating uiOptions[name] results in TS2590: Expression produces a union type that is too complex to represent
     // To avoid that, we cast uiOptions to `any` before accessing the name field
     uiOptions[name] || templates[name]
   );
@@ -1721,7 +1508,6 @@ function getTemplate(name, registry, uiOptions) {
 
 /** The map of schema types to widget type to widget name
  */
-
 const widgetMap = {
   boolean: {
     checkbox: "CheckboxWidget",
@@ -1780,29 +1566,26 @@ const widgetMap = {
  * @param AWidget - A widget that will be wrapped or one that is already wrapped
  * @returns - The wrapper widget
  */
-
 function mergeWidgetOptions(AWidget) {
-  let MergedWidget = get__default["default"](AWidget, "MergedWidget"); // cache return value as property of widget for proper react reconciliation
-
+  let MergedWidget = get__default["default"](AWidget, "MergedWidget");
+  // cache return value as property of widget for proper react reconciliation
   if (!MergedWidget) {
     const defaultOptions = AWidget.defaultProps && AWidget.defaultProps.options || {};
-
     MergedWidget = _ref => {
       let {
         options,
         ...props
       } = _ref;
       return /*#__PURE__*/React__default["default"].createElement(AWidget, {
-        options: { ...defaultOptions,
+        options: {
+          ...defaultOptions,
           ...options
         },
         ...props
       });
     };
-
     set__default["default"](AWidget, "MergedWidget", MergedWidget);
   }
-
   return MergedWidget;
 }
 /** Given a schema representing a field to render and either the name or actual `Widget` implementation, returns the
@@ -1816,40 +1599,31 @@ function mergeWidgetOptions(AWidget) {
  * @returns - The `Widget` component to use
  * @throws - An error if there is no `Widget` component that can be returned
  */
-
-
 function getWidget(schema, widget, registeredWidgets) {
   if (registeredWidgets === void 0) {
     registeredWidgets = {};
   }
-
   const type = getSchemaType(schema);
-
   if (typeof widget === "function" || widget && ReactIs__default["default"].isForwardRef( /*#__PURE__*/React__default["default"].createElement(widget)) || ReactIs__default["default"].isMemo(widget)) {
     return mergeWidgetOptions(widget);
   }
-
   if (typeof widget !== "string") {
-    throw new Error("Unsupported widget definition: " + typeof widget);
+    throw new Error(`Unsupported widget definition: ${typeof widget}`);
   }
-
   if (widget in registeredWidgets) {
     const registeredWidget = registeredWidgets[widget];
     return getWidget(schema, registeredWidget, registeredWidgets);
   }
-
   if (typeof type === "string") {
     if (!(type in widgetMap)) {
-      throw new Error("No widget for type '" + type + "'");
+      throw new Error(`No widget for type '${type}'`);
     }
-
     if (widget in widgetMap[type]) {
       const registeredWidget = registeredWidgets[widgetMap[type][widget]];
       return getWidget(schema, registeredWidget, registeredWidgets);
     }
   }
-
-  throw new Error("No widget '" + widget + "' for type '" + type + "'");
+  throw new Error(`No widget '${widget}' for type '${type}'`);
 }
 
 /** Detects whether the `widget` exists for the `schema` with the associated `registryWidgets` and returns true if it
@@ -1860,22 +1634,18 @@ function getWidget(schema, widget, registeredWidgets) {
  * @param [registeredWidgets={}] - A registry of widget name to `Widget` implementation
  * @returns - True if the widget exists, false otherwise
  */
-
 function hasWidget(schema, widget, registeredWidgets) {
   if (registeredWidgets === void 0) {
     registeredWidgets = {};
   }
-
   try {
     getWidget(schema, widget, registeredWidgets);
     return true;
   } catch (e) {
     const err = e;
-
     if (err.message && (err.message.startsWith("No widget") || err.message.startsWith("Unsupported widget"))) {
       return false;
     }
-
     throw e;
   }
 }
@@ -1896,16 +1666,13 @@ function localToUTC(dateString) {
  * @returns - The constant value for the schema
  * @throws - Error when the schema does not have a constant value
  */
-
 function toConstant(schema) {
   if (ENUM_KEY in schema && Array.isArray(schema.enum) && schema.enum.length === 1) {
     return schema.enum[0];
   }
-
   if (CONST_KEY in schema) {
     return schema.const;
   }
-
   throw new Error("schema cannot be inferred as a constant");
 }
 
@@ -1917,16 +1684,13 @@ function toConstant(schema) {
  * @param schema - The schema from which to extract the options list
  * @returns - The list of options from the schema
  */
-
 function optionsList(schema) {
   // enumNames was deprecated in v5 and is intentionally omitted from the RJSFSchema type.
   // Cast the type to include enumNames so the feature still works.
   const schemaWithEnumNames = schema;
-
   if (schemaWithEnumNames.enumNames && "development" !== "production") {
     console.warn("The enumNames property is deprecated and may be removed in a future major release.");
   }
-
   if (schema.enum) {
     return schema.enum.map((value, i) => {
       const label = schemaWithEnumNames.enumNames && schemaWithEnumNames.enumNames[i] || String(value);
@@ -1936,7 +1700,6 @@ function optionsList(schema) {
       };
     });
   }
-
   const altSchemas = schema.oneOf || schema.anyOf;
   return altSchemas && altSchemas.map(aSchemaDef => {
     const aSchema = aSchemaDef;
@@ -1964,32 +1727,25 @@ function orderProperties(properties, order) {
   if (!Array.isArray(order)) {
     return properties;
   }
-
   const arrayToHash = arr => arr.reduce((prev, curr) => {
     prev[curr] = true;
     return prev;
   }, {});
-
-  const errorPropList = arr => arr.length > 1 ? "properties '" + arr.join("', '") + "'" : "property '" + arr[0] + "'";
-
+  const errorPropList = arr => arr.length > 1 ? `properties '${arr.join("', '")}'` : `property '${arr[0]}'`;
   const propertyHash = arrayToHash(properties);
   const orderFiltered = order.filter(prop => prop === "*" || propertyHash[prop]);
   const orderHash = arrayToHash(orderFiltered);
   const rest = properties.filter(prop => !orderHash[prop]);
   const restIndex = orderFiltered.indexOf("*");
-
   if (restIndex === -1) {
     if (rest.length) {
-      throw new Error("uiSchema order list does not contain " + errorPropList(rest));
+      throw new Error(`uiSchema order list does not contain ${errorPropList(rest)}`);
     }
-
     return orderFiltered;
   }
-
   if (restIndex !== orderFiltered.lastIndexOf("*")) {
     throw new Error("uiSchema order list contains more than one wildcard item");
   }
-
   const complete = [...orderFiltered];
   complete.splice(restIndex, 1, ...rest);
   return complete;
@@ -2003,11 +1759,9 @@ function orderProperties(properties, order) {
  */
 function pad(num, width) {
   let s = String(num);
-
   while (s.length < width) {
     s = "0" + s;
   }
-
   return s;
 }
 
@@ -2022,7 +1776,6 @@ function parseDateString(dateString, includeTime) {
   if (includeTime === void 0) {
     includeTime = true;
   }
-
   if (!dateString) {
     return {
       year: -1,
@@ -2033,13 +1786,10 @@ function parseDateString(dateString, includeTime) {
       second: includeTime ? -1 : 0
     };
   }
-
   const date = new Date(dateString);
-
   if (Number.isNaN(date.getTime())) {
     throw new Error("Unable to parse date " + dateString);
   }
-
   return {
     year: date.getUTCFullYear(),
     month: date.getUTCMonth() + 1,
@@ -2060,42 +1810,34 @@ const nums = /*#__PURE__*/new Set(["number", "integer"]);
  * @param [options] - The UIOptionsType from which to potentially extract the emptyValue
  * @returns - The `value` converted to the proper type
  */
-
 function processSelectValue(schema, value, options) {
   const {
     enum: schemaEnum,
     type,
     items
   } = schema;
-
   if (value === "") {
     return options && options.emptyValue !== undefined ? options.emptyValue : undefined;
   }
-
   if (type === "array" && items && nums.has(get__default["default"](items, "type"))) {
     return value.map(asNumber);
   }
-
   if (type === "boolean") {
     return value === "true";
   }
-
   if (nums.has(type)) {
     return asNumber(value);
-  } // If type is undefined, but an enum is present, try and infer the type from
+  }
+  // If type is undefined, but an enum is present, try and infer the type from
   // the enum values
-
-
   if (Array.isArray(schemaEnum)) {
     if (schemaEnum.every(x => nums.has(guessType(x)))) {
       return asNumber(value);
     }
-
     if (schemaEnum.every(x => guessType(x) === "boolean")) {
       return value === "true";
     }
   }
-
   return value;
 }
 
@@ -2112,30 +1854,24 @@ function schemaRequiresTrueValue(schema) {
   // Check if const is a truthy value
   if (schema.const) {
     return true;
-  } // Check if an enum has a single value of true
-
-
+  }
+  // Check if an enum has a single value of true
   if (schema.enum && schema.enum.length === 1 && schema.enum[0] === true) {
     return true;
-  } // If anyOf has a single value, evaluate the subschema
-
-
+  }
+  // If anyOf has a single value, evaluate the subschema
   if (schema.anyOf && schema.anyOf.length === 1) {
     return schemaRequiresTrueValue(schema.anyOf[0]);
-  } // If oneOf has a single value, evaluate the subschema
-
-
+  }
+  // If oneOf has a single value, evaluate the subschema
   if (schema.oneOf && schema.oneOf.length === 1) {
     return schemaRequiresTrueValue(schema.oneOf[0]);
-  } // Evaluate each subschema in allOf, to see if one of them requires a true value
-
-
+  }
+  // Evaluate each subschema in allOf, to see if one of them requires a true value
   if (schema.allOf) {
     const schemaSome = subSchema => schemaRequiresTrueValue(subSchema);
-
     return schema.allOf.some(schemaSome);
   }
-
   return false;
 }
 
@@ -2147,7 +1883,6 @@ function schemaRequiresTrueValue(schema) {
  * @param nextState - The next set of state against which to check
  * @returns - True if the component should be re-rendered, false otherwise
  */
-
 function shouldRender(component, nextProps, nextState) {
   const {
     props,
@@ -2167,7 +1902,6 @@ function toDateString(dateObject, time) {
   if (time === void 0) {
     time = true;
   }
-
   const {
     year,
     month,
@@ -2186,17 +1920,15 @@ function toDateString(dateObject, time) {
  * @param jsonDate - A UTC date string
  * @returns - An empty string when `jsonDate` is falsey, otherwise a date string in local format
  */
-
 function utcToLocal(jsonDate) {
   if (!jsonDate) {
     return "";
-  } // required format of `'yyyy-MM-ddThh:mm' followed by optional ':ss' or ':ss.SSS'
+  }
+  // required format of `'yyyy-MM-ddThh:mm' followed by optional ':ss' or ':ss.SSS'
   // https://html.spec.whatwg.org/multipage/input.html#local-date-and-time-state-(type%3Ddatetime-local)
   // > should be a _valid local date and time string_ (not GMT)
   // Note - date constructor passed local ISO-8601 does not correctly
   // change time to UTC in node pre-8
-
-
   const date = new Date(jsonDate);
   const yyyy = pad(date.getFullYear(), 4);
   const MM = pad(date.getMonth() + 1, 2);
@@ -2205,7 +1937,7 @@ function utcToLocal(jsonDate) {
   const mm = pad(date.getMinutes(), 2);
   const ss = pad(date.getSeconds(), 2);
   const SSS = pad(date.getMilliseconds(), 3);
-  return yyyy + "-" + MM + "-" + dd + "T" + hh + ":" + mm + ":" + ss + "." + SSS;
+  return `${yyyy}-${MM}-${dd}T${hh}:${mm}:${ss}.${SSS}`;
 }
 
 exports.ADDITIONAL_PROPERTIES_KEY = ADDITIONAL_PROPERTIES_KEY;