@rjsf/core 4.2.2 → 4.2.3

package/lib/components/widgets/FileWidget.js

@@ -0,0 +1,201 @@
+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; }
+
+import React, { Component } from "react";
+import PropTypes from "prop-types";
+import { dataURItoBlob, shouldRender } from "../../utils";
+
+function addNameToDataURL(dataURL, name) {
+  return dataURL.replace(";base64", ";name=".concat(encodeURIComponent(name), ";base64"));
+}
+
+function processFile(file) {
+  var name = file.name,
+      size = file.size,
+      type = file.type;
+  return new Promise(function (resolve, reject) {
+    var reader = new window.FileReader();
+    reader.onerror = reject;
+
+    reader.onload = function (event) {
+      resolve({
+        dataURL: addNameToDataURL(event.target.result, name),
+        name: name,
+        size: size,
+        type: type
+      });
+    };
+
+    reader.readAsDataURL(file);
+  });
+}
+
+function processFiles(files) {
+  return Promise.all([].map.call(files, processFile));
+}
+
+function FilesInfo(props) {
+  var filesInfo = props.filesInfo;
+
+  if (filesInfo.length === 0) {
+    return null;
+  }
+
+  return (
+    /*#__PURE__*/
+    React.createElement("ul", {
+      className: "file-info"
+    }, filesInfo.map(function (fileInfo, key) {
+      var name = fileInfo.name,
+          size = fileInfo.size,
+          type = fileInfo.type;
+      return (
+        /*#__PURE__*/
+        React.createElement("li", {
+          key: key
+        },
+        /*#__PURE__*/
+        React.createElement("strong", null, name), " (", type, ", ", size, " bytes)")
+      );
+    }))
+  );
+}
+
+function extractFileInfo(dataURLs) {
+  return dataURLs.filter(function (dataURL) {
+    return typeof dataURL !== "undefined";
+  }).map(function (dataURL) {
+    var _dataURItoBlob = dataURItoBlob(dataURL),
+        blob = _dataURItoBlob.blob,
+        name = _dataURItoBlob.name;
+
+    return {
+      name: name,
+      size: blob.size,
+      type: blob.type
+    };
+  });
+}
+
+var FileWidget =
+/*#__PURE__*/
+function (_Component) {
+  _inherits(FileWidget, _Component);
+
+  function FileWidget(props) {
+    var _this;
+
+    _classCallCheck(this, FileWidget);
+
+    _this = _possibleConstructorReturn(this, _getPrototypeOf(FileWidget).call(this, props));
+
+    _defineProperty(_assertThisInitialized(_this), "onChange", function (event) {
+      var _this$props = _this.props,
+          multiple = _this$props.multiple,
+          onChange = _this$props.onChange;
+      processFiles(event.target.files).then(function (filesInfo) {
+        var state = {
+          values: filesInfo.map(function (fileInfo) {
+            return fileInfo.dataURL;
+          }),
+          filesInfo: filesInfo
+        };
+
+        _this.setState(state, function () {
+          if (multiple) {
+            onChange(state.values);
+          } else {
+            onChange(state.values[0]);
+          }
+        });
+      });
+    });
+
+    var value = props.value;
+    var values = Array.isArray(value) ? value : [value];
+    _this.state = {
+      values: values,
+      filesInfo: extractFileInfo(values)
+    };
+    return _this;
+  }
+
+  _createClass(FileWidget, [{
+    key: "shouldComponentUpdate",
+    value: function shouldComponentUpdate(nextProps, nextState) {
+      return shouldRender(this, nextProps, nextState);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+
+      var _this$props2 = this.props,
+          multiple = _this$props2.multiple,
+          id = _this$props2.id,
+          readonly = _this$props2.readonly,
+          disabled = _this$props2.disabled,
+          autofocus = _this$props2.autofocus,
+          options = _this$props2.options;
+      var filesInfo = this.state.filesInfo;
+      return (
+        /*#__PURE__*/
+        React.createElement("div", null,
+        /*#__PURE__*/
+        React.createElement("p", null,
+        /*#__PURE__*/
+        React.createElement("input", {
+          ref: function ref(_ref) {
+            return _this2.inputRef = _ref;
+          },
+          id: id,
+          type: "file",
+          disabled: readonly || disabled,
+          onChange: this.onChange,
+          defaultValue: "",
+          autoFocus: autofocus,
+          multiple: multiple,
+          accept: options.accept
+        })),
+        /*#__PURE__*/
+        React.createElement(FilesInfo, {
+          filesInfo: filesInfo
+        }))
+      );
+    }
+  }]);
+
+  return FileWidget;
+}(Component);
+
+FileWidget.defaultProps = {
+  autofocus: false
+};
+
+if (process.env.NODE_ENV !== "production") {
+  FileWidget.propTypes = {
+    multiple: PropTypes.bool,
+    value: PropTypes.oneOfType([PropTypes.string, PropTypes.arrayOf(PropTypes.string)]),
+    autofocus: PropTypes.bool
+  };
+}
+
+export default FileWidget;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/components/widgets/FileWidget.js"],"names":["React","Component","PropTypes","dataURItoBlob","shouldRender","addNameToDataURL","dataURL","name","replace","encodeURIComponent","processFile","file","size","type","Promise","resolve","reject","reader","window","FileReader","onerror","onload","event","target","result","readAsDataURL","processFiles","files","all","map","call","FilesInfo","props","filesInfo","length","fileInfo","key","extractFileInfo","dataURLs","filter","blob","FileWidget","multiple","onChange","then","state","values","setState","value","Array","isArray","nextProps","nextState","id","readonly","disabled","autofocus","options","ref","inputRef","accept","defaultProps","process","env","NODE_ENV","propTypes","bool","oneOfType","string","arrayOf"],"mappings":"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","sourcesContent":["import React, { Component } from \"react\";\nimport PropTypes from \"prop-types\";\n\nimport { dataURItoBlob, shouldRender } from \"../../utils\";\n\nfunction addNameToDataURL(dataURL, name) {\n  return dataURL.replace(\";base64\", `;name=${encodeURIComponent(name)};base64`);\n}\n\nfunction processFile(file) {\n  const { name, size, type } = file;\n  return new Promise((resolve, reject) => {\n    const reader = new window.FileReader();\n    reader.onerror = reject;\n    reader.onload = event => {\n      resolve({\n        dataURL: addNameToDataURL(event.target.result, name),\n        name,\n        size,\n        type,\n      });\n    };\n    reader.readAsDataURL(file);\n  });\n}\n\nfunction processFiles(files) {\n  return Promise.all([].map.call(files, processFile));\n}\n\nfunction FilesInfo(props) {\n  const { filesInfo } = props;\n  if (filesInfo.length === 0) {\n    return null;\n  }\n  return (\n    <ul className=\"file-info\">\n      {filesInfo.map((fileInfo, key) => {\n        const { name, size, type } = fileInfo;\n        return (\n          <li key={key}>\n            <strong>{name}</strong> ({type}, {size} bytes)\n          </li>\n        );\n      })}\n    </ul>\n  );\n}\n\nfunction extractFileInfo(dataURLs) {\n  return dataURLs\n    .filter(dataURL => typeof dataURL !== \"undefined\")\n    .map(dataURL => {\n      const { blob, name } = dataURItoBlob(dataURL);\n      return {\n        name: name,\n        size: blob.size,\n        type: blob.type,\n      };\n    });\n}\n\nclass FileWidget extends Component {\n  constructor(props) {\n    super(props);\n    const { value } = props;\n    const values = Array.isArray(value) ? value : [value];\n    this.state = { values, filesInfo: extractFileInfo(values) };\n  }\n\n  shouldComponentUpdate(nextProps, nextState) {\n    return shouldRender(this, nextProps, nextState);\n  }\n\n  onChange = event => {\n    const { multiple, onChange } = this.props;\n    processFiles(event.target.files).then(filesInfo => {\n      const state = {\n        values: filesInfo.map(fileInfo => fileInfo.dataURL),\n        filesInfo,\n      };\n      this.setState(state, () => {\n        if (multiple) {\n          onChange(state.values);\n        } else {\n          onChange(state.values[0]);\n        }\n      });\n    });\n  };\n\n  render() {\n    const { multiple, id, readonly, disabled, autofocus, options } = this.props;\n    const { filesInfo } = this.state;\n    return (\n      <div>\n        <p>\n          <input\n            ref={ref => (this.inputRef = ref)}\n            id={id}\n            type=\"file\"\n            disabled={readonly || disabled}\n            onChange={this.onChange}\n            defaultValue=\"\"\n            autoFocus={autofocus}\n            multiple={multiple}\n            accept={options.accept}\n          />\n        </p>\n        <FilesInfo filesInfo={filesInfo} />\n      </div>\n    );\n  }\n}\n\nFileWidget.defaultProps = {\n  autofocus: false,\n};\n\nif (process.env.NODE_ENV !== \"production\") {\n  FileWidget.propTypes = {\n    multiple: PropTypes.bool,\n    value: PropTypes.oneOfType([\n      PropTypes.string,\n      PropTypes.arrayOf(PropTypes.string),\n    ]),\n    autofocus: PropTypes.bool,\n  };\n}\n\nexport default FileWidget;\n"]}

