@rjsf/utils 6.0.0-alpha.0 → 6.0.0-beta.10

package/src/schema/retrieveSchema.ts

@@ -1,5 +1,4 @@
 import get from 'lodash/get';
-import isEqual from 'lodash/isEqual';
 import set from 'lodash/set';
 import times from 'lodash/times';
 import transform from 'lodash/transform';
@@ -14,19 +13,30 @@ import {
   ALL_OF_KEY,
   ANY_OF_KEY,
   DEPENDENCIES_KEY,
+  ID_KEY,
   IF_KEY,
+  ITEMS_KEY,
   ONE_OF_KEY,
-  REF_KEY,
+  PATTERN_PROPERTIES_KEY,
   PROPERTIES_KEY,
-  ITEMS_KEY,
+  REF_KEY,
 } from '../constants';
 import findSchemaDefinition, { splitKeyElementFromObject } from '../findSchemaDefinition';
 import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema';
 import guessType from '../guessType';
 import isObject from '../isObject';
 import mergeSchemas from '../mergeSchemas';
-import { FormContextType, GenericObjectType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+import {
+  Experimental_CustomMergeAllOf,
+  FormContextType,
+  GenericObjectType,
+  RJSFSchema,
+  StrictRJSFSchema,
+  ValidatorType,
+} from '../types';
 import getFirstMatchingOption from './getFirstMatchingOption';
+import deepEquals from '../deepEquals';
+import isEmpty from 'lodash/isEmpty';
 
 /** Retrieves an expanded schema that has had all of its conditions, additional properties, references and dependencies
  * resolved and merged into the `schema` given a `validator`, `rootSchema` and `rawFormData` that is used to do the
@@ -36,14 +46,29 @@ import getFirstMatchingOption from './getFirstMatchingOption';
  * @param schema - The schema for which retrieving a schema is desired
  * @param [rootSchema={}] - The root schema that will be forwarded to all the APIs
  * @param [rawFormData] - 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 schema having its conditions, additional properties, references and dependencies resolved
  */
 export default function retrieveSchema<
   T = any,
   S extends StrictRJSFSchema = RJSFSchema,
-  F extends FormContextType = any
->(validator: ValidatorType<T, S, F>, schema: S, rootSchema: S = {} as S, rawFormData?: T): S {
-  return retrieveSchemaInternal<T, S, F>(validator, schema, rootSchema, rawFormData)[0];
+  F extends FormContextType = any,
+>(
+  validator: ValidatorType<T, S, F>,
+  schema: S,
+  rootSchema: S = {} as S,
+  rawFormData?: T,
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
+): S {
+  return retrieveSchemaInternal<T, S, F>(
+    validator,
+    schema,
+    rootSchema,
+    rawFormData,
+    undefined,
+    undefined,
+    experimental_customMergeAllOf,
+  )[0];
 }
 
 /** Resolves a conditional block (if/else/then) by removing the condition and merging the appropriate conditional branch
@@ -57,6 +82,7 @@ export default function retrieveSchema<
  *          dependencies as a list of schemas
  * @param recurseList - The list of recursive references already processed
  * @param [formData] - The current formData to assist retrieving a schema
+ * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
  * @returns - A list of schemas with the appropriate conditions resolved, possibly with all branches expanded
  */
 export function resolveCondition<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
@@ -65,7 +91,8 @@ export function resolveCondition<T = any, S extends StrictRJSFSchema = RJSFSchem
   rootSchema: S,
   expandAllBranches: boolean,
   recurseList: string[],
-  formData?: T
+  formData?: T,
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ): S[] {
   const { if: expression, then, else: otherwise, ...resolvedSchemaLessConditional } = schema;
 
@@ -75,12 +102,28 @@ export function resolveCondition<T = any, S extends StrictRJSFSchema = RJSFSchem
   if (expandAllBranches) {
     if (then && typeof then !== 'boolean') {
       schemas = schemas.concat(
-        retrieveSchemaInternal<T, S, F>(validator, then as S, rootSchema, formData, expandAllBranches, recurseList)
+        retrieveSchemaInternal<T, S, F>(
+          validator,
+          then as S,
+          rootSchema,
+          formData,
+          expandAllBranches,
+          recurseList,
+          experimental_customMergeAllOf,
+        ),
       );
     }
     if (otherwise && typeof otherwise !== 'boolean') {
       schemas = schemas.concat(
-        retrieveSchemaInternal<T, S, F>(validator, otherwise as S, rootSchema, formData, expandAllBranches, recurseList)
+        retrieveSchemaInternal<T, S, F>(
+          validator,
+          otherwise as S,
+          rootSchema,
+          formData,
+          expandAllBranches,
+          recurseList,
+          experimental_customMergeAllOf,
+        ),
       );
     }
   } else {
@@ -93,8 +136,9 @@ export function resolveCondition<T = any, S extends StrictRJSFSchema = RJSFSchem
           rootSchema,
           formData,
           expandAllBranches,
-          recurseList
-        )
+          recurseList,
+          experimental_customMergeAllOf,
+        ),
       );
     }
   }
