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

package/dist/utils.umd.development.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('lodash-es/isEqualWith'), require('lodash-es/get'), require('lodash-es/isEmpty'), require('jsonpointer'), require('lodash-es/omit'), require('lodash-es/set'), require('json-schema-merge-allof'), require('lodash-es/union'), require('react'), require('react-is')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'lodash-es/isEqualWith', 'lodash-es/get', 'lodash-es/isEmpty', 'jsonpointer', 'lodash-es/omit', 'lodash-es/set', 'json-schema-merge-allof', 'lodash-es/union', 'react', 'react-is'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@rjsf/utils"] = {}, global.isEqualWith, global.get, global.isEmpty, global.jsonpointer, global.omit, global.set, global.mergeAllOf, global.union, global.React, global.ReactIs));
-})(this, (function (exports, isEqualWith, get, isEmpty, jsonpointer, omit, set, mergeAllOf, union, React, ReactIs) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('lodash-es/isEqualWith'), require('lodash-es/get'), require('lodash-es/isEmpty'), require('jsonpointer'), require('lodash-es/omit'), require('lodash-es/set'), require('json-schema-merge-allof'), require('lodash-es/union'), require('lodash-es/cloneDeep'), require('react'), require('react-is')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'lodash-es/isEqualWith', 'lodash-es/get', 'lodash-es/isEmpty', 'jsonpointer', 'lodash-es/omit', 'lodash-es/set', 'json-schema-merge-allof', 'lodash-es/union', 'lodash-es/cloneDeep', 'react', 'react-is'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@rjsf/utils"] = {}, global.isEqualWith, global.get, global.isEmpty, global.jsonpointer, global.omit, global.set, global.mergeAllOf, global.union, global.cloneDeep, global.React, global.ReactIs));
+})(this, (function (exports, isEqualWith, get, isEmpty, jsonpointer, omit, set, mergeAllOf, union, cloneDeep, React, ReactIs) { 'use strict';
 
   function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -14,6 +14,7 @@
   var set__default = /*#__PURE__*/_interopDefaultLegacy(set);
   var mergeAllOf__default = /*#__PURE__*/_interopDefaultLegacy(mergeAllOf);
   var union__default = /*#__PURE__*/_interopDefaultLegacy(union);
+  var cloneDeep__default = /*#__PURE__*/_interopDefaultLegacy(cloneDeep);
   var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
   var ReactIs__default = /*#__PURE__*/_interopDefaultLegacy(ReactIs);
 
@@ -27,6 +28,9 @@
     if (typeof File !== "undefined" && thing instanceof File) {
       return false;
     }
+    if (typeof Date !== "undefined" && thing instanceof Date) {
+      return false;
+    }
     return typeof thing === "object" && thing !== null && !Array.isArray(thing);
   }
 
@@ -74,38 +78,85 @@
       // specific precision or number of significant digits)
       return value;
     }
-    const n = Number(value);
-    const valid = typeof n === "number" && !Number.isNaN(n);
+    var n = Number(value);
+    var valid = typeof n === "number" && !Number.isNaN(n);
     return valid ? n : value;
   }
 
+  function _defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+      var descriptor = props[i];
+      descriptor.enumerable = descriptor.enumerable || false;
+      descriptor.configurable = true;
+      if ("value" in descriptor) descriptor.writable = true;
+      Object.defineProperty(target, descriptor.key, descriptor);
+    }
+  }
+  function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    Object.defineProperty(Constructor, "prototype", {
+      writable: false
+    });
+    return Constructor;
+  }
+  function _extends() {
+    _extends = Object.assign ? Object.assign.bind() : function (target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i];
+        for (var key in source) {
+          if (Object.prototype.hasOwnProperty.call(source, key)) {
+            target[key] = source[key];
+          }
+        }
+      }
+      return target;
+    };
+    return _extends.apply(this, arguments);
+  }
+  function _objectDestructuringEmpty(obj) {
+    if (obj == null) throw new TypeError("Cannot destructure " + obj);
+  }
+  function _objectWithoutPropertiesLoose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for (i = 0; i < sourceKeys.length; i++) {
+      key = sourceKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      target[key] = source[key];
+    }
+    return target;
+  }
+
   /** Below are the list of all the keys into various elements of a RJSFSchema or UiSchema that are used by the various
    * utility functions. In addition to those keys, there are the special `ADDITIONAL_PROPERTY_FLAG` and
    * `RJSF_ADDITONAL_PROPERTIES_FLAG` flags that is added to a schema under certain conditions by the `retrieveSchema()`
    * utility.
    */
