@rjsf/utils 5.0.2 → 5.1.0

package/dist/utils.esm.js

@@ -1071,17 +1071,48 @@ function getInnerSchemaForArrayItem(schema, additionalItems, idx) {
   }
   return {};
 }
+/** Either add `computedDefault` at `key` into `obj` or not add it based on its value and the value of
+ * `includeUndefinedValues`. Generally undefined `computedDefault` values are added only when `includeUndefinedValues`
+ * is either true or "excludeObjectChildren". If `includeUndefinedValues` is false, then non-undefined and
+ * non-empty-object values will be added.
+ *
+ * @param obj - The object into which the computed default may be added
+ * @param key - The key into the object at which the computed default may be added
+ * @param computedDefault - The computed default value that maybe should be added to the obj
+ * @param includeUndefinedValues - Optional flag, if true, cause undefined values to be added as defaults.
+ *          If "excludeObjectChildren", cause undefined values for this object and pass `includeUndefinedValues` as
+ *          false when computing defaults for any nested object properties. If "allowEmptyObject", prevents undefined
+ *          values in this object while allow the object itself to be empty and passing `includeUndefinedValues` as
+ *          false when computing defaults for any nested object properties.
+ * @param requiredFields - The list of fields that are required
+ */
+function maybeAddDefaultToObject(obj, key, computedDefault, includeUndefinedValues, requiredFields) {
+  if (requiredFields === void 0) {
+    requiredFields = [];
+  }
+  if (includeUndefinedValues) {
+    obj[key] = computedDefault;
+  } else if (isObject(computedDefault)) {
+    // Store computedDefault if it's a non-empty object (e.g. not {})
+    if (!isEmpty(computedDefault) || requiredFields.includes(key)) {
+      obj[key] = computedDefault;
+    }
+  } else if (computedDefault !== undefined) {
+    // Store computedDefault if it's a defined primitive (e.g. true)
+    obj[key] = computedDefault;
+  }
+}
 /** Computes the defaults for the current `schema` given the `rawFormData` and `parentDefaults` if any. This drills into
  * each level of the schema, recursively, to fill out every level of defaults provided by the schema.
  *
  * @param validator - an implementation of the `ValidatorType` interface that will be used when necessary
- * @param schema - The schema for which the default state is desired
+ * @param rawSchema - The schema for which the default state is desired
  * @param [parentDefaults] - Any defaults provided by the parent field in the schema
  * @param [rootSchema] - The options root schema, used to primarily to look up `$ref`s
  * @param [rawFormData] - The current formData, if any, onto which to provide any missing defaults
  * @param [includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults.
- *          If "excludeObjectChildren", pass `includeUndefinedValues` as false when computing defaults for any nested
- *          object properties.
+ *          If "excludeObjectChildren", cause undefined values for this object and pass `includeUndefinedValues` as
+ *          false when computing defaults for any nested object properties.
  * @returns - The resulting `formData` with all the defaults provided
  */
 function computeDefaults(validator, rawSchema, parentDefaults, rootSchema, rawFormData, includeUndefinedValues) {
@@ -1113,8 +1144,14 @@ function computeDefaults(validator, rawSchema, parentDefaults, rootSchema, rawFo
       return computeDefaults(validator, itemSchema, Array.isArray(parentDefaults) ? parentDefaults[idx] : undefined, rootSchema, formData, includeUndefinedValues);
     });
   } else if (ONE_OF_KEY in schema) {
+    if (schema.oneOf.length === 0) {
+      return undefined;
+    }
     schema = schema.oneOf[getClosestMatchingOption(validator, rootSchema, isEmpty(formData) ? undefined : formData, schema.oneOf, 0)];
   } else if (ANY_OF_KEY in schema) {
+    if (schema.anyOf.length === 0) {
+      return undefined;
+    }
     schema = schema.anyOf[getClosestMatchingOption(validator, rootSchema, isEmpty(formData) ? undefined : formData, schema.anyOf, 0)];
   }
   // Not defaults defined for this node, fallback to generic typed ones.
@@ -1124,23 +1161,25 @@ function computeDefaults(validator, rawSchema, parentDefaults, rootSchema, rawFo
   switch (getSchemaType(schema)) {
     // We need to recur for object schema inner default values.
     case "object":
-      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].
-        var computedDefault = computeDefaults(validator, get(schema, [PROPERTIES_KEY, key]), get(defaults, [key]), rootSchema, get(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(computedDefault)) {
-            acc[key] = computedDefault;
-          }
-        } else if (computedDefault !== undefined) {
-          // Store computedDefault if it's a defined primitive (e.g. true)
-          acc[key] = computedDefault;
+      {
+        var objectDefaults = 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].
+          var computedDefault = computeDefaults(validator, get(schema, [PROPERTIES_KEY, key]), get(defaults, [key]), rootSchema, get(formData, [key]), includeUndefinedValues === true);
+          maybeAddDefaultToObject(acc, key, computedDefault, includeUndefinedValues, schema.required);
+          return acc;
+        }, {});
+        if (schema.additionalProperties && isObject(defaults)) {
+          var additionalPropertiesSchema = isObject(schema.additionalProperties) ? schema.additionalProperties : {}; // as per spec additionalProperties may be either schema or boolean
+          Object.keys(defaults).filter(function (key) {
+            return !schema.properties || !schema.properties[key];
+          }).forEach(function (key) {
+            var computedDefault = computeDefaults(validator, additionalPropertiesSchema, get(defaults, [key]), rootSchema, get(formData, [key]), includeUndefinedValues === true);
+            maybeAddDefaultToObject(objectDefaults, key, computedDefault, includeUndefinedValues);
+          });
         }
-        return acc;
-      }, {});
+        return objectDefaults;
+      }
     case "array":
       // Inject defaults into existing array defaults
       if (Array.isArray(defaults)) {
@@ -1182,8 +1221,8 @@ function computeDefaults(validator, rawSchema, parentDefaults, rootSchema, rawFo
  * @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.
- *          If "excludeObjectChildren", pass `includeUndefinedValues` as false when computing defaults for any nested
- *          object properties.
+ *          If "excludeObjectChildren", cause undefined values for this object and 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) {