package/lib/components/widgets/HiddenWidget.js

@@ -0,0 +1,25 @@
+import React from "react";
+import PropTypes from "prop-types";
+
+function HiddenWidget(_ref) {
+  var id = _ref.id,
+      value = _ref.value;
+  return (
+    /*#__PURE__*/
+    React.createElement("input", {
+      type: "hidden",
+      id: id,
+      value: typeof value === "undefined" ? "" : value
+    })
+  );
+}
+
+if (process.env.NODE_ENV !== "production") {
+  HiddenWidget.propTypes = {
+    id: PropTypes.string.isRequired,
+    value: PropTypes.oneOfType([PropTypes.string, PropTypes.number, PropTypes.bool])
+  };
+}
+
+export default HiddenWidget;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb21wb25lbnRzL3dpZGdldHMvSGlkZGVuV2lkZ2V0LmpzIl0sIm5hbWVzIjpbIlJlYWN0IiwiUHJvcFR5cGVzIiwiSGlkZGVuV2lkZ2V0IiwiaWQiLCJ2YWx1ZSIsInByb2Nlc3MiLCJlbnYiLCJOT0RFX0VOViIsInByb3BUeXBlcyIsInN0cmluZyIsImlzUmVxdWlyZWQiLCJvbmVPZlR5cGUiLCJudW1iZXIiLCJib29sIl0sIm1hcHBpbmdzIjoiQUFBQSxPQUFPQSxLQUFQLE1BQWtCLE9BQWxCO0FBQ0EsT0FBT0MsU0FBUCxNQUFzQixZQUF0Qjs7QUFFQSxTQUFTQyxZQUFULE9BQXFDO0FBQUEsTUFBYkMsRUFBYSxRQUFiQSxFQUFhO0FBQUEsTUFBVEMsS0FBUyxRQUFUQSxLQUFTO0FBQ25DO0FBQUE7QUFDRTtBQUNFLE1BQUEsSUFBSSxFQUFDLFFBRFA7QUFFRSxNQUFBLEVBQUUsRUFBRUQsRUFGTjtBQUdFLE1BQUEsS0FBSyxFQUFFLE9BQU9DLEtBQVAsS0FBaUIsV0FBakIsR0FBK0IsRUFBL0IsR0FBb0NBO0FBSDdDO0FBREY7QUFPRDs7QUFFRCxJQUFJQyxPQUFPLENBQUNDLEdBQVIsQ0FBWUMsUUFBWixLQUF5QixZQUE3QixFQUEyQztBQUN6Q0wsRUFBQUEsWUFBWSxDQUFDTSxTQUFiLEdBQXlCO0FBQ3ZCTCxJQUFBQSxFQUFFLEVBQUVGLFNBQVMsQ0FBQ1EsTUFBVixDQUFpQkMsVUFERTtBQUV2Qk4sSUFBQUEsS0FBSyxFQUFFSCxTQUFTLENBQUNVLFNBQVYsQ0FBb0IsQ0FDekJWLFNBQVMsQ0FBQ1EsTUFEZSxFQUV6QlIsU0FBUyxDQUFDVyxNQUZlLEVBR3pCWCxTQUFTLENBQUNZLElBSGUsQ0FBcEI7QUFGZ0IsR0FBekI7QUFRRDs7QUFFRCxlQUFlWCxZQUFmIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gXCJyZWFjdFwiO1xuaW1wb3J0IFByb3BUeXBlcyBmcm9tIFwicHJvcC10eXBlc1wiO1xuXG5mdW5jdGlvbiBIaWRkZW5XaWRnZXQoeyBpZCwgdmFsdWUgfSkge1xuICByZXR1cm4gKFxuICAgIDxpbnB1dFxuICAgICAgdHlwZT1cImhpZGRlblwiXG4gICAgICBpZD17aWR9XG4gICAgICB2YWx1ZT17dHlwZW9mIHZhbHVlID09PSBcInVuZGVmaW5lZFwiID8gXCJcIiA6IHZhbHVlfVxuICAgIC8+XG4gICk7XG59XG5cbmlmIChwcm9jZXNzLmVudi5OT0RFX0VOViAhPT0gXCJwcm9kdWN0aW9uXCIpIHtcbiAgSGlkZGVuV2lkZ2V0LnByb3BUeXBlcyA9IHtcbiAgICBpZDogUHJvcFR5cGVzLnN0cmluZy5pc1JlcXVpcmVkLFxuICAgIHZhbHVlOiBQcm9wVHlwZXMub25lT2ZUeXBlKFtcbiAgICAgIFByb3BUeXBlcy5zdHJpbmcsXG4gICAgICBQcm9wVHlwZXMubnVtYmVyLFxuICAgICAgUHJvcFR5cGVzLmJvb2wsXG4gICAgXSksXG4gIH07XG59XG5cbmV4cG9ydCBkZWZhdWx0IEhpZGRlbldpZGdldDtcbiJdfQ==

