@rjsf/utils 5.20.1 → 5.21.0

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,7 +67,7 @@ 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(
@@ -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));

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
@@ -24,7 +24,7 @@ function parseSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends
 ) {
   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);

package/src/schema/getDefaultFormState.ts

@@ -141,12 +141,22 @@ function maybeAddDefaultToObject<T = any>(
 }
 
 interface ComputeDefaultsProps<T = any, S extends StrictRJSFSchema = RJSFSchema> {
+  /** Any defaults provided by the parent field in the schema */
   parentDefaults?: T;
+  /** The options root schema, used to primarily to look up `$ref`s */
   rootSchema?: S;
+  /** The current formData, if any, onto which to provide any missing defaults */
   rawFormData?: T;
+  /** Optional flag, if true, cause undefined values to be added as defaults.
+   *          If "excludeObjectChildren", cause undefined values for this object and pass `includeUndefinedValues` as
+   *          false when computing defaults for any nested object properties.
+   */
   includeUndefinedValues?: boolean | 'excludeObjectChildren';
+  /** The list of ref names currently being recursed, used to prevent infinite recursion */
   _recurseList?: string[];
+  /** Optional configuration object, if provided, allows users to override default form state behavior */
   experimental_defaultFormStateBehavior?: Experimental_DefaultFormStateBehavior;
+  /** Optional flag, if true, indicates this schema was required in the parent schema. */
   required?: boolean;
 }
 
@@ -155,22 +165,15 @@ interface ComputeDefaultsProps<T = any, S extends StrictRJSFSchema = RJSFSchema>
  *
  * @param validator - an implementation of the `ValidatorType` interface that will be used when necessary
  * @param rawSchema - The schema for which the default state is desired
