@rjsf/utils 5.21.0 → 5.21.1

package/dist/utils.esm.js

@@ -128,25 +128,14 @@ function createErrorHandler(formData) {
 }
 
 // src/deepEquals.ts
-import { createCustomEqual } from "fast-equals";
-function isFunctions(a, b) {
-  return typeof a === "function" && typeof b === "function";
-}
-var customDeepEqual = createCustomEqual({
-  createInternalComparator: (comparator) => {
-    return (a, b, _idxA, _idxB, _parentA, _parentB, state) => {
-      if (isFunctions(a, b)) {
-        return true;
-      }
-      return comparator(a, b, state);
-    };
-  }
-});
+import isEqualWith from "lodash/isEqualWith";
 function deepEquals(a, b) {
-  if (isFunctions(a, b)) {
-    return true;
-  }
-  return customDeepEqual(a, b);
+  return isEqualWith(a, b, (obj, other) => {
+    if (typeof obj === "function" && typeof other === "function") {
+      return true;
+    }
+    return void 0;
+  });
 }
 
 // src/schema/getDefaultFormState.ts
@@ -290,6 +279,7 @@ function getFirstMatchingOption(validator, formData, options, rootSchema, discri
 
 // src/schema/retrieveSchema.ts
 import get4 from "lodash/get";
+import isEqual from "lodash/isEqual";
 import set from "lodash/set";
 import times from "lodash/times";
 import transform from "lodash/transform";
@@ -469,10 +459,7 @@ function resolveSchema(validator, schema, rootSchema, expandAllBranches, recurse
       )
     );
     const allPermutations = getAllPermutationsOfXxxOf(allOfSchemaElements);
-    return allPermutations.map((permutation) => ({
-      ...schema,
-      allOf: permutation
-    }));
+    return allPermutations.map((permutation) => ({ ...schema, allOf: permutation }));
   }
   return [schema];
 }
@@ -524,7 +511,7 @@ function resolveAllReferences(schema, rootSchema, recurseList) {
       items: resolveAllReferences(resolvedSchema.items, rootSchema, recurseList)
     };
   }
-  return deepEquals(schema, resolvedSchema) ? schema : resolvedSchema;
+  return isEqual(schema, resolvedSchema) ? schema : resolvedSchema;
 }
 function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFormData) {
   const schema = {
@@ -1429,10 +1416,11 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
 
 // src/schema/toIdSchema.ts
 import get9 from "lodash/get";
+import isEqual2 from "lodash/isEqual";
 function toIdSchemaInternal(validator, schema, idPrefix, idSeparator, id, rootSchema, formData, _recurseList = []) {
   if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
     const _schema = retrieveSchema(validator, schema, rootSchema, formData);
-    const sameSchemaIndex = _recurseList.findIndex((item) => deepEquals(item, _schema));
+    const sameSchemaIndex = _recurseList.findIndex((item) => isEqual2(item, _schema));
     if (sameSchemaIndex === -1) {
       return toIdSchemaInternal(
         validator,
@@ -1486,11 +1474,12 @@ function toIdSchema(validator, schema, id, rootSchema, formData, idPrefix = "roo
 
 // src/schema/toPathSchema.ts
 import get10 from "lodash/get";
+import isEqual3 from "lodash/isEqual";
 import set2 from "lodash/set";
 function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _recurseList = []) {
   if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
     const _schema = retrieveSchema(validator, schema, rootSchema, formData);
-    const sameSchemaIndex = _recurseList.findIndex((item) => deepEquals(item, _schema));
+    const sameSchemaIndex = _recurseList.findIndex((item) => isEqual3(item, _schema));
     if (sameSchemaIndex === -1) {
       return toPathSchemaInternal(
         validator,
@@ -1861,6 +1850,9 @@ function englishStringTranslator(stringToTranslate, params) {
   return replaceStringParameters(stringToTranslate, params);
 }
 
+// src/enumOptionsDeselectValue.ts
+import isEqual4 from "lodash/isEqual";
+
 // src/enumOptionsValueForIndex.ts
 function enumOptionsValueForIndex(valueIndex, allEnumOptions = [], emptyValue) {
   if (Array.isArray(valueIndex)) {
@@ -1875,17 +1867,18 @@ function enumOptionsValueForIndex(valueIndex, allEnumOptions = [], emptyValue) {
 function enumOptionsDeselectValue(valueIndex, selected, allEnumOptions = []) {
   const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
   if (Array.isArray(selected)) {
-    return selected.filter((v) => !deepEquals(v, value));
+    return selected.filter((v) => !isEqual4(v, value));
   }
-  return deepEquals(value, selected) ? void 0 : selected;
+  return isEqual4(value, selected) ? void 0 : selected;
 }
 
 // src/enumOptionsIsSelected.ts
+import isEqual5 from "lodash/isEqual";
 function enumOptionsIsSelected(value, selected) {
   if (Array.isArray(selected)) {
-    return selected.some((sel) => deepEquals(sel, value));
+    return selected.some((sel) => isEqual5(sel, value));
   }
-  return deepEquals(selected, value);
+  return isEqual5(selected, value);
 }
 
 // src/enumOptionsIndexForValue.ts
@@ -2580,9 +2573,11 @@ var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
 
 // src/parser/schemaParser.ts
 import forEach from "lodash/forEach";
+import isEqual7 from "lodash/isEqual";
 
 // src/parser/ParserValidator.ts
 import get13 from "lodash/get";
+import isEqual6 from "lodash/isEqual";
 var ParserValidator = class {
   /** Construct the ParserValidator for the given `rootSchema`. This `rootSchema` will be stashed in the `schemaMap`
    * first.
@@ -2613,7 +2608,7 @@ var ParserValidator = class {
     const existing = this.schemaMap[key];
     if (!existing) {
       this.schemaMap[key] = identifiedSchema;
-    } else if (!deepEquals(existing, identifiedSchema)) {
+    } else if (!isEqual6(existing, identifiedSchema)) {
       console.error("existing schema:", JSON.stringify(existing, null, 2));
       console.error("new schema:", JSON.stringify(identifiedSchema, null, 2));
       throw new Error(
@@ -2635,7 +2630,7 @@ var ParserValidator = class {
    * @throws - Error when the given `rootSchema` differs from the root schema provided during construction
    */
   isValid(schema, _formData, rootSchema) {
-    if (!deepEquals(rootSchema, this.rootSchema)) {
+    if (!isEqual6(rootSchema, this.rootSchema)) {
       throw new Error("Unexpectedly calling isValid() with a rootSchema that differs from the construction rootSchema");
     }
     this.addSchema(schema, hashForSchema(schema));
@@ -2675,7 +2670,7 @@ var ParserValidator = class {
 function parseSchema(validator, recurseList, rootSchema, schema) {
   const schemas = retrieveSchemaInternal(validator, schema, rootSchema, void 0, true);
   schemas.forEach((schema2) => {
-    const sameSchemaIndex = recurseList.findIndex((item) => deepEquals(item, schema2));
+    const sameSchemaIndex = recurseList.findIndex((item) => isEqual7(item, schema2));
     if (sameSchemaIndex === -1) {
       recurseList.push(schema2);
       const allOptions = resolveAnyOrOneOfSchemas(validator, schema2, rootSchema, true);