@rjsf/utils 5.22.3 → 5.23.0

package/src/schema/getClosestMatchingOption.ts

@@ -10,7 +10,7 @@ import getFirstMatchingOption from './getFirstMatchingOption';
 import retrieveSchema, { resolveAllReferences } from './retrieveSchema';
 import { ONE_OF_KEY, REF_KEY, JUNK_OPTION_ID, ANY_OF_KEY } from '../constants';
 import guessType from '../guessType';
-import { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+import { Experimental_CustomMergeAllOf, FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
 import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema';
 import getOptionMatchingSimpleDiscriminator from '../getOptionMatchingSimpleDiscriminator';
 
@@ -45,13 +45,15 @@ export const JUNK_OPTION: StrictRJSFSchema = {
  * @param rootSchema - The root JSON schema of the entire form
  * @param schema - The schema for which the score is being calculated
  * @param formData - The form data associated with the schema, used to calculate the score
+ * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
  * @returns - The score a schema against the formData
  */
 export function calculateIndexScore<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
   validator: ValidatorType<T, S, F>,
   rootSchema: S,
   schema?: S,
-  formData?: any
+  formData?: any,
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>
 ): number {
   let totalScore = 0;
   if (schema) {
@@ -64,8 +66,23 @@ export function calculateIndexScore<T = any, S extends StrictRJSFSchema = RJSFSc
             return score;
           }
           if (has(value, REF_KEY)) {
-            const newSchema = retrieveSchema<T, S, F>(validator, value as S, rootSchema, formValue);
-            return score + calculateIndexScore<T, S, F>(validator, rootSchema, newSchema, formValue || {});
+            const newSchema = retrieveSchema<T, S, F>(
+              validator,
+              value as S,
+              rootSchema,
+              formValue,
+              experimental_customMergeAllOf
+            );
+            return (
+              score +
+              calculateIndexScore<T, S, F>(
+                validator,
+                rootSchema,
+                newSchema,
+                formValue || {},
+                experimental_customMergeAllOf
+              )
+            );
           }
           if ((has(value, ONE_OF_KEY) || has(value, ANY_OF_KEY)) && formValue) {
             const key = has(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
@@ -78,7 +95,8 @@ export function calculateIndexScore<T = any, S extends StrictRJSFSchema = RJSFSc
                 formValue,
                 get(value, key) as S[],
                 -1,
-                discriminator
+                discriminator,
+                experimental_customMergeAllOf
               )
             );
           }
@@ -87,7 +105,10 @@ export function calculateIndexScore<T = any, S extends StrictRJSFSchema = RJSFSc
               // If the structure is matching then give it a little boost in score
               score += 1;
             }
-            return score + calculateIndexScore<T, S, F>(validator, rootSchema, value as S, formValue);
+            return (
+              score +
+              calculateIndexScore<T, S, F>(validator, rootSchema, value as S, formValue, experimental_customMergeAllOf)
+            );
           }
           if (value.type === guessType(formValue)) {
             // If the types match, then we bump the score by one
@@ -135,6 +156,7 @@ export function calculateIndexScore<T = any, S extends StrictRJSFSchema = RJSFSc
  * @param [selectedOption=-1] - The index of the currently selected option, defaulted to -1 if not specified
  * @param [discriminatorField] - The optional name of the field within the options object whose value is used to
  *          determine which option is selected
+ * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
  * @returns - The index of the option that is the closest match to the `formData` or the `selectedOption` if no match
  */
 export default function getClosestMatchingOption<
@@ -147,7 +169,8 @@ export default function getClosestMatchingOption<
   formData: T | undefined,
   options: S[],
   selectedOption = -1,
-  discriminatorField?: string
+  discriminatorField?: string,
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>
 ): number {
   // First resolve any refs in the options
   const resolvedOptions = options.map((option) => {
@@ -185,7 +208,7 @@ export default function getClosestMatchingOption<
     (scoreData: BestType, index: number) => {
       const { bestScore } = scoreData;
       const option = resolvedOptions[index];
-      const score = calculateIndexScore(validator, rootSchema, option, formData);
+      const score = calculateIndexScore(validator, rootSchema, option, formData, experimental_customMergeAllOf);
       scoreCount.add(score);
       if (score > bestScore) {
         return { bestIndex: index, bestScore: score };

package/src/schema/getDefaultFormState.ts

@@ -31,9 +31,10 @@ import {
 } from '../types';
 import isMultiSelect from './isMultiSelect';
 import retrieveSchema, { resolveDependencies } from './retrieveSchema';
-import isConstant from '../isConstant';
 import { JSONSchema7Object } from 'json-schema';
 
+const PRIMITIVE_TYPES = ['string', 'number', 'integer', 'boolean', 'null'];
+
 /** Enum that indicates how `schema.additionalItems` should be handled by the `getInnerSchemaForArrayItem()` function.
  */
 export enum AdditionalItemsHandling {
@@ -199,9 +200,10 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
   let defaults: T | T[] | undefined = parentDefaults;
   // 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;
   let updatedRecurseList = _recurseList;
 
-  if (isConstant(schema)) {
+  if (schema[CONST_KEY] && experimental_defaultFormStateBehavior?.constAsDefaults !== 'never') {
     defaults = schema.const as unknown as T;
   } else if (isObject(defaults) && isObject(schema.default)) {
     // For object defaults, only override parent defaults that are defined in
@@ -239,6 +241,7 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
         includeUndefinedValues,
         _recurseList,
         experimental_defaultFormStateBehavior,
+        experimental_customMergeAllOf,
         parentDefaults: Array.isArray(parentDefaults) ? parentDefaults[idx] : undefined,
         rawFormData: formData as T,
         required,
@@ -250,6 +253,15 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
       return undefined;
     }
     const discriminator = getDiscriminatorFieldFromSchema<S>(schema);
+    const { type = 'null' } = remaining;
+    if (
+      !Array.isArray(type) &&
+      PRIMITIVE_TYPES.includes(type) &&
+      experimental_dfsb_to_compute?.constAsDefaults === 'skipOneOf'
+    ) {
+      // If we are in a oneOf of a primitive type, then we want to pass constAsDefaults as 'never' for the recursion
+      experimental_dfsb_to_compute = { ...experimental_dfsb_to_compute, constAsDefaults: 'never' };
+    }
     schemaToCompute = oneOf![
       getClosestMatchingOption<T, S, F>(
         validator,
@@ -257,7 +269,8 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
         isEmpty(formData) ? undefined : formData,
         oneOf as S[],
         0,
-        discriminator
+        discriminator,
+        experimental_customMergeAllOf
       )
     ] as S;
     schemaToCompute = mergeSchemas(remaining, schemaToCompute) as S;
@@ -274,7 +287,8 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
         isEmpty(formData) ? undefined : formData,
         anyOf as S[],
         0,
-        discriminator
+        discriminator,
+        experimental_customMergeAllOf
       )
     ] as S;
     schemaToCompute = mergeSchemas(remaining, schemaToCompute) as S;
@@ -285,7 +299,8 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
       rootSchema,
       includeUndefinedValues,
       _recurseList: updatedRecurseList,
-      experimental_defaultFormStateBehavior,
+      experimental_defaultFormStateBehavior: experimental_dfsb_to_compute,
+      experimental_customMergeAllOf,
       parentDefaults: defaults as T | undefined,
       rawFormData: formData as T,
       required,
@@ -337,9 +352,12 @@ export function getObjectDefaults<T = any, S extends StrictRJSFSchema = RJSFSche
     const objectDefaults = Object.keys(retrievedSchema.properties || {}).reduce(
       (acc: GenericObjectType, key: string) => {
         const propertySchema = get(retrievedSchema, [PROPERTIES_KEY, key]);
-        // Check if the parent schema has a const property defined, then we should always return the computedDefault since it's coming from the const.
+        // Check if the parent schema has a const property defined AND we are supporting const as defaults, then we
+        // should always return the computedDefault since it's coming from the const.
         const hasParentConst = isObject(parentConst) && (parentConst as JSONSchema7Object)[key] !== undefined;
-        const hasConst = (isObject(propertySchema) && CONST_KEY in propertySchema) || hasParentConst;
+        const hasConst =
+          ((isObject(propertySchema) && CONST_KEY in propertySchema) || hasParentConst) &&
+          experimental_defaultFormStateBehavior?.constAsDefaults !== 'never';
         // Compute the defaults for this node, with the parent defaults we might
         // have from a previous run: defaults[key].
         const computedDefault = computeDefaults<T, S, F>(validator, propertySchema, {
@@ -390,6 +408,7 @@ export function getObjectDefaults<T = any, S extends StrictRJSFSchema = RJSFSche
           rootSchema,
           _recurseList,
           experimental_defaultFormStateBehavior,
+          experimental_customMergeAllOf,
           includeUndefinedValues: includeUndefinedValues === true,
           parentDefaults: get(defaults, [key]),
           rawFormData: get(formData, [key]),
@@ -426,17 +445,21 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
     rootSchema = {} as S,
     _recurseList = [],
     experimental_defaultFormStateBehavior = undefined,
+    experimental_customMergeAllOf = undefined,
     required,
   }: ComputeDefaultsProps<T, S> = {},
   defaults?: T | T[] | undefined
 ): T | T[] | undefined {
   const schema: S = rawSchema;
 
-  const neverPopulate = experimental_defaultFormStateBehavior?.arrayMinItems?.populate === 'never';
-  const ignoreMinItemsFlagSet = experimental_defaultFormStateBehavior?.arrayMinItems?.populate === 'requiredOnly';
+  const arrayMinItemsStateBehavior = experimental_defaultFormStateBehavior?.arrayMinItems ?? {};
+  const { populate: arrayMinItemsPopulate, mergeExtraDefaults: arrayMergeExtraDefaults } = arrayMinItemsStateBehavior;
+
+  const neverPopulate = arrayMinItemsPopulate === 'never';
+  const ignoreMinItemsFlagSet = arrayMinItemsPopulate === 'requiredOnly';
+  const isPopulateAll = arrayMinItemsPopulate === 'all' || (!neverPopulate && !ignoreMinItemsFlagSet);
+  const computeSkipPopulate = arrayMinItemsStateBehavior?.computeSkipPopulate ?? (() => false);
   const isSkipEmptyDefaults = experimental_defaultFormStateBehavior?.emptyObjectFields === 'skipEmptyDefaults';
-  const computeSkipPopulate =
-    experimental_defaultFormStateBehavior?.arrayMinItems?.computeSkipPopulate ?? (() => false);
 
   const emptyDefault = isSkipEmptyDefaults ? undefined : [];
 
@@ -448,6 +471,7 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
         rootSchema,
         _recurseList,
         experimental_defaultFormStateBehavior,
+        experimental_customMergeAllOf,
         parentDefaults: item,
         required,
       });
@@ -460,21 +484,29 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
     if (neverPopulate) {
       defaults = rawFormData;
     } else {
-      defaults = rawFormData.map((item: T, idx: number) => {
+      const itemDefaults = rawFormData.map((item: T, idx: number) => {
         return computeDefaults<T, S, F>(validator, schemaItem, {
           rootSchema,
           _recurseList,
           experimental_defaultFormStateBehavior,
+          experimental_customMergeAllOf,
           rawFormData: item,
           parentDefaults: get(defaults, [idx]),
           required,
         });
       }) 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.
+      const mergeExtraDefaults = ((ignoreMinItemsFlagSet && required) || isPopulateAll) && arrayMergeExtraDefaults;
+      defaults = mergeDefaultsWithFormData(defaults, itemDefaults, mergeExtraDefaults);
     }
   }
 
-  // Check if the schema has a const property defined, then we should always return the computedDefault since it's coming from the const.
-  const hasConst = isObject(schema) && CONST_KEY in schema;
+  // Check if the schema has a const property defined AND we are supporting const as defaults, then we should always
+  // return the computedDefault since it's coming from the const.
+  const hasConst =
+    isObject(schema) && CONST_KEY in schema && experimental_defaultFormStateBehavior?.constAsDefaults !== 'never';
   if (hasConst === false) {
     if (neverPopulate) {
       return defaults ?? emptyDefault;
@@ -489,7 +521,7 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
   const defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
   if (
     !schema.minItems ||
-    isMultiSelect<T, S, F>(validator, schema, rootSchema) ||
+    isMultiSelect<T, S, F>(validator, schema, rootSchema, experimental_customMergeAllOf) ||
     computeSkipPopulate<T, S, F>(validator, schema, rootSchema) ||
     schema.minItems <= defaultsLength
   ) {
@@ -507,6 +539,7 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
       rootSchema,
       _recurseList,
       experimental_defaultFormStateBehavior,
+      experimental_customMergeAllOf,
       required,
     })
   ) as T[];

package/src/schema/getDisplayLabel.ts

@@ -9,6 +9,7 @@ import {
   StrictRJSFSchema,
   UiSchema,
   ValidatorType,
+  Experimental_CustomMergeAllOf,
 } from '../types';
 import isFilesArray from './isFilesArray';
 import isMultiSelect from './isMultiSelect';
@@ -21,6 +22,7 @@ import isMultiSelect from './isMultiSelect';
  * @param [uiSchema={}] - The UI schema from which to derive potentially displayable information
  * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
  * @param [globalOptions={}] - The optional Global UI Schema from which to get any fallback `xxx` options
+ * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
  * @returns - True if the label should be displayed or false if it should not
  */
 export default function getDisplayLabel<
@@ -32,7 +34,8 @@ export default function getDisplayLabel<
   schema: S,
   uiSchema: UiSchema<T, S, F> = {},
   rootSchema?: S,
-  globalOptions?: GlobalUISchemaOptions
+  globalOptions?: GlobalUISchemaOptions,
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>
 ): boolean {
   const uiOptions = getUiOptions<T, S, F>(uiSchema, globalOptions);
   const { label = true } = uiOptions;
@@ -41,8 +44,8 @@ export default function getDisplayLabel<
 
   if (schemaType === 'array') {
     displayLabel =
-      isMultiSelect<T, S, F>(validator, schema, rootSchema) ||
-      isFilesArray<T, S, F>(validator, schema, uiSchema, rootSchema) ||
+      isMultiSelect<T, S, F>(validator, schema, rootSchema, experimental_customMergeAllOf) ||
+      isFilesArray<T, S, F>(validator, schema, uiSchema, rootSchema, experimental_customMergeAllOf) ||
       isCustomWidget(uiSchema);
   }
 

package/src/schema/isFilesArray.ts

@@ -1,5 +1,12 @@
 import { UI_WIDGET_KEY } from '../constants';
-import { FormContextType, RJSFSchema, StrictRJSFSchema, UiSchema, ValidatorType } from '../types';
+import {
+  Experimental_CustomMergeAllOf,
+  FormContextType,
+  RJSFSchema,
+  StrictRJSFSchema,
+  UiSchema,
+  ValidatorType,
+} from '../types';
 import retrieveSchema from './retrieveSchema';
 
 /** Checks to see if the `schema` and `uiSchema` combination represents an array of files
@@ -8,19 +15,27 @@ import retrieveSchema from './retrieveSchema';
  * @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
  * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
  * @returns - True if schema/uiSchema contains an array of files, otherwise false
  */
 export default function isFilesArray<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
   validator: ValidatorType<T, S, F>,
   schema: S,
   uiSchema: UiSchema<T, S, F> = {},
-  rootSchema?: S
+  rootSchema?: S,
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>
 ) {
   if (uiSchema[UI_WIDGET_KEY] === 'files') {
     return true;
   }
   if (schema.items) {
-    const itemsSchema = retrieveSchema<T, S, F>(validator, schema.items as S, rootSchema);
+    const itemsSchema = retrieveSchema<T, S, F>(
+      validator,
+      schema.items as S,
+      rootSchema,
+      undefined,
+      experimental_customMergeAllOf
+    );
     return itemsSchema.type === 'string' && itemsSchema.format === 'data-url';
   }
   return false;

package/src/schema/isMultiSelect.ts

@@ -1,4 +1,4 @@
-import { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+import { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType, Experimental_CustomMergeAllOf } from '../types';
 
 import isSelect from './isSelect';
 
@@ -7,15 +7,21 @@ import isSelect from './isSelect';
  * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
  * @param schema - The schema for which check for a multi-select flag is desired
  * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
  * @returns - True if schema contains a multi-select, otherwise false
  */
 export default function isMultiSelect<
   T = any,
   S extends StrictRJSFSchema = RJSFSchema,
   F extends FormContextType = any
->(validator: ValidatorType<T, S, F>, schema: S, rootSchema?: S) {
+>(
+  validator: ValidatorType<T, S, F>,
+  schema: S,
+  rootSchema?: S,
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>
+) {
   if (!schema.uniqueItems || !schema.items || typeof schema.items === 'boolean') {
     return false;
   }
-  return isSelect<T, S, F>(validator, schema.items as S, rootSchema);
+  return isSelect<T, S, F>(validator, schema.items as S, rootSchema, experimental_customMergeAllOf);
 }

package/src/schema/isSelect.ts

@@ -1,5 +1,5 @@
 import isConstant from '../isConstant';
-import { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+import { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType, Experimental_CustomMergeAllOf } from '../types';
 import retrieveSchema from './retrieveSchema';
 
 /** Checks to see if the `schema` combination represents a select
@@ -7,14 +7,16 @@ import retrieveSchema from './retrieveSchema';
  * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
  * @param theSchema - The schema for which check for a select flag is desired
  * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
  * @returns - True if schema contains a select, otherwise false
  */
 export default function isSelect<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
   validator: ValidatorType<T, S, F>,
   theSchema: S,
-  rootSchema: S = {} as S
+  rootSchema: S = {} as S,
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>
 ) {
-  const schema = retrieveSchema<T, S, F>(validator, theSchema, rootSchema, undefined);
+  const schema = retrieveSchema<T, S, F>(validator, theSchema, rootSchema, undefined, experimental_customMergeAllOf);
   const altSchemas = schema.oneOf || schema.anyOf;
   if (Array.isArray(schema.enum)) {
     return true;

package/src/schema/retrieveSchema.ts

@@ -365,13 +365,20 @@ export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
  * @param theSchema - The schema for which the existing additional properties is desired
  * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s * @param validator
  * @param [aFormData] - The current formData, if any, to assist retrieving a schema
+ * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
  * @returns - The updated schema with additional properties stubbed
  */
 export function stubExistingAdditionalProperties<
   T = any,
   S extends StrictRJSFSchema = RJSFSchema,
   F extends FormContextType = any
->(validator: ValidatorType<T, S, F>, theSchema: S, rootSchema?: S, aFormData?: T): S {
+>(
+  validator: ValidatorType<T, S, F>,
+  theSchema: S,
+  rootSchema?: S,
+  aFormData?: T,
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>
+): S {
   // Clone the schema so that we don't ruin the consumer's original
   const schema = {
     ...theSchema,
@@ -393,7 +400,8 @@ export function stubExistingAdditionalProperties<
           validator,
           { $ref: get(schema.additionalProperties, [REF_KEY]) } as S,
           rootSchema,
-          formData as T
+          formData as T,
+          experimental_customMergeAllOf
         );
       } else if ('type' in schema.additionalProperties!) {
         additionalProperties = { ...schema.additionalProperties };
@@ -456,7 +464,8 @@ export function retrieveSchemaInternal<
     rootSchema,
     expandAllBranches,
     recurseList,
-    rawFormData
+    rawFormData,
+    experimental_customMergeAllOf
   );
   return resolvedSchemas.flatMap((s: S) => {
     let resolvedSchema = s;
@@ -507,7 +516,13 @@ export function retrieveSchemaInternal<
     const hasAdditionalProperties =
       ADDITIONAL_PROPERTIES_KEY in resolvedSchema && resolvedSchema.additionalProperties !== false;
     if (hasAdditionalProperties) {
-      return stubExistingAdditionalProperties<T, S, F>(validator, resolvedSchema, rootSchema, rawFormData as T);
+      return stubExistingAdditionalProperties<T, S, F>(
+        validator,
+        resolvedSchema,
+        rootSchema,
+        rawFormData as T,
+        experimental_customMergeAllOf
+      );
     }
 
     return resolvedSchema;

package/src/schema/sanitizeDataForNewSchema.ts

@@ -1,7 +1,14 @@
 import get from 'lodash/get';
 import has from 'lodash/has';
 
-import { FormContextType, GenericObjectType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+import {
+  Experimental_CustomMergeAllOf,
+  FormContextType,
+  GenericObjectType,
+  RJSFSchema,
+  StrictRJSFSchema,
+  ValidatorType,
+} from '../types';
 import { PROPERTIES_KEY, REF_KEY } from '../constants';
 import retrieveSchema from './retrieveSchema';
 
@@ -51,6 +58,7 @@ const NO_VALUE = Symbol('no Value');
  * @param [newSchema] - The new schema for which the data is being sanitized
  * @param [oldSchema] - The old schema from which the data originated
  * @param [data={}] - The form data associated with the schema, defaulting to an empty object when undefined
+ * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
  * @returns - The new form data, with all the fields uniquely associated with the old schema set
  *      to `undefined`. Will return `undefined` if the new schema is not an object containing properties.
  */
@@ -58,7 +66,14 @@ export default function sanitizeDataForNewSchema<
   T = any,
   S extends StrictRJSFSchema = RJSFSchema,
   F extends FormContextType = any
->(validator: ValidatorType<T, S, F>, rootSchema: S, newSchema?: S, oldSchema?: S, data: any = {}): T {
+>(
+  validator: ValidatorType<T, S, F>,
+  rootSchema: S,
+  newSchema?: S,
+  oldSchema?: S,
+  data: any = {},
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>
+): T {
   // By default, we will clear the form data
   let newFormData;
   // If the new schema is of type object and that object contains a list of properties
@@ -82,10 +97,22 @@ export default function sanitizeDataForNewSchema<
       let newKeyedSchema: S = get(newSchema, [PROPERTIES_KEY, key], {});
       // Resolve the refs if they exist
       if (has(oldKeyedSchema, REF_KEY)) {
-        oldKeyedSchema = retrieveSchema<T, S, F>(validator, oldKeyedSchema, rootSchema, formValue);
+        oldKeyedSchema = retrieveSchema<T, S, F>(
+          validator,
+          oldKeyedSchema,
+          rootSchema,
+          formValue,
+          experimental_customMergeAllOf
+        );
       }
       if (has(newKeyedSchema, REF_KEY)) {
-        newKeyedSchema = retrieveSchema<T, S, F>(validator, newKeyedSchema, rootSchema, formValue);
+        newKeyedSchema = retrieveSchema<T, S, F>(
+          validator,
+          newKeyedSchema,
+          rootSchema,
+          formValue,
+          experimental_customMergeAllOf
+        );
       }
       // Now get types and see if they are the same
       const oldSchemaTypeForKey = get(oldKeyedSchema, 'type');
@@ -104,7 +131,8 @@ export default function sanitizeDataForNewSchema<
             rootSchema,
             newKeyedSchema,
             oldKeyedSchema,
-            formValue
+            formValue,
+            experimental_customMergeAllOf
           );
           if (itemData !== undefined || newSchemaTypeForKey === 'array') {
             // only put undefined values for the array type and not the object type
@@ -154,10 +182,22 @@ export default function sanitizeDataForNewSchema<
       !Array.isArray(newSchemaItems)
     ) {
       if (has(oldSchemaItems, REF_KEY)) {
-        oldSchemaItems = retrieveSchema<T, S, F>(validator, oldSchemaItems as S, rootSchema, data as T);
+        oldSchemaItems = retrieveSchema<T, S, F>(
+          validator,
+          oldSchemaItems as S,
+          rootSchema,
+          data as T,
+          experimental_customMergeAllOf
+        );
       }
       if (has(newSchemaItems, REF_KEY)) {
-        newSchemaItems = retrieveSchema<T, S, F>(validator, newSchemaItems as S, rootSchema, data as T);
+        newSchemaItems = retrieveSchema<T, S, F>(
+          validator,
+          newSchemaItems as S,
+          rootSchema,
+          data as T,
+          experimental_customMergeAllOf
+        );
       }
       // Now get types and see if they are the same
       const oldSchemaType = get(oldSchemaItems, 'type');
@@ -172,7 +212,8 @@ export default function sanitizeDataForNewSchema<
               rootSchema,
               newSchemaItems as S,
               oldSchemaItems as S,
-              aValue
+              aValue,
+              experimental_customMergeAllOf
             );
             if (itemValue !== undefined && (maxItems < 0 || newValue.length < maxItems)) {
               newValue.push(itemValue);

package/src/schema/toIdSchema.ts

@@ -41,7 +41,7 @@ function toIdSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema, F
   experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>
 ): IdSchema<T> {
   if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
-    const _schema = retrieveSchema<T, S, F>(validator, schema, rootSchema, formData);
+    const _schema = retrieveSchema<T, S, F>(validator, schema, rootSchema, formData, experimental_customMergeAllOf);
     const sameSchemaIndex = _recurseList.findIndex((item) => isEqual(item, _schema));
     if (sameSchemaIndex === -1) {
       return toIdSchemaInternal<T, S, F>(