-  const ADDITIONAL_PROPERTY_FLAG = "__additional_property";
-  const ADDITIONAL_PROPERTIES_KEY = "additionalProperties";
-  const ALL_OF_KEY = "allOf";
-  const ANY_OF_KEY = "anyOf";
-  const CONST_KEY = "const";
-  const DEFAULT_KEY = "default";
-  const DEFINITIONS_KEY = "definitions";
-  const DEPENDENCIES_KEY = "dependencies";
-  const ENUM_KEY = "enum";
-  const ERRORS_KEY = "__errors";
-  const ID_KEY = "$id";
-  const ITEMS_KEY = "items";
-  const NAME_KEY = "$name";
-  const ONE_OF_KEY = "oneOf";
-  const PROPERTIES_KEY = "properties";
-  const REQUIRED_KEY = "required";
-  const SUBMIT_BTN_OPTIONS_KEY = "submitButtonOptions";
-  const REF_KEY = "$ref";
-  const RJSF_ADDITONAL_PROPERTIES_FLAG = "__rjsf_additionalProperties";
-  const UI_FIELD_KEY = "ui:field";
-  const UI_WIDGET_KEY = "ui:widget";
-  const UI_OPTIONS_KEY = "ui:options";
+  var ADDITIONAL_PROPERTY_FLAG = "__additional_property";
+  var ADDITIONAL_PROPERTIES_KEY = "additionalProperties";
+  var ALL_OF_KEY = "allOf";
+  var ANY_OF_KEY = "anyOf";
+  var CONST_KEY = "const";
+  var DEFAULT_KEY = "default";
+  var DEFINITIONS_KEY = "definitions";
+  var DEPENDENCIES_KEY = "dependencies";
+  var ENUM_KEY = "enum";
+  var ERRORS_KEY = "__errors";
+  var ID_KEY = "$id";
+  var ITEMS_KEY = "items";
+  var NAME_KEY = "$name";
+  var ONE_OF_KEY = "oneOf";
+  var PROPERTIES_KEY = "properties";
+  var REQUIRED_KEY = "required";
+  var SUBMIT_BTN_OPTIONS_KEY = "submitButtonOptions";
+  var REF_KEY = "$ref";
+  var RJSF_ADDITONAL_PROPERTIES_FLAG = "__rjsf_additionalProperties";
+  var UI_FIELD_KEY = "ui:field";
+  var UI_WIDGET_KEY = "ui:widget";
+  var UI_OPTIONS_KEY = "ui:options";
 
   /** Get all passed options from ui:options, and ui:<optionName>, returning them in an object with the `ui:`
    * stripped off.
@@ -117,22 +168,19 @@
     if (uiSchema === void 0) {
       uiSchema = {};
     }
-    return Object.keys(uiSchema).filter(key => key.indexOf("ui:") === 0).reduce((options, key) => {
-      const value = uiSchema[key];
+    return Object.keys(uiSchema).filter(function (key) {
+      return key.indexOf("ui:") === 0;
+    }).reduce(function (options, key) {
+      var _extends2;
+      var 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,
-          ...value
-        };
+        return _extends({}, options, value);
       }
-      return {
-        ...options,
-        [key.substring(3)]: value
-      };
+      return _extends({}, options, (_extends2 = {}, _extends2[key.substring(3)] = value, _extends2));
     }, {});
   }
 
@@ -152,9 +200,9 @@
     if (!schema.additionalProperties) {
       return false;
     }
-    const {
-      expandable = true
-    } = getUiOptions(uiSchema);
+    var _getUiOptions = getUiOptions(uiSchema),
+      _getUiOptions$expanda = _getUiOptions.expandable,
+      expandable = _getUiOptions$expanda === void 0 ? true : _getUiOptions$expanda;
     if (expandable === false) {
       return expandable;
     }
@@ -174,7 +222,7 @@
    * @returns - True if the `a` and `b` are deeply equal, false otherwise
    */
   function deepEquals(a, b) {
-    return isEqualWith__default["default"](a, b, (obj, other) => {
+    return isEqualWith__default["default"](a, b, function (obj, other) {
       if (typeof obj === "function" && typeof other === "function") {
         // Assume all functions are equivalent
         // see https://github.com/rjsf-team/react-jsonschema-form/issues/255
@@ -193,8 +241,8 @@
    *      value from `object[key]`
    */
   function splitKeyElementFromObject(key, object) {
-    const value = object[key];
-    const remaining = omit__default["default"](object, [key]);
+    var value = object[key];
+    var remaining = omit__default["default"](object, [key]);
     return [remaining, value];
   }
   /** Given the name of a `$ref` from within a schema, using the `rootSchema`, look up and return the sub-schema using the
@@ -210,25 +258,24 @@
     if (rootSchema === void 0) {
       rootSchema = {};
     }
-    let ref = $ref || "";
+    var 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);
+    var 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);
+      var _splitKeyElementFromO = splitKeyElementFromObject(REF_KEY, current),
+        remaining = _splitKeyElementFromO[0],
+        theRef = _splitKeyElementFromO[1];
+      var subSchema = findSchemaDefinition(theRef, rootSchema);
       if (Object.keys(remaining).length > 0) {
-        return {
-          ...remaining,
-          ...subSchema
-        };
+        return _extends({}, remaining, subSchema);
       }
       return subSchema;
     }
@@ -249,8 +296,8 @@
     if (formData === undefined) {
       return 0;
     }
-    for (let i = 0; i < options.length; i++) {
-      const option = options[i];
+    for (var i = 0; i < options.length; i++) {
+      var 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
@@ -261,18 +308,18 @@
       if (option.properties) {
         // Create an "anyOf" schema that requires at least one of the keys in the
         // "properties" object
-        const requiresAnyOf = {
-          anyOf: Object.keys(option.properties).map(key => ({
-            required: [key]
-          }))
+        var requiresAnyOf = {
+          anyOf: Object.keys(option.properties).map(function (key) {
+            return {
+              required: [key]
+            };
+          })
         };
-        let augmentedSchema;
+        var augmentedSchema = void 0;
         // If the "anyOf" keyword already exists, wrap the augmentation in an "allOf"
         if (option.anyOf) {
           // Create a shallow clone of the option
-          const {
-            ...shallowClone
-          } = option;
+          var shallowClone = _extends({}, (_objectDestructuringEmpty(option), option));
           if (!shallowClone.allOf) {
             shallowClone.allOf = [];
           } else {
@@ -338,20 +385,20 @@
    * @returns - The type of the schema
    */
   function getSchemaType(schema) {
-    let {
-      type
-    } = schema;
-    if (!type && schema.const) {
-      return guessType(schema.const);
+    var type = schema.type;
+    if (!type && schema["const"]) {
+      return guessType(schema["const"]);
     }
-    if (!type && schema.enum) {
+    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");
+      type = type.find(function (type) {
+        return type !== "null";
+      });
     }
     return type;
   }
@@ -363,7 +410,9 @@
    * @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));
+    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`
@@ -382,8 +431,8 @@
    */
   function mergeDefaultsWithFormData(defaults, formData) {
     if (Array.isArray(formData)) {
-      const defaultsArray = Array.isArray(defaults) ? defaults : [];
-      const mapped = formData.map((value, idx) => {
+      var defaultsArray = Array.isArray(defaults) ? defaults : [];
+      var mapped = formData.map(function (value, idx) {
         if (defaultsArray[idx]) {
           return mergeDefaultsWithFormData(defaultsArray[idx], value);
         }
@@ -392,8 +441,8 @@
       return mapped;
     }
     if (isObject(formData)) {
-      const acc = Object.assign({}, defaults); // Prevent mutation of source object.
-      return Object.keys(formData).reduce((acc, key) => {
+      var acc = Object.assign({}, defaults); // Prevent mutation of source object.
+      return Object.keys(formData).reduce(function (acc, key) {
         acc[key] = mergeDefaultsWithFormData(defaults ? get__default["default"](defaults, key) : {}, get__default["default"](formData, key));
         return acc;
       }, acc);
@@ -405,20 +454,31 @@
    *
    * @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
+   * @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((acc, key) => {
-      const left = obj1 ? obj1[key] : {},
+    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)) {
-        acc[key] = left.concat(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;
       }
@@ -433,7 +493,7 @@
    * @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;
+    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
@@ -445,9 +505,9 @@
    * @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] : {},
+    var acc = Object.assign({}, obj1); // Prevent mutation of source object.
+    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] = mergeSchemas(left, right);
@@ -461,6 +521,11 @@
     }, acc);
   }
 
+  var _excluded$1 = ["if", "then", "else"],
+    _excluded2 = ["$ref"],
+    _excluded3 = ["allOf"],
+    _excluded4 = ["dependencies"],
+    _excluded5 = ["oneOf"];
   /** Resolves a conditional block (if/else/then) by removing the condition and merging the appropriate conditional branch
    * with the rest of the schema
    *
@@ -471,13 +536,11 @@
    * @returns - A schema with the appropriate condition resolved
    */
   function resolveCondition(validator, schema, rootSchema, formData) {
-    const {
-      if: expression,
-      then,
-      else: otherwise,
-      ...resolvedSchemaLessConditional
-    } = schema;
-    const conditionalSchema = validator.isValid(expression, formData, rootSchema) ? then : otherwise;
+    var expression = schema["if"],
+      then = schema.then,
+      otherwise = schema["else"],
+      resolvedSchemaLessConditional = _objectWithoutPropertiesLoose(schema, _excluded$1);
+    var conditionalSchema = validator.isValid(expression, formData, rootSchema) ? then : otherwise;
     if (conditionalSchema && typeof conditionalSchema !== "boolean") {
       return retrieveSchema(validator, mergeSchemas(resolvedSchemaLessConditional, retrieveSchema(validator, conditionalSchema, rootSchema, formData)), rootSchema, formData);
     }
@@ -500,14 +563,15 @@
       return resolveReference(validator, schema, rootSchema, formData);
     }
     if (DEPENDENCIES_KEY in schema) {
-      const resolvedSchema = resolveDependencies(validator, schema, rootSchema, formData);
+      var resolvedSchema = resolveDependencies(validator, schema, rootSchema, formData);
       return retrieveSchema(validator, resolvedSchema, rootSchema, formData);
     }
     if (ALL_OF_KEY in schema) {
-      return {
-        ...schema,
-        allOf: schema.allOf.map(allOfSubschema => retrieveSchema(validator, allOfSubschema, rootSchema, formData))
-      };
+      return _extends({}, schema, {
+        allOf: schema.allOf.map(function (allOfSubschema) {
+          return retrieveSchema(validator, allOfSubschema, rootSchema, formData);
+        })
+      });
     }
     // No $ref or dependencies attribute found, returning the original schema.
     return schema;
@@ -522,17 +586,11 @@
    */
   function resolveReference(validator, schema, rootSchema, formData) {
     // Retrieve the referenced schema definition.
-    const $refSchema = findSchemaDefinition(schema.$ref, rootSchema);
+    var $refSchema = findSchemaDefinition(schema.$ref, rootSchema);
     // Drop the $ref property of the source schema.
-    const {
-      $ref,
-      ...localSchema
-    } = schema;
+    var localSchema = _objectWithoutPropertiesLoose(schema, _excluded2);
     // Update referenced schema definition with local schema properties.
-    return retrieveSchema(validator, {
-      ...$refSchema,
-      ...localSchema
-    }, rootSchema, formData);
+    return retrieveSchema(validator, _extends({}, $refSchema, localSchema), rootSchema, formData);
   }
   /** Creates new 'properties' items for each key in the `formData`
    *
@@ -544,29 +602,24 @@
    */
   function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFormData) {
     // Clone the schema so we don't ruin the consumer's original
-    const schema = {
-      ...theSchema,
-      properties: {
-        ...theSchema.properties
-      }
-    };
+    var schema = _extends({}, theSchema, {
+      properties: _extends({}, theSchema.properties)
+    });
     // make sure formData is an object
-    const formData = aFormData && isObject(aFormData) ? aFormData : {};
-    Object.keys(formData).forEach(key => {
+    var formData = aFormData && isObject(aFormData) ? aFormData : {};
+    Object.keys(formData).forEach(function (key) {
       if (key in schema.properties) {
         // No need to stub, our schema already has the property
         return;
       }
-      let additionalProperties = {};
+      var 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 = _extends({}, schema.additionalProperties);
         } else {
           additionalProperties = {
             type: guessType(get__default["default"](formData, [key]))
@@ -601,46 +654,24 @@
     if (!isObject(schema)) {
       return {};
     }
-    let resolvedSchema = resolveSchema(validator, schema, rootSchema, rawFormData);
+    var 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.
-    // Otherwise, nested allOf subschemas will not be correctly displayed.
-    if (resolvedSchema.properties) {
-      const properties = {};
-      Object.entries(resolvedSchema.properties).forEach(entries => {
-        const propName = entries[0];
-        const propSchema = entries[1];
-        const rawPropData = formData[propName];
-        const propData = isObject(rawPropData) ? rawPropData : {};
-        const resolvedPropSchema = retrieveSchema(validator, propSchema, rootSchema, propData);
-        properties[propName] = resolvedPropSchema;
-        if (propSchema !== resolvedPropSchema && resolvedSchema.properties !== properties) {
-          resolvedSchema = {
-            ...resolvedSchema,
-            properties
-          };
-        }
-      });
-    }
+    var formData = rawFormData || {};
     if (ALL_OF_KEY in schema) {
       try {
-        resolvedSchema = mergeAllOf__default["default"]({
-          ...resolvedSchema,
-          allOf: resolvedSchema.allOf
+        resolvedSchema = mergeAllOf__default["default"](resolvedSchema, {
+          deep: false
         });
       } catch (e) {
         console.warn("could not merge subschemas in allOf:\n" + e);
-        const {
-          allOf,
-          ...resolvedSchemaWithoutAllOf
-        } = resolvedSchema;
+        var _resolvedSchema = resolvedSchema,
+          resolvedSchemaWithoutAllOf = _objectWithoutPropertiesLoose(_resolvedSchema, _excluded3);
         return resolvedSchemaWithoutAllOf;
       }
     }
-    const hasAdditionalProperties = ADDITIONAL_PROPERTIES_KEY in resolvedSchema && resolvedSchema.additionalProperties !== false;
+    var hasAdditionalProperties = ADDITIONAL_PROPERTIES_KEY in resolvedSchema && resolvedSchema.additionalProperties !== false;
     if (hasAdditionalProperties) {
       return stubExistingAdditionalProperties(validator, resolvedSchema, rootSchema, formData);
     }
@@ -656,11 +687,9 @@
    */
   function resolveDependencies(validator, schema, rootSchema, formData) {
     // Drop the dependencies from the source schema.
-    const {
-      dependencies,
-      ...remainingSchema
-    } = schema;
-    let resolvedSchema = remainingSchema;
+    var dependencies = schema.dependencies,
+      remainingSchema = _objectWithoutPropertiesLoose(schema, _excluded4);
+    var resolvedSchema = remainingSchema;
     if (Array.isArray(resolvedSchema.oneOf)) {
       resolvedSchema = resolvedSchema.oneOf[getMatchingOption(validator, formData, resolvedSchema.oneOf, rootSchema)];
     } else if (Array.isArray(resolvedSchema.anyOf)) {
@@ -678,9 +707,9 @@
    * @returns - The schema with the `dependencies` resolved into it
    */
   function processDependencies(validator, dependencies, resolvedSchema, rootSchema, formData) {
-    let schema = resolvedSchema;
+    var schema = resolvedSchema;
     // Process dependencies updating the local schema properties as appropriate.
-    for (const dependencyKey in dependencies) {
+    for (var dependencyKey in dependencies) {
       // Skip this dependency if its trigger property is not present.
       if (get__default["default"](formData, [dependencyKey]) === undefined) {
         continue;
@@ -689,7 +718,9 @@
       if (schema.properties && !(dependencyKey in schema.properties)) {
         continue;
       }
-      const [remainingDependencies, dependencyValue] = splitKeyElementFromObject(dependencyKey, dependencies);
+      var _splitKeyElementFromO = splitKeyElementFromObject(dependencyKey, dependencies),
+        remainingDependencies = _splitKeyElementFromO[0],
+        dependencyValue = _splitKeyElementFromO[1];
       if (Array.isArray(dependencyValue)) {
         schema = withDependentProperties(schema, dependencyValue);
       } else if (isObject(dependencyValue)) {
@@ -709,11 +740,10 @@
     if (!additionallyRequired) {
       return schema;
     }
-    const required = Array.isArray(schema.required) ? Array.from(new Set([...schema.required, ...additionallyRequired])) : additionallyRequired;
-    return {
-      ...schema,
+    var required = Array.isArray(schema.required) ? Array.from(new Set([].concat(schema.required, additionallyRequired))) : additionallyRequired;
+    return _extends({}, schema, {
       required: required
-    };
+    });
   }
   /** Merges a dependent schema into the `schema` dealing with oneOfs and references
    *
@@ -726,17 +756,16 @@
    * @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);
+    var _retrieveSchema = retrieveSchema(validator, dependencyValue, rootSchema, formData),
+      oneOf = _retrieveSchema.oneOf,
+      dependentSchema = _objectWithoutPropertiesLoose(_retrieveSchema, _excluded5);
     schema = mergeSchemas(schema, dependentSchema);
     // Since it does not contain oneOf, we return the original schema.
     if (oneOf === undefined) {
       return schema;
     }
     // Resolve $refs inside oneOf.
-    const resolvedOneOf = oneOf.map(subschema => {
+    var resolvedOneOf = oneOf.map(function (subschema) {
       if (typeof subschema === "boolean" || !(REF_KEY in subschema)) {
         return subschema;
       }
@@ -755,23 +784,19 @@
    * @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 => {
+    var validSubschemas = oneOf.filter(function (subschema) {
       if (typeof subschema === "boolean" || !subschema || !subschema.properties) {
         return false;
       }
-      const {
-        [dependencyKey]: conditionPropertySchema
-      } = subschema.properties;
+      var conditionPropertySchema = subschema.properties[dependencyKey];
       if (conditionPropertySchema) {
-        const conditionSchema = {
+        var _properties;
+        var conditionSchema = {
           type: "object",
-          properties: {
-            [dependencyKey]: conditionPropertySchema
-          }
+          properties: (_properties = {}, _properties[dependencyKey] = conditionPropertySchema, _properties)
         };
-        const {
-          errors
-        } = validator.validateFormData(formData, conditionSchema);
+        var _validator$validateFo = validator.validateFormData(formData, conditionSchema),
+          errors = _validator$validateFo.errors;
         return errors.length === 0;
       }
       return false;
@@ -780,12 +805,12 @@
       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,
+    var subschema = validSubschemas[0];
+    var _splitKeyElementFromO2 = splitKeyElementFromObject(dependencyKey, subschema.properties),
+      dependentSubschema = _splitKeyElementFromO2[0];
+    var dependentSchema = _extends({}, subschema, {
       properties: dependentSubschema
-    };
+    });
     return mergeSchemas(schema, retrieveSchema(validator, dependentSchema, rootSchema, formData));
   }
 
@@ -800,13 +825,15 @@
     if (rootSchema === void 0) {
       rootSchema = {};
     }
-    const schema = retrieveSchema(validator, theSchema, rootSchema, undefined);
-    const altSchemas = schema.oneOf || schema.anyOf;
-    if (Array.isArray(schema.enum)) {
+    var schema = retrieveSchema(validator, theSchema, rootSchema, undefined);
+    var 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 altSchemas.every(function (altSchemas) {
+        return typeof altSchemas !== "boolean" && isConstant(altSchemas);
+      });
     }
     return false;
   }
@@ -857,7 +884,7 @@
     }
     if (idx >= 0) {
       if (Array.isArray(schema.items) && idx < schema.items.length) {
-        const item = schema.items[idx];
+        var item = schema.items[idx];
         if (typeof item !== "boolean") {
           return item;
         }
@@ -878,34 +905,39 @@
    * @param [parentDefaults] - Any defaults provided by the parent field in the schema
    * @param [rootSchema] - The options root schema, used to primarily to look up `$ref`s
    * @param [rawFormData] - The current formData, if any, onto which to provide any missing defaults
-   * @param [includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults
+   * @param [includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults.
+   *          If "excludeObjectChildren", pass `includeUndefinedValues` as false when computing defaults for any nested
+   *          object properties.
    * @returns - The resulting `formData` with all the defaults provided
    */
-  function computeDefaults(validator, schema, parentDefaults, rootSchema, rawFormData, includeUndefinedValues) {
+  function computeDefaults(validator, rawSchema, parentDefaults, rootSchema, rawFormData, includeUndefinedValues) {
     if (rootSchema === void 0) {
       rootSchema = {};
     }
     if (includeUndefinedValues === void 0) {
       includeUndefinedValues = false;
     }
-    const formData = isObject(rawFormData) ? rawFormData : {};
+    var formData = isObject(rawFormData) ? rawFormData : {};
+    var schema = isObject(rawSchema) ? rawSchema : {};
     // Compute the defaults recursively: give highest priority to deepest nodes.
-    let defaults = parentDefaults;
-    if (isObject(defaults) && isObject(schema.default)) {
+    var defaults = parentDefaults;
+    if (isObject(defaults) && isObject(schema["default"])) {
       // For object defaults, only override parent defaults that are defined in
       // schema.default.
-      defaults = mergeObjects(defaults, schema.default);
+      defaults = mergeObjects(defaults, schema["default"]);
     } else if (DEFAULT_KEY in schema) {
-      defaults = schema.default;
+      defaults = schema["default"];
     } else if (REF_KEY in schema) {
       // Use referenced schema defaults for this node.
-      const refSchema = findSchemaDefinition(schema[REF_KEY], rootSchema);
+      var refSchema = findSchemaDefinition(schema[REF_KEY], rootSchema);
       return computeDefaults(validator, refSchema, defaults, rootSchema, formData, includeUndefinedValues);
     } else if (DEPENDENCIES_KEY in schema) {
-      const resolvedSchema = resolveDependencies(validator, schema, rootSchema, formData);
+      var resolvedSchema = resolveDependencies(validator, schema, rootSchema, formData);
       return computeDefaults(validator, resolvedSchema, defaults, rootSchema, formData, includeUndefinedValues);
     } else if (isFixedItems(schema)) {
-      defaults = schema.items.map((itemSchema, idx) => computeDefaults(validator, itemSchema, Array.isArray(parentDefaults) ? parentDefaults[idx] : undefined, rootSchema, formData, includeUndefinedValues));
+      defaults = schema.items.map(function (itemSchema, idx) {
+        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__default["default"](formData) ? undefined : formData, schema.oneOf, rootSchema)];
     } else if (ANY_OF_KEY in schema) {
@@ -913,16 +945,24 @@
     }
     // Not defaults defined for this node, fallback to generic typed ones.
     if (typeof defaults === "undefined") {
-      defaults = schema.default;
+      defaults = schema["default"];
     }
     switch (getSchemaType(schema)) {
       // We need to recur for object schema inner default values.
       case "object":
-        return Object.keys(schema.properties || {}).reduce((acc, key) => {
+        return Object.keys(schema.properties || {}).reduce(function (acc, key) {
           // 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) {
+          var computedDefault = computeDefaults(validator, get__default["default"](schema, [PROPERTIES_KEY, key]), get__default["default"](defaults, [key]), rootSchema, get__default["default"](formData, [key]), includeUndefinedValues === "excludeObjectChildren" ? false : includeUndefinedValues);
+          if (includeUndefinedValues) {
+            acc[key] = computedDefault;
+          } else if (isObject(computedDefault)) {
+            // Store computedDefault if it's a non-empty object (e.g. not {})
+            if (!isEmpty__default["default"](computedDefault)) {
+              acc[key] = computedDefault;
+            }
+          } else if (computedDefault !== undefined) {
+            // Store computedDefault if it's a defined primitive (e.g. true)
             acc[key] = computedDefault;
           }
           return acc;
@@ -930,27 +970,27 @@
       case "array":
         // Inject defaults into existing array defaults
         if (Array.isArray(defaults)) {
-          defaults = defaults.map((item, idx) => {
-            const schemaItem = getInnerSchemaForArrayItem(schema, AdditionalItemsHandling.Fallback, idx);
+          defaults = defaults.map(function (item, idx) {
+            var schemaItem = getInnerSchemaForArrayItem(schema, AdditionalItemsHandling.Fallback, idx);
             return computeDefaults(validator, schemaItem, item, rootSchema);
           });
         }
         // Deeply inject defaults into already existing form data
         if (Array.isArray(rawFormData)) {
-          const schemaItem = getInnerSchemaForArrayItem(schema);
-          defaults = rawFormData.map((item, idx) => {
+          var schemaItem = getInnerSchemaForArrayItem(schema);
+          defaults = rawFormData.map(function (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;
+            var defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
             if (schema.minItems > defaultsLength) {
-              const defaultEntries = defaults || [];
+              var 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));
+              var fillerSchema = getInnerSchemaForArrayItem(schema, AdditionalItemsHandling.Invert);
+              var fillerDefault = fillerSchema["default"];
+              var 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);
             }
@@ -967,7 +1007,9 @@
    * @param theSchema - The schema for which the default state is desired
    * @param [formData] - The current formData, if any, onto which to provide any missing defaults
    * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
-   * @param [includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults
+   * @param [includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults.
+   *          If "excludeObjectChildren", pass `includeUndefinedValues` as false when computing defaults for any nested
+   *          object properties.
    * @returns - The resulting `formData` with all the defaults provided
    */
   function getDefaultFormState(validator, theSchema, formData, rootSchema, includeUndefinedValues) {
@@ -977,8 +1019,8 @@
     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);
+    var schema = retrieveSchema(validator, theSchema, rootSchema, formData);
+    var defaults = computeDefaults(validator, schema, undefined, rootSchema, formData, includeUndefinedValues);
     if (typeof formData === "undefined" || formData === null || typeof formData === "number" && isNaN(formData)) {
       // No form data? Use schema defaults.
       return defaults;
@@ -1024,7 +1066,7 @@
       return true;
     }
     if (schema.items) {
-      const itemsSchema = retrieveSchema(validator, schema.items, rootSchema);
+      var itemsSchema = retrieveSchema(validator, schema.items, rootSchema);
       return itemsSchema.type === "string" && itemsSchema.format === "data-url";
     }
     return false;
@@ -1043,12 +1085,11 @@
     if (uiSchema === void 0) {
       uiSchema = {};
     }
-    const uiOptions = getUiOptions(uiSchema);
-    const {
-      label = true
-    } = uiOptions;
-    let displayLabel = !!label;
-    const schemaType = getSchemaType(schema);
+    var uiOptions = getUiOptions(uiSchema);
+    var _uiOptions$label = uiOptions.label,
+      label = _uiOptions$label === void 0 ? true : _uiOptions$label;
+    var displayLabel = !!label;
+    var schemaType = getSchemaType(schema);
     if (schemaType === "array") {
       displayLabel = isMultiSelect(validator, schema, rootSchema) || isFilesArray(validator, schema, uiSchema, rootSchema) || isCustomWidget(uiSchema);
     }
@@ -1078,19 +1119,17 @@
     if (!additionalErrorSchema) {
       return validationData;
     }
-    const {
-      errors: oldErrors,
-      errorSchema: oldErrorSchema
-    } = validationData;
-    let errors = validator.toErrorList(additionalErrorSchema);
-    let errorSchema = additionalErrorSchema;
+    var oldErrors = validationData.errors,
+      oldErrorSchema = validationData.errorSchema;
+    var errors = validator.toErrorList(additionalErrorSchema);
+    var errorSchema = additionalErrorSchema;
     if (!isEmpty__default["default"](oldErrorSchema)) {
       errorSchema = mergeObjects(oldErrorSchema, additionalErrorSchema, true);
-      errors = [...oldErrors].concat(errors);
+      errors = [].concat(oldErrors).concat(errors);
     }
     return {
-      errorSchema,
-      errors
+      errorSchema: errorSchema,
+      errors: errors
     };
   }
 
@@ -1113,20 +1152,20 @@
       idSeparator = "_";
     }
     if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
-      const _schema = retrieveSchema(validator, schema, rootSchema, formData);
+      var _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
+    var $id = id || idPrefix;
+    var idSchema = {
+      $id: $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;
+      for (var name in schema.properties) {
+        var field = get__default["default"](schema, [PROPERTIES_KEY, name]);
+        var 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
         // array item has just been added, but not populated with data yet
@@ -1146,27 +1185,26 @@
    * @returns - The `PathSchema` object for the `schema`
    */
   function toPathSchema(validator, schema, name, rootSchema, formData) {
+    var _pathSchema;
     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);
+      var _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) {
+    var pathSchema = (_pathSchema = {}, _pathSchema[NAME_KEY] = name.replace(/^\./, ""), _pathSchema);
+    if (ADDITIONAL_PROPERTIES_KEY in schema && schema[ADDITIONAL_PROPERTIES_KEY] !== false) {
       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);
+      formData.forEach(function (element, i) {
+        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,
+      for (var property in schema.properties) {
+        var 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
         // array item has just been added, but not populated with data yet
         get__default["default"](formData, [property]));
@@ -1180,13 +1218,13 @@
    * 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 {
+  var SchemaUtils = /*#__PURE__*/function () {
     /** Constructs the `SchemaUtils` instance with the given `validator` and `rootSchema` stored as instance variables
      *
      * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
      * @param rootSchema - The root schema that will be forwarded to all the APIs
      */
-    constructor(validator, rootSchema) {
+    function SchemaUtils(validator, rootSchema) {
       this.rootSchema = void 0;
       this.validator = void 0;
       this.rootSchema = rootSchema;
@@ -1196,7 +1234,8 @@
      *
      * @returns - The `ValidatorType`
      */
-    getValidator() {
+    var _proto = SchemaUtils.prototype;
+    _proto.getValidator = function getValidator() {
       return this.validator;
     }
     /** Determines whether either the `validator` and `rootSchema` differ from the ones associated with this instance of
@@ -1206,8 +1245,8 @@
      * @param validator - An implementation of the `ValidatorType` interface that will be compared against the current one
      * @param rootSchema - The root schema that will be compared against the current one
      * @returns - True if the `SchemaUtilsType` differs from the given `validator` or `rootSchema`
-     */
-    doesSchemaUtilsDiffer(validator, rootSchema) {
+     */;
+    _proto.doesSchemaUtilsDiffer = function doesSchemaUtilsDiffer(validator, rootSchema) {
       if (!validator || !rootSchema) {
         return false;
       }
@@ -1218,10 +1257,12 @@
      *
      * @param schema - The schema for which the default state is desired
      * @param [formData] - The current formData, if any, onto which to provide any missing defaults
-     * @param [includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults
+     * @param [includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults.
+     *          If "excludeObjectChildren", pass `includeUndefinedValues` as false when computing defaults for any nested
+     *          object properties.
      * @returns - The resulting `formData` with all the defaults provided
-     */
-    getDefaultFormState(schema, formData, includeUndefinedValues) {
+     */;
+    _proto.getDefaultFormState = function getDefaultFormState$1(schema, formData, includeUndefinedValues) {
       if (includeUndefinedValues === void 0) {
         includeUndefinedValues = false;
       }
@@ -1233,8 +1274,8 @@
      * @param schema - The schema for which the display label flag is desired
      * @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) {
+     */;
+    _proto.getDisplayLabel = function getDisplayLabel$1(schema, uiSchema) {
       return getDisplayLabel(this.validator, schema, uiSchema, this.rootSchema);
     }
     /** Given the `formData` and list of `options`, attempts to find the index of the option that best matches the data.
@@ -1242,8 +1283,8 @@
      * @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
-     */
-    getMatchingOption(formData, options) {
+     */;
+    _proto.getMatchingOption = function getMatchingOption$1(formData, options) {
       return getMatchingOption(this.validator, formData, options, this.rootSchema);
     }
     /** Checks to see if the `schema` and `uiSchema` combination represents an array of files
@@ -1251,24 +1292,24 @@
      * @param schema - The schema for which check for array of files flag is desired
      * @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) {
+     */;
+    _proto.isFilesArray = function isFilesArray$1(schema, uiSchema) {
       return isFilesArray(this.validator, schema, uiSchema, this.rootSchema);
     }
     /** Checks to see if the `schema` combination represents a multi-select
      *
      * @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) {
+     */;
+    _proto.isMultiSelect = function isMultiSelect$1(schema) {
       return isMultiSelect(this.validator, schema, this.rootSchema);
     }
     /** Checks to see if the `schema` combination represents a select
      *
      * @param schema - The schema for which check for a select flag is desired
      * @returns - True if schema contains a select, otherwise false
-     */
-    isSelect(schema) {
+     */;
+    _proto.isSelect = function isSelect$1(schema) {
       return isSelect(this.validator, schema, this.rootSchema);
     }
     /** Merges the errors in `additionalErrorSchema` into the existing `validationData` by combining the hierarchies in
@@ -1279,8 +1320,8 @@
      * @param validationData - The current `ValidationData` into which to merge the additional errors
      * @param [additionalErrorSchema] - The additional set of errors
      * @returns - The `validationData` with the additional errors from `additionalErrorSchema` merged into it, if provided.
-     */
-    mergeValidationData(validationData, additionalErrorSchema) {
+     */;
+    _proto.mergeValidationData = function mergeValidationData$1(validationData, additionalErrorSchema) {
       return mergeValidationData(this.validator, validationData, additionalErrorSchema);
     }
     /** Retrieves an expanded schema that has had all of its conditions, additional properties, references and
@@ -1290,8 +1331,8 @@
      * @param schema - The schema for which retrieving a schema is desired
      * @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) {
+     */;
+    _proto.retrieveSchema = function retrieveSchema$1(schema, rawFormData) {
       return retrieveSchema(this.validator, schema, this.rootSchema, rawFormData);
     }
     /** Generates an `IdSchema` object for the `schema`, recursively
@@ -1302,8 +1343,8 @@
      * @param [idPrefix='root'] - The prefix to use for the id
      * @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) {
+     */;
+    _proto.toIdSchema = function toIdSchema$1(schema, id, formData, idPrefix, idSeparator) {
       if (idPrefix === void 0) {
         idPrefix = "root";
       }
@@ -1318,11 +1359,12 @@
      * @param [name] - The base name for the schema
      * @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) {
+     */;
+    _proto.toPathSchema = function toPathSchema$1(schema, name, formData) {
       return toPathSchema(this.validator, schema, name, this.rootSchema, formData);
-    }
-  }
+    };
+    return SchemaUtils;
+  }();
   /** 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.
    *
@@ -1342,17 +1384,17 @@
    */
   function dataURItoBlob(dataURI) {
     // Split metadata from data
-    const splitted = dataURI.split(",");
+    var splitted = dataURI.split(",");
     // Split params
-    const params = splitted[0].split(";");
+    var params = splitted[0].split(";");
     // Get mime-type from params
-    const type = params[0].replace("data:", "");
+    var type = params[0].replace("data:", "");
     // Filter the name property from params
-    const properties = params.filter(param => {
+    var properties = params.filter(function (param) {
       return param.split("=")[0] === "name";
     });
     // Look for the name and use unknown if no name property.
-    let name;
+    var name;
     if (properties.length !== 1) {
       name = "unknown";
     } else {
@@ -1361,21 +1403,126 @@
       name = properties[0].split("=")[1];
     }
     // Built the Uint8Array Blob parameter from the base64 string.
-    const binary = atob(splitted[1]);
-    const array = [];
-    for (let i = 0; i < binary.length; i++) {
+    var binary = atob(splitted[1]);
+    var array = [];
+    for (var i = 0; i < binary.length; i++) {
       array.push(binary.charCodeAt(i));
     }
     // Create the blob object
-    const blob = new window.Blob([new Uint8Array(array)], {
-      type
+    var blob = new window.Blob([new Uint8Array(array)], {
+      type: type
     });
     return {
-      blob,
-      name
+      blob: blob,
+      name: name
     };
   }
 
+  /** The `ErrorSchemaBuilder<T>` is used to build an `ErrorSchema<T>` since the definition of the `ErrorSchema` type is
+   * designed for reading information rather than writing it. Use this class to add, replace or clear errors in an error
+   * schema by using either dotted path or an array of path names. Once you are done building the `ErrorSchema`, you can
+   * get the result and/or reset all the errors back to an initial set and start again.
+   */
+  var ErrorSchemaBuilder = /*#__PURE__*/function () {
+    /** The error schema being built
+     *
+     * @private
+     */
+
+    /** Construct an `ErrorSchemaBuilder` with an optional initial set of errors in an `ErrorSchema`.
+     *
+     * @param [initialSchema] - The optional set of initial errors, that will be cloned into the class
+     */
+    function ErrorSchemaBuilder(initialSchema) {
+      this.errorSchema = {};
+      this.resetAllErrors(initialSchema);
+    }
+    /** Returns the `ErrorSchema` that has been updated by the methods of the `ErrorSchemaBuilder`
+     */
+    var _proto = ErrorSchemaBuilder.prototype;
+    /** Will get an existing `ErrorSchema` at the specified `pathOfError` or create and return one.
+     *
+     * @param [pathOfError] - The optional path into the `ErrorSchema` at which to add the error(s)
+     * @returns - The error block for the given `pathOfError` or the root if not provided
+     * @private
+     */
+    _proto.getOrCreateErrorBlock = function getOrCreateErrorBlock(pathOfError) {
+      var hasPath = Array.isArray(pathOfError) && pathOfError.length > 0 || typeof pathOfError === "string";
+      var errorBlock = hasPath ? get__default["default"](this.errorSchema, pathOfError) : this.errorSchema;
+      if (!errorBlock && pathOfError) {
+        errorBlock = {};
+        set__default["default"](this.errorSchema, pathOfError, errorBlock);
+      }
+      return errorBlock;
+    }
+    /** Resets all errors in the `ErrorSchemaBuilder` back to the `initialSchema` if provided, otherwise an empty set.
+     *
+     * @param [initialSchema] - The optional set of initial errors, that will be cloned into the class
+     * @returns - The `ErrorSchemaBuilder` object for chaining purposes
+     */;
+    _proto.resetAllErrors = function resetAllErrors(initialSchema) {
+      this.errorSchema = initialSchema ? cloneDeep__default["default"](initialSchema) : {};
+      return this;
+    }
+    /** Adds the `errorOrList` to the list of errors in the `ErrorSchema` at either the root level or the location within
+     * the schema described by the `pathOfError`. For more information about how to specify the path see the
+     * [eslint lodash plugin docs](https://github.com/wix/eslint-plugin-lodash/blob/master/docs/rules/path-style.md).
+     *
+     * @param errorOrList - The error or list of errors to add into the `ErrorSchema`
+     * @param [pathOfError] - The optional path into the `ErrorSchema` at which to add the error(s)
+     * @returns - The `ErrorSchemaBuilder` object for chaining purposes
+     */;
+    _proto.addErrors = function addErrors(errorOrList, pathOfError) {
+      var errorBlock = this.getOrCreateErrorBlock(pathOfError);
+      var errorsList = get__default["default"](errorBlock, ERRORS_KEY);
+      if (!Array.isArray(errorsList)) {
+        errorsList = [];
+        errorBlock[ERRORS_KEY] = errorsList;
+      }
+      if (Array.isArray(errorOrList)) {
+        var _errorsList;
+        (_errorsList = errorsList).push.apply(_errorsList, errorOrList);
+      } else {
+        errorsList.push(errorOrList);
+      }
+      return this;
+    }
+    /** Sets/replaces the `errorOrList` as the error(s) in the `ErrorSchema` at either the root level or the location
+     * within the schema described by the `pathOfError`. For more information about how to specify the path see the
+     * [eslint lodash plugin docs](https://github.com/wix/eslint-plugin-lodash/blob/master/docs/rules/path-style.md).
+     *
+     * @param errorOrList - The error or list of errors to set into the `ErrorSchema`
+     * @param [pathOfError] - The optional path into the `ErrorSchema` at which to set the error(s)
+     * @returns - The `ErrorSchemaBuilder` object for chaining purposes
+     */;
+    _proto.setErrors = function setErrors(errorOrList, pathOfError) {
+      var errorBlock = this.getOrCreateErrorBlock(pathOfError);
+      // Effectively clone the array being given to prevent accidental outside manipulation of the given list
+      var listToAdd = Array.isArray(errorOrList) ? [].concat(errorOrList) : [errorOrList];
+      set__default["default"](errorBlock, ERRORS_KEY, listToAdd);
+      return this;
+    }
+    /** Clears the error(s) in the `ErrorSchema` at either the root level or the location within the schema described by
+     * the `pathOfError`. For more information about how to specify the path see the
+     * [eslint lodash plugin docs](https://github.com/wix/eslint-plugin-lodash/blob/master/docs/rules/path-style.md).
+     *
+     * @param [pathOfError] - The optional path into the `ErrorSchema` at which to clear the error(s)
+     * @returns - The `ErrorSchemaBuilder` object for chaining purposes
+     */;
+    _proto.clearErrors = function clearErrors(pathOfError) {
+      var errorBlock = this.getOrCreateErrorBlock(pathOfError);
+      set__default["default"](errorBlock, ERRORS_KEY, []);
+      return this;
+    };
+    _createClass(ErrorSchemaBuilder, [{
+      key: "ErrorSchema",
+      get: function get() {
+        return this.errorSchema;
+      }
+    }]);
+    return ErrorSchemaBuilder;
+  }();
+
   /** Extracts the range spec information `{ step?: number, min?: number, max?: number }` that can be spread onto an HTML
    * input from the range analog in the schema `{ multipleOf?: number, minimum?: number, maximum?: number }`.
    *
@@ -1383,7 +1530,7 @@
    * @returns - A range specification from the schema
    */
   function rangeSpec(schema) {
-    const spec = {};
+    var spec = {};
     if (schema.multipleOf) {
       spec.step = schema.multipleOf;
     }
@@ -1411,10 +1558,9 @@
     if (autoDefaultStepAny === void 0) {
       autoDefaultStepAny = true;
     }
-    const inputProps = {
-      type: defaultType || "text",
-      ...rangeSpec(schema)
-    };
+    var inputProps = _extends({
+      type: defaultType || "text"
+    }, rangeSpec(schema));
     // If options.inputType is set use that as the input type
     if (options.inputType) {
       inputProps.type = options.inputType;
@@ -1445,7 +1591,7 @@
 
   /** The default submit button options, exported for testing purposes
    */
-  const DEFAULT_OPTIONS = {
+  var DEFAULT_OPTIONS = {
     props: {
       disabled: false
     },
@@ -1461,13 +1607,10 @@
     if (uiSchema === void 0) {
       uiSchema = {};
     }
-    const uiOptions = getUiOptions(uiSchema);
+    var uiOptions = getUiOptions(uiSchema);
     if (uiOptions && uiOptions[SUBMIT_BTN_OPTIONS_KEY]) {
-      const options = uiOptions[SUBMIT_BTN_OPTIONS_KEY];
-      return {
-        ...DEFAULT_OPTIONS,
-        ...options
-      };
+      var options = uiOptions[SUBMIT_BTN_OPTIONS_KEY];
+      return _extends({}, DEFAULT_OPTIONS, options);
     }
     return DEFAULT_OPTIONS;
   }
@@ -1484,9 +1627,7 @@
     if (uiOptions === void 0) {
       uiOptions = {};
     }
-    const {
-      templates
-    } = registry;
+    var templates = registry.templates;
     if (name === "ButtonTemplates") {
       return templates[name];
     }
@@ -1497,10 +1638,11 @@
     );
   }
 
+  var _excluded = ["options"];
   /** The map of schema types to widget type to widget name
    */
-  const widgetMap = {
-    boolean: {
+  var widgetMap = {
+    "boolean": {
       checkbox: "CheckboxWidget",
       radio: "RadioWidget",
       select: "SelectWidget",
@@ -1558,22 +1700,16 @@
    * @returns - The wrapper widget
    */
   function mergeWidgetOptions(AWidget) {
-    let MergedWidget = get__default["default"](AWidget, "MergedWidget");
+    var 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
-          },
-          ...props
-        });
+      var defaultOptions = AWidget.defaultProps && AWidget.defaultProps.options || {};
+      MergedWidget = function MergedWidget(_ref) {
+        var options = _ref.options,
+          props = _objectWithoutPropertiesLoose(_ref, _excluded);
+        return /*#__PURE__*/React__default["default"].createElement(AWidget, _extends({
+          options: _extends({}, defaultOptions, options)
+        }, props));
       };
       set__default["default"](AWidget, "MergedWidget", MergedWidget);
     }
@@ -1594,27 +1730,27 @@
     if (registeredWidgets === void 0) {
       registeredWidgets = {};
     }
-    const type = getSchemaType(schema);
+    var 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];
+      var 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);
+        var _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
@@ -1633,7 +1769,7 @@
       getWidget(schema, widget, registeredWidgets);
       return true;
     } catch (e) {
-      const err = e;
+      var err = e;
       if (err.message && (err.message.startsWith("No widget") || err.message.startsWith("Unsupported widget"))) {
         return false;
       }
@@ -1658,11 +1794,11 @@
    * @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 (ENUM_KEY in schema && Array.isArray(schema["enum"]) && schema["enum"].length === 1) {
+      return schema["enum"][0];
     }
     if (CONST_KEY in schema) {
-      return schema.const;
+      return schema["const"];
     }
     throw new Error("schema cannot be inferred as a constant");
   }
@@ -1678,28 +1814,28 @@
   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;
+    var 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);
+    if (schema["enum"]) {
+      return schema["enum"].map(function (value, i) {
+        var label = schemaWithEnumNames.enumNames && schemaWithEnumNames.enumNames[i] || String(value);
         return {
-          label,
-          value
+          label: label,
+          value: value
         };
       });
     }
-    const altSchemas = schema.oneOf || schema.anyOf;
-    return altSchemas && altSchemas.map(aSchemaDef => {
-      const aSchema = aSchemaDef;
-      const value = toConstant(aSchema);
-      const label = aSchema.title || String(value);
+    var altSchemas = schema.oneOf || schema.anyOf;
+    return altSchemas && altSchemas.map(function (aSchemaDef) {
+      var aSchema = aSchemaDef;
+      var value = toConstant(aSchema);
+      var label = aSchema.title || String(value);
       return {
         schema: aSchema,
-        label,
-        value
+        label: label,
+        value: value
       };
     });
   }
@@ -1718,27 +1854,35 @@
     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 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("*");
+    var arrayToHash = function arrayToHash(arr) {
+      return arr.reduce(function (prev, curr) {
+        prev[curr] = true;
+        return prev;
+      }, {});
+    };
+    var errorPropList = function errorPropList(arr) {
+      return arr.length > 1 ? "properties '" + arr.join("', '") + "'" : "property '" + arr[0] + "'";
+    };
+    var propertyHash = arrayToHash(properties);
+    var orderFiltered = order.filter(function (prop) {
+      return prop === "*" || propertyHash[prop];
+    });
+    var orderHash = arrayToHash(orderFiltered);
+    var rest = properties.filter(function (prop) {
+      return !orderHash[prop];
+    });
+    var 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);
+    var complete = [].concat(orderFiltered);
+    complete.splice.apply(complete, [restIndex, 1].concat(rest));
     return complete;
   }
 
@@ -1749,7 +1893,7 @@
    * @returns - The number converted to a string with leading zero padding if the number of digits is less than `width`
    */
   function pad(num, width) {
-    let s = String(num);
+    var s = String(num);
     while (s.length < width) {
       s = "0" + s;
     }
@@ -1777,7 +1921,7 @@
         second: includeTime ? -1 : 0
       };
     }
-    const date = new Date(dateString);
+    var date = new Date(dateString);
     if (Number.isNaN(date.getTime())) {
       throw new Error("Unable to parse date " + dateString);
     }
@@ -1791,7 +1935,7 @@
     };
   }
 
-  const nums = /*#__PURE__*/new Set(["number", "integer"]);
+  var nums = /*#__PURE__*/new Set(["number", "integer"]);
   /** Returns the real value for a select widget due to a silly limitation in the DOM which causes option change event
    * values to always be retrieved as strings. Uses the `schema` to help determine the value's true type. If the value is
    * an empty string, then the `emptyValue` from the `options` is returned, falling back to undefined.
@@ -1802,11 +1946,9 @@
    * @returns - The `value` converted to the proper type
    */
   function processSelectValue(schema, value, options) {
-    const {
-      enum: schemaEnum,
-      type,
-      items
-    } = schema;
+    var schemaEnum = schema["enum"],
+      type = schema.type,
+      items = schema.items;
     if (value === "") {
       return options && options.emptyValue !== undefined ? options.emptyValue : undefined;
     }
@@ -1822,10 +1964,14 @@
     // 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)))) {
+      if (schemaEnum.every(function (x) {
+        return nums.has(guessType(x));
+      })) {
         return asNumber(value);
       }
-      if (schemaEnum.every(x => guessType(x) === "boolean")) {
+      if (schemaEnum.every(function (x) {
+        return guessType(x) === "boolean";
+      })) {
         return value === "true";
       }
     }
@@ -1843,11 +1989,11 @@
    */
   function schemaRequiresTrueValue(schema) {
     // Check if const is a truthy value
-    if (schema.const) {
+    if (schema["const"]) {
       return true;
     }
     // Check if an enum has a single value of true
-    if (schema.enum && schema.enum.length === 1 && schema.enum[0] === true) {
+    if (schema["enum"] && schema["enum"].length === 1 && schema["enum"][0] === true) {
       return true;
     }
     // If anyOf has a single value, evaluate the subschema
@@ -1860,7 +2006,9 @@
     }
     // Evaluate each subschema in allOf, to see if one of them requires a true value
     if (schema.allOf) {
-      const schemaSome = subSchema => schemaRequiresTrueValue(subSchema);
+      var schemaSome = function schemaSome(subSchema) {
+        return schemaRequiresTrueValue(subSchema);
+      };
       return schema.allOf.some(schemaSome);
     }
     return false;
@@ -1875,10 +2023,8 @@
    * @returns - True if the component should be re-rendered, false otherwise
    */
   function shouldRender(component, nextProps, nextState) {
-    const {
-      props,
-      state
-    } = component;
+    var props = component.props,
+      state = component.state;
     return !deepEquals(props, nextProps) || !deepEquals(state, nextState);
   }
 
@@ -1893,16 +2039,17 @@
     if (time === void 0) {
       time = true;
     }
-    const {
-      year,
-      month,
-      day,
-      hour = 0,
-      minute = 0,
-      second = 0
-    } = dateObject;
-    const utcTime = Date.UTC(year, month - 1, day, hour, minute, second);
-    const datetime = new Date(utcTime).toJSON();
+    var year = dateObject.year,
+      month = dateObject.month,
+      day = dateObject.day,
+      _dateObject$hour = dateObject.hour,
+      hour = _dateObject$hour === void 0 ? 0 : _dateObject$hour,
+      _dateObject$minute = dateObject.minute,
+      minute = _dateObject$minute === void 0 ? 0 : _dateObject$minute,
+      _dateObject$second = dateObject.second,
+      second = _dateObject$second === void 0 ? 0 : _dateObject$second;
+    var utcTime = Date.UTC(year, month - 1, day, hour, minute, second);
+    var datetime = new Date(utcTime).toJSON();
     return time ? datetime : datetime.slice(0, 10);
   }
 
@@ -1920,15 +2067,15 @@
     // > 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);
-    const dd = pad(date.getDate(), 2);
-    const hh = pad(date.getHours(), 2);
-    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}`;
+    var date = new Date(jsonDate);
+    var yyyy = pad(date.getFullYear(), 4);
+    var MM = pad(date.getMonth() + 1, 2);
+    var dd = pad(date.getDate(), 2);
+    var hh = pad(date.getHours(), 2);
+    var mm = pad(date.getMinutes(), 2);
+    var ss = pad(date.getSeconds(), 2);
+    var SSS = pad(date.getMilliseconds(), 3);
+    return yyyy + "-" + MM + "-" + dd + "T" + hh + ":" + mm + ":" + ss + "." + SSS;
   }
 
   exports.ADDITIONAL_PROPERTIES_KEY = ADDITIONAL_PROPERTIES_KEY;
@@ -1941,6 +2088,7 @@
   exports.DEPENDENCIES_KEY = DEPENDENCIES_KEY;
   exports.ENUM_KEY = ENUM_KEY;
   exports.ERRORS_KEY = ERRORS_KEY;
+  exports.ErrorSchemaBuilder = ErrorSchemaBuilder;
   exports.ID_KEY = ID_KEY;
   exports.ITEMS_KEY = ITEMS_KEY;
   exports.NAME_KEY = NAME_KEY;