package/lib/components/widgets/PasswordWidget.js

@@ -0,0 +1,23 @@
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+import React from "react";
+import PropTypes from "prop-types";
+
+function PasswordWidget(props) {
+  var BaseInput = props.registry.widgets.BaseInput;
+  return (
+    /*#__PURE__*/
+    React.createElement(BaseInput, _extends({
+      type: "password"
+    }, props))
+  );
+}
+
+if (process.env.NODE_ENV !== "production") {
+  PasswordWidget.propTypes = {
+    value: PropTypes.string
+  };
+}
+
+export default PasswordWidget;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb21wb25lbnRzL3dpZGdldHMvUGFzc3dvcmRXaWRnZXQuanMiXSwibmFtZXMiOlsiUmVhY3QiLCJQcm9wVHlwZXMiLCJQYXNzd29yZFdpZGdldCIsInByb3BzIiwiQmFzZUlucHV0IiwicmVnaXN0cnkiLCJ3aWRnZXRzIiwicHJvY2VzcyIsImVudiIsIk5PREVfRU5WIiwicHJvcFR5cGVzIiwidmFsdWUiLCJzdHJpbmciXSwibWFwcGluZ3MiOiI7O0FBQUEsT0FBT0EsS0FBUCxNQUFrQixPQUFsQjtBQUNBLE9BQU9DLFNBQVAsTUFBc0IsWUFBdEI7O0FBRUEsU0FBU0MsY0FBVCxDQUF3QkMsS0FBeEIsRUFBK0I7QUFBQSxNQUNyQkMsU0FEcUIsR0FDUEQsS0FBSyxDQUFDRSxRQUFOLENBQWVDLE9BRFIsQ0FDckJGLFNBRHFCO0FBRTdCO0FBQUE7QUFBTyx3QkFBQyxTQUFEO0FBQVcsTUFBQSxJQUFJLEVBQUM7QUFBaEIsT0FBK0JELEtBQS9CO0FBQVA7QUFDRDs7QUFFRCxJQUFJSSxPQUFPLENBQUNDLEdBQVIsQ0FBWUMsUUFBWixLQUF5QixZQUE3QixFQUEyQztBQUN6Q1AsRUFBQUEsY0FBYyxDQUFDUSxTQUFmLEdBQTJCO0FBQ3pCQyxJQUFBQSxLQUFLLEVBQUVWLFNBQVMsQ0FBQ1c7QUFEUSxHQUEzQjtBQUdEOztBQUVELGVBQWVWLGNBQWYiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgUmVhY3QgZnJvbSBcInJlYWN0XCI7XG5pbXBvcnQgUHJvcFR5cGVzIGZyb20gXCJwcm9wLXR5cGVzXCI7XG5cbmZ1bmN0aW9uIFBhc3N3b3JkV2lkZ2V0KHByb3BzKSB7XG4gIGNvbnN0IHsgQmFzZUlucHV0IH0gPSBwcm9wcy5yZWdpc3RyeS53aWRnZXRzO1xuICByZXR1cm4gPEJhc2VJbnB1dCB0eXBlPVwicGFzc3dvcmRcIiB7Li4ucHJvcHN9IC8+O1xufVxuXG5pZiAocHJvY2Vzcy5lbnYuTk9ERV9FTlYgIT09IFwicHJvZHVjdGlvblwiKSB7XG4gIFBhc3N3b3JkV2lkZ2V0LnByb3BUeXBlcyA9IHtcbiAgICB2YWx1ZTogUHJvcFR5cGVzLnN0cmluZyxcbiAgfTtcbn1cblxuZXhwb3J0IGRlZmF1bHQgUGFzc3dvcmRXaWRnZXQ7XG4iXX0=