- * @param [props] - Optional props for this function
- * @param [props.parentDefaults] - Any defaults provided by the parent field in the schema
- * @param [props.rootSchema] - The options root schema, used to primarily to look up `$ref`s
- * @param [props.rawFormData] - The current formData, if any, onto which to provide any missing defaults
- * @param [props.includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults.
- *          If "excludeObjectChildren", cause undefined values for this object and pass `includeUndefinedValues` as
- *          false when computing defaults for any nested object properties.
- * @param [props._recurseList=[]] - The list of ref names currently being recursed, used to prevent infinite recursion
- * @param [props.experimental_defaultFormStateBehavior] Optional configuration object, if provided, allows users to override default form state behavior
- * @param [props.required] - Optional flag, if true, indicates this schema was required in the parent schema.
+ * @param {ComputeDefaultsProps} computeDefaultsProps - Optional props for this function
  * @returns - The resulting `formData` with all the defaults provided
  */
 export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
   validator: ValidatorType<T, S, F>,
   rawSchema: S,
-  {
+  computeDefaultsProps: ComputeDefaultsProps<T, S> = {}
+): T | T[] | undefined {
+  const {
     parentDefaults,
     rawFormData,
     rootSchema = {} as S,
@@ -178,8 +181,7 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
     _recurseList = [],
     experimental_defaultFormStateBehavior = undefined,
     required,
-  }: ComputeDefaultsProps<T, S> = {}
-): T | T[] | undefined {
+  } = computeDefaultsProps;
   const formData: T = (isObject(rawFormData) ? rawFormData : {}) as T;
   const schema: S = isObject(rawSchema) ? rawSchema : ({} as S);
   // Compute the defaults recursively: give highest priority to deepest nodes.
@@ -202,7 +204,12 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
       schemaToCompute = findSchemaDefinition<S>(refName, rootSchema);
     }
   } else if (DEPENDENCIES_KEY in schema) {
-    const resolvedSchema = resolveDependencies<T, S, F>(validator, schema, rootSchema, false, [], formData);
+    // Get the default if set from properties to ensure the dependencies conditions are resolved based on it
+    const defaultFormData: T = {
+      ...formData,
+      ...getDefaultBasedOnSchemaType(validator, schema, computeDefaultsProps, defaults),
+    };
+    const resolvedSchema = resolveDependencies<T, S, F>(validator, schema, rootSchema, false, [], defaultFormData);
     schemaToCompute = resolvedSchema[0]; // pick the first element from resolve dependencies
   } else if (isFixedItems(schema)) {
     defaults = (schema.items! as S[]).map((itemSchema: S, idx: number) =>
@@ -269,164 +276,238 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
     defaults = schema.default as unknown as T;
   }
 
-  switch (getSchemaType<S>(schema)) {
-    // We need to recurse for object schema inner default values.
-    case 'object': {
-      // This is a custom addition that fixes this issue:
-      // https://github.com/rjsf-team/react-jsonschema-form/issues/3832
-      const retrievedSchema =
-        experimental_defaultFormStateBehavior?.allOf === 'populateDefaults' && ALL_OF_KEY in schema
-          ? retrieveSchema<T, S, F>(validator, schema, rootSchema, formData)
-          : schema;
-      const objectDefaults = Object.keys(retrievedSchema.properties || {}).reduce(
-        (acc: GenericObjectType, key: string) => {
-          // Compute the defaults for this node, with the parent defaults we might
-          // have from a previous run: defaults[key].
-          const computedDefault = computeDefaults<T, S, F>(validator, get(retrievedSchema, [PROPERTIES_KEY, key]), {
-            rootSchema,
-            _recurseList,
-            experimental_defaultFormStateBehavior,
-            includeUndefinedValues: includeUndefinedValues === true,
-            parentDefaults: get(defaults, [key]),
-            rawFormData: get(formData, [key]),
-            required: retrievedSchema.required?.includes(key),
-          });
-          maybeAddDefaultToObject<T>(
-            acc,
-            key,
-            computedDefault,
-            includeUndefinedValues,
-            required,
-            retrievedSchema.required,
-            experimental_defaultFormStateBehavior
-          );
-          return acc;
-        },
-        {}
-      ) as T;
-      if (retrievedSchema.additionalProperties) {
-        // as per spec additionalProperties may be either schema or boolean
-        const additionalPropertiesSchema = isObject(retrievedSchema.additionalProperties)
-          ? retrievedSchema.additionalProperties
-          : {};
+  const defaultBasedOnSchemaType = getDefaultBasedOnSchemaType(validator, schema, computeDefaultsProps, defaults);
 
-        const keys = new Set<string>();
-        if (isObject(defaults)) {
-          Object.keys(defaults as GenericObjectType)
-            .filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key])
-            .forEach((key) => keys.add(key));
-        }
-        const formDataRequired: string[] = [];
-        Object.keys(formData as GenericObjectType)
-          .filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key])
-          .forEach((key) => {
-            keys.add(key);
-            formDataRequired.push(key);
-          });
-        keys.forEach((key) => {
-          const computedDefault = computeDefaults(validator, additionalPropertiesSchema as S, {
-            rootSchema,
-            _recurseList,
-            experimental_defaultFormStateBehavior,
-            includeUndefinedValues: includeUndefinedValues === true,
-            parentDefaults: get(defaults, [key]),
-            rawFormData: get(formData, [key]),
-            required: retrievedSchema.required?.includes(key),
-          });
-          // Since these are additional properties we don't need to add the `experimental_defaultFormStateBehavior` prop
-          maybeAddDefaultToObject<T>(
-            objectDefaults as GenericObjectType,
-            key,
-            computedDefault,
-            includeUndefinedValues,
-            required,
-            formDataRequired
-          );
-        });
-      }
-      return objectDefaults;
-    }
-    case 'array': {
-      const neverPopulate = experimental_defaultFormStateBehavior?.arrayMinItems?.populate === 'never';
-      const ignoreMinItemsFlagSet = experimental_defaultFormStateBehavior?.arrayMinItems?.populate === 'requiredOnly';
-      const isSkipEmptyDefaults = experimental_defaultFormStateBehavior?.emptyObjectFields === 'skipEmptyDefaults';
-      const computeSkipPopulate =
-        experimental_defaultFormStateBehavior?.arrayMinItems?.computeSkipPopulate ?? (() => false);
+  return defaultBasedOnSchemaType ?? defaults;
+}
 
