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

package/lib/schema/retrieveSchema.d.ts

@@ -1,4 +1,4 @@
-import { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+import { Experimental_CustomMergeAllOf, FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types.js';
 /** 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
  * potentially recursive resolution.
@@ -7,9 +7,10 @@ import { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '..
  * @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, rawFormData?: T): S;
+export default function retrieveSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema?: S, rawFormData?: T, experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>): S;
 /** Resolves a conditional block (if/else/then) by removing the condition and merging the appropriate conditional branch
  * with the rest of the schema. If `expandAllBranches` is true, then the `retrieveSchemaInteral()` results for both
  * conditions will be returned.
@@ -21,9 +22,10 @@ export default function retrieveSchema<T = any, S extends StrictRJSFSchema = RJS
  *          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 declare function resolveCondition<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema: S, expandAllBranches: boolean, recurseList: string[], formData?: T): S[];
+export declare function resolveCondition<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema: S, expandAllBranches: boolean, recurseList: string[], formData?: T, experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>): S[];
 /** Given a list of lists of allOf, anyOf or oneOf values, create a list of lists of all permutations of the values. The
  * `listOfLists` is expected to be all resolved values of the 1st...nth schemas within an `allOf`, `anyOf` or `oneOf`.
  * From those lists, build a matrix for each `xxxOf` where there is more than one schema for a row in the list of lists.
@@ -39,6 +41,13 @@ export declare function resolveCondition<T = any, S extends StrictRJSFSchema = R
  * @returns - The list of all permutations of schemas for a set of `xxxOf`s
  */
 export declare function getAllPermutationsOfXxxOf<S extends StrictRJSFSchema = RJSFSchema>(listOfLists: S[][]): S[][];
+/** 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 declare function getMatchingPatternProperties<S extends StrictRJSFSchema = RJSFSchema>(schema: S, key: string): 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.
@@ -50,9 +59,10 @@ export declare function getAllPermutationsOfXxxOf<S extends StrictRJSFSchema = R
  *          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 declare function resolveSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema: S, expandAllBranches: boolean, recurseList: string[], formData?: T): S[];
+export declare function resolveSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema: S, expandAllBranches: boolean, recurseList: string[], formData?: T, experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>): S[];
 /** Resolves all references within a schema and then returns the `retrieveSchemaInternal()` if the resolved schema is
  * actually different than the original. Passes the `expandAllBranches` flag down to the `retrieveSchemaInternal()`
  * helper call.
@@ -64,26 +74,29 @@ export declare function resolveSchema<T = any, S extends StrictRJSFSchema = RJSF
  *          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 declare function resolveReference<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema: S, expandAllBranches: boolean, recurseList: string[], formData?: T): S[];
+export declare function resolveReference<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema: S, expandAllBranches: boolean, recurseList: string[], formData?: T, experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>): S[];
 /** Resolves all references within the schema itself as well as any of its properties and array items.
  *
  * @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 declare function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(schema: S, rootSchema: S, recurseList: string[]): S;
+export declare function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(schema: S, rootSchema: S, recurseList: string[], baseURI?: string): S;
 /** Creates new 'properties' items for each key in the `formData`
  *
  * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
  * @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 declare function stubExistingAdditionalProperties<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, theSchema: S, rootSchema?: S, aFormData?: T): S;
+export declare function stubExistingAdditionalProperties<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, theSchema: S, rootSchema?: S, aFormData?: T, experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>): S;
 /** Internal handler that 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 potentially recursive resolution. If `expandAllBranches` is true, then all possible branches
@@ -96,10 +109,11 @@ export declare function stubExistingAdditionalProperties<T = any, S extends Stri
  * @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 declare function retrieveSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema: S, rawFormData?: T, expandAllBranches?: boolean, recurseList?: string[]): S[];
+export declare function retrieveSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema: S, rawFormData?: T, expandAllBranches?: boolean, recurseList?: string[], experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>): S[];
 /** Resolves an `anyOf` or `oneOf` within a schema (if present) to the list of schemas returned from
  * `retrieveSchemaInternal()` for the best matching option. If `expandAllBranches` is true, then a list of schemas for ALL
  * options are retrieved and returned.
@@ -123,9 +137,10 @@ export declare function resolveAnyOrOneOfSchemas<T = any, S extends StrictRJSFSc
  *          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 declare function resolveDependencies<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema: S, expandAllBranches: boolean, recurseList: string[], formData?: T): S[];
+export declare function resolveDependencies<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema: S, expandAllBranches: boolean, recurseList: string[], formData?: T, experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>): S[];
 /** Processes all the `dependencies` recursively into the list of `resolvedSchema`s as needed. Passes the
  * `expandAllBranches` flag down to the `withDependentSchema()` and the recursive `processDependencies()` helper calls.
  *
@@ -137,9 +152,10 @@ export declare function resolveDependencies<T = any, S extends StrictRJSFSchema
  *          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 declare function processDependencies<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, dependencies: S['dependencies'], resolvedSchema: S, rootSchema: S, expandAllBranches: boolean, recurseList: string[], formData?: T): S[];
+export declare function processDependencies<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, dependencies: S['dependencies'], resolvedSchema: S, rootSchema: S, expandAllBranches: boolean, recurseList: string[], formData?: T, experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>): S[];
 /** Updates a schema with additionally required properties added
  *
  * @param schema - The schema for which resolving a dependent properties is desired
@@ -159,9 +175,10 @@ export declare function withDependentProperties<S extends StrictRJSFSchema = RJS
  *          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 declare function withDependentSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema: S, dependencyKey: string, dependencyValue: S, expandAllBranches: boolean, recurseList: string[], formData?: T): S[];
+export declare function withDependentSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema: S, dependencyKey: string, dependencyValue: S, expandAllBranches: boolean, recurseList: string[], formData?: T, experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>): S[];
 /** Returns a list of `schema`s with the best choice from the `oneOf` options merged into it. If `expandAllBranches` is
  * true, then a list of schemas for ALL options are retrieved and returned. Passes the `expandAllBranches` flag down to
  * the `retrieveSchemaInternal()` helper call.
@@ -175,6 +192,7 @@ export declare function withDependentSchema<T = any, S extends StrictRJSFSchema
  *          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 declare function withExactlyOneSubschema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema: S, dependencyKey: string, oneOf: S['oneOf'], expandAllBranches: boolean, recurseList: string[], formData?: T): S[];
+export declare function withExactlyOneSubschema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema: S, dependencyKey: string, oneOf: S['oneOf'], expandAllBranches: boolean, recurseList: string[], formData?: T, experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>): S[];

package/lib/schema/retrieveSchema.js

@@ -1,19 +1,20 @@
-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';
-import merge from 'lodash/merge';
-import flattenDeep from 'lodash/flattenDeep';
-import uniq from 'lodash/uniq';
+import get from 'lodash-es/get.js';
+import set from 'lodash-es/set.js';
+import times from 'lodash-es/times.js';
+import transform from 'lodash-es/transform.js';
+import merge from 'lodash-es/merge.js';
+import flattenDeep from 'lodash-es/flattenDeep.js';
+import uniq from 'lodash-es/uniq.js';
 import mergeAllOf from 'json-schema-merge-allof';
-import { ADDITIONAL_PROPERTIES_KEY, ADDITIONAL_PROPERTY_FLAG, ALL_OF_KEY, ANY_OF_KEY, DEPENDENCIES_KEY, IF_KEY, ONE_OF_KEY, REF_KEY, PROPERTIES_KEY, ITEMS_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 getFirstMatchingOption from './getFirstMatchingOption';
+import { ADDITIONAL_PROPERTIES_KEY, ADDITIONAL_PROPERTY_FLAG, ALL_OF_KEY, ANY_OF_KEY, DEPENDENCIES_KEY, ID_KEY, IF_KEY, ITEMS_KEY, ONE_OF_KEY, PATTERN_PROPERTIES_KEY, PROPERTIES_KEY, REF_KEY, } from '../constants.js';
+import findSchemaDefinition, { splitKeyElementFromObject } from '../findSchemaDefinition.js';
+import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema.js';
+import guessType from '../guessType.js';
+import isObject from '../isObject.js';
+import mergeSchemas from '../mergeSchemas.js';
+import getFirstMatchingOption from './getFirstMatchingOption.js';
+import deepEquals from '../deepEquals.js';
+import isEmpty from 'lodash-es/isEmpty.js';
 /** 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
  * potentially recursive resolution.
@@ -22,10 +23,11 @@ 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(validator, schema, rootSchema = {}, rawFormData) {
-    return retrieveSchemaInternal(validator, schema, rootSchema, rawFormData)[0];
+export default function retrieveSchema(validator, schema, rootSchema = {}, rawFormData, experimental_customMergeAllOf) {
+    return retrieveSchemaInternal(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
  * with the rest of the schema. If `expandAllBranches` is true, then the `retrieveSchemaInteral()` results for both
@@ -38,31 +40,32 @@ export default function retrieveSchema(validator, schema, rootSchema = {}, rawFo
  *          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(validator, schema, rootSchema, expandAllBranches, recurseList, formData) {
+export function resolveCondition(validator, schema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
     const { if: expression, then, else: otherwise, ...resolvedSchemaLessConditional } = schema;
     const conditionValue = validator.isValid(expression, formData || {}, rootSchema);
     let resolvedSchemas = [resolvedSchemaLessConditional];
     let schemas = [];
     if (expandAllBranches) {
         if (then && typeof then !== 'boolean') {
-            schemas = schemas.concat(retrieveSchemaInternal(validator, then, rootSchema, formData, expandAllBranches, recurseList));
+            schemas = schemas.concat(retrieveSchemaInternal(validator, then, rootSchema, formData, expandAllBranches, recurseList, experimental_customMergeAllOf));
         }
         if (otherwise && typeof otherwise !== 'boolean') {
-            schemas = schemas.concat(retrieveSchemaInternal(validator, otherwise, rootSchema, formData, expandAllBranches, recurseList));
+            schemas = schemas.concat(retrieveSchemaInternal(validator, otherwise, rootSchema, formData, expandAllBranches, recurseList, experimental_customMergeAllOf));
         }
     }
     else {
         const conditionalSchema = conditionValue ? then : otherwise;
         if (conditionalSchema && typeof conditionalSchema !== 'boolean') {
-            schemas = schemas.concat(retrieveSchemaInternal(validator, conditionalSchema, rootSchema, formData, expandAllBranches, recurseList));
+            schemas = schemas.concat(retrieveSchemaInternal(validator, conditionalSchema, rootSchema, formData, expandAllBranches, recurseList, experimental_customMergeAllOf));
         }
     }
     if (schemas.length) {
         resolvedSchemas = schemas.map((s) => mergeSchemas(resolvedSchemaLessConditional, s));
     }
-    return resolvedSchemas.flatMap((s) => retrieveSchemaInternal(validator, s, rootSchema, formData, expandAllBranches, recurseList));
+    return resolvedSchemas.flatMap((s) => retrieveSchemaInternal(validator, s, rootSchema, formData, expandAllBranches, recurseList, experimental_customMergeAllOf));
 }
 /** Given a list of lists of allOf, anyOf or oneOf values, create a list of lists of all permutations of the values. The
  * `listOfLists` is expected to be all resolved values of the 1st...nth schemas within an `allOf`, `anyOf` or `oneOf`.
@@ -87,10 +90,24 @@ export function getAllPermutationsOfXxxOf(listOfLists) {
         // Otherwise just push in the single value into the current set of permutations
         permutations.forEach((permutation) => permutation.push(list[0]));
         return permutations;
-    }, [[]] // 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(schema, key) {
+    return Object.keys(schema.patternProperties)
+        .filter((pattern) => 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;
+    }, {});
+}
 /** 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.
@@ -102,9 +119,10 @@ export function getAllPermutationsOfXxxOf(listOfLists) {
  *          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(validator, schema, rootSchema, expandAllBranches, recurseList, formData) {
+export function resolveSchema(validator, schema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
     const updatedSchemas = resolveReference(validator, schema, rootSchema, expandAllBranches, recurseList, formData);
     if (updatedSchemas.length > 1 || updatedSchemas[0] !== schema) {
         // return the updatedSchemas array if it has either multiple schemas within it
@@ -114,13 +132,16 @@ export function resolveSchema(validator, schema, rootSchema, expandAllBranches,
     if (DEPENDENCIES_KEY in schema) {
         const resolvedSchemas = resolveDependencies(validator, schema, rootSchema, expandAllBranches, recurseList, formData);
         return resolvedSchemas.flatMap((s) => {
-            return retrieveSchemaInternal(validator, s, rootSchema, formData, expandAllBranches, recurseList);
+            return retrieveSchemaInternal(validator, s, rootSchema, formData, expandAllBranches, recurseList, experimental_customMergeAllOf);
         });
     }
     if (ALL_OF_KEY in schema && Array.isArray(schema.allOf)) {
-        const allOfSchemaElements = schema.allOf.map((allOfSubschema) => retrieveSchemaInternal(validator, allOfSubschema, rootSchema, formData, expandAllBranches, recurseList));
+        const allOfSchemaElements = schema.allOf.map((allOfSubschema) => retrieveSchemaInternal(validator, allOfSubschema, rootSchema, formData, expandAllBranches, recurseList, experimental_customMergeAllOf));
         const allPermutations = getAllPermutationsOfXxxOf(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];
@@ -136,13 +157,14 @@ export function resolveSchema(validator, schema, rootSchema, expandAllBranches,
  *          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(validator, schema, rootSchema, expandAllBranches, recurseList, formData) {
+export function resolveReference(validator, schema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
     const updatedSchema = resolveAllReferences(schema, rootSchema, recurseList);
     if (updatedSchema !== schema) {
         // Only call this if the schema was actually changed by the `resolveAllReferences()` function
-        return retrieveSchemaInternal(validator, updatedSchema, rootSchema, formData, expandAllBranches, recurseList);
+        return retrieveSchemaInternal(validator, updatedSchema, rootSchema, formData, expandAllBranches, recurseList, experimental_customMergeAllOf);
     }
     return [schema];
 }
@@ -151,9 +173,10 @@ export function resolveReference(validator, schema, rootSchema, expandAllBranche
  * @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(schema, rootSchema, recurseList) {
+export function resolveAllReferences(schema, rootSchema, recurseList, baseURI) {
     if (!isObject(schema)) {
         return schema;
     }
@@ -167,14 +190,17 @@ export function resolveAllReferences(schema, rootSchema, recurseList) {
         }
         recurseList.push($ref);
         // Retrieve the referenced schema definition.
-        const refSchema = findSchemaDefinition($ref, rootSchema);
+        const refSchema = findSchemaDefinition($ref, rootSchema, baseURI);
         resolvedSchema = { ...refSchema, ...localSchema };
+        if (ID_KEY in resolvedSchema) {
+            baseURI = resolvedSchema[ID_KEY];
+        }
     }
     if (PROPERTIES_KEY in resolvedSchema) {
         const childrenLists = [];
         const updatedProps = transform(resolvedSchema[PROPERTIES_KEY], (result, value, key) => {
             const childList = [...recurseList];
-            result[key] = resolveAllReferences(value, rootSchema, childList);
+            result[key] = resolveAllReferences(value, rootSchema, childList, baseURI);
             childrenLists.push(childList);
         }, {});
         merge(recurseList, uniq(flattenDeep(childrenLists)));
@@ -185,10 +211,10 @@ export function resolveAllReferences(schema, rootSchema, recurseList) {
         typeof resolvedSchema.items !== 'boolean') {
         resolvedSchema = {
             ...resolvedSchema,
-            items: resolveAllReferences(resolvedSchema.items, rootSchema, recurseList),
+            items: resolveAllReferences(resolvedSchema.items, 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`
  *
@@ -196,9 +222,10 @@ export function resolveAllReferences(schema, rootSchema, recurseList) {
  * @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(validator, theSchema, rootSchema, aFormData) {
+export function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFormData, experimental_customMergeAllOf) {
     // Clone the schema so that we don't ruin the consumer's original
     const schema = {
         ...theSchema,
@@ -211,31 +238,47 @@ export function stubExistingAdditionalProperties(validator, theSchema, rootSchem
             // No need to stub, our schema already has the property
             return;
         }
-        let additionalProperties = {};
-        if (typeof schema.additionalProperties !== 'boolean') {
-            if (REF_KEY in schema.additionalProperties) {
-                additionalProperties = retrieveSchema(validator, { $ref: get(schema.additionalProperties, [REF_KEY]) }, rootSchema, formData);
+        if (PATTERN_PROPERTIES_KEY in schema) {
+            const matchingProperties = getMatchingPatternProperties(schema, key);
+            if (!isEmpty(matchingProperties)) {
+                schema.properties[key] = retrieveSchema(validator, { allOf: Object.values(matchingProperties) }, rootSchema, get(formData, [key]), experimental_customMergeAllOf);
+                set(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
+                return;
             }
-            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,
-                };
+        }
+        if (ADDITIONAL_PROPERTIES_KEY in schema && schema.additionalProperties !== false) {
+            let additionalProperties = {};
+            if (typeof schema.additionalProperties !== 'boolean') {
+                if (REF_KEY in schema.additionalProperties) {
+                    additionalProperties = retrieveSchema(validator, { $ref: get(schema.additionalProperties, [REF_KEY]) }, rootSchema, formData, 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;
 }
@@ -251,18 +294,20 @@ export function stubExistingAdditionalProperties(validator, theSchema, rootSchem
  * @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(validator, schema, rootSchema, rawFormData, expandAllBranches = false, recurseList = []) {
+export function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expandAllBranches = false, recurseList = [], experimental_customMergeAllOf) {
     if (!isObject(schema)) {
         return [{}];
     }
-    const resolvedSchemas = resolveSchema(validator, schema, rootSchema, expandAllBranches, recurseList, rawFormData);
+    const resolvedSchemas = resolveSchema(validator, schema, rootSchema, expandAllBranches, recurseList, rawFormData, experimental_customMergeAllOf);
     return resolvedSchemas.flatMap((s) => {
+        var _a;
         let resolvedSchema = s;
         if (IF_KEY in resolvedSchema) {
-            return resolveCondition(validator, resolvedSchema, rootSchema, expandAllBranches, recurseList, rawFormData);
+            return resolveCondition(validator, resolvedSchema, rootSchema, expandAllBranches, recurseList, rawFormData, experimental_customMergeAllOf);
         }
         if (ALL_OF_KEY in resolvedSchema) {
             // resolve allOf schemas
@@ -271,9 +316,30 @@ export function retrieveSchemaInternal(validator, schema, rootSchema, rawFormDat
                 return [...allOf, restOfSchema];
             }
             try {
-                resolvedSchema = mergeAllOf(resolvedSchema, {
-                    deep: false,
+                const withContainsSchemas = [];
+                const withoutContainsSchemas = [];
+                (_a = resolvedSchema.allOf) === null || _a === void 0 ? void 0 : _a.forEach((s) => {
+                    if (typeof s === 'object' && s.contains) {
+                        withContainsSchemas.push(s);
+                    }
+                    else {
+                        withoutContainsSchemas.push(s);
+                    }
                 });
+                if (withContainsSchemas.length) {
+                    resolvedSchema = { ...resolvedSchema, allOf: withoutContainsSchemas };
+                }
+                resolvedSchema = experimental_customMergeAllOf
+                    ? experimental_customMergeAllOf(resolvedSchema)
+                    : mergeAllOf(resolvedSchema, {
+                        deep: false,
+                        resolvers: {
+                            $defs: mergeAllOf.options.resolvers.definitions,
+                        },
+                    });
+                if (withContainsSchemas.length) {
+                    resolvedSchema.allOf = withContainsSchemas;
+                }
             }
             catch (e) {
                 console.warn('could not merge subschemas in allOf:\n', e);
@@ -281,9 +347,22 @@ export function retrieveSchemaInternal(validator, schema, rootSchema, rawFormDat
                 return resolvedSchemaWithoutAllOf;
             }
         }
-        const hasAdditionalProperties = ADDITIONAL_PROPERTIES_KEY in resolvedSchema && resolvedSchema.additionalProperties !== false;
+        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(validator, { allOf: [schema.properties[key], ...Object.values(matchingProperties)] }, rootSchema, get(rawFormData, [key]), experimental_customMergeAllOf);
+                }
+                return schema;
+            }, {
+                ...resolvedSchema,
+                properties: { ...resolvedSchema.properties },
+            });
+        }
+        const hasAdditionalProperties = PATTERN_PROPERTIES_KEY in resolvedSchema ||
+            (ADDITIONAL_PROPERTIES_KEY in resolvedSchema && resolvedSchema.additionalProperties !== false);
         if (hasAdditionalProperties) {
-            return stubExistingAdditionalProperties(validator, resolvedSchema, rootSchema, rawFormData);
+            return stubExistingAdditionalProperties(validator, resolvedSchema, rootSchema, rawFormData, experimental_customMergeAllOf);
         }
         return resolvedSchema;
     });
@@ -337,13 +416,14 @@ export function resolveAnyOrOneOfSchemas(validator, schema, rootSchema, expandAl
  *          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(validator, schema, rootSchema, expandAllBranches, recurseList, formData) {
+export function resolveDependencies(validator, schema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
     // Drop the dependencies from the source schema.
     const { dependencies, ...remainingSchema } = schema;
     const resolvedSchemas = resolveAnyOrOneOfSchemas(validator, remainingSchema, rootSchema, expandAllBranches, formData);
-    return resolvedSchemas.flatMap((resolvedSchema) => processDependencies(validator, dependencies, resolvedSchema, rootSchema, expandAllBranches, recurseList, formData));
+    return resolvedSchemas.flatMap((resolvedSchema) => processDependencies(validator, dependencies, resolvedSchema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf));
 }
 /** Processes all the `dependencies` recursively into the list of `resolvedSchema`s as needed. Passes the
  * `expandAllBranches` flag down to the `withDependentSchema()` and the recursive `processDependencies()` helper calls.
@@ -356,9 +436,10 @@ export function resolveDependencies(validator, schema, rootSchema, expandAllBran
  *          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(validator, dependencies, resolvedSchema, rootSchema, expandAllBranches, recurseList, formData) {
+export function processDependencies(validator, dependencies, resolvedSchema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
     let schemas = [resolvedSchema];
     // Process dependencies updating the local schema properties as appropriate.
     for (const dependencyKey in dependencies) {
@@ -375,9 +456,9 @@ export function processDependencies(validator, dependencies, resolvedSchema, roo
             schemas[0] = withDependentProperties(resolvedSchema, dependencyValue);
         }
         else if (isObject(dependencyValue)) {
-            schemas = withDependentSchema(validator, resolvedSchema, rootSchema, dependencyKey, dependencyValue, expandAllBranches, recurseList, formData);
+            schemas = withDependentSchema(validator, resolvedSchema, rootSchema, dependencyKey, dependencyValue, expandAllBranches, recurseList, formData, experimental_customMergeAllOf);
         }
-        return schemas.flatMap((schema) => processDependencies(validator, remainingDependencies, schema, rootSchema, expandAllBranches, recurseList, formData));
+        return schemas.flatMap((schema) => processDependencies(validator, remainingDependencies, schema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf));
     }
     return schemas;
 }
@@ -408,10 +489,11 @@ export function withDependentProperties(schema, additionallyRequired) {
  *          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(validator, schema, rootSchema, dependencyKey, dependencyValue, expandAllBranches, recurseList, formData) {
-    const dependentSchemas = retrieveSchemaInternal(validator, dependencyValue, rootSchema, formData, expandAllBranches, recurseList);
+export function withDependentSchema(validator, schema, rootSchema, dependencyKey, dependencyValue, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
+    const dependentSchemas = retrieveSchemaInternal(validator, dependencyValue, rootSchema, formData, expandAllBranches, recurseList, experimental_customMergeAllOf);
     return dependentSchemas.flatMap((dependent) => {
         const { oneOf, ...dependentSchema } = dependent;
         schema = mergeSchemas(schema, dependentSchema);
@@ -427,7 +509,7 @@ export function withDependentSchema(validator, schema, rootSchema, dependencyKey
             return resolveReference(validator, subschema, rootSchema, expandAllBranches, recurseList, formData);
         });
         const allPermutations = getAllPermutationsOfXxxOf(resolvedOneOfs);
-        return allPermutations.flatMap((resolvedOneOf) => withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, resolvedOneOf, expandAllBranches, recurseList, formData));
+        return allPermutations.flatMap((resolvedOneOf) => withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, resolvedOneOf, expandAllBranches, recurseList, formData, experimental_customMergeAllOf));
     });
 }
 /** Returns a list of `schema`s with the best choice from the `oneOf` options merged into it. If `expandAllBranches` is
@@ -443,9 +525,10 @@ export function withDependentSchema(validator, schema, rootSchema, dependencyKey
  *          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(validator, schema, rootSchema, dependencyKey, oneOf, expandAllBranches, recurseList, formData) {
+export function withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, oneOf, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
     const validSubschemas = oneOf.filter((subschema) => {
         if (typeof subschema === 'boolean' || !subschema || !subschema.properties) {
             return false;
@@ -470,7 +553,7 @@ export function withExactlyOneSubschema(validator, schema, rootSchema, dependenc
         const subschema = s;
         const [dependentSubschema] = splitKeyElementFromObject(dependencyKey, subschema.properties);
         const dependentSchema = { ...subschema, properties: dependentSubschema };
-        const schemas = retrieveSchemaInternal(validator, dependentSchema, rootSchema, formData, expandAllBranches, recurseList);
+        const schemas = retrieveSchemaInternal(validator, dependentSchema, rootSchema, formData, expandAllBranches, recurseList, experimental_customMergeAllOf);
         return schemas.map((s) => mergeSchemas(schema, s));
     });
 }