package/lib/components/widgets/RadioWidget.js

@@ -0,0 +1,94 @@
+import React from "react";
+import PropTypes from "prop-types";
+
+function RadioWidget(props) {
+  var options = props.options,
+      value = props.value,
+      required = props.required,
+      disabled = props.disabled,
+      readonly = props.readonly,
+      autofocus = props.autofocus,
+      onBlur = props.onBlur,
+      onFocus = props.onFocus,
+      _onChange = props.onChange,
+      id = props.id; // Generating a unique field name to identify this set of radio buttons
+
+  var name = Math.random().toString();
+  var enumOptions = options.enumOptions,
+      enumDisabled = options.enumDisabled,
+      inline = options.inline; // checked={checked} has been moved above name={name}, As mentioned in #349;
+  // this is a temporary fix for radio button rendering bug in React, facebook/react#7630.
+
+  return (
+    /*#__PURE__*/
+    React.createElement("div", {
+      className: "field-radio-group",
+      id: id
+    }, enumOptions.map(function (option, i) {
+      var checked = option.value === value;
+      var itemDisabled = enumDisabled && enumDisabled.indexOf(option.value) != -1;
+      var disabledCls = disabled || itemDisabled || readonly ? "disabled" : "";
+      var radio =
+      /*#__PURE__*/
+      React.createElement("span", null,
+      /*#__PURE__*/
+      React.createElement("input", {
+        type: "radio",
+        checked: checked,
+        name: name,
+        required: required,
+        value: option.value,
+        disabled: disabled || itemDisabled || readonly,
+        autoFocus: autofocus && i === 0,
+        onChange: function onChange(_) {
+          return _onChange(option.value);
+        },
+        onBlur: onBlur && function (event) {
+          return onBlur(id, event.target.value);
+        },
+        onFocus: onFocus && function (event) {
+          return onFocus(id, event.target.value);
+        }
+      }),
+      /*#__PURE__*/
+      React.createElement("span", null, option.label));
+      return inline ?
+      /*#__PURE__*/
+      React.createElement("label", {
+        key: i,
+        className: "radio-inline ".concat(disabledCls)
+      }, radio) :
+      /*#__PURE__*/
+      React.createElement("div", {
+        key: i,
+        className: "radio ".concat(disabledCls)
+      },
+      /*#__PURE__*/
+      React.createElement("label", null, radio));
+    }))
+  );
+}
+
+RadioWidget.defaultProps = {
+  autofocus: false
+};
+
+if (process.env.NODE_ENV !== "production") {
+  RadioWidget.propTypes = {
+    schema: PropTypes.object.isRequired,
+    id: PropTypes.string.isRequired,
+    options: PropTypes.shape({
+      enumOptions: PropTypes.array,
+      inline: PropTypes.bool
+    }).isRequired,
+    value: PropTypes.any,
+    required: PropTypes.bool,
+    disabled: PropTypes.bool,
+    readonly: PropTypes.bool,
+    autofocus: PropTypes.bool,
+    onChange: PropTypes.func
+  };
+}
+
+export default RadioWidget;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/components/widgets/RangeWidget.js

