@rjsf/utils 5.21.0 → 5.21.1

package/dist/index.js

@@ -265,25 +265,14 @@ function createErrorHandler(formData) {
 }
 
 // src/deepEquals.ts
-var import_fast_equals = require("fast-equals");
-function isFunctions(a, b) {
-  return typeof a === "function" && typeof b === "function";
-}
-var customDeepEqual = (0, import_fast_equals.createCustomEqual)({
-  createInternalComparator: (comparator) => {
-    return (a, b, _idxA, _idxB, _parentA, _parentB, state) => {
-      if (isFunctions(a, b)) {
-        return true;
-      }
-      return comparator(a, b, state);
-    };
-  }
-});
+var import_isEqualWith = __toESM(require("lodash/isEqualWith"));
 function deepEquals(a, b) {
-  if (isFunctions(a, b)) {
-    return true;
-  }
-  return customDeepEqual(a, b);
+  return (0, import_isEqualWith.default)(a, b, (obj, other) => {
+    if (typeof obj === "function" && typeof other === "function") {
+      return true;
+    }
+    return void 0;
+  });
 }
 
 // src/schema/getDefaultFormState.ts
@@ -427,6 +416,7 @@ function getFirstMatchingOption(validator, formData, options, rootSchema, discri
 
 // src/schema/retrieveSchema.ts
 var import_get4 = __toESM(require("lodash/get"));
+var import_isEqual = __toESM(require("lodash/isEqual"));
 var import_set = __toESM(require("lodash/set"));
 var import_times = __toESM(require("lodash/times"));
 var import_transform = __toESM(require("lodash/transform"));
@@ -606,10 +596,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];
 }
@@ -661,7 +648,7 @@ function resolveAllReferences(schema, rootSchema, recurseList) {
       items: resolveAllReferences(resolvedSchema.items, rootSchema, recurseList)
     };
   }
-  return deepEquals(schema, resolvedSchema) ? schema : resolvedSchema;
+  return (0, import_isEqual.default)(schema, resolvedSchema) ? schema : resolvedSchema;
 }
 function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFormData) {
   const schema = {
@@ -1566,10 +1553,11 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
 
 // src/schema/toIdSchema.ts
 var import_get9 = __toESM(require("lodash/get"));
+var import_isEqual2 = __toESM(require("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) => (0, import_isEqual2.default)(item, _schema));
     if (sameSchemaIndex === -1) {
       return toIdSchemaInternal(
         validator,
@@ -1623,11 +1611,12 @@ function toIdSchema(validator, schema, id, rootSchema, formData, idPrefix = "roo
 
 // src/schema/toPathSchema.ts
 var import_get10 = __toESM(require("lodash/get"));
+var import_isEqual3 = __toESM(require("lodash/isEqual"));
 var import_set2 = __toESM(require("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) => (0, import_isEqual3.default)(item, _schema));
     if (sameSchemaIndex === -1) {
       return toPathSchemaInternal(
         validator,
@@ -1998,6 +1987,9 @@ function englishStringTranslator(stringToTranslate, params) {
   return replaceStringParameters(stringToTranslate, params);
 }
 
+// src/enumOptionsDeselectValue.ts
+var import_isEqual4 = __toESM(require("lodash/isEqual"));
+
 // src/enumOptionsValueForIndex.ts
 function enumOptionsValueForIndex(valueIndex, allEnumOptions = [], emptyValue) {
   if (Array.isArray(valueIndex)) {
@@ -2012,17 +2004,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) => !(0, import_isEqual4.default)(v, value));
   }
-  return deepEquals(value, selected) ? void 0 : selected;
+  return (0, import_isEqual4.default)(value, selected) ? void 0 : selected;
 }
 
 // src/enumOptionsIsSelected.ts
+var import_isEqual5 = __toESM(require("lodash/isEqual"));
 function enumOptionsIsSelected(value, selected) {
   if (Array.isArray(selected)) {
-    return selected.some((sel) => deepEquals(sel, value));
+    return selected.some((sel) => (0, import_isEqual5.default)(sel, value));
   }
-  return deepEquals(selected, value);
+  return (0, import_isEqual5.default)(selected, value);
 }
 
 // src/enumOptionsIndexForValue.ts
@@ -2717,9 +2710,11 @@ var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
 
 // src/parser/schemaParser.ts
 var import_forEach = __toESM(require("lodash/forEach"));
+var import_isEqual7 = __toESM(require("lodash/isEqual"));
 
 // src/parser/ParserValidator.ts
 var import_get13 = __toESM(require("lodash/get"));
+var import_isEqual6 = __toESM(require("lodash/isEqual"));
 var ParserValidator = class {
   /** Construct the ParserValidator for the given `rootSchema`. This `rootSchema` will be stashed in the `schemaMap`
    * first.
@@ -2750,7 +2745,7 @@ var ParserValidator = class {
     const existing = this.schemaMap[key];
     if (!existing) {
       this.schemaMap[key] = identifiedSchema;
-    } else if (!deepEquals(existing, identifiedSchema)) {
+    } else if (!(0, import_isEqual6.default)(existing, identifiedSchema)) {
       console.error("existing schema:", JSON.stringify(existing, null, 2));
       console.error("new schema:", JSON.stringify(identifiedSchema, null, 2));
       throw new Error(
@@ -2772,7 +2767,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 (!(0, import_isEqual6.default)(rootSchema, this.rootSchema)) {
       throw new Error("Unexpectedly calling isValid() with a rootSchema that differs from the construction rootSchema");
     }
     this.addSchema(schema, hashForSchema(schema));
@@ -2812,7 +2807,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) => (0, import_isEqual7.default)(item, schema2));
     if (sameSchemaIndex === -1) {
       recurseList.push(schema2);
       const allOptions = resolveAnyOrOneOfSchemas(validator, schema2, rootSchema, true);