@@ -102,7 +146,15 @@ export function resolveCondition<T = any, S extends StrictRJSFSchema = RJSFSchem
     resolvedSchemas = schemas.map((s) => mergeSchemas(resolvedSchemaLessConditional, s) as S);
   }
   return resolvedSchemas.flatMap((s) =>
-    retrieveSchemaInternal<T, S, F>(validator, s, rootSchema, formData, expandAllBranches, recurseList)
+    retrieveSchemaInternal<T, S, F>(
+      validator,
+      s,
+      rootSchema,
+      formData,
+      expandAllBranches,
+      recurseList,
+      experimental_customMergeAllOf,
+    ),
   );
 }
 
@@ -131,12 +183,34 @@ export function getAllPermutationsOfXxxOf<S extends StrictRJSFSchema = RJSFSchem
       permutations.forEach((permutation) => permutation.push(list[0]));
       return permutations;
     },
-    [[]] as S[][] // Start with an empty list
+    [[]] as S[][], // Start with an empty list
   );
 
   return allPermutations;
 }
 
+/** Returns the subset of 'patternProperties' specifications that match the given 'key'
+ *
+ * @param schema - The schema whose 'patternProperties' are to be filtered
+ * @param key - The key to match against the 'patternProperties' specifications
+ * @returns - The subset of 'patternProperties' specifications that match the given 'key'
+ */
+export function getMatchingPatternProperties<S extends StrictRJSFSchema = RJSFSchema>(
+  schema: S,
+  key: string,
+): Required<S['patternProperties']> {
+  return Object.keys(schema.patternProperties!)
+    .filter((pattern: string) => RegExp(pattern).test(key))
+    .reduce(
+      (obj, pattern) => {
+        // Pass the pattern using the `[]` index notation so that any `.` in the pattern are not used as a dotted path
+        set(obj, [pattern], schema.patternProperties![pattern]);
+        return obj;
+      },
+      {} as Required<S['patternProperties']>,
+    );
+}
+
 /** Resolves references and dependencies within a schema and its 'allOf' children. Passes the `expandAllBranches` flag
  * down to the `retrieveSchemaInternal()`, `resolveReference()` and `resolveDependencies()` helper calls. If
  * `expandAllBranches` is true, then all possible dependencies and/or allOf branches are returned.
@@ -148,6 +222,7 @@ export function getAllPermutationsOfXxxOf<S extends StrictRJSFSchema = RJSFSchem
  *          as a list of schemas
  * @param recurseList - The list of recursive references already processed
  * @param [formData] - 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 list of schemas having its references, dependencies and allOf schemas resolved
  */
 export function resolveSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