-      const emptyDefault = isSkipEmptyDefaults ? undefined : [];
+/** Computes the default value for objects.
+ *
+ * @param validator - an implementation of the `ValidatorType` interface that will be used when necessary
+ * @param rawSchema - The schema for which the default state is desired
+ * @param {ComputeDefaultsProps} computeDefaultsProps - Optional props for this function
+ * @param defaults - Optional props for this function
+ * @returns - The default value based on the schema type if they are defined for object or array schemas.
+ */
+export function getObjectDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
+  validator: ValidatorType<T, S, F>,
+  rawSchema: S,
+  {
+    rawFormData,
+    rootSchema = {} as S,
+    includeUndefinedValues = false,
+    _recurseList = [],
+    experimental_defaultFormStateBehavior = undefined,
+    required,
+  }: ComputeDefaultsProps<T, S> = {},
+  defaults?: T | T[] | undefined
+): T {
+  {
+    const formData: T = (isObject(rawFormData) ? rawFormData : {}) as T;
+    const schema: S = rawSchema;
+    // This is a custom addition that fixes this issue:
+    // https://github.com/rjsf-team/react-jsonschema-form/issues/3832
+    const retrievedSchema =
+      experimental_defaultFormStateBehavior?.allOf === 'populateDefaults' && ALL_OF_KEY in schema
+        ? retrieveSchema<T, S, F>(validator, schema, rootSchema, formData)
+        : schema;
+    const objectDefaults = Object.keys(retrievedSchema.properties || {}).reduce(
+      (acc: GenericObjectType, key: string) => {
+        // Compute the defaults for this node, with the parent defaults we might
+        // have from a previous run: defaults[key].
+        const computedDefault = computeDefaults<T, S, F>(validator, get(retrievedSchema, [PROPERTIES_KEY, key]), {
+          rootSchema,
+          _recurseList,
+          experimental_defaultFormStateBehavior,
+          includeUndefinedValues: includeUndefinedValues === true,
+          parentDefaults: get(defaults, [key]),
+          rawFormData: get(formData, [key]),
+          required: retrievedSchema.required?.includes(key),
+        });
+        maybeAddDefaultToObject<T>(
+          acc,
+          key,
+          computedDefault,
+          includeUndefinedValues,
+          required,
+          retrievedSchema.required,
+          experimental_defaultFormStateBehavior
+        );
+        return acc;
+      },
+      {}
+    ) as T;
+    if (retrievedSchema.additionalProperties) {
+      // as per spec additionalProperties may be either schema or boolean
+      const additionalPropertiesSchema = isObject(retrievedSchema.additionalProperties)
+        ? retrievedSchema.additionalProperties
+        : {};
 
-      // Inject defaults into existing array defaults
-      if (Array.isArray(defaults)) {
-        defaults = defaults.map((item, idx) => {
-          const schemaItem: S = getInnerSchemaForArrayItem<S>(schema, AdditionalItemsHandling.Fallback, idx);
-          return computeDefaults<T, S, F>(validator, schemaItem, {
-            rootSchema,
-            _recurseList,
-            experimental_defaultFormStateBehavior,
-            parentDefaults: item,
-            required,
-          });
-        }) as T[];
+      const keys = new Set<string>();
+      if (isObject(defaults)) {
+        Object.keys(defaults as GenericObjectType)
+          .filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key])
+          .forEach((key) => keys.add(key));
       }
+      const formDataRequired: string[] = [];
+      Object.keys(formData as GenericObjectType)
+        .filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key])
+        .forEach((key) => {
+          keys.add(key);
+          formDataRequired.push(key);
+        });
+      keys.forEach((key) => {
+        const computedDefault = computeDefaults(validator, additionalPropertiesSchema as S, {
+          rootSchema,
+          _recurseList,
+          experimental_defaultFormStateBehavior,
+          includeUndefinedValues: includeUndefinedValues === true,
+          parentDefaults: get(defaults, [key]),
+          rawFormData: get(formData, [key]),
+          required: retrievedSchema.required?.includes(key),
+        });
+        // Since these are additional properties we don't need to add the `experimental_defaultFormStateBehavior` prop
+        maybeAddDefaultToObject<T>(
+          objectDefaults as GenericObjectType,
+          key,
+          computedDefault,
+          includeUndefinedValues,
+          required,
+          formDataRequired
+        );
+      });
+    }
+    return objectDefaults;
+  }
+}
 
