@rjsf/utils 5.20.0 → 5.21.0

package/dist/index.js

@@ -265,14 +265,25 @@ function createErrorHandler(formData) {
 }
 
 // src/deepEquals.ts
-var import_isEqualWith = __toESM(require("lodash/isEqualWith"));
+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);
+    };
+  }
+});
 function deepEquals(a, b) {
-  return (0, import_isEqualWith.default)(a, b, (obj, other) => {
-    if (typeof obj === "function" && typeof other === "function") {
-      return true;
-    }
-    return void 0;
-  });
+  if (isFunctions(a, b)) {
+    return true;
+  }
+  return customDeepEqual(a, b);
 }
 
 // src/schema/getDefaultFormState.ts
@@ -416,7 +427,6 @@ 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"));
@@ -596,7 +606,10 @@ 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];
 }
@@ -648,7 +661,7 @@ function resolveAllReferences(schema, rootSchema, recurseList) {
       items: resolveAllReferences(resolvedSchema.items, rootSchema, recurseList)
     };
   }
-  return (0, import_isEqual.default)(schema, resolvedSchema) ? schema : resolvedSchema;
+  return deepEquals(schema, resolvedSchema) ? schema : resolvedSchema;
 }
 function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFormData) {
   const schema = {
@@ -1124,15 +1137,16 @@ function maybeAddDefaultToObject(obj, key, computedDefault, includeUndefinedValu
     }
   }
 }