@@ -156,7 +231,8 @@ export function resolveSchema<T = any, S extends StrictRJSFSchema = RJSFSchema,
   rootSchema: S,
   expandAllBranches: boolean,
   recurseList: string[],
-  formData?: T
+  formData?: T,
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ): S[] {
   const updatedSchemas = resolveReference<T, S, F>(
     validator,
@@ -164,7 +240,7 @@ export function resolveSchema<T = any, S extends StrictRJSFSchema = RJSFSchema,
     rootSchema,
     expandAllBranches,
     recurseList,
-    formData
+    formData,
   );
   if (updatedSchemas.length > 1 || updatedSchemas[0] !== schema) {
     // return the updatedSchemas array if it has either multiple schemas within it
@@ -178,10 +254,18 @@ export function resolveSchema<T = any, S extends StrictRJSFSchema = RJSFSchema,
       rootSchema,
       expandAllBranches,
       recurseList,
-      formData
+      formData,
     );
     return resolvedSchemas.flatMap((s) => {
-      return retrieveSchemaInternal<T, S, F>(validator, s, rootSchema, formData, expandAllBranches, recurseList);
+      return retrieveSchemaInternal<T, S, F>(
+        validator,
+        s,
+        rootSchema,
+        formData,
+        expandAllBranches,
+        recurseList,
+        experimental_customMergeAllOf,
+      );
     });
   }
   if (ALL_OF_KEY in schema && Array.isArray(schema.allOf)) {
@@ -192,11 +276,15 @@ export function resolveSchema<T = any, S extends StrictRJSFSchema = RJSFSchema,
         rootSchema,
         formData,
         expandAllBranches,
-        recurseList
-      )
+        recurseList,
+        experimental_customMergeAllOf,
+      ),
     );
     const allPermutations = getAllPermutationsOfXxxOf<S>(allOfSchemaElements);
-    return allPermutations.map((permutation) => ({ ...schema, allOf: permutation }));
+    return allPermutations.map((permutation) => ({
+      ...schema,
+      allOf: permutation,
+    }));
   }
   // No $ref or dependencies or allOf attribute was found, returning the original schema.
   return [schema];
@@ -213,6 +301,7 @@ export function resolveSchema<T = any, S extends StrictRJSFSchema = RJSFSchema,
  *          as a list of schemas
  * @param recurseList - The list of recursive references already processed
  * @param [formData] - 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 list schemas retrieved after having all references resolved
  */
 export function resolveReference<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
@@ -221,7 +310,8 @@ export function resolveReference<T = any, S extends StrictRJSFSchema = RJSFSchem
   rootSchema: S,
   expandAllBranches: boolean,
   recurseList: string[],
-  formData?: T
+  formData?: T,
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ): S[] {
   const updatedSchema = resolveAllReferences<S>(schema, rootSchema, recurseList);
   if (updatedSchema !== schema) {
@@ -232,7 +322,8 @@ export function resolveReference<T = any, S extends StrictRJSFSchema = RJSFSchem
       rootSchema,
       formData,
       expandAllBranches,
-      recurseList
+      recurseList,
+      experimental_customMergeAllOf,
     );
   }
   return [schema];
@@ -243,12 +334,14 @@ export function resolveReference<T = any, S extends StrictRJSFSchema = RJSFSchem
  * @param schema - The schema for which resolving all references is desired
  * @param rootSchema - The root schema that will be forwarded to all the APIs
  * @param recurseList - List of $refs already resolved to prevent recursion
+ * @param [baseURI] - The base URI to be used for resolving relative references
  * @returns - given schema will all references resolved or the original schema if no internal `$refs` were resolved
  */
 export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
   schema: S,
   rootSchema: S,
