@rjsf/utils 5.21.0 → 5.21.2

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 = {
@@ -730,9 +717,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 = (0, import_json_schema_merge_allof.default)(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;
@@ -1566,10 +1568,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 +1626,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 +2002,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 +2019,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
@@ -2051,6 +2059,7 @@ function enumOptionsSelectValue(valueIndex, selected, allEnumOptions = []) {
 var import_cloneDeep = __toESM(require("lodash/cloneDeep"));
 var import_get11 = __toESM(require("lodash/get"));
 var import_set3 = __toESM(require("lodash/set"));
+var import_setWith = __toESM(require("lodash/setWith"));
 var ErrorSchemaBuilder = class {
   /** Construct an `ErrorSchemaBuilder` with an optional initial set of errors in an `ErrorSchema`.
    *
@@ -2080,7 +2089,7 @@ var ErrorSchemaBuilder = class {
     let errorBlock = hasPath ? (0, import_get11.default)(this.errorSchema, pathOfError) : this.errorSchema;
     if (!errorBlock && pathOfError) {
       errorBlock = {};
-      (0, import_set3.default)(this.errorSchema, pathOfError, errorBlock);
+      (0, import_setWith.default)(this.errorSchema, pathOfError, errorBlock, Object);
     }
     return errorBlock;
   }
@@ -2717,9 +2726,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 +2761,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 +2783,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 +2823,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);