@@ -0,0 +1,34 @@
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+import React from "react";
+import PropTypes from "prop-types";
+import { rangeSpec } from "../../utils";
+
+function RangeWidget(props) {
+  var schema = props.schema,
+      value = props.value,
+      BaseInput = props.registry.widgets.BaseInput;
+  return (
+    /*#__PURE__*/
+    React.createElement("div", {
+      className: "field-range-wrapper"
+    },
+    /*#__PURE__*/
+    React.createElement(BaseInput, _extends({
+      type: "range"
+    }, props, rangeSpec(schema))),
+    /*#__PURE__*/
+    React.createElement("span", {
+      className: "range-view"
+    }, value))
+  );
+}
+
+if (process.env.NODE_ENV !== "production") {
+  RangeWidget.propTypes = {
+    value: PropTypes.oneOfType([PropTypes.string, PropTypes.number])
+  };
+}
+
+export default RangeWidget;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/components/widgets/SelectWidget.js

@@ -0,0 +1,138 @@
+import React from "react";
+import PropTypes from "prop-types";
+import { asNumber, guessType } from "../../utils";
+var nums = new Set(["number", "integer"]);
+/**
+ * This is a silly limitation in the DOM where option change event values are
+ * always retrieved as strings.
+ */
+
+function processValue(schema, value) {
+  // "enum" is a reserved word, so only "type" and "items" can be destructured
+  var type = schema.type,
+      items = schema.items;
+
+  if (value === "") {
+    return undefined;
+  } else if (type === "array" && items && nums.has(items.type)) {
+    return value.map(asNumber);
+  } else if (type === "boolean") {
+    return value === "true";
+  } else if (type === "number") {
+    return asNumber(value);
+  } // If type is undefined, but an enum is present, try and infer the type from
+  // the enum values
+
+
+  if (schema["enum"]) {
+    if (schema["enum"].every(function (x) {
+      return guessType(x) === "number";
+    })) {
+      return asNumber(value);
+    } else if (schema["enum"].every(function (x) {
+      return guessType(x) === "boolean";
+    })) {
+      return value === "true";
+    }
+  }
+
+  return value;
+}
+
+function getValue(event, multiple) {
+  if (multiple) {
+    return [].slice.call(event.target.options).filter(function (o) {
+      return o.selected;
+    }).map(function (o) {
+      return o.value;
+    });
+  } else {
+    return event.target.value;
+  }
+}
+
+function SelectWidget(props) {
+  var schema = props.schema,
+      id = props.id,
+      options = props.options,
+      value = props.value,
+      required = props.required,
+      disabled = props.disabled,
+      readonly = props.readonly,
+      multiple = props.multiple,
+      autofocus = props.autofocus,
+      _onChange = props.onChange,
+      onBlur = props.onBlur,
+      onFocus = props.onFocus,
+      placeholder = props.placeholder;
+  var enumOptions = options.enumOptions,
+      enumDisabled = options.enumDisabled;
+  var emptyValue = multiple ? [] : "";
+  return (
+    /*#__PURE__*/
+    React.createElement("select", {
+      id: id,
+      multiple: multiple,
+      className: "form-control",
+      value: typeof value === "undefined" ? emptyValue : value,
+      required: required,
+      disabled: disabled || readonly,
+      autoFocus: autofocus,
+      onBlur: onBlur && function (event) {
+        var newValue = getValue(event, multiple);
+        onBlur(id, processValue(schema, newValue));
+      },
+      onFocus: onFocus && function (event) {
+        var newValue = getValue(event, multiple);
+        onFocus(id, processValue(schema, newValue));
+      },
+      onChange: function onChange(event) {
+        var newValue = getValue(event, multiple);
+
+        _onChange(processValue(schema, newValue));
+      }
+    }, !multiple && schema["default"] === undefined &&
+    /*#__PURE__*/
+    React.createElement("option", {
+      value: ""
+    }, placeholder), enumOptions.map(function (_ref, i) {
+      var value = _ref.value,
+          label = _ref.label;
+      var disabled = enumDisabled && enumDisabled.indexOf(value) != -1;
+      return (
+        /*#__PURE__*/
+        React.createElement("option", {
+          key: i,
+          value: value,
+          disabled: disabled
+        }, label)
+      );
+    }))
+  );
+}
+
+SelectWidget.defaultProps = {
+  autofocus: false
+};
+
+if (process.env.NODE_ENV !== "production") {
+  SelectWidget.propTypes = {
+    schema: PropTypes.object.isRequired,
+    id: PropTypes.string.isRequired,
+    options: PropTypes.shape({
+      enumOptions: PropTypes.array
+    }).isRequired,
+    value: PropTypes.any,
+    required: PropTypes.bool,
+    disabled: PropTypes.bool,
+    readonly: PropTypes.bool,
+    multiple: PropTypes.bool,
+    autofocus: PropTypes.bool,
+    onChange: PropTypes.func,
+    onBlur: PropTypes.func,
+    onFocus: PropTypes.func
+  };
+}
+
+export default SelectWidget;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/components/widgets/SelectWidget.js"],"names":["React","PropTypes","asNumber","guessType","nums","Set","processValue","schema","value","type","items","undefined","has","map","every","x","getValue","event","multiple","slice","call","target","options","filter","o","selected","SelectWidget","props","id","required","disabled","readonly","autofocus","onChange","onBlur","onFocus","placeholder","enumOptions","enumDisabled","emptyValue","newValue","i","label","indexOf","defaultProps","process","env","NODE_ENV","propTypes","object","isRequired","string","shape","array","any","bool","func"],"mappings":"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","sourcesContent":["import React from \"react\";\nimport PropTypes from \"prop-types\";\n\nimport { asNumber, guessType } from \"../../utils\";\n\nconst nums = new Set([\"number\", \"integer\"]);\n\n/**\n * This is a silly limitation in the DOM where option change event values are\n * always retrieved as strings.\n */\nfunction processValue(schema, value) {\n  // \"enum\" is a reserved word, so only \"type\" and \"items\" can be destructured\n  const { type, items } = schema;\n  if (value === \"\") {\n    return undefined;\n  } else if (type === \"array\" && items && nums.has(items.type)) {\n    return value.map(asNumber);\n  } else if (type === \"boolean\") {\n    return value === \"true\";\n  } else if (type === \"number\") {\n    return asNumber(value);\n  }\n\n  // If type is undefined, but an enum is present, try and infer the type from\n  // the enum values\n  if (schema.enum) {\n    if (schema.enum.every(x => guessType(x) === \"number\")) {\n      return asNumber(value);\n    } else if (schema.enum.every(x => guessType(x) === \"boolean\")) {\n      return value === \"true\";\n    }\n  }\n\n  return value;\n}\n\nfunction getValue(event, multiple) {\n  if (multiple) {\n    return [].slice\n      .call(event.target.options)\n      .filter(o => o.selected)\n      .map(o => o.value);\n  } else {\n    return event.target.value;\n  }\n}\n\nfunction SelectWidget(props) {\n  const {\n    schema,\n    id,\n    options,\n    value,\n    required,\n    disabled,\n    readonly,\n    multiple,\n    autofocus,\n    onChange,\n    onBlur,\n    onFocus,\n    placeholder,\n  } = props;\n  const { enumOptions, enumDisabled } = options;\n  const emptyValue = multiple ? [] : \"\";\n  return (\n    <select\n      id={id}\n      multiple={multiple}\n      className=\"form-control\"\n      value={typeof value === \"undefined\" ? emptyValue : value}\n      required={required}\n      disabled={disabled || readonly}\n      autoFocus={autofocus}\n      onBlur={\n        onBlur &&\n        (event => {\n          const newValue = getValue(event, multiple);\n          onBlur(id, processValue(schema, newValue));\n        })\n      }\n      onFocus={\n        onFocus &&\n        (event => {\n          const newValue = getValue(event, multiple);\n          onFocus(id, processValue(schema, newValue));\n        })\n      }\n      onChange={event => {\n        const newValue = getValue(event, multiple);\n        onChange(processValue(schema, newValue));\n      }}>\n      {!multiple && schema.default === undefined && (\n        <option value=\"\">{placeholder}</option>\n      )}\n      {enumOptions.map(({ value, label }, i) => {\n        const disabled = enumDisabled && enumDisabled.indexOf(value) != -1;\n        return (\n          <option key={i} value={value} disabled={disabled}>\n            {label}\n          </option>\n        );\n      })}\n    </select>\n  );\n}\n\nSelectWidget.defaultProps = {\n  autofocus: false,\n};\n\nif (process.env.NODE_ENV !== \"production\") {\n  SelectWidget.propTypes = {\n    schema: PropTypes.object.isRequired,\n    id: PropTypes.string.isRequired,\n    options: PropTypes.shape({\n      enumOptions: PropTypes.array,\n    }).isRequired,\n    value: PropTypes.any,\n    required: PropTypes.bool,\n    disabled: PropTypes.bool,\n    readonly: PropTypes.bool,\n    multiple: PropTypes.bool,\n    autofocus: PropTypes.bool,\n    onChange: PropTypes.func,\n    onBlur: PropTypes.func,\n    onFocus: PropTypes.func,\n  };\n}\n\nexport default SelectWidget;\n"]}