-  recurseList: string[]
+  recurseList: string[],
+  baseURI?: string,
 ): S {
   if (!isObject(schema)) {
     return schema;
@@ -263,8 +356,11 @@ export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
     }
     recurseList.push($ref!);
     // Retrieve the referenced schema definition.
-    const refSchema = findSchemaDefinition<S>($ref, rootSchema);
+    const refSchema = findSchemaDefinition<S>($ref, rootSchema, baseURI);
     resolvedSchema = { ...refSchema, ...localSchema };
+    if (ID_KEY in resolvedSchema) {
+      baseURI = resolvedSchema[ID_KEY];
+    }
   }
 
   if (PROPERTIES_KEY in resolvedSchema) {
@@ -273,10 +369,10 @@ export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
       resolvedSchema[PROPERTIES_KEY]!,
       (result, value, key: string) => {
         const childList: string[] = [...recurseList];
-        result[key] = resolveAllReferences(value as S, rootSchema, childList);
+        result[key] = resolveAllReferences(value as S, rootSchema, childList, baseURI);
         childrenLists.push(childList);
       },
-      {} as RJSFSchema
+      {} as RJSFSchema,
     );
     merge(recurseList, uniq(flattenDeep(childrenLists)));
     resolvedSchema = { ...resolvedSchema, [PROPERTIES_KEY]: updatedProps };
@@ -289,11 +385,11 @@ export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
   ) {
     resolvedSchema = {
       ...resolvedSchema,
-      items: resolveAllReferences(resolvedSchema.items as S, rootSchema, recurseList),
+      items: resolveAllReferences(resolvedSchema.items as S, rootSchema, recurseList, baseURI),
     };
   }
 
-  return isEqual(schema, resolvedSchema) ? schema : resolvedSchema;
+  return deepEquals(schema, resolvedSchema) ? schema : resolvedSchema;
 }
 
 /** Creates new 'properties' items for each key in the `formData`
@@ -302,13 +398,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 {
+  F extends FormContextType = any,
+>(
+  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,
@@ -322,34 +425,55 @@ export function stubExistingAdditionalProperties<
       // No need to stub, our schema already has the property
       return;
     }
-
-    let additionalProperties: S['additionalProperties'] = {};
-    if (typeof schema.additionalProperties !== 'boolean') {
-      if (REF_KEY in schema.additionalProperties!) {
-        additionalProperties = retrieveSchema<T, S, F>(
+    if (PATTERN_PROPERTIES_KEY in schema) {
+      const matchingProperties = getMatchingPatternProperties(schema, key);
+      if (!isEmpty(matchingProperties)) {
+        schema.properties[key] = retrieveSchema<T, S, F>(
           validator,
-          { $ref: get(schema.additionalProperties, [REF_KEY]) } as S,
+          { allOf: Object.values(matchingProperties) } as S,
           rootSchema,
-          formData as T
+          get(formData, [key]) as T,
+          experimental_customMergeAllOf,
         );
-      } else if ('type' in schema.additionalProperties!) {
-        additionalProperties = { ...schema.additionalProperties };
-      } else if (ANY_OF_KEY in schema.additionalProperties! || ONE_OF_KEY in schema.additionalProperties!) {
-        additionalProperties = {
-          type: 'object',
-          ...schema.additionalProperties,
-        };
+        set(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
+        return;
+      }
+    }
+    if (ADDITIONAL_PROPERTIES_KEY in schema && schema.additionalProperties !== false) {
+      let additionalProperties: S['additionalProperties'] = {};
+      if (typeof schema.additionalProperties !== 'boolean') {
+        if (REF_KEY in schema.additionalProperties!) {
+          additionalProperties = retrieveSchema<T, S, F>(
+            validator,
+            { $ref: get(schema.additionalProperties, [REF_KEY]) } as S,
+            rootSchema,
+            formData as T,
+            experimental_customMergeAllOf,
+          );
+        } else if ('type' in schema.additionalProperties!) {
+          additionalProperties = { ...schema.additionalProperties };
+        } else if (ANY_OF_KEY in schema.additionalProperties! || ONE_OF_KEY in schema.additionalProperties!) {
+          additionalProperties = {
+            type: 'object',
+            ...schema.additionalProperties,
+          };
+        } else {
+          additionalProperties = { type: guessType(get(formData, [key])) };
+        }
       } else {
         additionalProperties = { type: guessType(get(formData, [key])) };
       }
+
+      // The type of our new key should match the additionalProperties value;
+      schema.properties[key] = additionalProperties;
+      // Set our additional property flag so we know it was dynamically added
+      set(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
     } else {
-      additionalProperties = { type: guessType(get(formData, [key])) };
+      // Invalid property
+      schema.properties[key] = { type: 'null' };
+      // Set our additional property flag so we know it was dynamically added
+      set(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
     }
-
-    // The type of our new key should match the additionalProperties value;
-    schema.properties[key] = additionalProperties;
-    // Set our additional property flag so we know it was dynamically added
-    set(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
   });
 
   return schema;
@@ -367,20 +491,22 @@ export function stubExistingAdditionalProperties<
  * @param [expandAllBranches=false] - Flag, if true, will return all possible branches of conditions, any/oneOf and
  *          dependencies as a list of schemas
  * @param [recurseList=[]] - The optional, list of recursive references already processed
+ * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
  * @returns - The schema(s) resulting from having its conditions, additional properties, references and dependencies
  *          resolved. Multiple schemas may be returned if `expandAllBranches` is true.
  */
 export function retrieveSchemaInternal<
   T = any,
   S extends StrictRJSFSchema = RJSFSchema,
