@rjsf/utils 5.5.0 → 5.5.1

package/dist/index.d.ts

@@ -1373,7 +1373,7 @@ declare function isObject(thing: any): boolean;
 /** Helper function that will return the value to use for a widget `label` based on `hideLabel`. The `fallback` is used
  * as the return value from the function when `hideLabel` is true. Due to the implementation of theme components, it
  * may be necessary to return something other than `undefined` to cause the theme component to not render a label. Some
- * themes require may `false` and others may require and empty string.
+ * themes require may `false` and others may require an empty string.
  *
  * @param [label] - The label string or component to render when not hidden
  * @param [hideLabel] - Flag, if true, will cause the label to be hidden

package/dist/utils.cjs.development.js

@@ -632,7 +632,7 @@ function retrieveSchema(validator, schema, rootSchema, rawFormData) {
         deep: false
       });
     } catch (e) {
-      console.warn('could not merge subschemas in allOf:\n' + e);
+      console.warn('could not merge subschemas in allOf:\n', e);
       var _resolvedSchema = resolvedSchema,
         resolvedSchemaWithoutAllOf = _objectWithoutPropertiesLoose(_resolvedSchema, _excluded3);
       return resolvedSchemaWithoutAllOf;
@@ -762,9 +762,7 @@ function withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, o
         type: 'object',
         properties: (_properties = {}, _properties[dependencyKey] = conditionPropertySchema, _properties)
       };
-      var _validator$validateFo = validator.validateFormData(formData, conditionSchema),
-        errors = _validator$validateFo.errors;
-      return errors.length === 0;
+      return validator.isValid(conditionSchema, formData, rootSchema);
     }
     return false;
   });
@@ -1142,15 +1140,19 @@ function maybeAddDefaultToObject(obj, key, computedDefault, includeUndefinedValu
  * @param [includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults.
  *          If "excludeObjectChildren", cause undefined values for this object and pass `includeUndefinedValues` as
  *          false when computing defaults for any nested object properties.
+ * @param [_recurseList=[]] - The list of ref names currently being recursed, used to prevent infinite recursion
  * @returns - The resulting `formData` with all the defaults provided
  */
