@rjsf/utils 5.21.0 → 5.21.2

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 = {
@@ -593,9 +580,24 @@ function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expa
         return [...allOf, restOfSchema];
       }
       try {
+        const withContainsSchemas = [];
+        const withoutContainsSchemas = [];
+        resolvedSchema.allOf?.forEach((s2) => {
+          if (typeof s2 === "object" && s2.contains) {
+            withContainsSchemas.push(s2);
+          } else {
+            withoutContainsSchemas.push(s2);
+          }
+        });
+        if (withContainsSchemas.length) {
+          resolvedSchema = { ...resolvedSchema, allOf: withoutContainsSchemas };
+        }
         resolvedSchema = mergeAllOf(resolvedSchema, {
           deep: false
         });
+        if (withContainsSchemas.length) {
+          resolvedSchema.allOf = withContainsSchemas;
+        }
       } catch (e) {
         console.warn("could not merge subschemas in allOf:\n", e);
         const { allOf, ...resolvedSchemaWithoutAllOf } = resolvedSchema;
@@ -1429,10 +1431,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 +1489,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 +1865,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 +1882,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
@@ -1914,6 +1922,7 @@ function enumOptionsSelectValue(valueIndex, selected, allEnumOptions = []) {
 import cloneDeep from "lodash/cloneDeep";
 import get11 from "lodash/get";
 import set3 from "lodash/set";
+import setWith from "lodash/setWith";
 var ErrorSchemaBuilder = class {
   /** Construct an `ErrorSchemaBuilder` with an optional initial set of errors in an `ErrorSchema`.
    *
@@ -1943,7 +1952,7 @@ var ErrorSchemaBuilder = class {
     let errorBlock = hasPath ? get11(this.errorSchema, pathOfError) : this.errorSchema;
     if (!errorBlock && pathOfError) {
       errorBlock = {};
-      set3(this.errorSchema, pathOfError, errorBlock);
+      setWith(this.errorSchema, pathOfError, errorBlock, Object);
     }
     return errorBlock;
   }
@@ -2580,9 +2589,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 +2624,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 +2646,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 +2686,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);