-      // Deeply inject defaults into already existing form data
-      if (Array.isArray(rawFormData)) {
-        const schemaItem: S = getInnerSchemaForArrayItem<S>(schema);
-        if (neverPopulate) {
-          defaults = rawFormData;
-        } else {
-          defaults = rawFormData.map((item: T, idx: number) => {
-            return computeDefaults<T, S, F>(validator, schemaItem, {
-              rootSchema,
-              _recurseList,
-              experimental_defaultFormStateBehavior,
-              rawFormData: item,
-              parentDefaults: get(defaults, [idx]),
-              required,
-            });
-          }) as T[];
-        }
-      }
+/** Computes the default value for arrays.
+ *
+ * @param validator - an implementation of the `ValidatorType` interface that will be used when necessary
+ * @param rawSchema - The schema for which the default state is desired
+ * @param {ComputeDefaultsProps} computeDefaultsProps - Optional props for this function
+ * @param defaults - Optional props for this function
+ * @returns - The default value based on the schema type if they are defined for object or array schemas.
+ */
+export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
+  validator: ValidatorType<T, S, F>,
+  rawSchema: S,
+  {
+    rawFormData,
+    rootSchema = {} as S,
+    _recurseList = [],
+    experimental_defaultFormStateBehavior = undefined,
+    required,
+  }: ComputeDefaultsProps<T, S> = {},
+  defaults?: T | T[] | undefined
+): T | T[] | undefined {
+  const schema: S = rawSchema;
 
-      if (neverPopulate) {
-        return defaults ?? emptyDefault;
-      }
-      if (ignoreMinItemsFlagSet && !required) {
-        // If no form data exists or defaults are set leave the field empty/non-existent, otherwise
-        // return form data/defaults
-        return defaults ? defaults : undefined;
-      }
+  const neverPopulate = experimental_defaultFormStateBehavior?.arrayMinItems?.populate === 'never';
+  const ignoreMinItemsFlagSet = experimental_defaultFormStateBehavior?.arrayMinItems?.populate === 'requiredOnly';
+  const isSkipEmptyDefaults = experimental_defaultFormStateBehavior?.emptyObjectFields === 'skipEmptyDefaults';
+  const computeSkipPopulate =
+    experimental_defaultFormStateBehavior?.arrayMinItems?.computeSkipPopulate ?? (() => false);
 
-      const defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
-      if (
-        !schema.minItems ||
-        isMultiSelect<T, S, F>(validator, schema, rootSchema) ||
-        computeSkipPopulate<T, S, F>(validator, schema, rootSchema) ||
-        schema.minItems <= defaultsLength
-      ) {
-        return defaults ? defaults : emptyDefault;
-      }
+  const emptyDefault = isSkipEmptyDefaults ? undefined : [];
 
-      const defaultEntries: T[] = (defaults || []) as T[];
-      const fillerSchema: S = getInnerSchemaForArrayItem<S>(schema, AdditionalItemsHandling.Invert);
-      const fillerDefault = fillerSchema.default;
+  // Inject defaults into existing array defaults
+  if (Array.isArray(defaults)) {
+    defaults = defaults.map((item, idx) => {
+      const schemaItem: S = getInnerSchemaForArrayItem<S>(schema, AdditionalItemsHandling.Fallback, idx);
+      return computeDefaults<T, S, F>(validator, schemaItem, {
+        rootSchema,
+        _recurseList,
+        experimental_defaultFormStateBehavior,
+        parentDefaults: item,
+        required,
+      });
+    }) as T[];
+  }
 
-      // Calculate filler entries for remaining items (minItems - existing raw data/defaults)
-      const fillerEntries: T[] = new Array(schema.minItems - defaultsLength).fill(
-        computeDefaults<any, S, F>(validator, fillerSchema, {
-          parentDefaults: fillerDefault,
+  // Deeply inject defaults into already existing form data
+  if (Array.isArray(rawFormData)) {
+    const schemaItem: S = getInnerSchemaForArrayItem<S>(schema);
+    if (neverPopulate) {
+      defaults = rawFormData;
+    } else {
+      defaults = rawFormData.map((item: T, idx: number) => {
+        return computeDefaults<T, S, F>(validator, schemaItem, {
           rootSchema,
           _recurseList,
           experimental_defaultFormStateBehavior,
+          rawFormData: item,
+          parentDefaults: get(defaults, [idx]),
           required,
-        })
-      ) as T[];
-      // then fill up the rest with either the item default or empty, up to minItems
-      return defaultEntries.concat(fillerEntries);
+        });
+      }) as T[];
     }
   }
 
-  return defaults;
+  if (neverPopulate) {
+    return defaults ?? emptyDefault;
+  }
+  if (ignoreMinItemsFlagSet && !required) {
+    // If no form data exists or defaults are set leave the field empty/non-existent, otherwise
+    // return form data/defaults
+    return defaults ? defaults : undefined;
+  }
+
+  const defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
+  if (
+    !schema.minItems ||
+    isMultiSelect<T, S, F>(validator, schema, rootSchema) ||
+    computeSkipPopulate<T, S, F>(validator, schema, rootSchema) ||
+    schema.minItems <= defaultsLength
+  ) {
+    return defaults ? defaults : emptyDefault;
+  }
+
+  const defaultEntries: T[] = (defaults || []) as T[];
+  const fillerSchema: S = getInnerSchemaForArrayItem<S>(schema, AdditionalItemsHandling.Invert);
+  const fillerDefault = fillerSchema.default;
+
+  // Calculate filler entries for remaining items (minItems - existing raw data/defaults)
+  const fillerEntries: T[] = new Array(schema.minItems - defaultsLength).fill(
+    computeDefaults<any, S, F>(validator, fillerSchema, {
+      parentDefaults: fillerDefault,
+      rootSchema,
+      _recurseList,
+      experimental_defaultFormStateBehavior,
+      required,
+    })
+  ) as T[];
+  // then fill up the rest with either the item default or empty, up to minItems
+  return defaultEntries.concat(fillerEntries);
+}
+
+/** Computes the default value based on the schema type.
+ *
+ * @param validator - an implementation of the `ValidatorType` interface that will be used when necessary
+ * @param rawSchema - The schema for which the default state is desired
+ * @param {ComputeDefaultsProps} computeDefaultsProps - Optional props for this function
+ * @param defaults - Optional props for this function
+ * @returns - The default value based on the schema type if they are defined for object or array schemas.
+ */
+export function getDefaultBasedOnSchemaType<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any
+>(
+  validator: ValidatorType<T, S, F>,
+  rawSchema: S,
+  computeDefaultsProps: ComputeDefaultsProps<T, S> = {},
+  defaults?: T | T[] | undefined
+): T | T[] | void {
+  switch (getSchemaType<S>(rawSchema)) {
+    // We need to recurse for object schema inner default values.
+    case 'object': {
+      return getObjectDefaults(validator, rawSchema, computeDefaultsProps, defaults);
+    }
+    case 'array': {
+      return getArrayDefaults(validator, rawSchema, computeDefaultsProps, defaults);
+    }
+  }
 }
 
 /** Returns the superset of `formData` that includes the given set updated to include any missing fields that have

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';
@@ -15,10 +14,10 @@ import {
   ANY_OF_KEY,
   DEPENDENCIES_KEY,
   IF_KEY,
+  ITEMS_KEY,
   ONE_OF_KEY,
-  REF_KEY,
   PROPERTIES_KEY,
-  ITEMS_KEY,
+  REF_KEY,
 } from '../constants';
 import findSchemaDefinition, { splitKeyElementFromObject } from '../findSchemaDefinition';
 import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema';
@@ -27,6 +26,7 @@ import isObject from '../isObject';
 import mergeSchemas from '../mergeSchemas';
 import { FormContextType, GenericObjectType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
 import getFirstMatchingOption from './getFirstMatchingOption';
+import deepEquals from '../deepEquals';
 
 /** 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
@@ -196,7 +196,10 @@ export function resolveSchema<T = any, S extends StrictRJSFSchema = RJSFSchema,
       )
     );
     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];
@@ -293,7 +296,7 @@ export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
     };
   }
 
-  return isEqual(schema, resolvedSchema) ? schema : resolvedSchema;
+  return deepEquals(schema, resolvedSchema) ? schema : resolvedSchema;
 }
 
 /** Creates new 'properties' items for each key in the `formData`

package/src/schema/toIdSchema.ts

@@ -1,11 +1,11 @@
 import get from 'lodash/get';
-import isEqual from 'lodash/isEqual';
 
 import { ALL_OF_KEY, DEPENDENCIES_KEY, ID_KEY, ITEMS_KEY, PROPERTIES_KEY, REF_KEY } from '../constants';
 import isObject from '../isObject';
 import { FormContextType, GenericObjectType, IdSchema, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
 import retrieveSchema from './retrieveSchema';
 import getSchemaType from '../getSchemaType';
+import deepEquals from '../deepEquals';
 
 /** An internal helper that generates an `IdSchema` object for the `schema`, recursively with protection against
  * infinite recursion
@@ -32,7 +32,7 @@ function toIdSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema, F
 ): IdSchema<T> {
   if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
     const _schema = retrieveSchema<T, S, F>(validator, schema, rootSchema, formData);
-    const sameSchemaIndex = _recurseList.findIndex((item) => isEqual(item, _schema));
+    const sameSchemaIndex = _recurseList.findIndex((item) => deepEquals(item, _schema));
     if (sameSchemaIndex === -1) {
       return toIdSchemaInternal<T, S, F>(
         validator,

package/src/schema/toPathSchema.ts

@@ -1,11 +1,10 @@
 import get from 'lodash/get';
-import isEqual from 'lodash/isEqual';
 import set from 'lodash/set';
 
 import {
+  ADDITIONAL_PROPERTIES_KEY,
   ALL_OF_KEY,
   ANY_OF_KEY,
-  ADDITIONAL_PROPERTIES_KEY,
   DEPENDENCIES_KEY,
   ITEMS_KEY,
   NAME_KEY,
@@ -18,6 +17,7 @@ import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema'
 import { FormContextType, GenericObjectType, PathSchema, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
 import getClosestMatchingOption from './getClosestMatchingOption';
 import retrieveSchema from './retrieveSchema';
+import deepEquals from '../deepEquals';
 
 /** An internal helper that generates an `PathSchema` object for the `schema`, recursively with protection against
  * infinite recursion
@@ -40,7 +40,7 @@ function toPathSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema,
 ): PathSchema<T> {
   if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
     const _schema = retrieveSchema<T, S, F>(validator, schema, rootSchema, formData);
-    const sameSchemaIndex = _recurseList.findIndex((item) => isEqual(item, _schema));
+    const sameSchemaIndex = _recurseList.findIndex((item) => deepEquals(item, _schema));
     if (sameSchemaIndex === -1) {
       return toPathSchemaInternal<T, S, F>(
         validator,