-function computeDefaults(validator, rawSchema, parentDefaults, rootSchema, rawFormData, includeUndefinedValues) {
+function computeDefaults(validator, rawSchema, parentDefaults, rootSchema, rawFormData, includeUndefinedValues, _recurseList) {
   if (rootSchema === void 0) {
     rootSchema = {};
   }
   if (includeUndefinedValues === void 0) {
     includeUndefinedValues = false;
   }
+  if (_recurseList === void 0) {
+    _recurseList = [];
+  }
   var formData = isObject(rawFormData) ? rawFormData : {};
   var schema = isObject(rawSchema) ? rawSchema : {};
   // Compute the defaults recursively: give highest priority to deepest nodes.
@@ -1162,15 +1164,18 @@ function computeDefaults(validator, rawSchema, parentDefaults, rootSchema, rawFo
   } else if (DEFAULT_KEY in schema) {
     defaults = schema["default"];
   } else if (REF_KEY in schema) {
+    var refName = schema[REF_KEY];
     // Use referenced schema defaults for this node.
-    var refSchema = findSchemaDefinition(schema[REF_KEY], rootSchema);
-    return computeDefaults(validator, refSchema, defaults, rootSchema, formData, includeUndefinedValues);
+    if (!_recurseList.includes(refName)) {
+      var refSchema = findSchemaDefinition(refName, rootSchema);
+      return computeDefaults(validator, refSchema, defaults, rootSchema, formData, includeUndefinedValues, _recurseList.concat(refName));
+    }
   } else if (DEPENDENCIES_KEY in schema) {
     var resolvedSchema = resolveDependencies(validator, schema, rootSchema, formData);
-    return computeDefaults(validator, resolvedSchema, defaults, rootSchema, formData, includeUndefinedValues);
+    return computeDefaults(validator, resolvedSchema, defaults, rootSchema, formData, includeUndefinedValues, _recurseList);
   } else if (isFixedItems(schema)) {
     defaults = schema.items.map(function (itemSchema, idx) {
-      return computeDefaults(validator, itemSchema, Array.isArray(parentDefaults) ? parentDefaults[idx] : undefined, rootSchema, formData, includeUndefinedValues);
+      return computeDefaults(validator, itemSchema, Array.isArray(parentDefaults) ? parentDefaults[idx] : undefined, rootSchema, formData, includeUndefinedValues, _recurseList);
     });
   } else if (ONE_OF_KEY in schema) {
     if (schema.oneOf.length === 0) {
@@ -1194,16 +1199,30 @@ function computeDefaults(validator, rawSchema, parentDefaults, rootSchema, rawFo
         var objectDefaults = Object.keys(schema.properties || {}).reduce(function (acc, key) {
           // Compute the defaults for this node, with the parent defaults we might
           // have from a previous run: defaults[key].
-          var computedDefault = computeDefaults(validator, get__default["default"](schema, [PROPERTIES_KEY, key]), get__default["default"](defaults, [key]), rootSchema, get__default["default"](formData, [key]), includeUndefinedValues === true);
+          var computedDefault = computeDefaults(validator, get__default["default"](schema, [PROPERTIES_KEY, key]), get__default["default"](defaults, [key]), rootSchema, get__default["default"](formData, [key]), includeUndefinedValues === true, _recurseList);
           maybeAddDefaultToObject(acc, key, computedDefault, includeUndefinedValues, schema.required);
           return acc;
         }, {});
-        if (schema.additionalProperties && isObject(defaults)) {
-          var additionalPropertiesSchema = isObject(schema.additionalProperties) ? schema.additionalProperties : {}; // as per spec additionalProperties may be either schema or boolean
-          Object.keys(defaults).filter(function (key) {
-            return !schema.properties || !schema.properties[key];
-          }).forEach(function (key) {
-            var computedDefault = computeDefaults(validator, additionalPropertiesSchema, get__default["default"](defaults, [key]), rootSchema, get__default["default"](formData, [key]), includeUndefinedValues === true);
+        if (schema.additionalProperties) {
+          // as per spec additionalProperties may be either schema or boolean
+          var additionalPropertiesSchema = isObject(schema.additionalProperties) ? schema.additionalProperties : {};
+          var keys = new Set();
+          if (isObject(defaults)) {
+            Object.keys(defaults).filter(function (key) {
+              return !schema.properties || !schema.properties[key];
+            }).forEach(function (key) {
+              return keys.add(key);
+            });
+          }
+          if (isObject(formData)) {
+            Object.keys(formData).filter(function (key) {
+              return !schema.properties || !schema.properties[key];
+            }).forEach(function (key) {
+              return keys.add(key);
+            });
+          }
+          keys.forEach(function (key) {
+            var computedDefault = computeDefaults(validator, additionalPropertiesSchema, get__default["default"](defaults, [key]), rootSchema, get__default["default"](formData, [key]), includeUndefinedValues === true, _recurseList);
             maybeAddDefaultToObject(objectDefaults, key, computedDefault, includeUndefinedValues);
           });
         }
@@ -1214,14 +1233,14 @@ function computeDefaults(validator, rawSchema, parentDefaults, rootSchema, rawFo
       if (Array.isArray(defaults)) {
         defaults = defaults.map(function (item, idx) {
           var schemaItem = getInnerSchemaForArrayItem(schema, AdditionalItemsHandling.Fallback, idx);
-          return computeDefaults(validator, schemaItem, item, rootSchema);
+          return computeDefaults(validator, schemaItem, item, rootSchema, undefined, undefined, _recurseList);
         });
       }
       // Deeply inject defaults into already existing form data
       if (Array.isArray(rawFormData)) {
         var schemaItem = getInnerSchemaForArrayItem(schema);
         defaults = rawFormData.map(function (item, idx) {
-          return computeDefaults(validator, schemaItem, get__default["default"](defaults, [idx]), rootSchema, item);
+          return computeDefaults(validator, schemaItem, get__default["default"](defaults, [idx]), rootSchema, item, undefined, _recurseList);
         });
       }
       if (schema.minItems) {
@@ -1232,7 +1251,7 @@ function computeDefaults(validator, rawSchema, parentDefaults, rootSchema, rawFo
             // populate the array with the defaults
             var fillerSchema = getInnerSchemaForArrayItem(schema, AdditionalItemsHandling.Invert);
             var fillerDefault = fillerSchema["default"];
-            var fillerEntries = new Array(schema.minItems - defaultsLength).fill(computeDefaults(validator, fillerSchema, fillerDefault, rootSchema));
+            var fillerEntries = new Array(schema.minItems - defaultsLength).fill(computeDefaults(validator, fillerSchema, fillerDefault, rootSchema, undefined, undefined, _recurseList));
             // then fill up the rest with either the item default or empty, up to minItems
             return defaultEntries.concat(fillerEntries);
           }
@@ -1539,30 +1558,34 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
   return newFormData;
 }
 
-/** Generates an `IdSchema` object for the `schema`, recursively
+/** An internal helper that generates an `IdSchema` object for the `schema`, recursively with protection against
+ * infinite recursion
  *
  * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
  * @param schema - The schema for which the `IdSchema` is desired
+ * @param idPrefix - The prefix to use for the id
+ * @param idSeparator - The separator to use for the path segments in the id
  * @param [id] - The base id for the schema
  * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
  * @param [formData] - The current formData, if any, to assist retrieving a schema
- * @param [idPrefix='root'] - The prefix to use for the id
- * @param [idSeparator='_'] - The separator to use for the path segments in the id
+ * @param [_recurseList=[]] - The list of retrieved schemas currently being recursed, used to prevent infinite recursion
  * @returns - The `IdSchema` object for the `schema`
  */
-function toIdSchema(validator, schema, id, rootSchema, formData, idPrefix, idSeparator) {
-  if (idPrefix === void 0) {
-    idPrefix = 'root';
-  }
-  if (idSeparator === void 0) {
-    idSeparator = '_';
+function toIdSchemaInternal(validator, schema, idPrefix, idSeparator, id, rootSchema, formData, _recurseList) {
+  if (_recurseList === void 0) {
+    _recurseList = [];
   }
   if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
     var _schema = retrieveSchema(validator, schema, rootSchema, formData);
-    return toIdSchema(validator, _schema, id, rootSchema, formData, idPrefix, idSeparator);
+    var sameSchemaIndex = _recurseList.findIndex(function (item) {
+      return isEqual__default["default"](item, _schema);
+    });
+    if (sameSchemaIndex === -1) {
+      return toIdSchemaInternal(validator, _schema, idPrefix, idSeparator, id, rootSchema, formData, _recurseList.concat(_schema));
+    }
   }
   if (ITEMS_KEY in schema && !get__default["default"](schema, [ITEMS_KEY, REF_KEY])) {
-    return toIdSchema(validator, get__default["default"](schema, ITEMS_KEY), id, rootSchema, formData, idPrefix, idSeparator);
+    return toIdSchemaInternal(validator, get__default["default"](schema, ITEMS_KEY), idPrefix, idSeparator, id, rootSchema, formData, _recurseList);
   }
   var $id = id || idPrefix;
   var idSchema = {
@@ -1572,62 +1595,104 @@ function toIdSchema(validator, schema, id, rootSchema, formData, idPrefix, idSep
     for (var name in schema.properties) {
       var field = get__default["default"](schema, [PROPERTIES_KEY, name]);
       var fieldId = idSchema[ID_KEY] + idSeparator + name;
-      idSchema[name] = toIdSchema(validator, isObject(field) ? field : {}, fieldId, rootSchema,
+      idSchema[name] = toIdSchemaInternal(validator, isObject(field) ? field : {}, idPrefix, idSeparator, fieldId, rootSchema,
       // It's possible that formData is not an object -- this can happen if an
       // array item has just been added, but not populated with data yet
-      get__default["default"](formData, [name]), idPrefix, idSeparator);
+      get__default["default"](formData, [name]), _recurseList);
     }
   }
   return idSchema;
 }
+/** Generates an `IdSchema` object for the `schema`, recursively
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param schema - The schema for which the `IdSchema` is desired
+ * @param [id] - The base id for the schema
+ * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @param [formData] - The current formData, if any, to assist retrieving a schema
+ * @param [idPrefix='root'] - The prefix to use for the id
+ * @param [idSeparator='_'] - The separator to use for the path segments in the id
+ * @returns - The `IdSchema` object for the `schema`
+ */
+function toIdSchema(validator, schema, id, rootSchema, formData, idPrefix, idSeparator) {
+  if (idPrefix === void 0) {
+    idPrefix = 'root';
+  }
+  if (idSeparator === void 0) {
+    idSeparator = '_';
+  }
+  return toIdSchemaInternal(validator, schema, idPrefix, idSeparator, id, rootSchema, formData);
+}
 
-/** Generates an `PathSchema` object for the `schema`, recursively
+/** An internal helper that generates an `PathSchema` object for the `schema`, recursively with protection against
+ * infinite recursion
  *
  * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
  * @param schema - The schema for which the `PathSchema` is desired
  * @param [name=''] - The base name for the schema
  * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
  * @param [formData] - The current formData, if any, to assist retrieving a schema
+ * @param [_recurseList=[]] - The list of retrieved schemas currently being recursed, used to prevent infinite recursion
  * @returns - The `PathSchema` object for the `schema`
  */
-function toPathSchema(validator, schema, name, rootSchema, formData) {
+function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _recurseList) {
   var _pathSchema;
-  if (name === void 0) {
-    name = '';
+  if (_recurseList === void 0) {
+    _recurseList = [];
   }
   if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
     var _schema = retrieveSchema(validator, schema, rootSchema, formData);
-    return toPathSchema(validator, _schema, name, rootSchema, formData);
+    var sameSchemaIndex = _recurseList.findIndex(function (item) {
+      return isEqual__default["default"](item, _schema);
+    });
+    if (sameSchemaIndex === -1) {
+      return toPathSchemaInternal(validator, _schema, name, rootSchema, formData, _recurseList.concat(_schema));
+    }
   }
   var pathSchema = (_pathSchema = {}, _pathSchema[NAME_KEY] = name.replace(/^\./, ''), _pathSchema);
   if (ONE_OF_KEY in schema) {
     var index = getClosestMatchingOption(validator, rootSchema, formData, schema.oneOf, 0);
     var _schema2 = schema.oneOf[index];
-    return toPathSchema(validator, _schema2, name, rootSchema, formData);
+    return toPathSchemaInternal(validator, _schema2, name, rootSchema, formData, _recurseList);
   }
   if (ANY_OF_KEY in schema) {
     var _index = getClosestMatchingOption(validator, rootSchema, formData, schema.anyOf, 0);
     var _schema3 = schema.anyOf[_index];
-    return toPathSchema(validator, _schema3, name, rootSchema, formData);
+    return toPathSchemaInternal(validator, _schema3, name, rootSchema, formData, _recurseList);
   }
   if (ADDITIONAL_PROPERTIES_KEY in schema && schema[ADDITIONAL_PROPERTIES_KEY] !== false) {
     set__default["default"](pathSchema, RJSF_ADDITONAL_PROPERTIES_FLAG, true);
   }
   if (ITEMS_KEY in schema && Array.isArray(formData)) {
     formData.forEach(function (element, i) {
-      pathSchema[i] = toPathSchema(validator, schema.items, name + "." + i, rootSchema, element);
+      pathSchema[i] = toPathSchemaInternal(validator, schema.items, name + "." + i, rootSchema, element, _recurseList);
     });
   } else if (PROPERTIES_KEY in schema) {
     for (var property in schema.properties) {
       var field = get__default["default"](schema, [PROPERTIES_KEY, property]);
-      pathSchema[property] = toPathSchema(validator, field, name + "." + property, rootSchema,
+      pathSchema[property] = toPathSchemaInternal(validator, field, name + "." + property, rootSchema,
       // It's possible that formData is not an object -- this can happen if an
       // array item has just been added, but not populated with data yet
-      get__default["default"](formData, [property]));
+      get__default["default"](formData, [property]), _recurseList);
     }
   }
   return pathSchema;
 }
+/** Generates an `PathSchema` object for the `schema`, recursively
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param schema - The schema for which the `PathSchema` is desired
+ * @param [name=''] - The base name for the schema
+ * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @param [formData] - The current formData, if any, to assist retrieving a schema
+ * @returns - The `PathSchema` object for the `schema`
+ */
+function toPathSchema(validator, schema, name, rootSchema, formData) {
+  if (name === void 0) {
+    name = '';
+  }
+  return toPathSchemaInternal(validator, schema, name, rootSchema, formData);
+}
 
 /** The `SchemaUtils` class provides a wrapper around the publicly exported APIs in the `utils/schema` directory such
  * that one does not have to explicitly pass the `validator` or `rootSchema` to each method. Since both the `validator`
@@ -2056,16 +2121,15 @@ function enumOptionsSelectValue(valueIndex, selected, allEnumOptions) {
  * get the result and/or reset all the errors back to an initial set and start again.
  */
 var ErrorSchemaBuilder = /*#__PURE__*/function () {
-  /** The error schema being built
-   *
-   * @private
-   */
-
   /** Construct an `ErrorSchemaBuilder` with an optional initial set of errors in an `ErrorSchema`.
    *
    * @param [initialSchema] - The optional set of initial errors, that will be cloned into the class
    */
   function ErrorSchemaBuilder(initialSchema) {
+    /** The error schema being built
+     *
+     * @private
+     */
     this.errorSchema = {};
     this.resetAllErrors(initialSchema);
   }