-function computeDefaults(validator, rawSchema, {
-  parentDefaults,
-  rawFormData,
-  rootSchema = {},
-  includeUndefinedValues = false,
-  _recurseList = [],
-  experimental_defaultFormStateBehavior = void 0,
-  required
-} = {}) {
+function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
+  const {
+    parentDefaults,
+    rawFormData,
+    rootSchema = {},
+    includeUndefinedValues = false,
+    _recurseList = [],
+    experimental_defaultFormStateBehavior = void 0,
+    required
+  } = computeDefaultsProps;
   const formData = isObject(rawFormData) ? rawFormData : {};
   const schema = isObject(rawSchema) ? rawSchema : {};
   let defaults = parentDefaults;
@@ -1149,7 +1163,11 @@ function computeDefaults(validator, rawSchema, {
       schemaToCompute = findSchemaDefinition(refName, rootSchema);
     }
   } else if (DEPENDENCIES_KEY in schema) {
-    const resolvedSchema = resolveDependencies(validator, schema, rootSchema, false, [], formData);
+    const defaultFormData = {
+      ...formData,
+      ...getDefaultBasedOnSchemaType(validator, schema, computeDefaultsProps, defaults)
+    };
+    const resolvedSchema = resolveDependencies(validator, schema, rootSchema, false, [], defaultFormData);
     schemaToCompute = resolvedSchema[0];
   } else if (isFixedItems(schema)) {
     defaults = schema.items.map(
@@ -1208,127 +1226,154 @@ function computeDefaults(validator, rawSchema, {
   if (defaults === void 0) {
     defaults = schema.default;
   }
-  switch (getSchemaType(schema)) {
-    case "object": {
-      const retrievedSchema = experimental_defaultFormStateBehavior?.allOf === "populateDefaults" && ALL_OF_KEY in schema ? retrieveSchema(validator, schema, rootSchema, formData) : schema;
-      const objectDefaults = Object.keys(retrievedSchema.properties || {}).reduce(
-        (acc, key) => {
-          const computedDefault = computeDefaults(validator, (0, import_get7.default)(retrievedSchema, [PROPERTIES_KEY, key]), {
-            rootSchema,
-            _recurseList,
-            experimental_defaultFormStateBehavior,
-            includeUndefinedValues: includeUndefinedValues === true,
-            parentDefaults: (0, import_get7.default)(defaults, [key]),
-            rawFormData: (0, import_get7.default)(formData, [key]),
-            required: retrievedSchema.required?.includes(key)
-          });
-          maybeAddDefaultToObject(
-            acc,
-            key,
-            computedDefault,
-            includeUndefinedValues,
-            required,
-            retrievedSchema.required,
-            experimental_defaultFormStateBehavior
-          );
-          return acc;
-        },
-        {}
-      );
-      if (retrievedSchema.additionalProperties) {
-        const additionalPropertiesSchema = isObject(retrievedSchema.additionalProperties) ? retrievedSchema.additionalProperties : {};
-        const keys = /* @__PURE__ */ new Set();
-        if (isObject(defaults)) {
-          Object.keys(defaults).filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key]).forEach((key) => keys.add(key));
-        }
-        const formDataRequired = [];
-        Object.keys(formData).filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key]).forEach((key) => {
-          keys.add(key);
-          formDataRequired.push(key);
-        });
-        keys.forEach((key) => {
-          const computedDefault = computeDefaults(validator, additionalPropertiesSchema, {
-            rootSchema,
-            _recurseList,
-            experimental_defaultFormStateBehavior,
-            includeUndefinedValues: includeUndefinedValues === true,
-            parentDefaults: (0, import_get7.default)(defaults, [key]),
-            rawFormData: (0, import_get7.default)(formData, [key]),
-            required: retrievedSchema.required?.includes(key)
-          });
-          maybeAddDefaultToObject(
-            objectDefaults,
-            key,
-            computedDefault,
-            includeUndefinedValues,
-            required,
-            formDataRequired
-          );
+  const defaultBasedOnSchemaType = getDefaultBasedOnSchemaType(validator, schema, computeDefaultsProps, defaults);
+  return defaultBasedOnSchemaType ?? defaults;
+}
+function getObjectDefaults(validator, rawSchema, {
+  rawFormData,
+  rootSchema = {},
+  includeUndefinedValues = false,
+  _recurseList = [],
+  experimental_defaultFormStateBehavior = void 0,
+  required
+} = {}, defaults) {
+  {
+    const formData = isObject(rawFormData) ? rawFormData : {};
+    const schema = rawSchema;
+    const retrievedSchema = experimental_defaultFormStateBehavior?.allOf === "populateDefaults" && ALL_OF_KEY in schema ? retrieveSchema(validator, schema, rootSchema, formData) : schema;
+    const objectDefaults = Object.keys(retrievedSchema.properties || {}).reduce(
+      (acc, key) => {
+        const computedDefault = computeDefaults(validator, (0, import_get7.default)(retrievedSchema, [PROPERTIES_KEY, key]), {
+          rootSchema,
+          _recurseList,
+          experimental_defaultFormStateBehavior,
+          includeUndefinedValues: includeUndefinedValues === true,
+          parentDefaults: (0, import_get7.default)(defaults, [key]),
+          rawFormData: (0, import_get7.default)(formData, [key]),
+          required: retrievedSchema.required?.includes(key)
         });
+        maybeAddDefaultToObject(
+          acc,
+          key,
+          computedDefault,
+          includeUndefinedValues,
+          required,
+          retrievedSchema.required,
+          experimental_defaultFormStateBehavior
+        );
+        return acc;
+      },
+      {}
+    );
+    if (retrievedSchema.additionalProperties) {
+      const additionalPropertiesSchema = isObject(retrievedSchema.additionalProperties) ? retrievedSchema.additionalProperties : {};
+      const keys = /* @__PURE__ */ new Set();
+      if (isObject(defaults)) {
+        Object.keys(defaults).filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key]).forEach((key) => keys.add(key));
       }
-      return objectDefaults;
-    }
-    case "array": {
-      const neverPopulate = experimental_defaultFormStateBehavior?.arrayMinItems?.populate === "never";
-      const ignoreMinItemsFlagSet = experimental_defaultFormStateBehavior?.arrayMinItems?.populate === "requiredOnly";
-      const isSkipEmptyDefaults = experimental_defaultFormStateBehavior?.emptyObjectFields === "skipEmptyDefaults";
-      const computeSkipPopulate = experimental_defaultFormStateBehavior?.arrayMinItems?.computeSkipPopulate ?? (() => false);
-      const emptyDefault = isSkipEmptyDefaults ? void 0 : [];
-      if (Array.isArray(defaults)) {
-        defaults = defaults.map((item, idx) => {
-          const schemaItem = getInnerSchemaForArrayItem(schema, 2 /* Fallback */, idx);
-          return computeDefaults(validator, schemaItem, {
-            rootSchema,
-            _recurseList,
-            experimental_defaultFormStateBehavior,
-            parentDefaults: item,
-            required
-          });
+      const formDataRequired = [];
+      Object.keys(formData).filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key]).forEach((key) => {
+        keys.add(key);
+        formDataRequired.push(key);
+      });
+      keys.forEach((key) => {
+        const computedDefault = computeDefaults(validator, additionalPropertiesSchema, {
+          rootSchema,
+          _recurseList,
+          experimental_defaultFormStateBehavior,
+          includeUndefinedValues: includeUndefinedValues === true,
+          parentDefaults: (0, import_get7.default)(defaults, [key]),
+          rawFormData: (0, import_get7.default)(formData, [key]),
+          required: retrievedSchema.required?.includes(key)
         });
-      }
-      if (Array.isArray(rawFormData)) {
-        const schemaItem = getInnerSchemaForArrayItem(schema);
-        if (neverPopulate) {
-          defaults = rawFormData;
-        } else {
-          defaults = rawFormData.map((item, idx) => {
-            return computeDefaults(validator, schemaItem, {
-              rootSchema,
-              _recurseList,
-              experimental_defaultFormStateBehavior,
-              rawFormData: item,
-              parentDefaults: (0, import_get7.default)(defaults, [idx]),
-              required
-            });
-          });
-        }
-      }
-      if (neverPopulate) {
-        return defaults ?? emptyDefault;
-      }
-      if (ignoreMinItemsFlagSet && !required) {
-        return defaults ? defaults : void 0;
-      }
-      const defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
-      if (!schema.minItems || isMultiSelect(validator, schema, rootSchema) || computeSkipPopulate(validator, schema, rootSchema) || schema.minItems <= defaultsLength) {
-        return defaults ? defaults : emptyDefault;
-      }
-      const defaultEntries = defaults || [];
-      const fillerSchema = getInnerSchemaForArrayItem(schema, 1 /* Invert */);
-      const fillerDefault = fillerSchema.default;
-      const fillerEntries = new Array(schema.minItems - defaultsLength).fill(
-        computeDefaults(validator, fillerSchema, {
-          parentDefaults: fillerDefault,
+        maybeAddDefaultToObject(
+          objectDefaults,
+          key,
+          computedDefault,
+          includeUndefinedValues,
+          required,
+          formDataRequired
+        );
+      });
+    }
+    return objectDefaults;
+  }
+}
+function getArrayDefaults(validator, rawSchema, {
+  rawFormData,
+  rootSchema = {},
+  _recurseList = [],
+  experimental_defaultFormStateBehavior = void 0,
+  required
+} = {}, defaults) {
+  const schema = rawSchema;
+  const neverPopulate = experimental_defaultFormStateBehavior?.arrayMinItems?.populate === "never";
+  const ignoreMinItemsFlagSet = experimental_defaultFormStateBehavior?.arrayMinItems?.populate === "requiredOnly";
+  const isSkipEmptyDefaults = experimental_defaultFormStateBehavior?.emptyObjectFields === "skipEmptyDefaults";
+  const computeSkipPopulate = experimental_defaultFormStateBehavior?.arrayMinItems?.computeSkipPopulate ?? (() => false);
+  const emptyDefault = isSkipEmptyDefaults ? void 0 : [];
+  if (Array.isArray(defaults)) {
+    defaults = defaults.map((item, idx) => {
+      const schemaItem = getInnerSchemaForArrayItem(schema, 2 /* Fallback */, idx);
+      return computeDefaults(validator, schemaItem, {
+        rootSchema,
+        _recurseList,
+        experimental_defaultFormStateBehavior,
+        parentDefaults: item,
+        required
+      });
+    });
+  }
+  if (Array.isArray(rawFormData)) {
+    const schemaItem = getInnerSchemaForArrayItem(schema);
+    if (neverPopulate) {
+      defaults = rawFormData;
+    } else {
+      defaults = rawFormData.map((item, idx) => {
+        return computeDefaults(validator, schemaItem, {
           rootSchema,
           _recurseList,
           experimental_defaultFormStateBehavior,
+          rawFormData: item,
+          parentDefaults: (0, import_get7.default)(defaults, [idx]),
           required
-        })
-      );
-      return defaultEntries.concat(fillerEntries);
+        });
+      });
+    }
+  }
+  if (neverPopulate) {
+    return defaults ?? emptyDefault;
+  }
+  if (ignoreMinItemsFlagSet && !required) {
+    return defaults ? defaults : void 0;
+  }
+  const defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
+  if (!schema.minItems || isMultiSelect(validator, schema, rootSchema) || computeSkipPopulate(validator, schema, rootSchema) || schema.minItems <= defaultsLength) {
+    return defaults ? defaults : emptyDefault;
+  }
+  const defaultEntries = defaults || [];
+  const fillerSchema = getInnerSchemaForArrayItem(schema, 1 /* Invert */);
+  const fillerDefault = fillerSchema.default;
+  const fillerEntries = new Array(schema.minItems - defaultsLength).fill(
+    computeDefaults(validator, fillerSchema, {
+      parentDefaults: fillerDefault,
+      rootSchema,
+      _recurseList,
+      experimental_defaultFormStateBehavior,
+      required
+    })
+  );
+  return defaultEntries.concat(fillerEntries);
+}
+function getDefaultBasedOnSchemaType(validator, rawSchema, computeDefaultsProps = {}, defaults) {
+  switch (getSchemaType(rawSchema)) {
+    case "object": {
+      return getObjectDefaults(validator, rawSchema, computeDefaultsProps, defaults);
+    }
+    case "array": {
+      return getArrayDefaults(validator, rawSchema, computeDefaultsProps, defaults);
     }
   }
-  return defaults;
 }
 function getDefaultFormState(validator, theSchema, formData, rootSchema, includeUndefinedValues = false, experimental_defaultFormStateBehavior) {
   if (!isObject(theSchema)) {
@@ -1521,11 +1566,10 @@ 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) => (0, import_isEqual2.default)(item, _schema));
+    const sameSchemaIndex = _recurseList.findIndex((item) => deepEquals(item, _schema));
     if (sameSchemaIndex === -1) {
       return toIdSchemaInternal(
         validator,
@@ -1579,12 +1623,11 @@ 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) => (0, import_isEqual3.default)(item, _schema));
+    const sameSchemaIndex = _recurseList.findIndex((item) => deepEquals(item, _schema));
     if (sameSchemaIndex === -1) {
       return toPathSchemaInternal(
         validator,
@@ -1955,9 +1998,6 @@ 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)) {
@@ -1972,18 +2012,17 @@ function enumOptionsValueForIndex(valueIndex, allEnumOptions = [], emptyValue) {
 function enumOptionsDeselectValue(valueIndex, selected, allEnumOptions = []) {
   const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
   if (Array.isArray(selected)) {
-    return selected.filter((v) => !(0, import_isEqual4.default)(v, value));
+    return selected.filter((v) => !deepEquals(v, value));
   }
-  return (0, import_isEqual4.default)(value, selected) ? void 0 : selected;
+  return deepEquals(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) => (0, import_isEqual5.default)(sel, value));
+    return selected.some((sel) => deepEquals(sel, value));
   }
-  return (0, import_isEqual5.default)(selected, value);
+  return deepEquals(selected, value);
 }
 
 // src/enumOptionsIndexForValue.ts
@@ -2678,11 +2717,9 @@ 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.
@@ -2713,7 +2750,7 @@ var ParserValidator = class {
     const existing = this.schemaMap[key];
     if (!existing) {
       this.schemaMap[key] = identifiedSchema;
-    } else if (!(0, import_isEqual6.default)(existing, identifiedSchema)) {
+    } else if (!deepEquals(existing, identifiedSchema)) {
       console.error("existing schema:", JSON.stringify(existing, null, 2));
       console.error("new schema:", JSON.stringify(identifiedSchema, null, 2));
       throw new Error(
@@ -2735,7 +2772,7 @@ var ParserValidator = class {
    * @throws - Error when the given `rootSchema` differs from the root schema provided during construction
    */
   isValid(schema, _formData, rootSchema) {
-    if (!(0, import_isEqual6.default)(rootSchema, this.rootSchema)) {
+    if (!deepEquals(rootSchema, this.rootSchema)) {
       throw new Error("Unexpectedly calling isValid() with a rootSchema that differs from the construction rootSchema");
     }
     this.addSchema(schema, hashForSchema(schema));
@@ -2775,7 +2812,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) => (0, import_isEqual7.default)(item, schema2));
+    const sameSchemaIndex = recurseList.findIndex((item) => deepEquals(item, schema2));
     if (sameSchemaIndex === -1) {
       recurseList.push(schema2);
       const allOptions = resolveAnyOrOneOfSchemas(validator, schema2, rootSchema, true);