package/lib/components/widgets/SubmitButton.js

@@ -0,0 +1,24 @@
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+import React from "react";
+import { getSubmitButtonOptions } from ".././../utils";
+export default function SubmitButton(_ref) {
+  var uiSchema = _ref.uiSchema;
+
+  var _getSubmitButtonOptio = getSubmitButtonOptions(uiSchema),
+      submitText = _getSubmitButtonOptio.submitText,
+      norender = _getSubmitButtonOptio.norender,
+      submitButtonProps = _getSubmitButtonOptio.props;
+
+  return (
+    /*#__PURE__*/
+    React.createElement("div", null, !norender &&
+    /*#__PURE__*/
+    React.createElement("button", _extends({
+      type: "submit"
+    }, submitButtonProps, {
+      className: "btn btn-info"
+    }), submitText))
+  );
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb21wb25lbnRzL3dpZGdldHMvU3VibWl0QnV0dG9uLmpzIl0sIm5hbWVzIjpbIlJlYWN0IiwiZ2V0U3VibWl0QnV0dG9uT3B0aW9ucyIsIlN1Ym1pdEJ1dHRvbiIsInVpU2NoZW1hIiwic3VibWl0VGV4dCIsIm5vcmVuZGVyIiwic3VibWl0QnV0dG9uUHJvcHMiLCJwcm9wcyJdLCJtYXBwaW5ncyI6Ijs7QUFBQSxPQUFPQSxLQUFQLE1BQWtCLE9BQWxCO0FBQ0EsU0FBU0Msc0JBQVQsUUFBdUMsZUFBdkM7QUFFQSxlQUFlLFNBQVNDLFlBQVQsT0FBb0M7QUFBQSxNQUFaQyxRQUFZLFFBQVpBLFFBQVk7O0FBQUEsOEJBSzdDRixzQkFBc0IsQ0FBQ0UsUUFBRCxDQUx1QjtBQUFBLE1BRS9DQyxVQUYrQyx5QkFFL0NBLFVBRitDO0FBQUEsTUFHL0NDLFFBSCtDLHlCQUcvQ0EsUUFIK0M7QUFBQSxNQUl4Q0MsaUJBSndDLHlCQUkvQ0MsS0FKK0M7O0FBTWpEO0FBQUE7QUFDRSxxQ0FDRyxDQUFDRixRQUFEO0FBQUE7QUFDQztBQUFRLE1BQUEsSUFBSSxFQUFDO0FBQWIsT0FBMEJDLGlCQUExQjtBQUE2QyxNQUFBLFNBQVMsRUFBQztBQUF2RCxRQUNHRixVQURILENBRko7QUFERjtBQVNEIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gXCJyZWFjdFwiO1xuaW1wb3J0IHsgZ2V0U3VibWl0QnV0dG9uT3B0aW9ucyB9IGZyb20gXCIuLi8uLy4uL3V0aWxzXCI7XG5cbmV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIFN1Ym1pdEJ1dHRvbih7IHVpU2NoZW1hIH0pIHtcbiAgY29uc3Qge1xuICAgIHN1Ym1pdFRleHQsXG4gICAgbm9yZW5kZXIsXG4gICAgcHJvcHM6IHN1Ym1pdEJ1dHRvblByb3BzLFxuICB9ID0gZ2V0U3VibWl0QnV0dG9uT3B0aW9ucyh1aVNjaGVtYSk7XG4gIHJldHVybiAoXG4gICAgPGRpdj5cbiAgICAgIHshbm9yZW5kZXIgJiYgKFxuICAgICAgICA8YnV0dG9uIHR5cGU9XCJzdWJtaXRcIiB7Li4uc3VibWl0QnV0dG9uUHJvcHN9IGNsYXNzTmFtZT1cImJ0biBidG4taW5mb1wiPlxuICAgICAgICAgIHtzdWJtaXRUZXh0fVxuICAgICAgICA8L2J1dHRvbj5cbiAgICAgICl9XG4gICAgPC9kaXY+XG4gICk7XG59XG4iXX0=

package/lib/components/widgets/TextWidget.js

@@ -0,0 +1,20 @@
+import React from "react";
+import PropTypes from "prop-types";
+
+function TextWidget(props) {
+  var BaseInput = props.registry.widgets.BaseInput;
+  return (
+    /*#__PURE__*/
+    React.createElement(BaseInput, props)
+  );
+}
+
+if (process.env.NODE_ENV !== "production") {
+  TextWidget.propTypes = {
+    value: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
+    id: PropTypes.string
+  };
+}
+
+export default TextWidget;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb21wb25lbnRzL3dpZGdldHMvVGV4dFdpZGdldC5qcyJdLCJuYW1lcyI6WyJSZWFjdCIsIlByb3BUeXBlcyIsIlRleHRXaWRnZXQiLCJwcm9wcyIsIkJhc2VJbnB1dCIsInJlZ2lzdHJ5Iiwid2lkZ2V0cyIsInByb2Nlc3MiLCJlbnYiLCJOT0RFX0VOViIsInByb3BUeXBlcyIsInZhbHVlIiwib25lT2ZUeXBlIiwic3RyaW5nIiwibnVtYmVyIiwiaWQiXSwibWFwcGluZ3MiOiJBQUFBLE9BQU9BLEtBQVAsTUFBa0IsT0FBbEI7QUFDQSxPQUFPQyxTQUFQLE1BQXNCLFlBQXRCOztBQUVBLFNBQVNDLFVBQVQsQ0FBb0JDLEtBQXBCLEVBQTJCO0FBQUEsTUFDakJDLFNBRGlCLEdBQ0hELEtBQUssQ0FBQ0UsUUFBTixDQUFlQyxPQURaLENBQ2pCRixTQURpQjtBQUV6QjtBQUFBO0FBQU8sd0JBQUMsU0FBRCxFQUFlRCxLQUFmO0FBQVA7QUFDRDs7QUFFRCxJQUFJSSxPQUFPLENBQUNDLEdBQVIsQ0FBWUMsUUFBWixLQUF5QixZQUE3QixFQUEyQztBQUN6Q1AsRUFBQUEsVUFBVSxDQUFDUSxTQUFYLEdBQXVCO0FBQ3JCQyxJQUFBQSxLQUFLLEVBQUVWLFNBQVMsQ0FBQ1csU0FBVixDQUFvQixDQUFDWCxTQUFTLENBQUNZLE1BQVgsRUFBbUJaLFNBQVMsQ0FBQ2EsTUFBN0IsQ0FBcEIsQ0FEYztBQUVyQkMsSUFBQUEsRUFBRSxFQUFFZCxTQUFTLENBQUNZO0FBRk8sR0FBdkI7QUFJRDs7QUFFRCxlQUFlWCxVQUFmIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gXCJyZWFjdFwiO1xuaW1wb3J0IFByb3BUeXBlcyBmcm9tIFwicHJvcC10eXBlc1wiO1xuXG5mdW5jdGlvbiBUZXh0V2lkZ2V0KHByb3BzKSB7XG4gIGNvbnN0IHsgQmFzZUlucHV0IH0gPSBwcm9wcy5yZWdpc3RyeS53aWRnZXRzO1xuICByZXR1cm4gPEJhc2VJbnB1dCB7Li4ucHJvcHN9IC8+O1xufVxuXG5pZiAocHJvY2Vzcy5lbnYuTk9ERV9FTlYgIT09IFwicHJvZHVjdGlvblwiKSB7XG4gIFRleHRXaWRnZXQucHJvcFR5cGVzID0ge1xuICAgIHZhbHVlOiBQcm9wVHlwZXMub25lT2ZUeXBlKFtQcm9wVHlwZXMuc3RyaW5nLCBQcm9wVHlwZXMubnVtYmVyXSksXG4gICAgaWQ6IFByb3BUeXBlcy5zdHJpbmcsXG4gIH07XG59XG5cbmV4cG9ydCBkZWZhdWx0IFRleHRXaWRnZXQ7XG4iXX0=