-  F extends FormContextType = any
+  F extends FormContextType = any,
 >(
   validator: ValidatorType<T, S, F>,
   schema: S,
   rootSchema: S,
   rawFormData?: T,
   expandAllBranches = false,
-  recurseList: string[] = []
+  recurseList: string[] = [],
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ): S[] {
   if (!isObject(schema)) {
     return [{} as S];
@@ -391,7 +517,8 @@ export function retrieveSchemaInternal<
     rootSchema,
     expandAllBranches,
     recurseList,
-    rawFormData
+    rawFormData,
+    experimental_customMergeAllOf,
   );
   return resolvedSchemas.flatMap((s: S) => {
     let resolvedSchema = s;
@@ -402,7 +529,8 @@ export function retrieveSchemaInternal<
         rootSchema,
         expandAllBranches,
         recurseList,
-        rawFormData as T
+        rawFormData as T,
+        experimental_customMergeAllOf,
       );
     }
     if (ALL_OF_KEY in resolvedSchema) {
@@ -412,19 +540,67 @@ export function retrieveSchemaInternal<
         return [...(allOf as S[]), restOfSchema as S];
       }
       try {
-        resolvedSchema = mergeAllOf(resolvedSchema, {
-          deep: false,
-        } as Options) as S;
+        const withContainsSchemas = [] as S[];
+        const withoutContainsSchemas = [] as S[];
+        resolvedSchema.allOf?.forEach((s) => {
+          if (typeof s === 'object' && s.contains) {
+            withContainsSchemas.push(s as S);
+          } else {
+            withoutContainsSchemas.push(s as S);
+          }
+        });
+        if (withContainsSchemas.length) {
+          resolvedSchema = { ...resolvedSchema, allOf: withoutContainsSchemas };
+        }
+        resolvedSchema = experimental_customMergeAllOf
+          ? experimental_customMergeAllOf(resolvedSchema)
+          : (mergeAllOf(resolvedSchema, {
+              deep: false,
+              resolvers: {
+                $defs: mergeAllOf.options.resolvers.definitions,
+              },
+            } as Options) as S);
+        if (withContainsSchemas.length) {
+          resolvedSchema.allOf = withContainsSchemas;
+        }
       } catch (e) {
         console.warn('could not merge subschemas in allOf:\n', e);
         const { allOf, ...resolvedSchemaWithoutAllOf } = resolvedSchema;
         return resolvedSchemaWithoutAllOf as S;
       }
     }
