@rjsf/utils 5.20.1 → 5.21.1

package/dist/utils.umd.js

@@ -941,15 +941,16 @@
       }
     }
   }
-  function computeDefaults(validator, rawSchema, {
-    parentDefaults,
-    rawFormData,
-    rootSchema = {},
-    includeUndefinedValues = false,
-    _recurseList = [],
-    experimental_defaultFormStateBehavior = void 0,
-    required
-  } = {}) {
+  function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
+    const {
+      parentDefaults,
+      rawFormData,
+      rootSchema = {},
+      includeUndefinedValues = false,
+      _recurseList = [],
+      experimental_defaultFormStateBehavior = void 0,
+      required
+    } = computeDefaultsProps;
     const formData = isObject(rawFormData) ? rawFormData : {};
     const schema = isObject(rawSchema) ? rawSchema : {};
     let defaults = parentDefaults;
@@ -966,7 +967,11 @@
         schemaToCompute = findSchemaDefinition(refName, rootSchema);
       }
     } else if (DEPENDENCIES_KEY in schema) {
-      const resolvedSchema = resolveDependencies(validator, schema, rootSchema, false, [], formData);
+      const defaultFormData = {
+        ...formData,
+        ...getDefaultBasedOnSchemaType(validator, schema, computeDefaultsProps, defaults)
+      };
+      const resolvedSchema = resolveDependencies(validator, schema, rootSchema, false, [], defaultFormData);
       schemaToCompute = resolvedSchema[0];
     } else if (isFixedItems(schema)) {
       defaults = schema.items.map(
@@ -1025,127 +1030,154 @@
     if (defaults === void 0) {
       defaults = schema.default;
     }
-    switch (getSchemaType(schema)) {
-      case "object": {
-        const retrievedSchema = experimental_defaultFormStateBehavior?.allOf === "populateDefaults" && ALL_OF_KEY in schema ? retrieveSchema(validator, schema, rootSchema, formData) : schema;
-        const objectDefaults = Object.keys(retrievedSchema.properties || {}).reduce(
-          (acc, key) => {
-            const computedDefault = computeDefaults(validator, get8(retrievedSchema, [PROPERTIES_KEY, key]), {
-              rootSchema,
-              _recurseList,
-              experimental_defaultFormStateBehavior,
-              includeUndefinedValues: includeUndefinedValues === true,
-              parentDefaults: get8(defaults, [key]),
-              rawFormData: get8(formData, [key]),
-              required: retrievedSchema.required?.includes(key)
-            });
-            maybeAddDefaultToObject(
-              acc,
-              key,
-              computedDefault,
-              includeUndefinedValues,
-              required,
-              retrievedSchema.required,
-              experimental_defaultFormStateBehavior
-            );
-            return acc;
-          },
-          {}
-        );
-        if (retrievedSchema.additionalProperties) {
-          const additionalPropertiesSchema = isObject(retrievedSchema.additionalProperties) ? retrievedSchema.additionalProperties : {};
-          const keys = /* @__PURE__ */ new Set();
-          if (isObject(defaults)) {
-            Object.keys(defaults).filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key]).forEach((key) => keys.add(key));
-          }
-          const formDataRequired = [];
-          Object.keys(formData).filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key]).forEach((key) => {
-            keys.add(key);
-            formDataRequired.push(key);
-          });
-          keys.forEach((key) => {
-            const computedDefault = computeDefaults(validator, additionalPropertiesSchema, {
-              rootSchema,
-              _recurseList,
-              experimental_defaultFormStateBehavior,
-              includeUndefinedValues: includeUndefinedValues === true,
-              parentDefaults: get8(defaults, [key]),
-              rawFormData: get8(formData, [key]),
-              required: retrievedSchema.required?.includes(key)
-            });
-            maybeAddDefaultToObject(
-              objectDefaults,
-              key,
-              computedDefault,
-              includeUndefinedValues,
-              required,
-              formDataRequired
-            );
+    const defaultBasedOnSchemaType = getDefaultBasedOnSchemaType(validator, schema, computeDefaultsProps, defaults);
+    return defaultBasedOnSchemaType ?? defaults;
+  }
+  function getObjectDefaults(validator, rawSchema, {
+    rawFormData,
+    rootSchema = {},
+    includeUndefinedValues = false,
+    _recurseList = [],
+    experimental_defaultFormStateBehavior = void 0,
+    required
+  } = {}, defaults) {
+    {
+      const formData = isObject(rawFormData) ? rawFormData : {};
+      const schema = rawSchema;
+      const retrievedSchema = experimental_defaultFormStateBehavior?.allOf === "populateDefaults" && ALL_OF_KEY in schema ? retrieveSchema(validator, schema, rootSchema, formData) : schema;
+      const objectDefaults = Object.keys(retrievedSchema.properties || {}).reduce(
+        (acc, key) => {
+          const computedDefault = computeDefaults(validator, get8(retrievedSchema, [PROPERTIES_KEY, key]), {
+            rootSchema,
+            _recurseList,
+            experimental_defaultFormStateBehavior,
+            includeUndefinedValues: includeUndefinedValues === true,
+            parentDefaults: get8(defaults, [key]),
+            rawFormData: get8(formData, [key]),
+            required: retrievedSchema.required?.includes(key)
           });
+          maybeAddDefaultToObject(
+            acc,
+            key,
+            computedDefault,
+            includeUndefinedValues,
+            required,
+            retrievedSchema.required,
+            experimental_defaultFormStateBehavior
+          );
+          return acc;
+        },
+        {}
+      );
+      if (retrievedSchema.additionalProperties) {
+        const additionalPropertiesSchema = isObject(retrievedSchema.additionalProperties) ? retrievedSchema.additionalProperties : {};
+        const keys = /* @__PURE__ */ new Set();
+        if (isObject(defaults)) {
+          Object.keys(defaults).filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key]).forEach((key) => keys.add(key));
         }
-        return objectDefaults;
-      }
-      case "array": {
-        const neverPopulate = experimental_defaultFormStateBehavior?.arrayMinItems?.populate === "never";
-        const ignoreMinItemsFlagSet = experimental_defaultFormStateBehavior?.arrayMinItems?.populate === "requiredOnly";
-        const isSkipEmptyDefaults = experimental_defaultFormStateBehavior?.emptyObjectFields === "skipEmptyDefaults";
-        const computeSkipPopulate = experimental_defaultFormStateBehavior?.arrayMinItems?.computeSkipPopulate ?? (() => false);
-        const emptyDefault = isSkipEmptyDefaults ? void 0 : [];
-        if (Array.isArray(defaults)) {
-          defaults = defaults.map((item, idx) => {
-            const schemaItem = getInnerSchemaForArrayItem(schema, 2 /* Fallback */, idx);
-            return computeDefaults(validator, schemaItem, {
-              rootSchema,
-              _recurseList,
-              experimental_defaultFormStateBehavior,
-              parentDefaults: item,
-              required
-            });
+        const formDataRequired = [];
+        Object.keys(formData).filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key]).forEach((key) => {
+          keys.add(key);
+          formDataRequired.push(key);
+        });
+        keys.forEach((key) => {
+          const computedDefault = computeDefaults(validator, additionalPropertiesSchema, {
+            rootSchema,
+            _recurseList,
+            experimental_defaultFormStateBehavior,
+            includeUndefinedValues: includeUndefinedValues === true,
+            parentDefaults: get8(defaults, [key]),
+            rawFormData: get8(formData, [key]),
+            required: retrievedSchema.required?.includes(key)
           });
-        }
-        if (Array.isArray(rawFormData)) {
-          const schemaItem = getInnerSchemaForArrayItem(schema);
-          if (neverPopulate) {
-            defaults = rawFormData;
-          } else {
-            defaults = rawFormData.map((item, idx) => {
-              return computeDefaults(validator, schemaItem, {
-                rootSchema,
-                _recurseList,
-                experimental_defaultFormStateBehavior,
-                rawFormData: item,
-                parentDefaults: get8(defaults, [idx]),
-                required
-              });
-            });
-          }
-        }
-        if (neverPopulate) {
-          return defaults ?? emptyDefault;
-        }
-        if (ignoreMinItemsFlagSet && !required) {
-          return defaults ? defaults : void 0;
-        }
-        const defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
-        if (!schema.minItems || isMultiSelect(validator, schema, rootSchema) || computeSkipPopulate(validator, schema, rootSchema) || schema.minItems <= defaultsLength) {
-          return defaults ? defaults : emptyDefault;
-        }
-        const defaultEntries = defaults || [];
-        const fillerSchema = getInnerSchemaForArrayItem(schema, 1 /* Invert */);
-        const fillerDefault = fillerSchema.default;
-        const fillerEntries = new Array(schema.minItems - defaultsLength).fill(
-          computeDefaults(validator, fillerSchema, {
-            parentDefaults: fillerDefault,
+          maybeAddDefaultToObject(
+            objectDefaults,
+            key,
+            computedDefault,
+            includeUndefinedValues,
+            required,
+            formDataRequired
+          );
+        });
+      }
+      return objectDefaults;
+    }
+  }
+  function getArrayDefaults(validator, rawSchema, {
+    rawFormData,
+    rootSchema = {},
+    _recurseList = [],
+    experimental_defaultFormStateBehavior = void 0,
+    required
+  } = {}, defaults) {
+    const schema = rawSchema;
+    const neverPopulate = experimental_defaultFormStateBehavior?.arrayMinItems?.populate === "never";
+    const ignoreMinItemsFlagSet = experimental_defaultFormStateBehavior?.arrayMinItems?.populate === "requiredOnly";
+    const isSkipEmptyDefaults = experimental_defaultFormStateBehavior?.emptyObjectFields === "skipEmptyDefaults";
+    const computeSkipPopulate = experimental_defaultFormStateBehavior?.arrayMinItems?.computeSkipPopulate ?? (() => false);
+    const emptyDefault = isSkipEmptyDefaults ? void 0 : [];
+    if (Array.isArray(defaults)) {
+      defaults = defaults.map((item, idx) => {
+        const schemaItem = getInnerSchemaForArrayItem(schema, 2 /* Fallback */, idx);
+        return computeDefaults(validator, schemaItem, {
+          rootSchema,
+          _recurseList,
+          experimental_defaultFormStateBehavior,
+          parentDefaults: item,
+          required
+        });
+      });
+    }
+    if (Array.isArray(rawFormData)) {
+      const schemaItem = getInnerSchemaForArrayItem(schema);
+      if (neverPopulate) {
+        defaults = rawFormData;
+      } else {
+        defaults = rawFormData.map((item, idx) => {
+          return computeDefaults(validator, schemaItem, {
             rootSchema,
             _recurseList,
             experimental_defaultFormStateBehavior,
+            rawFormData: item,
+            parentDefaults: get8(defaults, [idx]),
             required
-          })
-        );
-        return defaultEntries.concat(fillerEntries);
+          });
+        });
+      }
+    }
+    if (neverPopulate) {
+      return defaults ?? emptyDefault;
+    }
+    if (ignoreMinItemsFlagSet && !required) {
+      return defaults ? defaults : void 0;
+    }
+    const defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
+    if (!schema.minItems || isMultiSelect(validator, schema, rootSchema) || computeSkipPopulate(validator, schema, rootSchema) || schema.minItems <= defaultsLength) {
+      return defaults ? defaults : emptyDefault;
+    }
+    const defaultEntries = defaults || [];
+    const fillerSchema = getInnerSchemaForArrayItem(schema, 1 /* Invert */);
+    const fillerDefault = fillerSchema.default;
+    const fillerEntries = new Array(schema.minItems - defaultsLength).fill(
+      computeDefaults(validator, fillerSchema, {
+        parentDefaults: fillerDefault,
+        rootSchema,
+        _recurseList,
+        experimental_defaultFormStateBehavior,
+        required
+      })
+    );
+    return defaultEntries.concat(fillerEntries);
+  }
+  function getDefaultBasedOnSchemaType(validator, rawSchema, computeDefaultsProps = {}, defaults) {
+    switch (getSchemaType(rawSchema)) {
+      case "object": {
+        return getObjectDefaults(validator, rawSchema, computeDefaultsProps, defaults);
+      }
+      case "array": {
+        return getArrayDefaults(validator, rawSchema, computeDefaultsProps, defaults);
       }
     }
-    return defaults;
   }
   function getDefaultFormState(validator, theSchema, formData, rootSchema, includeUndefinedValues = false, experimental_defaultFormStateBehavior) {
     if (!isObject(theSchema)) {

package/lib/schema/getDefaultFormState.d.ts

@@ -23,12 +23,22 @@ export declare enum AdditionalItemsHandling {
  */
 export declare function getInnerSchemaForArrayItem<S extends StrictRJSFSchema = RJSFSchema>(schema: S, additionalItems?: AdditionalItemsHandling, idx?: number): S;
 interface ComputeDefaultsProps<T = any, S extends StrictRJSFSchema = RJSFSchema> {
+    /** Any defaults provided by the parent field in the schema */
     parentDefaults?: T;
+    /** The options root schema, used to primarily to look up `$ref`s */
     rootSchema?: S;
+    /** The current formData, if any, onto which to provide any missing defaults */
     rawFormData?: T;
+    /** 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.
+     */
     includeUndefinedValues?: boolean | 'excludeObjectChildren';
+    /** The list of ref names currently being recursed, used to prevent infinite recursion */
     _recurseList?: string[];
+    /** Optional configuration object, if provided, allows users to override default form state behavior */
     experimental_defaultFormStateBehavior?: Experimental_DefaultFormStateBehavior;
+    /** Optional flag, if true, indicates this schema was required in the parent schema. */
     required?: boolean;
 }
 /** Computes the defaults for the current `schema` given the `rawFormData` and `parentDefaults` if any. This drills into
@@ -36,19 +46,37 @@ interface ComputeDefaultsProps<T = any, S extends StrictRJSFSchema = RJSFSchema>
  *
  * @param validator - an implementation of the `ValidatorType` interface that will be used when necessary
  * @param rawSchema - The schema for which the default state is desired
- * @param [props] - Optional props for this function
- * @param [props.parentDefaults] - Any defaults provided by the parent field in the schema
- * @param [props.rootSchema] - The options root schema, used to primarily to look up `$ref`s
- * @param [props.rawFormData] - The current formData, if any, onto which to provide any missing defaults
- * @param [props.includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults.
- *          If "excludeObjectChildren", cause undefined values for this object and pass `includeUndefinedValues` as
- *          false when computing defaults for any nested object properties.
- * @param [props._recurseList=[]] - The list of ref names currently being recursed, used to prevent infinite recursion
- * @param [props.experimental_defaultFormStateBehavior] Optional configuration object, if provided, allows users to override default form state behavior
- * @param [props.required] - Optional flag, if true, indicates this schema was required in the parent schema.
+ * @param {ComputeDefaultsProps} computeDefaultsProps - Optional props for this function
  * @returns - The resulting `formData` with all the defaults provided
  */
-export declare function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, rawSchema: S, { parentDefaults, rawFormData, rootSchema, includeUndefinedValues, _recurseList, experimental_defaultFormStateBehavior, required, }?: ComputeDefaultsProps<T, S>): T | T[] | undefined;
+export declare function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, rawSchema: S, computeDefaultsProps?: ComputeDefaultsProps<T, S>): T | T[] | undefined;
+/** Computes the default value for objects.
+ *
+ * @param validator - an implementation of the `ValidatorType` interface that will be used when necessary
+ * @param rawSchema - The schema for which the default state is desired
+ * @param {ComputeDefaultsProps} computeDefaultsProps - Optional props for this function
+ * @param defaults - Optional props for this function
+ * @returns - The default value based on the schema type if they are defined for object or array schemas.
+ */
+export declare function getObjectDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, rawSchema: S, { rawFormData, rootSchema, includeUndefinedValues, _recurseList, experimental_defaultFormStateBehavior, required, }?: ComputeDefaultsProps<T, S>, defaults?: T | T[] | undefined): T;
+/** Computes the default value for arrays.
+ *
+ * @param validator - an implementation of the `ValidatorType` interface that will be used when necessary
+ * @param rawSchema - The schema for which the default state is desired
+ * @param {ComputeDefaultsProps} computeDefaultsProps - Optional props for this function
+ * @param defaults - Optional props for this function
+ * @returns - The default value based on the schema type if they are defined for object or array schemas.
+ */
+export declare function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, rawSchema: S, { rawFormData, rootSchema, _recurseList, experimental_defaultFormStateBehavior, required, }?: ComputeDefaultsProps<T, S>, defaults?: T | T[] | undefined): T | T[] | undefined;
+/** Computes the default value based on the schema type.
+ *
+ * @param validator - an implementation of the `ValidatorType` interface that will be used when necessary
+ * @param rawSchema - The schema for which the default state is desired
+ * @param {ComputeDefaultsProps} computeDefaultsProps - Optional props for this function
+ * @param defaults - Optional props for this function
+ * @returns - The default value based on the schema type if they are defined for object or array schemas.
+ */
+export declare function getDefaultBasedOnSchemaType<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, rawSchema: S, computeDefaultsProps?: ComputeDefaultsProps<T, S>, defaults?: T | T[] | undefined): T | T[] | void;
 /** Returns the superset of `formData` that includes the given set updated to include any missing fields that have
  * computed to have defaults provided in the `schema`.
  *