@rjsf/core 3.0.1 → 3.2.1

package/dist/cjs/components/Form.js

@@ -0,0 +1,567 @@
+"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 _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);
+      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 _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, _utils.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,
+          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;
+      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;
+      var FormTag = tagName ? tagName : "form";
+
+      if (deprecatedAutocomplete) {
+        console.warn("Using autocomplete property of Form is deprecated, use autoComplete instead.");
+      }
+
+      var autoComplete = currentAutoComplete ? currentAutoComplete : deprecatedAutocomplete;
+      return _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,
+        ref: function ref(form) {
+          _this2.formElement = form;
+        }
+      }, this.renderErrors(), _react["default"].createElement(_SchemaField, {
+        schema: schema,
+        uiSchema: uiSchema,
+        errorSchema: errorSchema,
+        idSchema: idSchema,
+        idPrefix: idPrefix,
+        formContext: formContext,
+        formData: formData,
+        onChange: this.onChange,
+        onBlur: this.onBlur,
+        onFocus: this.onFocus,
+        registry: registry,
+        disabled: disabled,
+        readonly: readonly
+      }), children ? children : _react["default"].createElement("div", null, _react["default"].createElement("button", {
+        type: "submit",
+        className: "btn btn-info"
+      }, "Submit")));
+    }
+  }]);
+
+  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,
+    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","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","registry","_SchemaField","SchemaField","FormTag","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\";\n\nimport { default as DefaultErrorList } from \"./ErrorList\";\nimport {\n  getDefaultFormState,\n  retrieveSchema,\n  shouldRender,\n  toIdSchema,\n  getDefaultRegistry,\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    );\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      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    } = this.props;\n\n    const { schema, uiSchema, formData, errorSchema, idSchema } = this.state;\n    const registry = this.getRegistry();\n    const _SchemaField = registry.fields.SchemaField;\n    const FormTag = tagName ? tagName : \"form\";\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        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          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 ? (\n          children\n        ) : (\n          <div>\n            <button type=\"submit\" className=\"btn btn-info\">\n              Submit\n            </button>\n          </div>\n        )}\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    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"]}