+    if (PROPERTIES_KEY in resolvedSchema && PATTERN_PROPERTIES_KEY in resolvedSchema) {
+      resolvedSchema = Object.keys(resolvedSchema.properties!).reduce(
+        (schema, key) => {
+          const matchingProperties = getMatchingPatternProperties(schema, key);
+          if (!isEmpty(matchingProperties)) {
+            schema.properties[key] = retrieveSchema<T, S, F>(
+              validator,
+              { allOf: [schema.properties[key], ...Object.values(matchingProperties)] } as S,
+              rootSchema,
+              get(rawFormData, [key]) as T,
+              experimental_customMergeAllOf,
+            );
+          }
+          return schema;
+        },
+        {
+          ...resolvedSchema,
+          properties: { ...resolvedSchema.properties },
+        },
+      );
+    }
     const hasAdditionalProperties =
-      ADDITIONAL_PROPERTIES_KEY in resolvedSchema && resolvedSchema.additionalProperties !== false;
+      PATTERN_PROPERTIES_KEY in resolvedSchema ||
+      (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;
@@ -446,7 +622,7 @@ export function retrieveSchemaInternal<
 export function resolveAnyOrOneOfSchemas<
   T = any,
   S extends StrictRJSFSchema = RJSFSchema,
-  F extends FormContextType = any
+  F extends FormContextType = any,
 >(validator: ValidatorType<T, S, F>, schema: S, rootSchema: S, expandAllBranches: boolean, rawFormData?: T) {
   let anyOrOneOf: S[] | undefined;
   const { oneOf, anyOf, ...remaining } = schema;
@@ -484,6 +660,7 @@ export function resolveAnyOrOneOfSchemas<
  *          as a list of schemas
  * @param recurseList - The list of recursive references already processed
  * @param [formData] - 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 list of schemas with their dependencies resolved
  */
 export function resolveDependencies<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
@@ -492,7 +669,8 @@ export function resolveDependencies<T = any, S extends StrictRJSFSchema = RJSFSc
   rootSchema: S,
   expandAllBranches: boolean,
   recurseList: string[],
-  formData?: T
+  formData?: T,
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ): S[] {
   // Drop the dependencies from the source schema.
   const { dependencies, ...remainingSchema } = schema;
@@ -501,7 +679,7 @@ export function resolveDependencies<T = any, S extends StrictRJSFSchema = RJSFSc
     remainingSchema as S,
     rootSchema,
     expandAllBranches,
-    formData
+    formData,
   );
   return resolvedSchemas.flatMap((resolvedSchema) =>
     processDependencies<T, S, F>(
@@ -511,8 +689,9 @@ export function resolveDependencies<T = any, S extends StrictRJSFSchema = RJSFSc
       rootSchema,
       expandAllBranches,
       recurseList,
-      formData
-    )
+      formData,
+      experimental_customMergeAllOf,
+    ),
   );
 }
 
@@ -527,6 +706,7 @@ export function resolveDependencies<T = any, S extends StrictRJSFSchema = RJSFSc
  *          as a list of schemas
  * @param recurseList - The list of recursive references already processed
  * @param [formData] - 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 schema with the `dependencies` resolved into it
  */
 export function processDependencies<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
@@ -536,7 +716,8 @@ export function processDependencies<T = any, S extends StrictRJSFSchema = RJSFSc
   rootSchema: S,
   expandAllBranches: boolean,
   recurseList: string[],
