switch lodash.isEqual to fast-equals.deepEqual to improve performance

CHANGELOG.md

@@ -16,6 +16,16 @@ should change the heading of the (upcoming) version to include a major version b
 
 -->
 
+# 5.25.0
+
+## @rjsf/utils
+
+- Switched uses of `lodash.isEqual()` to `fast-equals.deepEqual()` in many utility functions.
+
+## @rjsf/validator-ajv8
+
+- Switched uses of `lodash.isEqual()` to `fast-equals.deepEqual()` at precompiledValidator.
+
 # 5.24.0
 
 ## @rjsf/core 

packages/utils/package.json

@@ -36,6 +36,7 @@
     "react": "^16.14.0 || >=17"
   },
   "dependencies": {
+    "fast-equals": "^5.2.1",
     "json-schema-merge-allof": "^0.8.1",
     "jsonpointer": "^5.0.1",
     "lodash": "^4.17.21",

packages/utils/src/enumOptionsDeselectValue.ts

@@ -1,7 +1,7 @@
-import isEqual from 'lodash/isEqual';
+import { deepEqual } from "fast-equals";
 
-import { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
-import enumOptionsValueForIndex from './enumOptionsValueForIndex';
+import { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from "./types";
+import enumOptionsValueForIndex from "./enumOptionsValueForIndex";
 
 /** Removes the enum option value at the `valueIndex` from the currently `selected` (list of) value(s). If `selected` is
  * a list, then that list is updated to remove the enum option value with the `valueIndex` in `allEnumOptions`. If it is
@@ -15,14 +15,16 @@ import enumOptionsValueForIndex from './enumOptionsValueForIndex';
  *        unless `selected` is a single value. In that case, if the `valueIndex` value matches `selected`, returns
  *        undefined, otherwise `selected`.
  */
-export default function enumOptionsDeselectValue<S extends StrictRJSFSchema = RJSFSchema>(
+export default function enumOptionsDeselectValue<
+  S extends StrictRJSFSchema = RJSFSchema,
+>(
   valueIndex: string | number,
-  selected?: EnumOptionsType<S>['value'] | EnumOptionsType<S>['value'][],
-  allEnumOptions: EnumOptionsType<S>[] = []
-): EnumOptionsType<S>['value'] | EnumOptionsType<S>['value'][] | undefined {
+  selected?: EnumOptionsType<S>["value"] | EnumOptionsType<S>["value"][],
+  allEnumOptions: EnumOptionsType<S>[] = [],
+): EnumOptionsType<S>["value"] | EnumOptionsType<S>["value"][] | undefined {
   const value = enumOptionsValueForIndex<S>(valueIndex, allEnumOptions);
   if (Array.isArray(selected)) {
-    return selected.filter((v) => !isEqual(v, value));
+    return selected.filter((v) => !deepEqual(v, value));
   }
-  return isEqual(value, selected) ? undefined : selected;
+  return deepEqual(value, selected) ? undefined : selected;
 }

packages/utils/src/enumOptionsIsSelected.ts

@@ -1,19 +1,21 @@
-import isEqual from 'lodash/isEqual';
+import { deepEqual } from "fast-equals";
 
-import { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
+import { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from "./types";
 
 /** Determines whether the given `value` is (one of) the `selected` value(s).
  *
  * @param value - The value being checked to see if it is selected
  * @param selected - The current selected value or list of values
  * @returns - true if the `value` is one of the `selected` ones, false otherwise
  */
-export default function enumOptionsIsSelected<S extends StrictRJSFSchema = RJSFSchema>(
-  value: EnumOptionsType<S>['value'],
-  selected: EnumOptionsType<S>['value'] | EnumOptionsType<S>['value'][]
+export default function enumOptionsIsSelected<
+  S extends StrictRJSFSchema = RJSFSchema,
+>(
+  value: EnumOptionsType<S>["value"],
+  selected: EnumOptionsType<S>["value"] | EnumOptionsType<S>["value"][],
 ) {
   if (Array.isArray(selected)) {
-    return selected.some((sel) => isEqual(sel, value));
+    return selected.some((sel) => deepEqual(sel, value));
   }
-  return isEqual(selected, value);
+  return deepEqual(selected, value);
 }

packages/utils/src/parser/ParserValidator.ts

@@ -1,8 +1,8 @@
-import get from 'lodash/get';
-import isEqual from 'lodash/isEqual';
+import get from "lodash/get";
+import { deepEqual } from "fast-equals";
 
-import { ID_KEY } from '../constants';
-import hashForSchema from '../hashForSchema';
+import { ID_KEY } from "../constants";
+import hashForSchema from "../hashForSchema";
 import {
   CustomValidator,
   ErrorSchema,
@@ -14,7 +14,7 @@ import {
   UiSchema,
   ValidationData,
   ValidatorType,
-} from '../types';
+} from "../types";
 
 /** The type of the map of schema hash to schema
  */
@@ -29,9 +29,11 @@ export type SchemaMap<S extends StrictRJSFSchema = RJSFSchema> = {
  * the hashed value of the schema. NOTE: After hashing the schema, an $id with the hash value is added to the
  * schema IF that schema doesn't already have an $id, prior to putting the schema into the map.
  */
-export default class ParserValidator<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>
-  implements ValidatorType<T, S, F>
-{
+export default class ParserValidator<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any,
+> implements ValidatorType<T, S, F> {
   /** The rootSchema provided during construction of the class */
   readonly rootSchema: S;
 
@@ -67,11 +69,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)) {
-      console.error('existing schema:', JSON.stringify(existing, null, 2));
-      console.error('new schema:', JSON.stringify(identifiedSchema, null, 2));
+    } else if (!deepEqual(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,8 +93,10 @@ 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)) {
-      throw new Error('Unexpectedly calling isValid() with a rootSchema that differs from the construction rootSchema');
+    if (!deepEqual(rootSchema, this.rootSchema)) {
+      throw new Error(
+        "Unexpectedly calling isValid() with a rootSchema that differs from the construction rootSchema",
+      );
     }
     this.addSchema(schema, hashForSchema<S>(schema));
 
@@ -104,17 +108,27 @@ export default class ParserValidator<T = any, S extends StrictRJSFSchema = RJSFS
    * @param _schema - The schema parameter that is ignored
    * @param _formData - The formData parameter that is ignored
    */
-  rawValidation<Result = any>(_schema: S, _formData?: T): { errors?: Result[]; validationError?: Error } {
-    throw new Error('Unexpectedly calling the `rawValidation()` method during schema parsing');
+  rawValidation<Result = any>(
+    _schema: S,
+    _formData?: T,
+  ): { errors?: Result[]; validationError?: Error } {
+    throw new Error(
+      "Unexpectedly calling the `rawValidation()` method during schema parsing",
+    );
   }
 
   /** Implements the `ValidatorType` `toErrorList()` method to throw an error since it is never supposed to be called
    *
    * @param _errorSchema - The error schema parameter that is ignored
    * @param _fieldPath - The field path parameter that is ignored
    */
-  toErrorList(_errorSchema?: ErrorSchema<T>, _fieldPath?: string[]): RJSFValidationError[] {
-    throw new Error('Unexpectedly calling the `toErrorList()` method during schema parsing');
+  toErrorList(
+    _errorSchema?: ErrorSchema<T>,
+    _fieldPath?: string[],
+  ): RJSFValidationError[] {
+    throw new Error(
+      "Unexpectedly calling the `toErrorList()` method during schema parsing",
+    );
   }
 
   /** Implements the `ValidatorType` `validateFormData()` method to throw an error since it is never supposed to be
@@ -131,8 +145,10 @@ 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');
+    throw new Error(
+      "Unexpectedly calling the `validateFormData()` method during schema parsing",
+    );
   }
 }

packages/utils/src/parser/schemaParser.ts

@@ -1,10 +1,13 @@
-import forEach from 'lodash/forEach';
-import isEqual from 'lodash/isEqual';
+import forEach from "lodash/forEach";
 
-import { FormContextType, RJSFSchema, StrictRJSFSchema } from '../types';
-import { PROPERTIES_KEY, ITEMS_KEY } from '../constants';
-import ParserValidator, { SchemaMap } from './ParserValidator';
-import { retrieveSchemaInternal, resolveAnyOrOneOfSchemas } from '../schema/retrieveSchema';
+import { FormContextType, RJSFSchema, StrictRJSFSchema } from "../types";
+import { ITEMS_KEY, PROPERTIES_KEY } from "../constants";
+import ParserValidator, { SchemaMap } from "./ParserValidator";
+import {
+  resolveAnyOrOneOfSchemas,
+  retrieveSchemaInternal,
+} from "../schema/retrieveSchema";
+import { deepEqual } from "fast-equals";
 
 /** 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
@@ -16,27 +19,57 @@ import { retrieveSchemaInternal, resolveAnyOrOneOfSchemas } from '../schema/retr
  * @param rootSchema - The root schema from which the schema parsing began
  * @param schema - The current schema element being parsed
  */
-function parseSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
+function parseSchema<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any,
+>(
   validator: ParserValidator<T, S, F>,
   recurseList: S[],
   rootSchema: S,
-  schema: S
+  schema: S,
 ) {
-  const schemas = retrieveSchemaInternal<T, S, F>(validator, schema, rootSchema, undefined, true);
+  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) =>
+      deepEqual(item, schema)
+    );
     if (sameSchemaIndex === -1) {
       recurseList.push(schema);
-      const allOptions = resolveAnyOrOneOfSchemas<T, S, F>(validator, schema, rootSchema, true);
+      const allOptions = resolveAnyOrOneOfSchemas<T, S, F>(
+        validator,
+        schema,
+        rootSchema,
+        true,
+      );
       allOptions.forEach((s) => {
         if (PROPERTIES_KEY in s && s[PROPERTIES_KEY]) {
           forEach(schema[PROPERTIES_KEY], (value) => {
-            parseSchema<T, S, F>(validator, recurseList, rootSchema, value as S);
+            parseSchema<T, S, F>(
+              validator,
+              recurseList,
+              rootSchema,
+              value as S,
+            );
           });
         }
       });
-      if (ITEMS_KEY in schema && !Array.isArray(schema.items) && typeof schema.items !== 'boolean') {
-        parseSchema<T, S, F>(validator, recurseList, rootSchema, schema.items as S);
+      if (
+        ITEMS_KEY in schema && !Array.isArray(schema.items) &&
+        typeof schema.items !== "boolean"
+      ) {
+        parseSchema<T, S, F>(
+          validator,
+          recurseList,
+          rootSchema,
+          schema.items as S,
+        );
       }
     }
   });
@@ -48,8 +81,12 @@ function parseSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends
  * @param rootSchema - The root schema to parse for sub-schemas used by `isValid()` calls
  * @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
+export default function schemaParser<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any,
+>(
+  rootSchema: S,
 ): SchemaMap<S> {
   const validator = new ParserValidator<T, S, F>(rootSchema);
   const recurseList: S[] = [];