@rjsf/utils 6.6.1 → 6.7.0

package/src/schema/getDefaultFormState.ts

@@ -1,4 +1,4 @@
-import { JSONSchema7Object } from 'json-schema';
+import type { JSONSchema7Object } from 'json-schema';
 import get from 'lodash/get';
 import isEmpty from 'lodash/isEmpty';
 
@@ -25,7 +25,7 @@ import mergeDefaultsWithFormData from '../mergeDefaultsWithFormData';
 import mergeObjects from '../mergeObjects';
 import mergeSchemas from '../mergeSchemas';
 import optionsList from '../optionsList';
-import {
+import type {
   Experimental_CustomMergeAllOf,
   Experimental_DefaultFormStateBehavior,
   FormContextType,
@@ -109,7 +109,7 @@ export function computeDefaultBasedOnSchemaTypeAndDefaults<T = any, S extends St
  * includeUndefinedValues` is false and `emptyObjectFields` is not "skipDefaults", then non-undefined and non-empty-object
  * values will be added based on certain conditions.
  *
- * @param obj - The object into which the computed default may be added
+ * @param acc - 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.
@@ -125,7 +125,7 @@ export function computeDefaultBasedOnSchemaTypeAndDefaults<T = any, S extends St
  * @param isNullType - The type of the schema is null
  */
 function maybeAddDefaultToObject<T = any>(
-  obj: GenericObjectType,
+  acc: GenericObjectType,
   key: string,
   computedDefault: T | T[] | undefined,
   includeUndefinedValues: boolean | 'excludeObjectChildren',
@@ -140,12 +140,12 @@ function maybeAddDefaultToObject<T = any>(
   if (includeUndefinedValues === true || isConst) {
     // If includeUndefinedValues is explicitly true
     // Or if the schema has a const property defined, then we should always return the computedDefault since it's coming from the const.
-    obj[key] = computedDefault;
+    acc[key] = computedDefault;
   } else if (includeUndefinedValues === 'excludeObjectChildren') {
     // Fix for Issue #4709: When in 'excludeObjectChildren' mode, don't set primitive fields to empty objects
     // Only add the computed default if it's not an empty object placeholder for a primitive field
     if ((isNullType && computedDefault !== undefined) || !isObject(computedDefault) || !isEmpty(computedDefault)) {
-      obj[key] = computedDefault;
+      acc[key] = computedDefault;
     }
     // If computedDefault is an empty object {}, don't add it - let the field stay undefined
   } else if (emptyObjectFields !== 'skipDefaults') {
@@ -157,7 +157,7 @@ function maybeAddDefaultToObject<T = any>(
       // If emptyObjectFields 'skipEmptyDefaults' store computedDefault if it's a non-empty object(e.g. not {})
       if (emptyObjectFields === 'skipEmptyDefaults') {
         if (!isEmpty(computedDefault)) {
-          obj[key] = computedDefault;
+          acc[key] = computedDefault;
         }
       } // Else store computedDefault if it's a non-empty object(e.g. not {}) and satisfies certain conditions
       // Condition 1: If computedDefault is not empty or if the key is a required field
@@ -166,7 +166,7 @@ function maybeAddDefaultToObject<T = any>(
         (!isEmpty(computedDefault) || requiredFields.includes(key)) &&
         (isSelfOrParentRequired || emptyObjectFields !== 'populateRequiredDefaults')
       ) {
-        obj[key] = computedDefault;
+        acc[key] = computedDefault;
       }
     } else if (
       // Store computedDefault if it's a defined primitive (e.g., true) and satisfies certain conditions
@@ -178,7 +178,7 @@ function maybeAddDefaultToObject<T = any>(
         emptyObjectFields === 'skipEmptyDefaults' ||
         (isSelfOrParentRequired && requiredFields.includes(key)))
     ) {
-      obj[key] = computedDefault;
+      acc[key] = computedDefault;
     }
   }
 }
@@ -232,16 +232,18 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
     rootSchema = {} as S,
     includeUndefinedValues = false,
     _recurseList = [],
-    experimental_defaultFormStateBehavior = undefined,
-    experimental_customMergeAllOf = undefined,
+    experimental_defaultFormStateBehavior,
+    experimental_customMergeAllOf,
     required,
     shouldMergeDefaultsIntoFormData = false,
     initialDefaultsGenerated,
   } = computeDefaultsProps;
   let formData: T = (isObject(rawFormData) ? rawFormData : {}) as T;
   const schema: S = isObject(rawSchema) ? rawSchema : ({} as S);
-  // Compute the defaults recursively: give highest priority to deepest nodes.
+  // Compute the defaults recursively: give highest priority to deepest nodes unless nestedDefaultsPrecedence is ancestorWins.
   let defaults: T | T[] | undefined = parentDefaults;
+  const preferParentDefaults =
+    defaults && experimental_defaultFormStateBehavior?.nestedDefaultsPrecedence === 'ancestorWins';
   // If we get a new schema, then we need to recompute defaults again for the new schema found.
   let schemaToCompute: S | null = null;
   let experimental_dfsb_to_compute = experimental_defaultFormStateBehavior;
@@ -259,12 +261,25 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
     !schema[ONE_OF_KEY] &&
     !schema[REF_KEY]
   ) {
-    // For object defaults, only override parent defaults that are defined in
-    // schema.default. Skip this for anyOf/oneOf/$ref schemas - they need special handling.
-    defaults = mergeObjects(defaults!, schema.default as GenericObjectType) as T;
-  } else if (DEFAULT_KEY in schema && !schema[ANY_OF_KEY] && !schema[ONE_OF_KEY] && !schema[REF_KEY]) {
-    // If the schema has a default value, then we should use it as the default.
-    // And if the schema does not have anyOf or oneOf, this is done because we need to merge the defaults with the formData.
+    // For object defaults, merge defaults by precedence setting.
+    // Skip this for anyOf/oneOf/$ref schemas - they need special handling.
+    if (preferParentDefaults) {
+      // Use schema.default as the base and only override values that are defined in parent defaults.
+      defaults = mergeObjects(schema.default as GenericObjectType, defaults) as T;
+    } else {
+      // Only override parent defaults that are defined in schema.default.
+      defaults = mergeObjects(defaults, schema.default as GenericObjectType) as T;
+    }
+  } else if (
+    DEFAULT_KEY in schema &&
+    !preferParentDefaults &&
+    !schema[ANY_OF_KEY] &&
+    !schema[ONE_OF_KEY] &&
+    !schema[REF_KEY]
+  ) {
+    // If the schema has a default value and parentDefaults does not have precedence
+    // And if the schema does not have anyOf or oneOf (since we need to merge the defaults with the formData)
+    // Then we should use it as the default.
     defaults = schema.default as unknown as T;
   } else if (REF_KEY in schema) {
     const refName = schema[REF_KEY];
@@ -304,8 +319,10 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
       defaultFormData,
       experimental_customMergeAllOf,
     );
-    schemaToCompute = resolvedSchema[0]; // pick the first element from resolve dependencies
-  } else if (isFixedItems(schema)) {
+    [schemaToCompute] = resolvedSchema; // pick the first element from resolve dependencies
+  } else if (isFixedItems(schema) && !preferParentDefaults) {
+    // If the schema contains fixed items and parentDefaults does not have precedence
+    // Then construct defaults from defaults of array items.
     defaults = (schema.items! as S[]).map((itemSchema: S, idx: number) =>
       computeDefaults<T, S>(validator, itemSchema, {
         rootSchema,
@@ -314,7 +331,7 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
         experimental_defaultFormStateBehavior,
         experimental_customMergeAllOf,
         parentDefaults: Array.isArray(parentDefaults) ? parentDefaults[idx] : undefined,
-        rawFormData: formData as T,
+        rawFormData: formData,
         required,
         shouldMergeDefaultsIntoFormData,
       }),
@@ -377,7 +394,7 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
       experimental_defaultFormStateBehavior: experimental_dfsb_to_compute,
       experimental_customMergeAllOf,
       parentDefaults: defaults as T | undefined,
-      rawFormData: (rawFormData ?? formData) as T,
+      rawFormData: rawFormData ?? formData,
       required,
       shouldMergeDefaultsIntoFormData,
       initialDefaultsGenerated,
@@ -443,19 +460,44 @@ export function ensureFormDataMatchingSchema<
   experimental_defaultFormStateBehavior?: Experimental_DefaultFormStateBehavior,
   experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ): T | T[] | undefined {
+  const shouldRetrieveAllOf =
+    experimental_defaultFormStateBehavior?.allOf === 'populateDefaults' && ALL_OF_KEY in schema;
+  const schemaToMatch = shouldRetrieveAllOf
+    ? retrieveSchema<T, S, F>(validator, schema, rootSchema, formData, experimental_customMergeAllOf)
+    : schema;
   const isSelectField =
-    !isConstant<S>(schema) && isSelect<T, S, F>(validator, schema, rootSchema, experimental_customMergeAllOf);
+    !isConstant<S>(schemaToMatch) &&
+    isSelect<T, S, F>(validator, schemaToMatch, rootSchema, experimental_customMergeAllOf);
   let validFormData: T | T[] | undefined = formData;
   if (isSelectField) {
-    const getOptionsList = optionsList<T, S, F>(schema);
+    const getOptionsList = optionsList<T, S, F>(schemaToMatch);
     const isValid = getOptionsList?.some((option) => deepEquals(option.value, formData));
     validFormData = isValid ? formData : undefined;
   }
 
   // Override the formData with the const if the constAsDefaults is set to always
-  const constTakesPrecedence = schema[CONST_KEY] && experimental_defaultFormStateBehavior?.constAsDefaults === 'always';
+  const constTakesPrecedence =
+    schemaToMatch[CONST_KEY] && experimental_defaultFormStateBehavior?.constAsDefaults === 'always';
   if (constTakesPrecedence) {
-    validFormData = schema.const as T;
+    validFormData = schemaToMatch.const as T;
+  } else if (isObject(validFormData) && isObject(schemaToMatch.properties)) {
+    validFormData = Object.keys(schemaToMatch.properties).reduce(
+      (acc: GenericObjectType, key: string) => {
+        const propertySchema: S = get(schemaToMatch, [PROPERTIES_KEY, key], {}) as S;
+        if (key in acc && (shouldRetrieveAllOf || (isObject(propertySchema) && ALL_OF_KEY in propertySchema))) {
+          acc[key] = ensureFormDataMatchingSchema<T, S, F>(
+            validator,
+            propertySchema,
+            rootSchema,
+            get(acc, key),
+            experimental_defaultFormStateBehavior,
+            experimental_customMergeAllOf,
+          );
+        }
+        return acc;
+      },
+      { ...(validFormData as GenericObjectType) },
+    ) as T;
   }
 
   return validFormData;
@@ -477,8 +519,8 @@ export function getObjectDefaults<T = any, S extends StrictRJSFSchema = RJSFSche
     rootSchema = {} as S,
     includeUndefinedValues = false,
     _recurseList = [],
-    experimental_defaultFormStateBehavior = undefined,
-    experimental_customMergeAllOf = undefined,
+    experimental_defaultFormStateBehavior,
+    experimental_customMergeAllOf,
     required,
     shouldMergeDefaultsIntoFormData,
     initialDefaultsGenerated,
@@ -595,7 +637,7 @@ export function getObjectDefaults<T = any, S extends StrictRJSFSchema = RJSFSche
  * @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 - Optional props for this function
- * @param defaults - Optional props for this function
+ * @param initialDefaults - Optional props for this function
  * @returns - The default value based on the schema type if they are defined for object or array schemas.
  */
 export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
@@ -605,15 +647,16 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
     rawFormData,
     rootSchema = {} as S,
     _recurseList = [],
-    experimental_defaultFormStateBehavior = undefined,
-    experimental_customMergeAllOf = undefined,
+    experimental_defaultFormStateBehavior,
+    experimental_customMergeAllOf,
     required,
     requiredAsRoot = false,
     shouldMergeDefaultsIntoFormData,
     initialDefaultsGenerated,
   }: ComputeDefaultsProps<T, S> = {},
-  defaults?: T[],
+  initialDefaults?: T[],
 ): T[] | undefined {
+  let defaults = initialDefaults;
   const schema: S = rawSchema;
 
   const arrayMinItemsStateBehavior = experimental_defaultFormStateBehavior?.arrayMinItems ?? {};
@@ -652,8 +695,8 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
     if (neverPopulate) {
       defaults = rawFormData as typeof defaults;
     } else {
-      const itemDefaults = rawFormData.map((item: T, idx: number) => {
-        return computeDefaults<T, S, F>(validator, schemaItem, {
+      const itemDefaults = rawFormData.map((item: T, idx: number) =>
+        computeDefaults<T, S, F>(validator, schemaItem, {
           rootSchema,
           _recurseList,
           experimental_defaultFormStateBehavior,
@@ -663,8 +706,8 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
           required,
           shouldMergeDefaultsIntoFormData,
           initialDefaultsGenerated,
-        });
-      }) as T[];
+        }),
+      ) as T[];
 
       // If the populate 'requiredOnly' flag is set then we only merge and include extra defaults if they are required.
       // Or if populate 'all' is set we merge and include extra defaults.
@@ -673,17 +716,25 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
     }
   }
 
+  const defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
+
   if (neverPopulate) {
+    if (shouldMergeDefaultsIntoFormData) {
+      if (schema.minItems && schema.minItems > defaultsLength) {
+        const fillerEntries = Array.from({ length: schema.minItems - defaultsLength }, () => null) as T[];
+        return (defaults ?? []).concat(fillerEntries);
+      }
+      return defaults;
+    }
     return defaults ?? emptyDefault;
   }
   if (ignoreMinItemsFlagSet && !required) {
     // If no form data exists or defaults are set leave the field empty/non-existent, otherwise
     // return form data/defaults
-    return defaults ? defaults : undefined;
+    return defaults || undefined;
   }
 
   let arrayDefault: T[] | undefined;
-  const defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
   if (
     !schema.minItems ||
     isMultiSelect<T, S, F>(validator, schema, rootSchema, experimental_customMergeAllOf) ||
@@ -693,7 +744,7 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
     // we don't want undefined defaults unless it is both not required or not required as root
     arrayDefault = defaults || (!required && !requiredAsRoot) ? defaults : emptyDefault;
   } else {
-    const defaultEntries: T[] = (defaults || []) as T[];
+    const defaultEntries: T[] = defaults || [];
     const fillerSchema: S = getInnerSchemaForArrayItem<S>(schema, AdditionalItemsHandling.Invert);
     const fillerDefault = fillerSchema.default;
 
@@ -732,8 +783,8 @@ export function getDefaultBasedOnSchemaType<
   validator: ValidatorType<T, S, F>,
   rawSchema: S,
   computeDefaultsProps: ComputeDefaultsProps<T, S> = {},
-  defaults?: T | T[] | undefined,
-): T | T[] | void {
+  defaults?: T | T[],
+): T | T[] | undefined {
   switch (getSchemaType<S>(rawSchema)) {
     // We need to recurse for object schema inner default values.
     case 'object': {
@@ -742,6 +793,8 @@ export function getDefaultBasedOnSchemaType<
     case 'array': {
       return getArrayDefaults(validator, rawSchema, computeDefaultsProps, defaults as T[]);
     }
+    default:
+      return undefined;
   }
 }
 
@@ -775,7 +828,7 @@ export default function getDefaultFormState<
   initialDefaultsGenerated?: boolean,
 ) {
   if (!isObject(theSchema)) {
-    throw new Error('Invalid schema: ' + theSchema);
+    throw new Error(`Invalid schema: ${theSchema}`);
   }
   const schema = retrieveSchema<T, S, F>(validator, theSchema, rootSchema, formData, experimental_customMergeAllOf);
 
@@ -805,9 +858,17 @@ export default function getDefaultFormState<
   if (isObject(formData) || Array.isArray(formData)) {
     const { mergeDefaultsIntoFormData } = experimental_defaultFormStateBehavior || {};
     const defaultSupercedesUndefined = mergeDefaultsIntoFormData === 'useDefaultIfFormDataUndefined';
+    const matchingFormData = ensureFormDataMatchingSchema<T, S, F>(
+      validator,
+      schema,
+      rootSchema ?? schema,
+      formData,
+      experimental_defaultFormStateBehavior,
+      experimental_customMergeAllOf,
+    );
     const result = mergeDefaultsWithFormData<T | T[]>(
       defaults,
-      formData,
+      matchingFormData,
       true, // set to true to add any additional default array entries.
       defaultSupercedesUndefined,
       true, // set to true to override formData with defaults if they exist.

package/src/schema/getDisplayLabel.ts

@@ -1,12 +1,11 @@
-import get from 'lodash/get';
-
 import { ADDITIONAL_PROPERTY_FLAG, UI_FIELD_KEY, UI_WIDGET_KEY } from '../constants';
 import getSchemaType from '../getSchemaType';
 import getUiOptions from '../getUiOptions';
 import isCustomWidget from '../isCustomWidget';
-import {
+import type {
   FormContextType,
   GlobalUISchemaOptions,
+  RJSFMarkedSchema,
   RJSFSchema,
   StrictRJSFSchema,
   UiSchema,
@@ -44,7 +43,7 @@ export default function getDisplayLabel<
   let displayLabel = Boolean(label);
   if (displayLabel) {
     const schemaType = getSchemaType<S>(schema);
-    const addedByAdditionalProperty = get(schema, ADDITIONAL_PROPERTY_FLAG, false);
+    const addedByAdditionalProperty = Boolean((schema as RJSFMarkedSchema)[ADDITIONAL_PROPERTY_FLAG]);
 
     if (schemaType === 'array') {
       displayLabel =
@@ -60,7 +59,7 @@ export default function getDisplayLabel<
     if (schemaType === 'boolean' && uiSchema && !uiSchema[UI_WIDGET_KEY]) {
       displayLabel = false;
     }
-    if (uiSchema && uiSchema[UI_FIELD_KEY]) {
+    if (uiSchema?.[UI_FIELD_KEY]) {
       displayLabel = false;
     }
   }

package/src/schema/getFirstMatchingOption.ts

@@ -4,7 +4,7 @@ import isNumber from 'lodash/isNumber';
 
 import { PROPERTIES_KEY } from '../constants';
 import getOptionMatchingSimpleDiscriminator from '../getOptionMatchingSimpleDiscriminator';
-import { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+import type { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
 
 /** Given the `formData` and list of `options`, attempts to find the index of the first option that matches the data.
  * Always returns the first option if there is nothing that matches.
@@ -39,7 +39,7 @@ export default function getFirstMatchingOption<
     return simpleDiscriminatorMatch;
   }
 
-  for (let i = 0; i < options.length; i++) {
+  for (let i = 0; i < options.length; i += 1) {
     const option = options[i];
 
     // If we have a discriminator field, then we will use this to make the determination
@@ -84,7 +84,7 @@ export default function getFirstMatchingOption<
 
         augmentedSchema = shallowClone;
       } else {
-        augmentedSchema = Object.assign({}, option, requiresAnyOf);
+        augmentedSchema = { ...option, ...requiresAnyOf };
       }
 
       // Remove the "required" field as it's likely that not all fields have

package/src/schema/getFromSchema.ts

@@ -3,7 +3,7 @@ import has from 'lodash/has';
 import isEmpty from 'lodash/isEmpty';
 
 import { REF_KEY } from '../constants';
-import {
+import type {
   Experimental_CustomMergeAllOf,
   FormContextType,
   RJSFSchema,

package/src/schema/index.ts

@@ -18,10 +18,12 @@ export {
   findSelectedOptionInXxxOf,
   getDefaultFormState,
   getDisplayLabel,
+  // oxlint-disable-next-line typescript/no-deprecated
   getFieldNames, // Exported only to prevent breaking change in core
   getClosestMatchingOption,
   getFirstMatchingOption,
   getFromSchema,
+  // oxlint-disable-next-line typescript/no-deprecated
   getUsedFormData, // Exported only to prevent breaking change in core
   isFilesArray,
   isMultiSelect,
@@ -31,5 +33,6 @@ export {
   relaxOptionsForScoring,
   retrieveSchema,
   sanitizeDataForNewSchema,
+  // oxlint-disable-next-line typescript/no-deprecated
   toPathSchema,
 };

package/src/schema/isFilesArray.ts

@@ -1,5 +1,5 @@
 import { UI_WIDGET_KEY } from '../constants';
-import {
+import type {
   Experimental_CustomMergeAllOf,
   FormContextType,
   RJSFSchema,

package/src/schema/isMultiSelect.ts

@@ -1,4 +1,10 @@
-import { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType, Experimental_CustomMergeAllOf } from '../types';
+import type {
+  FormContextType,
+  RJSFSchema,
+  StrictRJSFSchema,
+  ValidatorType,
+  Experimental_CustomMergeAllOf,
+} from '../types';
 import isSelect from './isSelect';
 
 /** Checks to see if the `schema` combination represents a multi-select

package/src/schema/isSelect.ts

@@ -1,5 +1,11 @@
 import isConstant from '../isConstant';
-import { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType, Experimental_CustomMergeAllOf } from '../types';
+import type {
+  FormContextType,
+  RJSFSchema,
+  StrictRJSFSchema,
+  ValidatorType,
+  Experimental_CustomMergeAllOf,
+} from '../types';
 import retrieveSchema from './retrieveSchema';
 
 /** Checks to see if the `schema` combination represents a select
@@ -22,7 +28,7 @@ export default function isSelect<T = any, S extends StrictRJSFSchema = RJSFSchem
     return true;
   }
   if (Array.isArray(altSchemas)) {
-    return altSchemas.every((altSchemas) => typeof altSchemas !== 'boolean' && isConstant(altSchemas));
+    return altSchemas.every((altSchema) => typeof altSchema !== 'boolean' && isConstant(altSchema));
   }
   return false;
 }