-  formData?: T
+  formData?: T,
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ): S[] {
   let schemas = [resolvedSchema];
   // Process dependencies updating the local schema properties as appropriate.
@@ -551,7 +732,7 @@ export function processDependencies<T = any, S extends StrictRJSFSchema = RJSFSc
     }
     const [remainingDependencies, dependencyValue] = splitKeyElementFromObject(
       dependencyKey,
-      dependencies as GenericObjectType
+      dependencies as GenericObjectType,
     );
     if (Array.isArray(dependencyValue)) {
       schemas[0] = withDependentProperties<S>(resolvedSchema, dependencyValue);
@@ -564,7 +745,8 @@ export function processDependencies<T = any, S extends StrictRJSFSchema = RJSFSc
         dependencyValue as S,
         expandAllBranches,
         recurseList,
-        formData
+        formData,
+        experimental_customMergeAllOf,
       );
     }
     return schemas.flatMap((schema) =>
@@ -575,8 +757,9 @@ export function processDependencies<T = any, S extends StrictRJSFSchema = RJSFSc
         rootSchema,
         expandAllBranches,
         recurseList,
-        formData
-      )
+        formData,
+        experimental_customMergeAllOf,
+      ),
     );
   }
   return schemas;
@@ -590,7 +773,7 @@ export function processDependencies<T = any, S extends StrictRJSFSchema = RJSFSc
  */
 export function withDependentProperties<S extends StrictRJSFSchema = RJSFSchema>(
   schema: S,
-  additionallyRequired?: string[]
+  additionallyRequired?: string[],
 ) {
   if (!additionallyRequired) {
     return schema;
@@ -613,6 +796,7 @@ export function withDependentProperties<S extends StrictRJSFSchema = RJSFSchema>
  *          as a list of schemas
  * @param recurseList - The list of recursive references already processed
  * @param [formData]- The current formData to assist retrieving a schema
+ * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
  * @returns - The list of schemas with the dependent schema resolved into them
  */
 export function withDependentSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
@@ -623,7 +807,8 @@ export function withDependentSchema<T = any, S extends StrictRJSFSchema = RJSFSc
   dependencyValue: S,
   expandAllBranches: boolean,
   recurseList: string[],
-  formData?: T
+  formData?: T,
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ): S[] {
   const dependentSchemas = retrieveSchemaInternal<T, S, F>(
     validator,
@@ -631,7 +816,8 @@ export function withDependentSchema<T = any, S extends StrictRJSFSchema = RJSFSc
     rootSchema,
     formData,
     expandAllBranches,
-    recurseList
+    recurseList,
+    experimental_customMergeAllOf,
   );
   return dependentSchemas.flatMap((dependent) => {
     const { oneOf, ...dependentSchema } = dependent;
@@ -657,8 +843,9 @@ export function withDependentSchema<T = any, S extends StrictRJSFSchema = RJSFSc
         resolvedOneOf,
         expandAllBranches,
         recurseList,
-        formData
-      )
+        formData,
+        experimental_customMergeAllOf,
+      ),
     );
   });
 }
@@ -676,12 +863,13 @@ export function withDependentSchema<T = any, S extends StrictRJSFSchema = RJSFSc
  *          as a list of schemas
  * @param recurseList - The list of recursive references already processed
  * @param [formData] - The current formData to assist retrieving a schema
+ * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
  * @returns - Either an array containing the best matching option or all options if `expandAllBranches` is true
  */
 export function withExactlyOneSubschema<
   T = any,
   S extends StrictRJSFSchema = RJSFSchema,
-  F extends FormContextType = any
+  F extends FormContextType = any,
 >(
   validator: ValidatorType<T, S, F>,
   schema: S,
@@ -690,7 +878,8 @@ export function withExactlyOneSubschema<
   oneOf: S['oneOf'],
   expandAllBranches: boolean,
   recurseList: string[],
-  formData?: T
+  formData?: T,
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ): S[] {
   const validSubschemas = oneOf!.filter((subschema) => {
     if (typeof subschema === 'boolean' || !subschema || !subschema.properties) {
@@ -723,7 +912,8 @@ export function withExactlyOneSubschema<
       rootSchema,
       formData,
       expandAllBranches,
-      recurseList
+      recurseList,
+      experimental_customMergeAllOf,
     );
     return schemas.map((s) => mergeSchemas(schema, s) as S);
   });