@rjsf/core 3.0.1 → 3.2.1

package/dist/cjs/components/fields/ArrayField.js

@@ -0,0 +1,854 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _AddButton = _interopRequireDefault(require("../AddButton"));
+
+var _IconButton = _interopRequireDefault(require("../IconButton"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _includes = _interopRequireDefault(require("core-js-pure/es/array/includes"));
+
+var types = _interopRequireWildcard(require("../../types"));
+
+var _utils = require("../../utils");
+
+var _nanoid = require("nanoid");
+
+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 _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+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 _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
+
+function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
+
+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; }
+
+function ArrayFieldTitle(_ref) {
+  var TitleField = _ref.TitleField,
+      idSchema = _ref.idSchema,
+      title = _ref.title,
+      required = _ref.required;
+
+  if (!title) {
+    return null;
+  }
+
+  var id = "".concat(idSchema.$id, "__title");
+  return _react["default"].createElement(TitleField, {
+    id: id,
+    title: title,
+    required: required
+  });
+}
+
+function ArrayFieldDescription(_ref2) {
+  var DescriptionField = _ref2.DescriptionField,
+      idSchema = _ref2.idSchema,
+      description = _ref2.description;
+
+  if (!description) {
+    return null;
+  }
+
+  var id = "".concat(idSchema.$id, "__description");
+  return _react["default"].createElement(DescriptionField, {
+    id: id,
+    description: description
+  });
+} // Used in the two templates
+
+
+function DefaultArrayItem(props) {
+  var btnStyle = {
+    flex: 1,
+    paddingLeft: 6,
+    paddingRight: 6,
+    fontWeight: "bold"
+  };
+  return _react["default"].createElement("div", {
+    key: props.key,
+    className: props.className
+  }, _react["default"].createElement("div", {
+    className: props.hasToolbar ? "col-xs-9" : "col-xs-12"
+  }, props.children), props.hasToolbar && _react["default"].createElement("div", {
+    className: "col-xs-3 array-item-toolbox"
+  }, _react["default"].createElement("div", {
+    className: "btn-group",
+    style: {
+      display: "flex",
+      justifyContent: "space-around"
+    }
+  }, (props.hasMoveUp || props.hasMoveDown) && _react["default"].createElement(_IconButton["default"], {
+    icon: "arrow-up",
+    "aria-label": "Move up",
+    className: "array-item-move-up",
+    tabIndex: "-1",
+    style: btnStyle,
+    disabled: props.disabled || props.readonly || !props.hasMoveUp,
+    onClick: props.onReorderClick(props.index, props.index - 1)
+  }), (props.hasMoveUp || props.hasMoveDown) && _react["default"].createElement(_IconButton["default"], {
+    icon: "arrow-down",
+    className: "array-item-move-down",
+    "aria-label": "Move down",
+    tabIndex: "-1",
+    style: btnStyle,
+    disabled: props.disabled || props.readonly || !props.hasMoveDown,
+    onClick: props.onReorderClick(props.index, props.index + 1)
+  }), props.hasRemove && _react["default"].createElement(_IconButton["default"], {
+    type: "danger",
+    icon: "remove",
+    "aria-label": "Remove",
+    className: "array-item-remove",
+    tabIndex: "-1",
+    style: btnStyle,
+    disabled: props.disabled || props.readonly,
+    onClick: props.onDropIndexClick(props.index)
+  }))));
+}
+
+function DefaultFixedArrayFieldTemplate(props) {
+  return _react["default"].createElement("fieldset", {
+    className: props.className,
+    id: props.idSchema.$id
+  }, _react["default"].createElement(ArrayFieldTitle, {
+    key: "array-field-title-".concat(props.idSchema.$id),
+    TitleField: props.TitleField,
+    idSchema: props.idSchema,
+    title: props.uiSchema["ui:title"] || props.title,
+    required: props.required
+  }), (props.uiSchema["ui:description"] || props.schema.description) && _react["default"].createElement("div", {
+    className: "field-description",
+    key: "field-description-".concat(props.idSchema.$id)
+  }, props.uiSchema["ui:description"] || props.schema.description), _react["default"].createElement("div", {
+    className: "row array-item-list",
+    key: "array-item-list-".concat(props.idSchema.$id)
+  }, props.items && props.items.map(DefaultArrayItem)), props.canAdd && _react["default"].createElement(_AddButton["default"], {
+    className: "array-item-add",
+    onClick: props.onAddClick,
+    disabled: props.disabled || props.readonly
+  }));
+}
+
+function DefaultNormalArrayFieldTemplate(props) {
+  return _react["default"].createElement("fieldset", {
+    className: props.className,
+    id: props.idSchema.$id
+  }, _react["default"].createElement(ArrayFieldTitle, {
+    key: "array-field-title-".concat(props.idSchema.$id),
+    TitleField: props.TitleField,
+    idSchema: props.idSchema,
+    title: props.uiSchema["ui:title"] || props.title,
+    required: props.required
+  }), (props.uiSchema["ui:description"] || props.schema.description) && _react["default"].createElement(ArrayFieldDescription, {
+    key: "array-field-description-".concat(props.idSchema.$id),
+    DescriptionField: props.DescriptionField,
+    idSchema: props.idSchema,
+    description: props.uiSchema["ui:description"] || props.schema.description
+  }), _react["default"].createElement("div", {
+    className: "row array-item-list",
+    key: "array-item-list-".concat(props.idSchema.$id)
+  }, props.items && props.items.map(function (p) {
+    return DefaultArrayItem(p);
+  })), props.canAdd && _react["default"].createElement(_AddButton["default"], {
+    className: "array-item-add",
+    onClick: props.onAddClick,
+    disabled: props.disabled || props.readonly
+  }));
+}
+
+function generateRowId() {
+  return (0, _nanoid.nanoid)();
+}
+
+function generateKeyedFormData(formData) {
+  return !Array.isArray(formData) ? [] : formData.map(function (item) {
+    return {
+      key: generateRowId(),
+      item: item
+    };
+  });
+}
+
+function keyedToPlainFormData(keyedFormData) {
+  return keyedFormData.map(function (keyedItem) {
+    return keyedItem.item;
+  });
+}
+
+var ArrayField =
+/*#__PURE__*/
+function (_Component) {
+  _inherits(ArrayField, _Component);
+
+  function ArrayField(props) {
+    var _this;
+
+    _classCallCheck(this, ArrayField);
+
+    _this = _possibleConstructorReturn(this, _getPrototypeOf(ArrayField).call(this, props));
+
+    _defineProperty(_assertThisInitialized(_this), "_getNewFormDataRow", function () {
+      var _this$props = _this.props,
+          schema = _this$props.schema,
+          _this$props$registry = _this$props.registry,
+          registry = _this$props$registry === void 0 ? (0, _utils.getDefaultRegistry)() : _this$props$registry;
+      var rootSchema = registry.rootSchema;
+      var itemSchema = schema.items;
+
+      if ((0, _utils.isFixedItems)(schema) && (0, _utils.allowAdditionalItems)(schema)) {
+        itemSchema = schema.additionalItems;
+      }
+
+      return (0, _utils.getDefaultFormState)(itemSchema, undefined, rootSchema);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "onAddClick", function (event) {
+      if (event) {
+        event.preventDefault();
+      }
+
+      var onChange = _this.props.onChange;
+      var newKeyedFormDataRow = {
+        key: generateRowId(),
+        item: _this._getNewFormDataRow()
+      };
+      var newKeyedFormData = [].concat(_toConsumableArray(_this.state.keyedFormData), [newKeyedFormDataRow]);
+
+      _this.setState({
+        keyedFormData: newKeyedFormData,
+        updatedKeyedFormData: true
+      }, function () {
+        return onChange(keyedToPlainFormData(newKeyedFormData));
+      });
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "onAddIndexClick", function (index) {
+      return function (event) {
+        if (event) {
+          event.preventDefault();
+        }
+
+        var onChange = _this.props.onChange;
+        var newKeyedFormDataRow = {
+          key: generateRowId(),
+          item: _this._getNewFormDataRow()
+        };
+
+        var newKeyedFormData = _toConsumableArray(_this.state.keyedFormData);
+
+        newKeyedFormData.splice(index, 0, newKeyedFormDataRow);
+
+        _this.setState({
+          keyedFormData: newKeyedFormData,
+          updatedKeyedFormData: true
+        }, function () {
+          return onChange(keyedToPlainFormData(newKeyedFormData));
+        });
+      };
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "onDropIndexClick", function (index) {
+      return function (event) {
+        if (event) {
+          event.preventDefault();
+        }
+
+        var onChange = _this.props.onChange;
+        var keyedFormData = _this.state.keyedFormData; // refs #195: revalidate to ensure properly reindexing errors
+
+        var newErrorSchema;
+
+        if (_this.props.errorSchema) {
+          newErrorSchema = {};
+          var errorSchema = _this.props.errorSchema;
+
+          for (var i in errorSchema) {
+            i = parseInt(i);
+
+            if (i < index) {
+              newErrorSchema[i] = errorSchema[i];
+            } else if (i > index) {
+              newErrorSchema[i - 1] = errorSchema[i];
+            }
+          }
+        }
+
+        var newKeyedFormData = keyedFormData.filter(function (_, i) {
+          return i !== index;
+        });
+
+        _this.setState({
+          keyedFormData: newKeyedFormData,
+          updatedKeyedFormData: true
+        }, function () {
+          return onChange(keyedToPlainFormData(newKeyedFormData), newErrorSchema);
+        });
+      };
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "onReorderClick", function (index, newIndex) {
+      return function (event) {
+        if (event) {
+          event.preventDefault();
+          event.target.blur();
+        }
+
+        var onChange = _this.props.onChange;
+        var newErrorSchema;
+
+        if (_this.props.errorSchema) {
+          newErrorSchema = {};
+          var errorSchema = _this.props.errorSchema;
+
+          for (var i in errorSchema) {
+            if (i == index) {
+              newErrorSchema[newIndex] = errorSchema[index];
+            } else if (i == newIndex) {
+              newErrorSchema[index] = errorSchema[newIndex];
+            } else {
+              newErrorSchema[i] = errorSchema[i];
+            }
+          }
+        }
+
+        var keyedFormData = _this.state.keyedFormData;
+
+        function reOrderArray() {
+          // Copy item
+          var _newKeyedFormData = keyedFormData.slice(); // Moves item from index to newIndex
+
+
+          _newKeyedFormData.splice(index, 1);
+
+          _newKeyedFormData.splice(newIndex, 0, keyedFormData[index]);
+
+          return _newKeyedFormData;
+        }
+
+        var newKeyedFormData = reOrderArray();
+
+        _this.setState({
+          keyedFormData: newKeyedFormData
+        }, function () {
+          return onChange(keyedToPlainFormData(newKeyedFormData), newErrorSchema);
+        });
+      };
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "onChangeForIndex", function (index) {
+      return function (value, errorSchema) {
+        var _this$props2 = _this.props,
+            formData = _this$props2.formData,
+            onChange = _this$props2.onChange;
+        var newFormData = formData.map(function (item, i) {
+          // We need to treat undefined items as nulls to have validation.
+          // See https://github.com/tdegrunt/jsonschema/issues/206
+          var jsonValue = typeof value === "undefined" ? null : value;
+          return index === i ? jsonValue : item;
+        });
+        onChange(newFormData, errorSchema && _this.props.errorSchema && _objectSpread({}, _this.props.errorSchema, _defineProperty({}, index, errorSchema)));
+      };
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "onSelectChange", function (value) {
+      _this.props.onChange(value);
+    });
+
+    var _formData = props.formData;
+
+    var _keyedFormData = generateKeyedFormData(_formData);
+
+    _this.state = {
+      keyedFormData: _keyedFormData,
+      updatedKeyedFormData: false
+    };
+    return _this;
+  }
+
+  _createClass(ArrayField, [{
+    key: "isItemRequired",
+    value: function isItemRequired(itemSchema) {
+      if (Array.isArray(itemSchema.type)) {
+        // While we don't yet support composite/nullable jsonschema types, it's
+        // future-proof to check for requirement against these.
+        return !(0, _includes["default"])(itemSchema.type, "null");
+      } // All non-null array item types are inherently required by design
+
+
+      return itemSchema.type !== "null";
+    }
+  }, {
+    key: "canAddItem",
+    value: function canAddItem(formItems) {
+      var _this$props3 = this.props,
+          schema = _this$props3.schema,
+          uiSchema = _this$props3.uiSchema;
+
+      var _getUiOptions = (0, _utils.getUiOptions)(uiSchema),
+          addable = _getUiOptions.addable;
+
+      if (addable !== false) {
+        // if ui:options.addable was not explicitly set to false, we can add
+        // another item if we have not exceeded maxItems yet
+        if (schema.maxItems !== undefined) {
+          addable = formItems.length < schema.maxItems;
+        } else {
+          addable = true;
+        }
+      }
+
+      return addable;
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props4 = this.props,
+          schema = _this$props4.schema,
+          uiSchema = _this$props4.uiSchema,
+          idSchema = _this$props4.idSchema,
+          _this$props4$registry = _this$props4.registry,
+          registry = _this$props4$registry === void 0 ? (0, _utils.getDefaultRegistry)() : _this$props4$registry;
+      var rootSchema = registry.rootSchema;
+
+      if (!schema.hasOwnProperty("items")) {
+        var fields = registry.fields;
+        var UnsupportedField = fields.UnsupportedField;
+        return _react["default"].createElement(UnsupportedField, {
+          schema: schema,
+          idSchema: idSchema,
+          reason: "Missing items definition"
+        });
+      }
+
+      if ((0, _utils.isFixedItems)(schema)) {
+        return this.renderFixedArray();
+      }
+
+      if ((0, _utils.isFilesArray)(schema, uiSchema, rootSchema)) {
+        return this.renderFiles();
+      }
+
+      if ((0, _utils.isMultiSelect)(schema, rootSchema)) {
+        return this.renderMultiSelect();
+      }
+
+      return this.renderNormalArray();
+    }
+  }, {
+    key: "renderNormalArray",
+    value: function renderNormalArray() {
+      var _this2 = this;
+
+      var _this$props5 = this.props,
+          schema = _this$props5.schema,
+          uiSchema = _this$props5.uiSchema,
+          errorSchema = _this$props5.errorSchema,
+          idSchema = _this$props5.idSchema,
+          name = _this$props5.name,
+          required = _this$props5.required,
+          disabled = _this$props5.disabled,
+          readonly = _this$props5.readonly,
+          autofocus = _this$props5.autofocus,
+          _this$props5$registry = _this$props5.registry,
+          registry = _this$props5$registry === void 0 ? (0, _utils.getDefaultRegistry)() : _this$props5$registry,
+          onBlur = _this$props5.onBlur,
+          onFocus = _this$props5.onFocus,
+          idPrefix = _this$props5.idPrefix,
+          rawErrors = _this$props5.rawErrors;
+      var title = schema.title === undefined ? name : schema.title;
+      var ArrayFieldTemplate = registry.ArrayFieldTemplate,
+          rootSchema = registry.rootSchema,
+          fields = registry.fields,
+          formContext = registry.formContext;
+      var TitleField = fields.TitleField,
+          DescriptionField = fields.DescriptionField;
+      var itemsSchema = (0, _utils.retrieveSchema)(schema.items, rootSchema);
+      var formData = keyedToPlainFormData(this.state.keyedFormData);
+      var arrayProps = {
+        canAdd: this.canAddItem(formData),
+        items: this.state.keyedFormData.map(function (keyedItem, index) {
+          var key = keyedItem.key,
+              item = keyedItem.item;
+          var itemSchema = (0, _utils.retrieveSchema)(schema.items, rootSchema, item);
+          var itemErrorSchema = errorSchema ? errorSchema[index] : undefined;
+          var itemIdPrefix = idSchema.$id + "_" + index;
+          var itemIdSchema = (0, _utils.toIdSchema)(itemSchema, itemIdPrefix, rootSchema, item, idPrefix);
+          return _this2.renderArrayFieldItem({
+            key: key,
+            index: index,
+            canMoveUp: index > 0,
+            canMoveDown: index < formData.length - 1,
+            itemSchema: itemSchema,
+            itemIdSchema: itemIdSchema,
+            itemErrorSchema: itemErrorSchema,
+            itemData: item,
+            itemUiSchema: uiSchema.items,
+            autofocus: autofocus && index === 0,
+            onBlur: onBlur,
+            onFocus: onFocus
+          });
+        }),
+        className: "field field-array field-array-of-".concat(itemsSchema.type),
+        DescriptionField: DescriptionField,
+        disabled: disabled,
+        idSchema: idSchema,
+        uiSchema: uiSchema,
+        onAddClick: this.onAddClick,
+        readonly: readonly,
+        required: required,
+        schema: schema,
+        title: title,
+        TitleField: TitleField,
+        formContext: formContext,
+        formData: formData,
+        rawErrors: rawErrors,
+        registry: registry
+      }; // Check if a custom render function was passed in
+
+      var Component = uiSchema["ui:ArrayFieldTemplate"] || ArrayFieldTemplate || DefaultNormalArrayFieldTemplate;
+      return _react["default"].createElement(Component, arrayProps);
+    }
+  }, {
+    key: "renderMultiSelect",
+    value: function renderMultiSelect() {
+      var _this$props6 = this.props,
+          schema = _this$props6.schema,
+          idSchema = _this$props6.idSchema,
+          uiSchema = _this$props6.uiSchema,
+          formData = _this$props6.formData,
+          disabled = _this$props6.disabled,
+          readonly = _this$props6.readonly,
+          required = _this$props6.required,
+          placeholder = _this$props6.placeholder,
+          autofocus = _this$props6.autofocus,
+          onBlur = _this$props6.onBlur,
+          onFocus = _this$props6.onFocus,
+          _this$props6$registry = _this$props6.registry,
+          registry = _this$props6$registry === void 0 ? (0, _utils.getDefaultRegistry)() : _this$props6$registry,
+          rawErrors = _this$props6.rawErrors,
+          name = _this$props6.name;
+      var items = this.props.formData;
+      var widgets = registry.widgets,
+          rootSchema = registry.rootSchema,
+          formContext = registry.formContext;
+      var itemsSchema = (0, _utils.retrieveSchema)(schema.items, rootSchema, formData);
+      var title = schema.title || name;
+      var enumOptions = (0, _utils.optionsList)(itemsSchema);
+
+      var _getUiOptions$enumOpt = _objectSpread({}, (0, _utils.getUiOptions)(uiSchema), {
+        enumOptions: enumOptions
+      }),
+          _getUiOptions$enumOpt2 = _getUiOptions$enumOpt.widget,
+          widget = _getUiOptions$enumOpt2 === void 0 ? "select" : _getUiOptions$enumOpt2,
+          options = _objectWithoutProperties(_getUiOptions$enumOpt, ["widget"]);
+
+      var Widget = (0, _utils.getWidget)(schema, widget, widgets);
+      return _react["default"].createElement(Widget, {
+        id: idSchema && idSchema.$id,
+        multiple: true,
+        onChange: this.onSelectChange,
+        onBlur: onBlur,
+        onFocus: onFocus,
+        options: options,
+        schema: schema,
+        registry: registry,
+        value: items,
+        disabled: disabled,
+        readonly: readonly,
+        required: required,
+        label: title,
+        placeholder: placeholder,
+        formContext: formContext,
+        autofocus: autofocus,
+        rawErrors: rawErrors
+      });
+    }
+  }, {
+    key: "renderFiles",
+    value: function renderFiles() {
+      var _this$props7 = this.props,
+          schema = _this$props7.schema,
+          uiSchema = _this$props7.uiSchema,
+          idSchema = _this$props7.idSchema,
+          name = _this$props7.name,
+          disabled = _this$props7.disabled,
+          readonly = _this$props7.readonly,
+          autofocus = _this$props7.autofocus,
+          onBlur = _this$props7.onBlur,
+          onFocus = _this$props7.onFocus,
+          _this$props7$registry = _this$props7.registry,
+          registry = _this$props7$registry === void 0 ? (0, _utils.getDefaultRegistry)() : _this$props7$registry,
+          rawErrors = _this$props7.rawErrors;
+      var title = schema.title || name;
+      var items = this.props.formData;
+      var widgets = registry.widgets,
+          formContext = registry.formContext;
+
+      var _getUiOptions2 = (0, _utils.getUiOptions)(uiSchema),
+          _getUiOptions2$widget = _getUiOptions2.widget,
+          widget = _getUiOptions2$widget === void 0 ? "files" : _getUiOptions2$widget,
+          options = _objectWithoutProperties(_getUiOptions2, ["widget"]);
+
+      var Widget = (0, _utils.getWidget)(schema, widget, widgets);
+      return _react["default"].createElement(Widget, {
+        options: options,
+        id: idSchema && idSchema.$id,
+        multiple: true,
+        onChange: this.onSelectChange,
+        onBlur: onBlur,
+        onFocus: onFocus,
+        schema: schema,
+        title: title,
+        value: items,
+        disabled: disabled,
+        readonly: readonly,
+        formContext: formContext,
+        autofocus: autofocus,
+        rawErrors: rawErrors
+      });
+    }
+  }, {
+    key: "renderFixedArray",
+    value: function renderFixedArray() {
+      var _this3 = this;
+
+      var _this$props8 = this.props,
+          schema = _this$props8.schema,
+          uiSchema = _this$props8.uiSchema,
+          formData = _this$props8.formData,
+          errorSchema = _this$props8.errorSchema,
+          idPrefix = _this$props8.idPrefix,
+          idSchema = _this$props8.idSchema,
+          name = _this$props8.name,
+          required = _this$props8.required,
+          disabled = _this$props8.disabled,
+          readonly = _this$props8.readonly,
+          autofocus = _this$props8.autofocus,
+          _this$props8$registry = _this$props8.registry,
+          registry = _this$props8$registry === void 0 ? (0, _utils.getDefaultRegistry)() : _this$props8$registry,
+          onBlur = _this$props8.onBlur,
+          onFocus = _this$props8.onFocus,
+          rawErrors = _this$props8.rawErrors;
+      var title = schema.title || name;
+      var items = this.props.formData;
+      var ArrayFieldTemplate = registry.ArrayFieldTemplate,
+          rootSchema = registry.rootSchema,
+          fields = registry.fields,
+          formContext = registry.formContext;
+      var TitleField = fields.TitleField;
+      var itemSchemas = schema.items.map(function (item, index) {
+        return (0, _utils.retrieveSchema)(item, rootSchema, formData[index]);
+      });
+      var additionalSchema = (0, _utils.allowAdditionalItems)(schema) ? (0, _utils.retrieveSchema)(schema.additionalItems, rootSchema, formData) : null;
+
+      if (!items || items.length < itemSchemas.length) {
+        // to make sure at least all fixed items are generated
+        items = items || [];
+        items = items.concat(new Array(itemSchemas.length - items.length));
+      } // These are the props passed into the render function
+
+
+      var arrayProps = {
+        canAdd: this.canAddItem(items) && additionalSchema,
+        className: "field field-array field-array-fixed-items",
+        disabled: disabled,
+        idSchema: idSchema,
+        formData: formData,
+        items: this.state.keyedFormData.map(function (keyedItem, index) {
+          var key = keyedItem.key,
+              item = keyedItem.item;
+          var additional = index >= itemSchemas.length;
+          var itemSchema = additional ? (0, _utils.retrieveSchema)(schema.additionalItems, rootSchema, item) : itemSchemas[index];
+          var itemIdPrefix = idSchema.$id + "_" + index;
+          var itemIdSchema = (0, _utils.toIdSchema)(itemSchema, itemIdPrefix, rootSchema, item, idPrefix);
+          var itemUiSchema = additional ? uiSchema.additionalItems || {} : Array.isArray(uiSchema.items) ? uiSchema.items[index] : uiSchema.items || {};
+          var itemErrorSchema = errorSchema ? errorSchema[index] : undefined;
+          return _this3.renderArrayFieldItem({
+            key: key,
+            index: index,
+            canRemove: additional,
+            canMoveUp: index >= itemSchemas.length + 1,
+            canMoveDown: additional && index < items.length - 1,
+            itemSchema: itemSchema,
+            itemData: item,
+            itemUiSchema: itemUiSchema,
+            itemIdSchema: itemIdSchema,
+            itemErrorSchema: itemErrorSchema,
+            autofocus: autofocus && index === 0,
+            onBlur: onBlur,
+            onFocus: onFocus
+          });
+        }),
+        onAddClick: this.onAddClick,
+        readonly: readonly,
+        required: required,
+        schema: schema,
+        uiSchema: uiSchema,
+        title: title,
+        TitleField: TitleField,
+        formContext: formContext,
+        rawErrors: rawErrors
+      }; // Check if a custom template template was passed in
+
+      var Template = uiSchema["ui:ArrayFieldTemplate"] || ArrayFieldTemplate || DefaultFixedArrayFieldTemplate;
+      return _react["default"].createElement(Template, arrayProps);
+    }
+  }, {
+    key: "renderArrayFieldItem",
+    value: function renderArrayFieldItem(props) {
+      var key = props.key,
+          index = props.index,
+          _props$canRemove = props.canRemove,
+          canRemove = _props$canRemove === void 0 ? true : _props$canRemove,
+          _props$canMoveUp = props.canMoveUp,
+          canMoveUp = _props$canMoveUp === void 0 ? true : _props$canMoveUp,
+          _props$canMoveDown = props.canMoveDown,
+          canMoveDown = _props$canMoveDown === void 0 ? true : _props$canMoveDown,
+          itemSchema = props.itemSchema,
+          itemData = props.itemData,
+          itemUiSchema = props.itemUiSchema,
+          itemIdSchema = props.itemIdSchema,
+          itemErrorSchema = props.itemErrorSchema,
+          autofocus = props.autofocus,
+          onBlur = props.onBlur,
+          onFocus = props.onFocus,
+          rawErrors = props.rawErrors;
+      var _this$props9 = this.props,
+          disabled = _this$props9.disabled,
+          readonly = _this$props9.readonly,
+          uiSchema = _this$props9.uiSchema,
+          _this$props9$registry = _this$props9.registry,
+          registry = _this$props9$registry === void 0 ? (0, _utils.getDefaultRegistry)() : _this$props9$registry;
+      var SchemaField = registry.fields.SchemaField;
+
+      var _orderable$removable$ = _objectSpread({
+        orderable: true,
+        removable: true
+      }, uiSchema["ui:options"]),
+          orderable = _orderable$removable$.orderable,
+          removable = _orderable$removable$.removable;
+
+      var has = {
+        moveUp: orderable && canMoveUp,
+        moveDown: orderable && canMoveDown,
+        remove: removable && canRemove
+      };
+      has.toolbar = Object.keys(has).some(function (key) {
+        return has[key];
+      });
+      return {
+        children: _react["default"].createElement(SchemaField, {
+          index: index,
+          schema: itemSchema,
+          uiSchema: itemUiSchema,
+          formData: itemData,
+          errorSchema: itemErrorSchema,
+          idSchema: itemIdSchema,
+          required: this.isItemRequired(itemSchema),
+          onChange: this.onChangeForIndex(index),
+          onBlur: onBlur,
+          onFocus: onFocus,
+          registry: this.props.registry,
+          disabled: this.props.disabled,
+          readonly: this.props.readonly,
+          autofocus: autofocus,
+          rawErrors: rawErrors
+        }),
+        className: "array-item",
+        disabled: disabled,
+        hasToolbar: has.toolbar,
+        hasMoveUp: has.moveUp,
+        hasMoveDown: has.moveDown,
+        hasRemove: has.remove,
+        index: index,
+        key: key,
+        onAddIndexClick: this.onAddIndexClick,
+        onDropIndexClick: this.onDropIndexClick,
+        onReorderClick: this.onReorderClick,
+        readonly: readonly
+      };
+    }
+  }, {
+    key: "itemTitle",
+    get: function get() {
+      var schema = this.props.schema;
+      return schema.items.title || schema.items.description || "Item";
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(nextProps, prevState) {
+      // Don't call getDerivedStateFromProps if keyed formdata was just updated.
+      if (prevState.updatedKeyedFormData) {
+        return {
+          updatedKeyedFormData: false
+        };
+      }
+
+      var nextFormData = nextProps.formData || [];
+      var previousKeyedFormData = prevState.keyedFormData || [];
+      var newKeyedFormData = nextFormData.length === previousKeyedFormData.length ? previousKeyedFormData.map(function (previousKeyedFormDatum, index) {
+        return {
+          key: previousKeyedFormDatum.key,
+          item: nextFormData[index]
+        };
+      }) : generateKeyedFormData(nextFormData);
+      return {
+        keyedFormData: newKeyedFormData
+      };
+    }
+  }]);
+
+  return ArrayField;
+}(_react.Component);
+
+_defineProperty(ArrayField, "defaultProps", {
+  uiSchema: {},
+  formData: [],
+  idSchema: {},
+  required: false,
+  disabled: false,
+  readonly: false,
+  autofocus: false
+});
+
+if (process.env.NODE_ENV !== "production") {
+  ArrayField.propTypes = types.fieldProps;
+}
+
+var _default = ArrayField;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/components/fields/ArrayField.js"],"names":["ArrayFieldTitle","TitleField","idSchema","title","required","id","$id","ArrayFieldDescription","DescriptionField","description","DefaultArrayItem","props","btnStyle","flex","paddingLeft","paddingRight","fontWeight","key","className","hasToolbar","children","display","justifyContent","hasMoveUp","hasMoveDown","disabled","readonly","onReorderClick","index","hasRemove","onDropIndexClick","DefaultFixedArrayFieldTemplate","uiSchema","schema","items","map","canAdd","onAddClick","DefaultNormalArrayFieldTemplate","p","generateRowId","generateKeyedFormData","formData","Array","isArray","item","keyedToPlainFormData","keyedFormData","keyedItem","ArrayField","registry","rootSchema","itemSchema","additionalItems","undefined","event","preventDefault","onChange","newKeyedFormDataRow","_getNewFormDataRow","newKeyedFormData","state","setState","updatedKeyedFormData","splice","newErrorSchema","errorSchema","i","parseInt","filter","_","newIndex","target","blur","reOrderArray","_newKeyedFormData","slice","value","newFormData","jsonValue","type","formItems","addable","maxItems","length","hasOwnProperty","fields","UnsupportedField","renderFixedArray","renderFiles","renderMultiSelect","renderNormalArray","name","autofocus","onBlur","onFocus","idPrefix","rawErrors","ArrayFieldTemplate","formContext","itemsSchema","arrayProps","canAddItem","itemErrorSchema","itemIdPrefix","itemIdSchema","renderArrayFieldItem","canMoveUp","canMoveDown","itemData","itemUiSchema","Component","placeholder","widgets","enumOptions","widget","options","Widget","onSelectChange","itemSchemas","additionalSchema","concat","additional","canRemove","Template","SchemaField","orderable","removable","has","moveUp","moveDown","remove","toolbar","Object","keys","some","isItemRequired","onChangeForIndex","onAddIndexClick","nextProps","prevState","nextFormData","previousKeyedFormData","previousKeyedFormDatum","process","env","NODE_ENV","propTypes","types","fieldProps"],"mappings":"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","sourcesContent":["import AddButton from \"../AddButton\";\nimport IconButton from \"../IconButton\";\nimport React, { Component } from \"react\";\nimport includes from \"core-js-pure/es/array/includes\";\nimport * as types from \"../../types\";\n\nimport {\n  getWidget,\n  getDefaultFormState,\n  getUiOptions,\n  isMultiSelect,\n  isFilesArray,\n  isFixedItems,\n  allowAdditionalItems,\n  optionsList,\n  retrieveSchema,\n  toIdSchema,\n  getDefaultRegistry,\n} from \"../../utils\";\nimport { nanoid } from \"nanoid\";\n\nfunction ArrayFieldTitle({ TitleField, idSchema, title, required }) {\n  if (!title) {\n    return null;\n  }\n  const id = `${idSchema.$id}__title`;\n  return <TitleField id={id} title={title} required={required} />;\n}\n\nfunction ArrayFieldDescription({ DescriptionField, idSchema, description }) {\n  if (!description) {\n    return null;\n  }\n  const id = `${idSchema.$id}__description`;\n  return <DescriptionField id={id} description={description} />;\n}\n\n// Used in the two templates\nfunction DefaultArrayItem(props) {\n  const btnStyle = {\n    flex: 1,\n    paddingLeft: 6,\n    paddingRight: 6,\n    fontWeight: \"bold\",\n  };\n  return (\n    <div key={props.key} className={props.className}>\n      <div className={props.hasToolbar ? \"col-xs-9\" : \"col-xs-12\"}>\n        {props.children}\n      </div>\n\n      {props.hasToolbar && (\n        <div className=\"col-xs-3 array-item-toolbox\">\n          <div\n            className=\"btn-group\"\n            style={{\n              display: \"flex\",\n              justifyContent: \"space-around\",\n            }}>\n            {(props.hasMoveUp || props.hasMoveDown) && (\n              <IconButton\n                icon=\"arrow-up\"\n                aria-label=\"Move up\"\n                className=\"array-item-move-up\"\n                tabIndex=\"-1\"\n                style={btnStyle}\n                disabled={props.disabled || props.readonly || !props.hasMoveUp}\n                onClick={props.onReorderClick(props.index, props.index - 1)}\n              />\n            )}\n\n            {(props.hasMoveUp || props.hasMoveDown) && (\n              <IconButton\n                icon=\"arrow-down\"\n                className=\"array-item-move-down\"\n                aria-label=\"Move down\"\n                tabIndex=\"-1\"\n                style={btnStyle}\n                disabled={\n                  props.disabled || props.readonly || !props.hasMoveDown\n                }\n                onClick={props.onReorderClick(props.index, props.index + 1)}\n              />\n            )}\n\n            {props.hasRemove && (\n              <IconButton\n                type=\"danger\"\n                icon=\"remove\"\n                aria-label=\"Remove\"\n                className=\"array-item-remove\"\n                tabIndex=\"-1\"\n                style={btnStyle}\n                disabled={props.disabled || props.readonly}\n                onClick={props.onDropIndexClick(props.index)}\n              />\n            )}\n          </div>\n        </div>\n      )}\n    </div>\n  );\n}\n\nfunction DefaultFixedArrayFieldTemplate(props) {\n  return (\n    <fieldset className={props.className} id={props.idSchema.$id}>\n      <ArrayFieldTitle\n        key={`array-field-title-${props.idSchema.$id}`}\n        TitleField={props.TitleField}\n        idSchema={props.idSchema}\n        title={props.uiSchema[\"ui:title\"] || props.title}\n        required={props.required}\n      />\n\n      {(props.uiSchema[\"ui:description\"] || props.schema.description) && (\n        <div\n          className=\"field-description\"\n          key={`field-description-${props.idSchema.$id}`}>\n          {props.uiSchema[\"ui:description\"] || props.schema.description}\n        </div>\n      )}\n\n      <div\n        className=\"row array-item-list\"\n        key={`array-item-list-${props.idSchema.$id}`}>\n        {props.items && props.items.map(DefaultArrayItem)}\n      </div>\n\n      {props.canAdd && (\n        <AddButton\n          className=\"array-item-add\"\n          onClick={props.onAddClick}\n          disabled={props.disabled || props.readonly}\n        />\n      )}\n    </fieldset>\n  );\n}\n\nfunction DefaultNormalArrayFieldTemplate(props) {\n  return (\n    <fieldset className={props.className} id={props.idSchema.$id}>\n      <ArrayFieldTitle\n        key={`array-field-title-${props.idSchema.$id}`}\n        TitleField={props.TitleField}\n        idSchema={props.idSchema}\n        title={props.uiSchema[\"ui:title\"] || props.title}\n        required={props.required}\n      />\n\n      {(props.uiSchema[\"ui:description\"] || props.schema.description) && (\n        <ArrayFieldDescription\n          key={`array-field-description-${props.idSchema.$id}`}\n          DescriptionField={props.DescriptionField}\n          idSchema={props.idSchema}\n          description={\n            props.uiSchema[\"ui:description\"] || props.schema.description\n          }\n        />\n      )}\n\n      <div\n        className=\"row array-item-list\"\n        key={`array-item-list-${props.idSchema.$id}`}>\n        {props.items && props.items.map(p => DefaultArrayItem(p))}\n      </div>\n\n      {props.canAdd && (\n        <AddButton\n          className=\"array-item-add\"\n          onClick={props.onAddClick}\n          disabled={props.disabled || props.readonly}\n        />\n      )}\n    </fieldset>\n  );\n}\n\nfunction generateRowId() {\n  return nanoid();\n}\n\nfunction generateKeyedFormData(formData) {\n  return !Array.isArray(formData)\n    ? []\n    : formData.map(item => {\n        return {\n          key: generateRowId(),\n          item,\n        };\n      });\n}\n\nfunction keyedToPlainFormData(keyedFormData) {\n  return keyedFormData.map(keyedItem => keyedItem.item);\n}\n\nclass ArrayField extends Component {\n  static defaultProps = {\n    uiSchema: {},\n    formData: [],\n    idSchema: {},\n    required: false,\n    disabled: false,\n    readonly: false,\n    autofocus: false,\n  };\n\n  constructor(props) {\n    super(props);\n    const { formData } = props;\n    const keyedFormData = generateKeyedFormData(formData);\n    this.state = {\n      keyedFormData,\n      updatedKeyedFormData: false,\n    };\n  }\n\n  static getDerivedStateFromProps(nextProps, prevState) {\n    // Don't call getDerivedStateFromProps if keyed formdata was just updated.\n    if (prevState.updatedKeyedFormData) {\n      return {\n        updatedKeyedFormData: false,\n      };\n    }\n    const nextFormData = nextProps.formData || [];\n    const previousKeyedFormData = prevState.keyedFormData || [];\n    const newKeyedFormData =\n      nextFormData.length === previousKeyedFormData.length\n        ? previousKeyedFormData.map((previousKeyedFormDatum, index) => {\n            return {\n              key: previousKeyedFormDatum.key,\n              item: nextFormData[index],\n            };\n          })\n        : generateKeyedFormData(nextFormData);\n    return {\n      keyedFormData: newKeyedFormData,\n    };\n  }\n\n  get itemTitle() {\n    const { schema } = this.props;\n    return schema.items.title || schema.items.description || \"Item\";\n  }\n\n  isItemRequired(itemSchema) {\n    if (Array.isArray(itemSchema.type)) {\n      // While we don't yet support composite/nullable jsonschema types, it's\n      // future-proof to check for requirement against these.\n      return !includes(itemSchema.type, \"null\");\n    }\n    // All non-null array item types are inherently required by design\n    return itemSchema.type !== \"null\";\n  }\n\n  canAddItem(formItems) {\n    const { schema, uiSchema } = this.props;\n    let { addable } = getUiOptions(uiSchema);\n    if (addable !== false) {\n      // if ui:options.addable was not explicitly set to false, we can add\n      // another item if we have not exceeded maxItems yet\n      if (schema.maxItems !== undefined) {\n        addable = formItems.length < schema.maxItems;\n      } else {\n        addable = true;\n      }\n    }\n    return addable;\n  }\n\n  _getNewFormDataRow = () => {\n    const { schema, registry = getDefaultRegistry() } = this.props;\n    const { rootSchema } = registry;\n    let itemSchema = schema.items;\n    if (isFixedItems(schema) && allowAdditionalItems(schema)) {\n      itemSchema = schema.additionalItems;\n    }\n    return getDefaultFormState(itemSchema, undefined, rootSchema);\n  };\n\n  onAddClick = event => {\n    if (event) {\n      event.preventDefault();\n    }\n\n    const { onChange } = this.props;\n    const newKeyedFormDataRow = {\n      key: generateRowId(),\n      item: this._getNewFormDataRow(),\n    };\n    const newKeyedFormData = [...this.state.keyedFormData, newKeyedFormDataRow];\n    this.setState(\n      {\n        keyedFormData: newKeyedFormData,\n        updatedKeyedFormData: true,\n      },\n      () => onChange(keyedToPlainFormData(newKeyedFormData))\n    );\n  };\n\n  onAddIndexClick = index => {\n    return event => {\n      if (event) {\n        event.preventDefault();\n      }\n      const { onChange } = this.props;\n      const newKeyedFormDataRow = {\n        key: generateRowId(),\n        item: this._getNewFormDataRow(),\n      };\n      let newKeyedFormData = [...this.state.keyedFormData];\n      newKeyedFormData.splice(index, 0, newKeyedFormDataRow);\n\n      this.setState(\n        {\n          keyedFormData: newKeyedFormData,\n          updatedKeyedFormData: true,\n        },\n        () => onChange(keyedToPlainFormData(newKeyedFormData))\n      );\n    };\n  };\n\n  onDropIndexClick = index => {\n    return event => {\n      if (event) {\n        event.preventDefault();\n      }\n      const { onChange } = this.props;\n      const { keyedFormData } = this.state;\n      // refs #195: revalidate to ensure properly reindexing errors\n      let newErrorSchema;\n      if (this.props.errorSchema) {\n        newErrorSchema = {};\n        const errorSchema = this.props.errorSchema;\n        for (let i in errorSchema) {\n          i = parseInt(i);\n          if (i < index) {\n            newErrorSchema[i] = errorSchema[i];\n          } else if (i > index) {\n            newErrorSchema[i - 1] = errorSchema[i];\n          }\n        }\n      }\n      const newKeyedFormData = keyedFormData.filter((_, i) => i !== index);\n      this.setState(\n        {\n          keyedFormData: newKeyedFormData,\n          updatedKeyedFormData: true,\n        },\n        () => onChange(keyedToPlainFormData(newKeyedFormData), newErrorSchema)\n      );\n    };\n  };\n\n  onReorderClick = (index, newIndex) => {\n    return event => {\n      if (event) {\n        event.preventDefault();\n        event.target.blur();\n      }\n      const { onChange } = this.props;\n      let newErrorSchema;\n      if (this.props.errorSchema) {\n        newErrorSchema = {};\n        const errorSchema = this.props.errorSchema;\n        for (let i in errorSchema) {\n          if (i == index) {\n            newErrorSchema[newIndex] = errorSchema[index];\n          } else if (i == newIndex) {\n            newErrorSchema[index] = errorSchema[newIndex];\n          } else {\n            newErrorSchema[i] = errorSchema[i];\n          }\n        }\n      }\n\n      const { keyedFormData } = this.state;\n      function reOrderArray() {\n        // Copy item\n        let _newKeyedFormData = keyedFormData.slice();\n\n        // Moves item from index to newIndex\n        _newKeyedFormData.splice(index, 1);\n        _newKeyedFormData.splice(newIndex, 0, keyedFormData[index]);\n\n        return _newKeyedFormData;\n      }\n      const newKeyedFormData = reOrderArray();\n      this.setState(\n        {\n          keyedFormData: newKeyedFormData,\n        },\n        () => onChange(keyedToPlainFormData(newKeyedFormData), newErrorSchema)\n      );\n    };\n  };\n\n  onChangeForIndex = index => {\n    return (value, errorSchema) => {\n      const { formData, onChange } = this.props;\n      const newFormData = formData.map((item, i) => {\n        // We need to treat undefined items as nulls to have validation.\n        // See https://github.com/tdegrunt/jsonschema/issues/206\n        const jsonValue = typeof value === \"undefined\" ? null : value;\n        return index === i ? jsonValue : item;\n      });\n      onChange(\n        newFormData,\n        errorSchema &&\n          this.props.errorSchema && {\n            ...this.props.errorSchema,\n            [index]: errorSchema,\n          }\n      );\n    };\n  };\n\n  onSelectChange = value => {\n    this.props.onChange(value);\n  };\n\n  render() {\n    const {\n      schema,\n      uiSchema,\n      idSchema,\n      registry = getDefaultRegistry(),\n    } = this.props;\n    const { rootSchema } = registry;\n    if (!schema.hasOwnProperty(\"items\")) {\n      const { fields } = registry;\n      const { UnsupportedField } = fields;\n\n      return (\n        <UnsupportedField\n          schema={schema}\n          idSchema={idSchema}\n          reason=\"Missing items definition\"\n        />\n      );\n    }\n    if (isFixedItems(schema)) {\n      return this.renderFixedArray();\n    }\n    if (isFilesArray(schema, uiSchema, rootSchema)) {\n      return this.renderFiles();\n    }\n    if (isMultiSelect(schema, rootSchema)) {\n      return this.renderMultiSelect();\n    }\n    return this.renderNormalArray();\n  }\n\n  renderNormalArray() {\n    const {\n      schema,\n      uiSchema,\n      errorSchema,\n      idSchema,\n      name,\n      required,\n      disabled,\n      readonly,\n      autofocus,\n      registry = getDefaultRegistry(),\n      onBlur,\n      onFocus,\n      idPrefix,\n      rawErrors,\n    } = this.props;\n    const title = schema.title === undefined ? name : schema.title;\n    const { ArrayFieldTemplate, rootSchema, fields, formContext } = registry;\n    const { TitleField, DescriptionField } = fields;\n    const itemsSchema = retrieveSchema(schema.items, rootSchema);\n    const formData = keyedToPlainFormData(this.state.keyedFormData);\n    const arrayProps = {\n      canAdd: this.canAddItem(formData),\n      items: this.state.keyedFormData.map((keyedItem, index) => {\n        const { key, item } = keyedItem;\n        const itemSchema = retrieveSchema(schema.items, rootSchema, item);\n        const itemErrorSchema = errorSchema ? errorSchema[index] : undefined;\n        const itemIdPrefix = idSchema.$id + \"_\" + index;\n        const itemIdSchema = toIdSchema(\n          itemSchema,\n          itemIdPrefix,\n          rootSchema,\n          item,\n          idPrefix\n        );\n        return this.renderArrayFieldItem({\n          key,\n          index,\n          canMoveUp: index > 0,\n          canMoveDown: index < formData.length - 1,\n          itemSchema: itemSchema,\n          itemIdSchema,\n          itemErrorSchema,\n          itemData: item,\n          itemUiSchema: uiSchema.items,\n          autofocus: autofocus && index === 0,\n          onBlur,\n          onFocus,\n        });\n      }),\n      className: `field field-array field-array-of-${itemsSchema.type}`,\n      DescriptionField,\n      disabled,\n      idSchema,\n      uiSchema,\n      onAddClick: this.onAddClick,\n      readonly,\n      required,\n      schema,\n      title,\n      TitleField,\n      formContext,\n      formData,\n      rawErrors,\n      registry,\n    };\n\n    // Check if a custom render function was passed in\n    const Component =\n      uiSchema[\"ui:ArrayFieldTemplate\"] ||\n      ArrayFieldTemplate ||\n      DefaultNormalArrayFieldTemplate;\n    return <Component {...arrayProps} />;\n  }\n\n  renderMultiSelect() {\n    const {\n      schema,\n      idSchema,\n      uiSchema,\n      formData,\n      disabled,\n      readonly,\n      required,\n      placeholder,\n      autofocus,\n      onBlur,\n      onFocus,\n      registry = getDefaultRegistry(),\n      rawErrors,\n      name,\n    } = this.props;\n    const items = this.props.formData;\n    const { widgets, rootSchema, formContext } = registry;\n    const itemsSchema = retrieveSchema(schema.items, rootSchema, formData);\n    const title = schema.title || name;\n    const enumOptions = optionsList(itemsSchema);\n    const { widget = \"select\", ...options } = {\n      ...getUiOptions(uiSchema),\n      enumOptions,\n    };\n    const Widget = getWidget(schema, widget, widgets);\n    return (\n      <Widget\n        id={idSchema && idSchema.$id}\n        multiple\n        onChange={this.onSelectChange}\n        onBlur={onBlur}\n        onFocus={onFocus}\n        options={options}\n        schema={schema}\n        registry={registry}\n        value={items}\n        disabled={disabled}\n        readonly={readonly}\n        required={required}\n        label={title}\n        placeholder={placeholder}\n        formContext={formContext}\n        autofocus={autofocus}\n        rawErrors={rawErrors}\n      />\n    );\n  }\n\n  renderFiles() {\n    const {\n      schema,\n      uiSchema,\n      idSchema,\n      name,\n      disabled,\n      readonly,\n      autofocus,\n      onBlur,\n      onFocus,\n      registry = getDefaultRegistry(),\n      rawErrors,\n    } = this.props;\n    const title = schema.title || name;\n    const items = this.props.formData;\n    const { widgets, formContext } = registry;\n    const { widget = \"files\", ...options } = getUiOptions(uiSchema);\n    const Widget = getWidget(schema, widget, widgets);\n    return (\n      <Widget\n        options={options}\n        id={idSchema && idSchema.$id}\n        multiple\n        onChange={this.onSelectChange}\n        onBlur={onBlur}\n        onFocus={onFocus}\n        schema={schema}\n        title={title}\n        value={items}\n        disabled={disabled}\n        readonly={readonly}\n        formContext={formContext}\n        autofocus={autofocus}\n        rawErrors={rawErrors}\n      />\n    );\n  }\n\n  renderFixedArray() {\n    const {\n      schema,\n      uiSchema,\n      formData,\n      errorSchema,\n      idPrefix,\n      idSchema,\n      name,\n      required,\n      disabled,\n      readonly,\n      autofocus,\n      registry = getDefaultRegistry(),\n      onBlur,\n      onFocus,\n      rawErrors,\n    } = this.props;\n    const title = schema.title || name;\n    let items = this.props.formData;\n    const { ArrayFieldTemplate, rootSchema, fields, formContext } = registry;\n    const { TitleField } = fields;\n    const itemSchemas = schema.items.map((item, index) =>\n      retrieveSchema(item, rootSchema, formData[index])\n    );\n    const additionalSchema = allowAdditionalItems(schema)\n      ? retrieveSchema(schema.additionalItems, rootSchema, formData)\n      : null;\n\n    if (!items || items.length < itemSchemas.length) {\n      // to make sure at least all fixed items are generated\n      items = items || [];\n      items = items.concat(new Array(itemSchemas.length - items.length));\n    }\n\n    // These are the props passed into the render function\n    const arrayProps = {\n      canAdd: this.canAddItem(items) && additionalSchema,\n      className: \"field field-array field-array-fixed-items\",\n      disabled,\n      idSchema,\n      formData,\n      items: this.state.keyedFormData.map((keyedItem, index) => {\n        const { key, item } = keyedItem;\n        const additional = index >= itemSchemas.length;\n        const itemSchema = additional\n          ? retrieveSchema(schema.additionalItems, rootSchema, item)\n          : itemSchemas[index];\n        const itemIdPrefix = idSchema.$id + \"_\" + index;\n        const itemIdSchema = toIdSchema(\n          itemSchema,\n          itemIdPrefix,\n          rootSchema,\n          item,\n          idPrefix\n        );\n        const itemUiSchema = additional\n          ? uiSchema.additionalItems || {}\n          : Array.isArray(uiSchema.items)\n          ? uiSchema.items[index]\n          : uiSchema.items || {};\n        const itemErrorSchema = errorSchema ? errorSchema[index] : undefined;\n\n        return this.renderArrayFieldItem({\n          key,\n          index,\n          canRemove: additional,\n          canMoveUp: index >= itemSchemas.length + 1,\n          canMoveDown: additional && index < items.length - 1,\n          itemSchema,\n          itemData: item,\n          itemUiSchema,\n          itemIdSchema,\n          itemErrorSchema,\n          autofocus: autofocus && index === 0,\n          onBlur,\n          onFocus,\n        });\n      }),\n      onAddClick: this.onAddClick,\n      readonly,\n      required,\n      schema,\n      uiSchema,\n      title,\n      TitleField,\n      formContext,\n      rawErrors,\n    };\n\n    // Check if a custom template template was passed in\n    const Template =\n      uiSchema[\"ui:ArrayFieldTemplate\"] ||\n      ArrayFieldTemplate ||\n      DefaultFixedArrayFieldTemplate;\n    return <Template {...arrayProps} />;\n  }\n\n  renderArrayFieldItem(props) {\n    const {\n      key,\n      index,\n      canRemove = true,\n      canMoveUp = true,\n      canMoveDown = true,\n      itemSchema,\n      itemData,\n      itemUiSchema,\n      itemIdSchema,\n      itemErrorSchema,\n      autofocus,\n      onBlur,\n      onFocus,\n      rawErrors,\n    } = props;\n    const {\n      disabled,\n      readonly,\n      uiSchema,\n      registry = getDefaultRegistry(),\n    } = this.props;\n    const {\n      fields: { SchemaField },\n    } = registry;\n    const { orderable, removable } = {\n      orderable: true,\n      removable: true,\n      ...uiSchema[\"ui:options\"],\n    };\n    const has = {\n      moveUp: orderable && canMoveUp,\n      moveDown: orderable && canMoveDown,\n      remove: removable && canRemove,\n    };\n    has.toolbar = Object.keys(has).some(key => has[key]);\n\n    return {\n      children: (\n        <SchemaField\n          index={index}\n          schema={itemSchema}\n          uiSchema={itemUiSchema}\n          formData={itemData}\n          errorSchema={itemErrorSchema}\n          idSchema={itemIdSchema}\n          required={this.isItemRequired(itemSchema)}\n          onChange={this.onChangeForIndex(index)}\n          onBlur={onBlur}\n          onFocus={onFocus}\n          registry={this.props.registry}\n          disabled={this.props.disabled}\n          readonly={this.props.readonly}\n          autofocus={autofocus}\n          rawErrors={rawErrors}\n        />\n      ),\n      className: \"array-item\",\n      disabled,\n      hasToolbar: has.toolbar,\n      hasMoveUp: has.moveUp,\n      hasMoveDown: has.moveDown,\n      hasRemove: has.remove,\n      index,\n      key,\n      onAddIndexClick: this.onAddIndexClick,\n      onDropIndexClick: this.onDropIndexClick,\n      onReorderClick: this.onReorderClick,\n      readonly,\n    };\n  }\n}\n\nif (process.env.NODE_ENV !== \"production\") {\n  ArrayField.propTypes = types.fieldProps;\n}\n\nexport default ArrayField;\n"]}