@rjsf/core 4.2.2 → 4.2.3

package/dist/cjs/components/Form.js

@@ -0,0 +1,588 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _pick2 = _interopRequireDefault(require("lodash/pick"));
+
+var _get2 = _interopRequireDefault(require("lodash/get"));
+
+var _isEmpty2 = _interopRequireDefault(require("lodash/isEmpty"));
+
+var _defaultRegistry = require("../defaultRegistry");
+
+var _ErrorList = _interopRequireDefault(require("./ErrorList"));
+
+var _utils = require("../utils");
+
+var _validate = _interopRequireWildcard(require("../validate"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj["default"] = obj; return newObj; } }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Form =
+/*#__PURE__*/
+function (_Component) {
+  _inherits(Form, _Component);
+
+  function Form(props) {
+    var _this;
+
+    _classCallCheck(this, Form);
+
+    _this = _possibleConstructorReturn(this, _getPrototypeOf(Form).call(this, props));
+
+    _defineProperty(_assertThisInitialized(_this), "getUsedFormData", function (formData, fields) {
+      //for the case of a single input form
+      if (fields.length === 0 && _typeof(formData) !== "object") {
+        return formData;
+      }
+
+      var data = (0, _pick2["default"])(formData, fields);
+
+      if (Array.isArray(formData)) {
+        return Object.keys(data).map(function (key) {
+          return data[key];
+        });
+      }
+
+      return data;
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "getFieldNames", function (pathSchema, formData) {
+      var getAllPaths = function getAllPaths(_obj) {
+        var acc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+        var paths = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [""];
+        Object.keys(_obj).forEach(function (key) {
+          if (_typeof(_obj[key]) === "object") {
+            var newPaths = paths.map(function (path) {
+              return "".concat(path, ".").concat(key);
+            }); // If an object is marked with additionalProperties, all its keys are valid
+
+            if (_obj[key].__rjsf_additionalProperties && _obj[key].$name !== "") {
+              acc.push(_obj[key].$name);
+            } else {
+              getAllPaths(_obj[key], acc, newPaths);
+            }
+          } else if (key === "$name" && _obj[key] !== "") {
+            paths.forEach(function (path) {
+              path = path.replace(/^\./, "");
+              var formValue = (0, _get2["default"])(formData, path); // adds path to fieldNames if it points to a value
+              // or an empty object/array
+
+              if (_typeof(formValue) !== "object" || (0, _isEmpty2["default"])(formValue)) {
+                acc.push(path);
+              }
+            });
+          }
+        });
+        return acc;
+      };
+
+      return getAllPaths(pathSchema);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "onChange", function (formData, newErrorSchema) {
+      if ((0, _utils.isObject)(formData) || Array.isArray(formData)) {
+        var newState = _this.getStateFromProps(_this.props, formData);
+
+        formData = newState.formData;
+      }
+
+      var mustValidate = !_this.props.noValidate && _this.props.liveValidate;
+      var state = {
+        formData: formData
+      };
+      var newFormData = formData;
+
+      if (_this.props.omitExtraData === true && _this.props.liveOmit === true) {
+        var retrievedSchema = (0, _utils.retrieveSchema)(_this.state.schema, _this.state.schema, formData);
+        var pathSchema = (0, _utils.toPathSchema)(retrievedSchema, "", _this.state.schema, formData);
+
+        var fieldNames = _this.getFieldNames(pathSchema, formData);
+
+        newFormData = _this.getUsedFormData(formData, fieldNames);
+        state = {
+          formData: newFormData
+        };
+      }
+
+      if (mustValidate) {
+        var schemaValidation = _this.validate(newFormData);
+
+        var errors = schemaValidation.errors;
+        var errorSchema = schemaValidation.errorSchema;
+        var schemaValidationErrors = errors;
+        var schemaValidationErrorSchema = errorSchema;
+
+        if (_this.props.extraErrors) {
+          errorSchema = (0, _utils.mergeObjects)(errorSchema, _this.props.extraErrors, !!"concat arrays");
+          errors = (0, _validate.toErrorList)(errorSchema);
+        }
+
+        state = {
+          formData: newFormData,
+          errors: errors,
+          errorSchema: errorSchema,
+          schemaValidationErrors: schemaValidationErrors,
+          schemaValidationErrorSchema: schemaValidationErrorSchema
+        };
+      } else if (!_this.props.noValidate && newErrorSchema) {
+        var _errorSchema = _this.props.extraErrors ? (0, _utils.mergeObjects)(newErrorSchema, _this.props.extraErrors, !!"concat arrays") : newErrorSchema;
+
+        state = {
+          formData: newFormData,
+          errorSchema: _errorSchema,
+          errors: (0, _validate.toErrorList)(_errorSchema)
+        };
+      }
+
+      _this.setState(state, function () {
+        return _this.props.onChange && _this.props.onChange(_this.state);
+      });
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "onBlur", function () {
+      if (_this.props.onBlur) {
+        var _this$props;
+
+        (_this$props = _this.props).onBlur.apply(_this$props, arguments);
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "onFocus", function () {
+      if (_this.props.onFocus) {
+        var _this$props2;
+
+        (_this$props2 = _this.props).onFocus.apply(_this$props2, arguments);
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "onSubmit", function (event) {
+      event.preventDefault();
+
+      if (event.target !== event.currentTarget) {
+        return;
+      }
+
+      event.persist();
+      var newFormData = _this.state.formData;
+
+      if (_this.props.omitExtraData === true) {
+        var retrievedSchema = (0, _utils.retrieveSchema)(_this.state.schema, _this.state.schema, newFormData);
+        var pathSchema = (0, _utils.toPathSchema)(retrievedSchema, "", _this.state.schema, newFormData);
+
+        var fieldNames = _this.getFieldNames(pathSchema, newFormData);
+
+        newFormData = _this.getUsedFormData(newFormData, fieldNames);
+      }
+
+      if (!_this.props.noValidate) {
+        var schemaValidation = _this.validate(newFormData);
+
+        var _errors = schemaValidation.errors;
+        var _errorSchema2 = schemaValidation.errorSchema;
+        var schemaValidationErrors = _errors;
+        var schemaValidationErrorSchema = _errorSchema2;
+
+        if (Object.keys(_errors).length > 0) {
+          if (_this.props.extraErrors) {
+            _errorSchema2 = (0, _utils.mergeObjects)(_errorSchema2, _this.props.extraErrors, !!"concat arrays");
+            _errors = (0, _validate.toErrorList)(_errorSchema2);
+          }
+
+          _this.setState({
+            errors: _errors,
+            errorSchema: _errorSchema2,
+            schemaValidationErrors: schemaValidationErrors,
+            schemaValidationErrorSchema: schemaValidationErrorSchema
+          }, function () {
+            if (_this.props.onError) {
+              _this.props.onError(_errors);
+            } else {
+              console.error("Form validation failed", _errors);
+            }
+          });
+
+          return;
+        }
+      } // There are no errors generated through schema validation.
+      // Check for user provided errors and update state accordingly.
+
+
+      var errorSchema;
+      var errors;
+
+      if (_this.props.extraErrors) {
+        errorSchema = _this.props.extraErrors;
+        errors = (0, _validate.toErrorList)(errorSchema);
+      } else {
+        errorSchema = {};
+        errors = [];
+      }
+
+      _this.setState({
+        formData: newFormData,
+        errors: errors,
+        errorSchema: errorSchema,
+        schemaValidationErrors: [],
+        schemaValidationErrorSchema: {}
+      }, function () {
+        if (_this.props.onSubmit) {
+          _this.props.onSubmit(_objectSpread({}, _this.state, {
+            formData: newFormData,
+            status: "submitted"
+          }), event);
+        }
+      });
+    });
+
+    _this.state = _this.getStateFromProps(props, props.formData);
+
+    if (_this.props.onChange && !(0, _utils.deepEquals)(_this.state.formData, _this.props.formData)) {
+      _this.props.onChange(_this.state);
+    }
+
+    _this.formElement = null;
+    return _this;
+  }
+
+  _createClass(Form, [{
+    key: "UNSAFE_componentWillReceiveProps",
+    value: function UNSAFE_componentWillReceiveProps(nextProps) {
+      var nextState = this.getStateFromProps(nextProps, nextProps.formData);
+
+      if (!(0, _utils.deepEquals)(nextState.formData, nextProps.formData) && !(0, _utils.deepEquals)(nextState.formData, this.state.formData) && this.props.onChange) {
+        this.props.onChange(nextState);
+      }
+
+      this.setState(nextState);
+    }
+  }, {
+    key: "getStateFromProps",
+    value: function getStateFromProps(props, inputFormData) {
+      var state = this.state || {};
+      var schema = "schema" in props ? props.schema : this.props.schema;
+      var uiSchema = "uiSchema" in props ? props.uiSchema : this.props.uiSchema;
+      var edit = typeof inputFormData !== "undefined";
+      var liveValidate = "liveValidate" in props ? props.liveValidate : this.props.liveValidate;
+      var mustValidate = edit && !props.noValidate && liveValidate;
+      var rootSchema = schema;
+      var formData = (0, _utils.getDefaultFormState)(schema, inputFormData, rootSchema);
+      var retrievedSchema = (0, _utils.retrieveSchema)(schema, rootSchema, formData);
+      var customFormats = props.customFormats;
+      var additionalMetaSchemas = props.additionalMetaSchemas;
+
+      var getCurrentErrors = function getCurrentErrors() {
+        if (props.noValidate) {
+          return {
+            errors: [],
+            errorSchema: {}
+          };
+        } else if (!props.liveValidate) {
+          return {
+            errors: state.schemaValidationErrors || [],
+            errorSchema: state.schemaValidationErrorSchema || {}
+          };
+        }
+
+        return {
+          errors: state.errors || [],
+          errorSchema: state.errorSchema || {}
+        };
+      };
+
+      var errors, errorSchema, schemaValidationErrors, schemaValidationErrorSchema;
+
+      if (mustValidate) {
+        var schemaValidation = this.validate(formData, schema, additionalMetaSchemas, customFormats);
+        errors = schemaValidation.errors;
+        errorSchema = schemaValidation.errorSchema;
+        schemaValidationErrors = errors;
+        schemaValidationErrorSchema = errorSchema;
+      } else {
+        var currentErrors = getCurrentErrors();
+        errors = currentErrors.errors;
+        errorSchema = currentErrors.errorSchema;
+        schemaValidationErrors = state.schemaValidationErrors;
+        schemaValidationErrorSchema = state.schemaValidationErrorSchema;
+      }
+
+      if (props.extraErrors) {
+        errorSchema = (0, _utils.mergeObjects)(errorSchema, props.extraErrors, !!"concat arrays");
+        errors = (0, _validate.toErrorList)(errorSchema);
+      }
+
+      var idSchema = (0, _utils.toIdSchema)(retrievedSchema, uiSchema["ui:rootFieldId"], rootSchema, formData, props.idPrefix, props.idSeparator);
+      var nextState = {
+        schema: schema,
+        uiSchema: uiSchema,
+        idSchema: idSchema,
+        formData: formData,
+        edit: edit,
+        errors: errors,
+        errorSchema: errorSchema,
+        additionalMetaSchemas: additionalMetaSchemas
+      };
+
+      if (schemaValidationErrors) {
+        nextState.schemaValidationErrors = schemaValidationErrors;
+        nextState.schemaValidationErrorSchema = schemaValidationErrorSchema;
+      }
+
+      return nextState;
+    }
+  }, {
+    key: "shouldComponentUpdate",
+    value: function shouldComponentUpdate(nextProps, nextState) {
+      return (0, _utils.shouldRender)(this, nextProps, nextState);
+    }
+  }, {
+    key: "validate",
+    value: function validate(formData) {
+      var schema = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.props.schema;
+      var additionalMetaSchemas = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.props.additionalMetaSchemas;
+      var customFormats = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : this.props.customFormats;
+      var _this$props3 = this.props,
+          validate = _this$props3.validate,
+          transformErrors = _this$props3.transformErrors;
+
+      var _this$getRegistry = this.getRegistry(),
+          rootSchema = _this$getRegistry.rootSchema;
+
+      var resolvedSchema = (0, _utils.retrieveSchema)(schema, rootSchema, formData);
+      return (0, _validate["default"])(formData, resolvedSchema, validate, transformErrors, additionalMetaSchemas, customFormats);
+    }
+  }, {
+    key: "renderErrors",
+    value: function renderErrors() {
+      var _this$state = this.state,
+          errors = _this$state.errors,
+          errorSchema = _this$state.errorSchema,
+          schema = _this$state.schema,
+          uiSchema = _this$state.uiSchema;
+      var _this$props4 = this.props,
+          ErrorList = _this$props4.ErrorList,
+          showErrorList = _this$props4.showErrorList,
+          formContext = _this$props4.formContext;
+
+      if (errors.length && showErrorList != false) {
+        return (
+          /*#__PURE__*/
+          _react["default"].createElement(ErrorList, {
+            errors: errors,
+            errorSchema: errorSchema,
+            schema: schema,
+            uiSchema: uiSchema,
+            formContext: formContext
+          })
+        );
+      }
+
+      return null;
+    }
+  }, {
+    key: "getRegistry",
+    value: function getRegistry() {
+      // For BC, accept passed SchemaField and TitleField props and pass them to
+      // the "fields" registry one.
+      var _getDefaultRegistry = (0, _defaultRegistry.getDefaultRegistry)(),
+          fields = _getDefaultRegistry.fields,
+          widgets = _getDefaultRegistry.widgets;
+
+      return {
+        fields: _objectSpread({}, fields, this.props.fields),
+        widgets: _objectSpread({}, widgets, this.props.widgets),
+        ArrayFieldTemplate: this.props.ArrayFieldTemplate,
+        ObjectFieldTemplate: this.props.ObjectFieldTemplate,
+        FieldTemplate: this.props.FieldTemplate,
+        definitions: this.props.schema.definitions || {},
+        rootSchema: this.props.schema,
+        formContext: this.props.formContext || {}
+      };
+    }
+  }, {
+    key: "submit",
+    value: function submit() {
+      if (this.formElement) {
+        this.formElement.dispatchEvent(new CustomEvent("submit", {
+          cancelable: true
+        }));
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+
+      var _this$props5 = this.props,
+          children = _this$props5.children,
+          id = _this$props5.id,
+          idPrefix = _this$props5.idPrefix,
+          idSeparator = _this$props5.idSeparator,
+          className = _this$props5.className,
+          tagName = _this$props5.tagName,
+          name = _this$props5.name,
+          method = _this$props5.method,
+          target = _this$props5.target,
+          action = _this$props5.action,
+          deprecatedAutocomplete = _this$props5.autocomplete,
+          currentAutoComplete = _this$props5.autoComplete,
+          enctype = _this$props5.enctype,
+          acceptcharset = _this$props5.acceptcharset,
+          noHtml5Validate = _this$props5.noHtml5Validate,
+          disabled = _this$props5.disabled,
+          readonly = _this$props5.readonly,
+          formContext = _this$props5.formContext,
+          _internalFormWrapper = _this$props5._internalFormWrapper;
+      var _this$state2 = this.state,
+          schema = _this$state2.schema,
+          uiSchema = _this$state2.uiSchema,
+          formData = _this$state2.formData,
+          errorSchema = _this$state2.errorSchema,
+          idSchema = _this$state2.idSchema;
+      var registry = this.getRegistry();
+      var _SchemaField = registry.fields.SchemaField; // The `semantic-ui` and `material-ui` themes have `_internalFormWrapper`s that take an `as` prop that is the
+      // PropTypes.elementType to use for the inner tag so we'll need to pass `tagName` along if it is provided.
+      // NOTE, the `as` prop is native to `semantic-ui` and is emulated in the `material-ui` theme
+
+      var as = _internalFormWrapper ? tagName : undefined;
+      var FormTag = _internalFormWrapper || tagName || "form";
+      var SubmitButton = registry.widgets.SubmitButton;
+
+      if (deprecatedAutocomplete) {
+        console.warn("Using autocomplete property of Form is deprecated, use autoComplete instead.");
+      }
+
+      var autoComplete = currentAutoComplete ? currentAutoComplete : deprecatedAutocomplete;
+      return (
+        /*#__PURE__*/
+        _react["default"].createElement(FormTag, {
+          className: className ? className : "rjsf",
+          id: id,
+          name: name,
+          method: method,
+          target: target,
+          action: action,
+          autoComplete: autoComplete,
+          encType: enctype,
+          acceptCharset: acceptcharset,
+          noValidate: noHtml5Validate,
+          onSubmit: this.onSubmit,
+          as: as,
+          ref: function ref(form) {
+            _this2.formElement = form;
+          }
+        }, this.renderErrors(),
+        /*#__PURE__*/
+        _react["default"].createElement(_SchemaField, {
+          schema: schema,
+          uiSchema: uiSchema,
+          errorSchema: errorSchema,
+          idSchema: idSchema,
+          idPrefix: idPrefix,
+          idSeparator: idSeparator,
+          formContext: formContext,
+          formData: formData,
+          onChange: this.onChange,
+          onBlur: this.onBlur,
+          onFocus: this.onFocus,
+          registry: registry,
+          disabled: disabled,
+          readonly: readonly
+        }), children ? children :
+        /*#__PURE__*/
+        _react["default"].createElement(SubmitButton, {
+          uiSchema: uiSchema
+        }))
+      );
+    }
+  }]);
+
+  return Form;
+}(_react.Component);
+
+exports["default"] = Form;
+
+_defineProperty(Form, "defaultProps", {
+  uiSchema: {},
+  noValidate: false,
+  liveValidate: false,
+  disabled: false,
+  readonly: false,
+  noHtml5Validate: false,
+  ErrorList: _ErrorList["default"],
+  omitExtraData: false
+});
+
+if (process.env.NODE_ENV !== "production") {
+  Form.propTypes = {
+    schema: _propTypes["default"].object.isRequired,
+    uiSchema: _propTypes["default"].object,
+    formData: _propTypes["default"].any,
+    disabled: _propTypes["default"].bool,
+    readonly: _propTypes["default"].bool,
+    widgets: _propTypes["default"].objectOf(_propTypes["default"].oneOfType([_propTypes["default"].func, _propTypes["default"].object])),
+    fields: _propTypes["default"].objectOf(_propTypes["default"].elementType),
+    ArrayFieldTemplate: _propTypes["default"].elementType,
+    ObjectFieldTemplate: _propTypes["default"].elementType,
+    FieldTemplate: _propTypes["default"].elementType,
+    ErrorList: _propTypes["default"].func,
+    onChange: _propTypes["default"].func,
+    onError: _propTypes["default"].func,
+    showErrorList: _propTypes["default"].bool,
+    onSubmit: _propTypes["default"].func,
+    id: _propTypes["default"].string,
+    className: _propTypes["default"].string,
+    tagName: _propTypes["default"].elementType,
+    _internalFormWrapper: _propTypes["default"].elementType,
+    name: _propTypes["default"].string,
+    method: _propTypes["default"].string,
+    target: _propTypes["default"].string,
+    action: _propTypes["default"].string,
+    autocomplete: _propTypes["default"].string,
+    autoComplete: _propTypes["default"].string,
+    enctype: _propTypes["default"].string,
+    acceptcharset: _propTypes["default"].string,
+    noValidate: _propTypes["default"].bool,
+    noHtml5Validate: _propTypes["default"].bool,
+    liveValidate: _propTypes["default"].bool,
+    validate: _propTypes["default"].func,
+    transformErrors: _propTypes["default"].func,
+    formContext: _propTypes["default"].object,
+    customFormats: _propTypes["default"].object,
+    additionalMetaSchemas: _propTypes["default"].arrayOf(_propTypes["default"].object),
+    omitExtraData: _propTypes["default"].bool,
+    extraErrors: _propTypes["default"].object
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/components/Form.js"],"names":["Form","props","formData","fields","length","data","Array","isArray","Object","keys","map","key","pathSchema","getAllPaths","_obj","acc","paths","forEach","newPaths","path","__rjsf_additionalProperties","$name","push","replace","formValue","newErrorSchema","newState","getStateFromProps","mustValidate","noValidate","liveValidate","state","newFormData","omitExtraData","liveOmit","retrievedSchema","schema","fieldNames","getFieldNames","getUsedFormData","schemaValidation","validate","errors","errorSchema","schemaValidationErrors","schemaValidationErrorSchema","extraErrors","setState","onChange","onBlur","onFocus","event","preventDefault","target","currentTarget","persist","onError","console","error","onSubmit","status","formElement","nextProps","nextState","inputFormData","uiSchema","edit","rootSchema","customFormats","additionalMetaSchemas","getCurrentErrors","currentErrors","idSchema","idPrefix","idSeparator","transformErrors","getRegistry","resolvedSchema","ErrorList","showErrorList","formContext","widgets","ArrayFieldTemplate","ObjectFieldTemplate","FieldTemplate","definitions","dispatchEvent","CustomEvent","cancelable","children","id","className","tagName","name","method","action","deprecatedAutocomplete","autocomplete","currentAutoComplete","autoComplete","enctype","acceptcharset","noHtml5Validate","disabled","readonly","_internalFormWrapper","registry","_SchemaField","SchemaField","as","undefined","FormTag","SubmitButton","warn","form","renderErrors","Component","DefaultErrorList","process","env","NODE_ENV","propTypes","PropTypes","object","isRequired","any","bool","objectOf","oneOfType","func","elementType","string","arrayOf"],"mappings":"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","sourcesContent":["import React, { Component } from \"react\";\nimport PropTypes from \"prop-types\";\nimport _pick from \"lodash/pick\";\nimport _get from \"lodash/get\";\nimport _isEmpty from \"lodash/isEmpty\";\nimport { getDefaultRegistry } from \"../defaultRegistry\";\n\nimport { default as DefaultErrorList } from \"./ErrorList\";\nimport {\n  getDefaultFormState,\n  retrieveSchema,\n  shouldRender,\n  toIdSchema,\n  deepEquals,\n  toPathSchema,\n  isObject,\n} from \"../utils\";\nimport validateFormData, { toErrorList } from \"../validate\";\nimport { mergeObjects } from \"../utils\";\n\nexport default class Form extends Component {\n  static defaultProps = {\n    uiSchema: {},\n    noValidate: false,\n    liveValidate: false,\n    disabled: false,\n    readonly: false,\n    noHtml5Validate: false,\n    ErrorList: DefaultErrorList,\n    omitExtraData: false,\n  };\n\n  constructor(props) {\n    super(props);\n    this.state = this.getStateFromProps(props, props.formData);\n    if (\n      this.props.onChange &&\n      !deepEquals(this.state.formData, this.props.formData)\n    ) {\n      this.props.onChange(this.state);\n    }\n    this.formElement = null;\n  }\n\n  UNSAFE_componentWillReceiveProps(nextProps) {\n    const nextState = this.getStateFromProps(nextProps, nextProps.formData);\n    if (\n      !deepEquals(nextState.formData, nextProps.formData) &&\n      !deepEquals(nextState.formData, this.state.formData) &&\n      this.props.onChange\n    ) {\n      this.props.onChange(nextState);\n    }\n    this.setState(nextState);\n  }\n\n  getStateFromProps(props, inputFormData) {\n    const state = this.state || {};\n    const schema = \"schema\" in props ? props.schema : this.props.schema;\n    const uiSchema = \"uiSchema\" in props ? props.uiSchema : this.props.uiSchema;\n    const edit = typeof inputFormData !== \"undefined\";\n    const liveValidate =\n      \"liveValidate\" in props ? props.liveValidate : this.props.liveValidate;\n    const mustValidate = edit && !props.noValidate && liveValidate;\n    const rootSchema = schema;\n    const formData = getDefaultFormState(schema, inputFormData, rootSchema);\n    const retrievedSchema = retrieveSchema(schema, rootSchema, formData);\n    const customFormats = props.customFormats;\n    const additionalMetaSchemas = props.additionalMetaSchemas;\n\n    const getCurrentErrors = () => {\n      if (props.noValidate) {\n        return { errors: [], errorSchema: {} };\n      } else if (!props.liveValidate) {\n        return {\n          errors: state.schemaValidationErrors || [],\n          errorSchema: state.schemaValidationErrorSchema || {},\n        };\n      }\n      return {\n        errors: state.errors || [],\n        errorSchema: state.errorSchema || {},\n      };\n    };\n\n    let errors,\n      errorSchema,\n      schemaValidationErrors,\n      schemaValidationErrorSchema;\n    if (mustValidate) {\n      const schemaValidation = this.validate(\n        formData,\n        schema,\n        additionalMetaSchemas,\n        customFormats\n      );\n      errors = schemaValidation.errors;\n      errorSchema = schemaValidation.errorSchema;\n      schemaValidationErrors = errors;\n      schemaValidationErrorSchema = errorSchema;\n    } else {\n      const currentErrors = getCurrentErrors();\n      errors = currentErrors.errors;\n      errorSchema = currentErrors.errorSchema;\n      schemaValidationErrors = state.schemaValidationErrors;\n      schemaValidationErrorSchema = state.schemaValidationErrorSchema;\n    }\n    if (props.extraErrors) {\n      errorSchema = mergeObjects(\n        errorSchema,\n        props.extraErrors,\n        !!\"concat arrays\"\n      );\n      errors = toErrorList(errorSchema);\n    }\n    const idSchema = toIdSchema(\n      retrievedSchema,\n      uiSchema[\"ui:rootFieldId\"],\n      rootSchema,\n      formData,\n      props.idPrefix,\n      props.idSeparator\n    );\n    const nextState = {\n      schema,\n      uiSchema,\n      idSchema,\n      formData,\n      edit,\n      errors,\n      errorSchema,\n      additionalMetaSchemas,\n    };\n    if (schemaValidationErrors) {\n      nextState.schemaValidationErrors = schemaValidationErrors;\n      nextState.schemaValidationErrorSchema = schemaValidationErrorSchema;\n    }\n    return nextState;\n  }\n\n  shouldComponentUpdate(nextProps, nextState) {\n    return shouldRender(this, nextProps, nextState);\n  }\n\n  validate(\n    formData,\n    schema = this.props.schema,\n    additionalMetaSchemas = this.props.additionalMetaSchemas,\n    customFormats = this.props.customFormats\n  ) {\n    const { validate, transformErrors } = this.props;\n    const { rootSchema } = this.getRegistry();\n    const resolvedSchema = retrieveSchema(schema, rootSchema, formData);\n    return validateFormData(\n      formData,\n      resolvedSchema,\n      validate,\n      transformErrors,\n      additionalMetaSchemas,\n      customFormats\n    );\n  }\n\n  renderErrors() {\n    const { errors, errorSchema, schema, uiSchema } = this.state;\n    const { ErrorList, showErrorList, formContext } = this.props;\n\n    if (errors.length && showErrorList != false) {\n      return (\n        <ErrorList\n          errors={errors}\n          errorSchema={errorSchema}\n          schema={schema}\n          uiSchema={uiSchema}\n          formContext={formContext}\n        />\n      );\n    }\n    return null;\n  }\n\n  getUsedFormData = (formData, fields) => {\n    //for the case of a single input form\n    if (fields.length === 0 && typeof formData !== \"object\") {\n      return formData;\n    }\n\n    let data = _pick(formData, fields);\n    if (Array.isArray(formData)) {\n      return Object.keys(data).map(key => data[key]);\n    }\n\n    return data;\n  };\n\n  getFieldNames = (pathSchema, formData) => {\n    const getAllPaths = (_obj, acc = [], paths = [\"\"]) => {\n      Object.keys(_obj).forEach(key => {\n        if (typeof _obj[key] === \"object\") {\n          let newPaths = paths.map(path => `${path}.${key}`);\n          // If an object is marked with additionalProperties, all its keys are valid\n          if (_obj[key].__rjsf_additionalProperties && _obj[key].$name !== \"\") {\n            acc.push(_obj[key].$name);\n          } else {\n            getAllPaths(_obj[key], acc, newPaths);\n          }\n        } else if (key === \"$name\" && _obj[key] !== \"\") {\n          paths.forEach(path => {\n            path = path.replace(/^\\./, \"\");\n            const formValue = _get(formData, path);\n            // adds path to fieldNames if it points to a value\n            // or an empty object/array\n            if (typeof formValue !== \"object\" || _isEmpty(formValue)) {\n              acc.push(path);\n            }\n          });\n        }\n      });\n      return acc;\n    };\n\n    return getAllPaths(pathSchema);\n  };\n\n  onChange = (formData, newErrorSchema) => {\n    if (isObject(formData) || Array.isArray(formData)) {\n      const newState = this.getStateFromProps(this.props, formData);\n      formData = newState.formData;\n    }\n    const mustValidate = !this.props.noValidate && this.props.liveValidate;\n    let state = { formData };\n    let newFormData = formData;\n\n    if (this.props.omitExtraData === true && this.props.liveOmit === true) {\n      const retrievedSchema = retrieveSchema(\n        this.state.schema,\n        this.state.schema,\n        formData\n      );\n      const pathSchema = toPathSchema(\n        retrievedSchema,\n        \"\",\n        this.state.schema,\n        formData\n      );\n\n      const fieldNames = this.getFieldNames(pathSchema, formData);\n\n      newFormData = this.getUsedFormData(formData, fieldNames);\n      state = {\n        formData: newFormData,\n      };\n    }\n\n    if (mustValidate) {\n      let schemaValidation = this.validate(newFormData);\n      let errors = schemaValidation.errors;\n      let errorSchema = schemaValidation.errorSchema;\n      const schemaValidationErrors = errors;\n      const schemaValidationErrorSchema = errorSchema;\n      if (this.props.extraErrors) {\n        errorSchema = mergeObjects(\n          errorSchema,\n          this.props.extraErrors,\n          !!\"concat arrays\"\n        );\n        errors = toErrorList(errorSchema);\n      }\n      state = {\n        formData: newFormData,\n        errors,\n        errorSchema,\n        schemaValidationErrors,\n        schemaValidationErrorSchema,\n      };\n    } else if (!this.props.noValidate && newErrorSchema) {\n      const errorSchema = this.props.extraErrors\n        ? mergeObjects(\n            newErrorSchema,\n            this.props.extraErrors,\n            !!\"concat arrays\"\n          )\n        : newErrorSchema;\n      state = {\n        formData: newFormData,\n        errorSchema: errorSchema,\n        errors: toErrorList(errorSchema),\n      };\n    }\n    this.setState(\n      state,\n      () => this.props.onChange && this.props.onChange(this.state)\n    );\n  };\n\n  onBlur = (...args) => {\n    if (this.props.onBlur) {\n      this.props.onBlur(...args);\n    }\n  };\n\n  onFocus = (...args) => {\n    if (this.props.onFocus) {\n      this.props.onFocus(...args);\n    }\n  };\n\n  onSubmit = event => {\n    event.preventDefault();\n    if (event.target !== event.currentTarget) {\n      return;\n    }\n\n    event.persist();\n    let newFormData = this.state.formData;\n\n    if (this.props.omitExtraData === true) {\n      const retrievedSchema = retrieveSchema(\n        this.state.schema,\n        this.state.schema,\n        newFormData\n      );\n      const pathSchema = toPathSchema(\n        retrievedSchema,\n        \"\",\n        this.state.schema,\n        newFormData\n      );\n\n      const fieldNames = this.getFieldNames(pathSchema, newFormData);\n\n      newFormData = this.getUsedFormData(newFormData, fieldNames);\n    }\n\n    if (!this.props.noValidate) {\n      let schemaValidation = this.validate(newFormData);\n      let errors = schemaValidation.errors;\n      let errorSchema = schemaValidation.errorSchema;\n      const schemaValidationErrors = errors;\n      const schemaValidationErrorSchema = errorSchema;\n      if (Object.keys(errors).length > 0) {\n        if (this.props.extraErrors) {\n          errorSchema = mergeObjects(\n            errorSchema,\n            this.props.extraErrors,\n            !!\"concat arrays\"\n          );\n          errors = toErrorList(errorSchema);\n        }\n        this.setState(\n          {\n            errors,\n            errorSchema,\n            schemaValidationErrors,\n            schemaValidationErrorSchema,\n          },\n          () => {\n            if (this.props.onError) {\n              this.props.onError(errors);\n            } else {\n              console.error(\"Form validation failed\", errors);\n            }\n          }\n        );\n        return;\n      }\n    }\n\n    // There are no errors generated through schema validation.\n    // Check for user provided errors and update state accordingly.\n    let errorSchema;\n    let errors;\n    if (this.props.extraErrors) {\n      errorSchema = this.props.extraErrors;\n      errors = toErrorList(errorSchema);\n    } else {\n      errorSchema = {};\n      errors = [];\n    }\n\n    this.setState(\n      {\n        formData: newFormData,\n        errors: errors,\n        errorSchema: errorSchema,\n        schemaValidationErrors: [],\n        schemaValidationErrorSchema: {},\n      },\n      () => {\n        if (this.props.onSubmit) {\n          this.props.onSubmit(\n            { ...this.state, formData: newFormData, status: \"submitted\" },\n            event\n          );\n        }\n      }\n    );\n  };\n\n  getRegistry() {\n    // For BC, accept passed SchemaField and TitleField props and pass them to\n    // the \"fields\" registry one.\n    const { fields, widgets } = getDefaultRegistry();\n    return {\n      fields: { ...fields, ...this.props.fields },\n      widgets: { ...widgets, ...this.props.widgets },\n      ArrayFieldTemplate: this.props.ArrayFieldTemplate,\n      ObjectFieldTemplate: this.props.ObjectFieldTemplate,\n      FieldTemplate: this.props.FieldTemplate,\n      definitions: this.props.schema.definitions || {},\n      rootSchema: this.props.schema,\n      formContext: this.props.formContext || {},\n    };\n  }\n\n  submit() {\n    if (this.formElement) {\n      this.formElement.dispatchEvent(\n        new CustomEvent(\"submit\", {\n          cancelable: true,\n        })\n      );\n    }\n  }\n\n  render() {\n    const {\n      children,\n      id,\n      idPrefix,\n      idSeparator,\n      className,\n      tagName,\n      name,\n      method,\n      target,\n      action,\n      autocomplete: deprecatedAutocomplete,\n      autoComplete: currentAutoComplete,\n      enctype,\n      acceptcharset,\n      noHtml5Validate,\n      disabled,\n      readonly,\n      formContext,\n      /**\n       * _internalFormWrapper is currently used by the material-ui and semantic-ui themes to provide a custom wrapper\n       * around `<Form />` that supports the proper rendering of those themes. To use this prop, one must pass a\n       * component that takes two props: `children` and `as`. That component, at minimum, should render the `children`\n       * inside of a <form /> tag unless `as` is provided, in which case, use the `as` prop in place of `<form />`.\n       * i.e.:\n       * ```\n       * export default function InternalForm({ children, as}) {\n       *   const FormTag = as || 'form';\n       *   return <FormTag>{children}</FormTag>;\n       * }\n       * ```\n       */\n      _internalFormWrapper,\n    } = this.props;\n\n    const { schema, uiSchema, formData, errorSchema, idSchema } = this.state;\n    const registry = this.getRegistry();\n    const _SchemaField = registry.fields.SchemaField;\n    // The `semantic-ui` and `material-ui` themes have `_internalFormWrapper`s that take an `as` prop that is the\n    // PropTypes.elementType to use for the inner tag so we'll need to pass `tagName` along if it is provided.\n    // NOTE, the `as` prop is native to `semantic-ui` and is emulated in the `material-ui` theme\n    const as = _internalFormWrapper ? tagName : undefined;\n    const FormTag = _internalFormWrapper || tagName || \"form\";\n    const SubmitButton = registry.widgets.SubmitButton;\n    if (deprecatedAutocomplete) {\n      console.warn(\n        \"Using autocomplete property of Form is deprecated, use autoComplete instead.\"\n      );\n    }\n    const autoComplete = currentAutoComplete\n      ? currentAutoComplete\n      : deprecatedAutocomplete;\n\n    return (\n      <FormTag\n        className={className ? className : \"rjsf\"}\n        id={id}\n        name={name}\n        method={method}\n        target={target}\n        action={action}\n        autoComplete={autoComplete}\n        encType={enctype}\n        acceptCharset={acceptcharset}\n        noValidate={noHtml5Validate}\n        onSubmit={this.onSubmit}\n        as={as}\n        ref={form => {\n          this.formElement = form;\n        }}>\n        {this.renderErrors()}\n        <_SchemaField\n          schema={schema}\n          uiSchema={uiSchema}\n          errorSchema={errorSchema}\n          idSchema={idSchema}\n          idPrefix={idPrefix}\n          idSeparator={idSeparator}\n          formContext={formContext}\n          formData={formData}\n          onChange={this.onChange}\n          onBlur={this.onBlur}\n          onFocus={this.onFocus}\n          registry={registry}\n          disabled={disabled}\n          readonly={readonly}\n        />\n        {children ? children : <SubmitButton uiSchema={uiSchema} />}\n      </FormTag>\n    );\n  }\n}\n\nif (process.env.NODE_ENV !== \"production\") {\n  Form.propTypes = {\n    schema: PropTypes.object.isRequired,\n    uiSchema: PropTypes.object,\n    formData: PropTypes.any,\n    disabled: PropTypes.bool,\n    readonly: PropTypes.bool,\n    widgets: PropTypes.objectOf(\n      PropTypes.oneOfType([PropTypes.func, PropTypes.object])\n    ),\n    fields: PropTypes.objectOf(PropTypes.elementType),\n    ArrayFieldTemplate: PropTypes.elementType,\n    ObjectFieldTemplate: PropTypes.elementType,\n    FieldTemplate: PropTypes.elementType,\n    ErrorList: PropTypes.func,\n    onChange: PropTypes.func,\n    onError: PropTypes.func,\n    showErrorList: PropTypes.bool,\n    onSubmit: PropTypes.func,\n    id: PropTypes.string,\n    className: PropTypes.string,\n    tagName: PropTypes.elementType,\n    _internalFormWrapper: PropTypes.elementType,\n    name: PropTypes.string,\n    method: PropTypes.string,\n    target: PropTypes.string,\n    action: PropTypes.string,\n    autocomplete: PropTypes.string,\n    autoComplete: PropTypes.string,\n    enctype: PropTypes.string,\n    acceptcharset: PropTypes.string,\n    noValidate: PropTypes.bool,\n    noHtml5Validate: PropTypes.bool,\n    liveValidate: PropTypes.bool,\n    validate: PropTypes.func,\n    transformErrors: PropTypes.func,\n    formContext: PropTypes.object,\n    customFormats: PropTypes.object,\n    additionalMetaSchemas: PropTypes.arrayOf(PropTypes.object),\n    omitExtraData: PropTypes.bool,\n    extraErrors: PropTypes.object,\n  };\n}\n"]}