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

package/src/mergeDefaultsWithFormData.ts

@@ -2,6 +2,7 @@ import get from 'lodash/get';
 
 import isObject from './isObject';
 import { GenericObjectType } from '../src';
+import isNil from 'lodash/isNil';
 
 /** Merges the `defaults` object of type `T` into the `formData` of type `T`
  *
@@ -12,42 +13,86 @@ import { GenericObjectType } from '../src';
  *     are deeply merged; additional entries from the defaults are ignored unless `mergeExtraArrayDefaults` is true, in
  *     which case the extras are appended onto the end of the form data
  *   - when the array is not set in form data, the default is copied over
- * - scalars are overwritten/set by form data
+ * - scalars are overwritten/set by form data unless undefined and there is a default AND `defaultSupercedesUndefined`
+ *   is true
  *
  * @param [defaults] - The defaults to merge
  * @param [formData] - The form data into which the defaults will be merged
  * @param [mergeExtraArrayDefaults=false] - If true, any additional default array entries are appended onto the formData
+ * @param [defaultSupercedesUndefined=false] - If true, an explicit undefined value will be overwritten by the default value
+ * @param [overrideFormDataWithDefaults=false] - If true, the default value will overwrite the form data value. If the value
+ *        doesn't exist in the default, we take it from formData and in the case where the value is set to undefined in formData.
+ *       This is useful when we have already merged formData with defaults and want to add an additional field from formData
+ *       that does not exist in defaults.
  * @returns - The resulting merged form data with defaults
  */
 export default function mergeDefaultsWithFormData<T = any>(
   defaults?: T,
   formData?: T,
-  mergeExtraArrayDefaults = false
+  mergeExtraArrayDefaults = false,
+  defaultSupercedesUndefined = false,
+  overrideFormDataWithDefaults = false,
 ): T | undefined {
   if (Array.isArray(formData)) {
     const defaultsArray = Array.isArray(defaults) ? defaults : [];
-    const mapped = formData.map((value, idx) => {
-      if (defaultsArray[idx]) {
-        return mergeDefaultsWithFormData<any>(defaultsArray[idx], value, mergeExtraArrayDefaults);
+
+    // If overrideFormDataWithDefaults is true, we want to override the formData with the defaults
+    const overrideArray = overrideFormDataWithDefaults ? defaultsArray : formData;
+    const overrideOppositeArray = overrideFormDataWithDefaults ? formData : defaultsArray;
+
+    const mapped = overrideArray.map((value, idx) => {
+      // We want to explicitly make sure that the value is NOT undefined since null, 0 and empty space are valid values
+      if (overrideOppositeArray[idx] !== undefined) {
+        return mergeDefaultsWithFormData<any>(
+          defaultsArray[idx],
+          formData[idx],
+          mergeExtraArrayDefaults,
+          defaultSupercedesUndefined,
+          overrideFormDataWithDefaults,
+        );
       }
       return value;
     });
+
     // Merge any extra defaults when mergeExtraArrayDefaults is true
-    if (mergeExtraArrayDefaults && mapped.length < defaultsArray.length) {
-      mapped.push(...defaultsArray.slice(mapped.length));
+    // Or when overrideFormDataWithDefaults is true and the default array is shorter than the formData array
+    if ((mergeExtraArrayDefaults || overrideFormDataWithDefaults) && mapped.length < overrideOppositeArray.length) {
+      mapped.push(...overrideOppositeArray.slice(mapped.length));
     }
     return mapped as unknown as T;
   }
   if (isObject(formData)) {
     const acc: { [key in keyof T]: any } = Object.assign({}, defaults); // Prevent mutation of source object.
     return Object.keys(formData as GenericObjectType).reduce((acc, key) => {
+      const keyValue = get(formData, key);
+      const keyExistsInDefaults = isObject(defaults) && key in (defaults as GenericObjectType);
+      const keyExistsInFormData = key in (formData as GenericObjectType);
       acc[key as keyof T] = mergeDefaultsWithFormData<T>(
         defaults ? get(defaults, key) : {},
-        get(formData, key),
-        mergeExtraArrayDefaults
+        keyValue,
+        mergeExtraArrayDefaults,
+        defaultSupercedesUndefined,
+        // overrideFormDataWithDefaults can be true only when the key value exists in defaults
+        // Or if the key value doesn't exist in formData
+        overrideFormDataWithDefaults && (keyExistsInDefaults || !keyExistsInFormData),
       );
       return acc;
     }, acc);
   }
+
+  /**
+   * If the defaultSupercedesUndefined flag is true
+   *    And formData is set to undefined or null and defaults are defined
+   *    Or if formData is a number and is NaN return defaults
+   * Or if overrideFormDataWithDefaults flag is true and formData is set to not undefined/null return defaults
+   */
+  if (
+    (defaultSupercedesUndefined &&
+      ((!isNil(defaults) && isNil(formData)) || (typeof formData === 'number' && isNaN(formData)))) ||
+    (overrideFormDataWithDefaults && !isNil(formData))
+  ) {
+    return defaults;
+  }
+
   return formData;
 }

package/src/mergeObjects.ts

@@ -13,27 +13,30 @@ import { GenericObjectType } from './types';
 export default function mergeObjects(
   obj1: GenericObjectType,
   obj2: GenericObjectType,
-  concatArrays: boolean | 'preventDuplicates' = false
+  concatArrays: boolean | 'preventDuplicates' = false,
 ) {
-  return Object.keys(obj2).reduce((acc, key) => {
-    const left = obj1 ? obj1[key] : {},
-      right = obj2[key];
-    if (obj1 && key in obj1 && isObject(right)) {
-      acc[key] = mergeObjects(left, right, concatArrays);
-    } else if (concatArrays && Array.isArray(left) && Array.isArray(right)) {
-      let toMerge = right;
-      if (concatArrays === 'preventDuplicates') {
-        toMerge = right.reduce((result, value) => {
-          if (!left.includes(value)) {
-            result.push(value);
-          }
-          return result;
-        }, []);
+  return Object.keys(obj2).reduce(
+    (acc, key) => {
+      const left = obj1 ? obj1[key] : {},
+        right = obj2[key];
+      if (obj1 && key in obj1 && isObject(right)) {
+        acc[key] = mergeObjects(left, right, concatArrays);
+      } else if (concatArrays && Array.isArray(left) && Array.isArray(right)) {
+        let toMerge = right;
+        if (concatArrays === 'preventDuplicates') {
+          toMerge = right.reduce((result, value) => {
+            if (!left.includes(value)) {
+              result.push(value);
+            }
+            return result;
+          }, []);
+        }
+        acc[key] = left.concat(toMerge);
+      } else {
+        acc[key] = right;
       }
-      acc[key] = left.concat(toMerge);
-    } else {
-      acc[key] = right;
-    }
-    return acc;
-  }, Object.assign({}, obj1)); // Prevent mutation of source object.
+      return acc;
+    },
+    Object.assign({}, obj1),
+  ); // Prevent mutation of source object.
 }

package/src/optionsList.ts

@@ -1,40 +1,34 @@
+import get from 'lodash/get';
+
+import { CONST_KEY, DEFAULT_KEY, PROPERTIES_KEY } from './constants';
+import getDiscriminatorFieldFromSchema from './getDiscriminatorFieldFromSchema';
+import getUiOptions from './getUiOptions';
 import toConstant from './toConstant';
 import { RJSFSchema, EnumOptionsType, StrictRJSFSchema, FormContextType, UiSchema } from './types';
-import getUiOptions from './getUiOptions';
 
 /** Gets the list of options from the `schema`. If the schema has an enum list, then those enum values are returned. The
- * labels for the options will be extracted from the non-standard, RJSF-deprecated `enumNames` if it exists, otherwise
- * the label will be the same as the `value`. If the schema has a `oneOf` or `anyOf`, then the value is the list of
- * `const` values from the schema and the label is either the `schema.title` or the value. If a `uiSchema` is provided
- * and it has the `ui:enumNames` matched with `enum` or it has an associated `oneOf` or `anyOf` with a list of objects
- * containing `ui:title` then the UI schema values will replace the values from the schema.
+ * label will be the same as the `value`.
+ *
+ * If the schema has a `oneOf` or `anyOf`, then the value is the list of either:
+ * - The `const` values from the schema if present
+ * - If the schema has a discriminator and the label using either the `schema.title` or the value. If a `uiSchema` is
+ * provided, and it has the `ui:enumNames` matched with `enum` or it has an associated `oneOf` or `anyOf` with a list of
+ * objects containing `ui:title` then the UI schema values will replace the values from the schema.
  *
  * @param schema - The schema from which to extract the options list
  * @param [uiSchema] - The optional uiSchema from which to get alternate labels for the options
  * @returns - The list of options from the schema
  */
-export default function optionsList<S extends StrictRJSFSchema = RJSFSchema, T = any, F extends FormContextType = any>(
+export default function optionsList<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
   schema: S,
-  uiSchema?: UiSchema<T, S, F>
+  uiSchema?: UiSchema<T, S, F>,
 ): EnumOptionsType<S>[] | undefined {
-  // TODO flip generics to move T first in v6
-  const schemaWithEnumNames = schema as S & { enumNames?: string[] };
   if (schema.enum) {
     let enumNames: string[] | undefined;
     if (uiSchema) {
       const { enumNames: uiEnumNames } = getUiOptions<T, S, F>(uiSchema);
       enumNames = uiEnumNames;
     }
-    if (!enumNames && schemaWithEnumNames.enumNames) {
-      // enumNames was deprecated in v5 and is intentionally omitted from the RJSFSchema type.
-      // Cast the type to include enumNames so the feature still works.
-      if (process.env.NODE_ENV !== 'production') {
-        console.warn(
-          'The "enumNames" property in the schema is deprecated and will be removed in a future major release. Use the "ui:enumNames" property in the uiSchema instead.'
-        );
-      }
-      enumNames = schemaWithEnumNames.enumNames;
-    }
     return schema.enum.map((value, i) => {
       const label = enumNames?.[i] || String(value);
       return { label, value };
@@ -49,13 +43,28 @@ export default function optionsList<S extends StrictRJSFSchema = RJSFSchema, T =
     altSchemas = schema.oneOf;
     altUiSchemas = uiSchema?.oneOf;
   }
+  // See if there is a discriminator path specified in the schema, and if so, use it as the selectorField, otherwise
+  // pull one from the uiSchema
+  let selectorField = getDiscriminatorFieldFromSchema<S>(schema);
+  if (uiSchema) {
+    const { optionsSchemaSelector = selectorField } = getUiOptions<T, S, F>(uiSchema);
+    selectorField = optionsSchemaSelector;
+  }
   return (
     altSchemas &&
     altSchemas.map((aSchemaDef, index) => {
       const { title } = getUiOptions<T, S, F>(altUiSchemas?.[index]);
       const aSchema = aSchemaDef as S;
-      const value = toConstant(aSchema);
-      const label = title || aSchema.title || String(value);
+      let value: EnumOptionsType<S>['value'];
+      let label = title;
+      if (selectorField) {
+        const innerSchema: S = get(aSchema, [PROPERTIES_KEY, selectorField], {}) as S;
+        value = get(innerSchema, DEFAULT_KEY, get(innerSchema, CONST_KEY));
+        label = label || innerSchema?.title || aSchema.title || String(value);
+      } else {
+        value = toConstant(aSchema);
+        label = label || aSchema.title || String(value);
+      }
       return {
         schema: aSchema,
         label,

package/src/parser/ParserValidator.ts

@@ -1,5 +1,4 @@
 import get from 'lodash/get';
-import isEqual from 'lodash/isEqual';
 
 import { ID_KEY } from '../constants';
 import hashForSchema from '../hashForSchema';
@@ -15,6 +14,7 @@ import {
   ValidationData,
   ValidatorType,
 } from '../types';
+import deepEquals from '../deepEquals';
 
 /** The type of the map of schema hash to schema
  */
@@ -67,11 +67,11 @@ export default class ParserValidator<T = any, S extends StrictRJSFSchema = RJSFS
     const existing = this.schemaMap[key];
     if (!existing) {
       this.schemaMap[key] = identifiedSchema;
-    } else if (!isEqual(existing, identifiedSchema)) {
+    } else if (!deepEquals(existing, identifiedSchema)) {
       console.error('existing schema:', JSON.stringify(existing, null, 2));
       console.error('new schema:', JSON.stringify(identifiedSchema, null, 2));
       throw new Error(
-        `Two different schemas exist with the same key ${key}! What a bad coincidence. If possible, try adding an $id to one of the schemas`
+        `Two different schemas exist with the same key ${key}! What a bad coincidence. If possible, try adding an $id to one of the schemas`,
       );
     }
   }
@@ -91,7 +91,7 @@ export default class ParserValidator<T = any, S extends StrictRJSFSchema = RJSFS
    * @throws - Error when the given `rootSchema` differs from the root schema provided during construction
    */
   isValid(schema: S, _formData: T, rootSchema: S): boolean {
-    if (!isEqual(rootSchema, this.rootSchema)) {
+    if (!deepEquals(rootSchema, this.rootSchema)) {
       throw new Error('Unexpectedly calling isValid() with a rootSchema that differs from the construction rootSchema');
     }
     this.addSchema(schema, hashForSchema<S>(schema));
@@ -131,7 +131,7 @@ export default class ParserValidator<T = any, S extends StrictRJSFSchema = RJSFS
     _schema: S,
     _customValidate?: CustomValidator<T, S, F>,
     _transformErrors?: ErrorTransformer<T, S, F>,
-    _uiSchema?: UiSchema<T, S, F>
+    _uiSchema?: UiSchema<T, S, F>,
   ): ValidationData<T> {
     throw new Error('Unexpectedly calling the `validateFormData()` method during schema parsing');
   }

package/src/parser/schemaParser.ts

@@ -1,10 +1,10 @@
 import forEach from 'lodash/forEach';
-import isEqual from 'lodash/isEqual';
 
 import { FormContextType, RJSFSchema, StrictRJSFSchema } from '../types';
-import { PROPERTIES_KEY, ITEMS_KEY } from '../constants';
+import { ITEMS_KEY, PROPERTIES_KEY } from '../constants';
 import ParserValidator, { SchemaMap } from './ParserValidator';
-import { retrieveSchemaInternal, resolveAnyOrOneOfSchemas } from '../schema/retrieveSchema';
+import { resolveAnyOrOneOfSchemas, retrieveSchemaInternal } from '../schema/retrieveSchema';
+import deepEquals from '../deepEquals';
 
 /** Recursive function used to parse the given `schema` belonging to the `rootSchema`. The `validator` is used to
  * capture the sub-schemas that the `isValid()` function is called with. For each schema returned by the
@@ -20,11 +20,11 @@ function parseSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends
   validator: ParserValidator<T, S, F>,
   recurseList: S[],
   rootSchema: S,
-  schema: S
+  schema: S,
 ) {
   const schemas = retrieveSchemaInternal<T, S, F>(validator, schema, rootSchema, undefined, true);
   schemas.forEach((schema) => {
-    const sameSchemaIndex = recurseList.findIndex((item) => isEqual(item, schema));
+    const sameSchemaIndex = recurseList.findIndex((item) => deepEquals(item, schema));
     if (sameSchemaIndex === -1) {
       recurseList.push(schema);
       const allOptions = resolveAnyOrOneOfSchemas<T, S, F>(validator, schema, rootSchema, true);
@@ -49,7 +49,7 @@ function parseSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends
  * @returns - The `SchemaMap` of all schemas that were parsed
  */
 export default function schemaParser<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
-  rootSchema: S
+  rootSchema: S,
 ): SchemaMap<S> {
   const validator = new ParserValidator<T, S, F>(rootSchema);
   const recurseList: S[] = [];

package/src/schema/findFieldInSchema.ts

@@ -0,0 +1,138 @@
+import get from 'lodash/get';
+import has from 'lodash/has';
+
+import findSelectedOptionInXxxOf from './findSelectedOptionInXxxOf';
+import getFromSchema from './getFromSchema';
+import { ANY_OF_KEY, ONE_OF_KEY, PROPERTIES_KEY, REQUIRED_KEY } from '../constants';
+import {
+  Experimental_CustomMergeAllOf,
+  FormContextType,
+  FoundFieldType,
+  RJSFSchema,
+  StrictRJSFSchema,
+  ValidatorType,
+} from '../types';
+
+/** Unique schema that represents no schema was found, exported for testing purposes */
+export const NOT_FOUND_SCHEMA = { title: '!@#$_UNKNOWN_$#@!' };
+
+/** Finds the field specified by the `path` within the root or recursed `schema`. If there is no field for the specified
+ * `path`, then the default `{ field: undefined, isRequired: undefined }` is returned. It determines whether a leaf
+ * field is in the `required` list for its parent and if so, it is marked as required on return.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+ * @param rootSchema - The root schema that will be forwarded to all the APIs
+ // * @param schema - The node within the JSON schema in which to search
+ * @param path - The keys in the path to the desired field
+ * @param [formData={}] - The form data that is used to determine which anyOf/oneOf option to descend
+ * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
+ * @returns - An object that contains the field and its required state. If no field can be found then
+ *            `{ field: undefined, isRequired: undefined }` is returned.
+ */
+export default function findFieldInSchema<
+  T = undefined,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any,
+>(
+  validator: ValidatorType<T, S, F>,
+  rootSchema: S,
+  schema: S,
+  path: string | string[],
+  formData: T = {} as T,
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
+): FoundFieldType<S> {
+  const pathList = Array.isArray(path) ? [...path] : path.split('.');
+  let parentField = schema;
+
+  // store the desired field into a variable and removing it from the `pathList`
+  const fieldName = pathList.pop()!;
+
+  if (pathList.length) {
+    // drilling into the schema for each sub-path and taking into account of the any/oneOfs
+    pathList.forEach((subPath) => {
+      parentField = getFromSchema<T, S, F>(
+        validator,
+        rootSchema,
+        parentField,
+        [PROPERTIES_KEY, subPath],
+        {} as S,
+        experimental_customMergeAllOf,
+      );
+      if (has(parentField, ONE_OF_KEY)) {
+        // if this sub-path has a `oneOf` then use the formData to drill into the schema with the selected option
+        parentField = findSelectedOptionInXxxOf(
+          validator,
+          rootSchema,
+          parentField,
+          fieldName,
+          ONE_OF_KEY,
+          get(formData, subPath),
+          experimental_customMergeAllOf,
+        )!;
+      } else if (has(parentField, ANY_OF_KEY)) {
+        // if this sub-path has a `anyOf` then use the formData to drill into the schema with the selected option
+        parentField = findSelectedOptionInXxxOf(
+          validator,
+          rootSchema,
+          parentField,
+          fieldName,
+          ANY_OF_KEY,
+          get(formData, subPath),
+          experimental_customMergeAllOf,
+        )!;
+      }
+    });
+  }
+
+  if (has(parentField, ONE_OF_KEY)) {
+    // When oneOf is in the root schema, use the formData to drill into the schema with the selected option
+    parentField = findSelectedOptionInXxxOf(
+      validator,
+      rootSchema,
+      parentField,
+      fieldName,
+      ONE_OF_KEY,
+      formData,
+      experimental_customMergeAllOf,
+    )!;
+  } else if (has(parentField, ANY_OF_KEY)) {
+    // When anyOf is in the root schema, use the formData to drill into the schema with the selected option
+    parentField = findSelectedOptionInXxxOf(
+      validator,
+      rootSchema,
+      parentField,
+      fieldName,
+      ANY_OF_KEY,
+      formData,
+      experimental_customMergeAllOf,
+    )!;
+  }
+
+  // taking the most updated `parentField`, get our desired field
+  let field: S | undefined = getFromSchema<T, S, F>(
+    validator,
+    rootSchema,
+    parentField,
+    [PROPERTIES_KEY, fieldName],
+    NOT_FOUND_SCHEMA as S,
+    experimental_customMergeAllOf,
+  );
+  if (field === NOT_FOUND_SCHEMA) {
+    field = undefined;
+  }
+  // check to see if our desired field is in the `required` list for its parent
+  const requiredArray = getFromSchema<T, S, F>(
+    validator,
+    rootSchema,
+    parentField,
+    REQUIRED_KEY,
+    [] as T,
+    experimental_customMergeAllOf,
+  );
+  let isRequired: boolean | undefined;
+  if (field && Array.isArray(requiredArray)) {
+    isRequired = requiredArray.includes(fieldName);
+  }
+
+  return { field, isRequired };
+}

package/src/schema/findSelectedOptionInXxxOf.ts

@@ -0,0 +1,53 @@
+import get from 'lodash/get';
+import isEqual from 'lodash/isEqual';
+
+import { CONST_KEY, DEFAULT_KEY, PROPERTIES_KEY } from '../constants';
+import { Experimental_CustomMergeAllOf, FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+import retrieveSchema from './retrieveSchema';
+import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema';
+
+/** Finds the option inside the `schema['any/oneOf']` list which has the `properties[selectorField].default` or
+ * `properties[selectorField].const` that matches the `formData[selectorField]` value. For the purposes of this
+ * function, `selectorField` is either `schema.discriminator.propertyName` or `fallbackField`. The `LayoutGridField`
+ * works directly with schemas in a recursive manner, making this faster than `getFirstMatchingOption()`.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+ * @param rootSchema - The root schema that will be forwarded to all the APIs
+ * @param schema - The schema element in which to search for the selected anyOf/oneOf option
+ * @param fallbackField - The field to use as a backup selector field if the schema does not have a required field
+ * @param xxx - Either `anyOf` or `oneOf`, defines which value is being sought
+ * @param [formData={}] - The form data that is used to determine which anyOf/oneOf option to descend
+ * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
+ * @returns - The anyOf/oneOf option that matches the selector field in the schema or undefined if nothing is selected
+ */
+export default function findSelectedOptionInXxxOf<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any,
+>(
+  validator: ValidatorType<T, S, F>,
+  rootSchema: S,
+  schema: S,
+  fallbackField: string,
+  xxx: 'anyOf' | 'oneOf',
+  formData: T = {} as T,
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
+): S | undefined {
+  if (Array.isArray(schema[xxx])) {
+    const discriminator = getDiscriminatorFieldFromSchema<S>(schema);
+    const selectorField = discriminator || fallbackField;
+    const xxxOfs = schema[xxx]!.map((xxxOf) =>
+      retrieveSchema<T, S, F>(validator, xxxOf as S, rootSchema, formData, experimental_customMergeAllOf),
+    );
+    const data = get(formData, selectorField);
+    if (data !== undefined) {
+      return xxxOfs.find((xxx) => {
+        return isEqual(
+          get(xxx, [PROPERTIES_KEY, selectorField, DEFAULT_KEY], get(xxx, [PROPERTIES_KEY, selectorField, CONST_KEY])),
+          data,
+        );
+      });
+    }
+  }
+  return undefined;
+}

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,12 +95,20 @@ export function calculateIndexScore<T = any, S extends StrictRJSFSchema = RJSFSc
                 formValue,
                 get(value, key) as S[],
                 -1,
-                discriminator
+                discriminator,
+                experimental_customMergeAllOf,
               )
             );
           }
           if (value.type === 'object') {
-            return score + calculateIndexScore<T, S, F>(validator, rootSchema, value as S, formValue || {});
+            if (isObject(formValue)) {
+              // 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, experimental_customMergeAllOf)
+            );
           }
           if (value.type === guessType(formValue)) {
             // If the types match, then we bump the score by one
@@ -102,7 +127,7 @@ export function calculateIndexScore<T = any, S extends StrictRJSFSchema = RJSFSc
           }
           return score;
         },
-        0
+        0,
       );
     } else if (isString(schema.type) && schema.type === guessType(formData)) {
       totalScore += 1;
@@ -131,19 +156,21 @@ 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<
   T = any,
   S extends StrictRJSFSchema = RJSFSchema,
-  F extends FormContextType = any
+  F extends FormContextType = any,
 >(
   validator: ValidatorType<T, S, F>,
   rootSchema: S,
   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) => {
@@ -181,14 +208,14 @@ 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 };
       }
       return scoreData;
     },
-    { bestIndex: selectedOption, bestScore: 0 }
+    { bestIndex: selectedOption, bestScore: 0 },
   );
   // if all scores are the same go with selectedOption
   if (scoreCount.size === 1 && selectedOption >= 0) {