@rjsf/utils 5.5.0 → 5.5.2

package/dist/utils.umd.development.js

@@ -615,7 +615,7 @@
           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;
@@ -745,9 +745,7 @@
           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;
     });
@@ -1125,15 +1123,19 @@
    * @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.
@@ -1145,15 +1147,18 @@
     } 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) {
@@ -1177,16 +1182,30 @@
           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);
             });
           }
@@ -1197,14 +1216,14 @@
         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) {
@@ -1215,7 +1234,7 @@
               // 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);
             }
@@ -1522,30 +1541,34 @@
     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 = {
@@ -1555,62 +1578,104 @@
       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`
@@ -2039,16 +2104,15 @@
    * 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);
     }