@rjsf/core 4.2.2 → 4.2.3

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

@@ -0,0 +1,959 @@
+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; }
+
+import AddButton from "../AddButton";
+import IconButton from "../IconButton";
+import React, { Component } from "react";
+import includes from "core-js-pure/es/array/includes";
+import * as types from "../../types";
+import { getWidget, getDefaultFormState, getUiOptions, isMultiSelect, isFilesArray, isFixedItems, allowAdditionalItems, isCustomWidget, optionsList, retrieveSchema, toIdSchema } from "../../utils";
+import { nanoid } from "nanoid";
+
+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 (
+    /*#__PURE__*/
+    React.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 (
+    /*#__PURE__*/
+    React.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 (
+    /*#__PURE__*/
+    React.createElement("div", {
+      key: props.key,
+      className: props.className
+    },
+    /*#__PURE__*/
+    React.createElement("div", {
+      className: props.hasToolbar ? "col-xs-9" : "col-xs-12"
+    }, props.children), props.hasToolbar &&
+    /*#__PURE__*/
+    React.createElement("div", {
+      className: "col-xs-3 array-item-toolbox"
+    },
+    /*#__PURE__*/
+    React.createElement("div", {
+      className: "btn-group",
+      style: {
+        display: "flex",
+        justifyContent: "space-around"
+      }
+    }, (props.hasMoveUp || props.hasMoveDown) &&
+    /*#__PURE__*/
+    React.createElement(IconButton, {
+      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) &&
+    /*#__PURE__*/
+    React.createElement(IconButton, {
+      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 &&
+    /*#__PURE__*/
+    React.createElement(IconButton, {
+      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 (
+    /*#__PURE__*/
+    React.createElement("fieldset", {
+      className: props.className,
+      id: props.idSchema.$id
+    },
+    /*#__PURE__*/
+    React.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) &&
+    /*#__PURE__*/
+    React.createElement("div", {
+      className: "field-description",
+      key: "field-description-".concat(props.idSchema.$id)
+    }, props.uiSchema["ui:description"] || props.schema.description),
+    /*#__PURE__*/
+    React.createElement("div", {
+      className: "row array-item-list",
+      key: "array-item-list-".concat(props.idSchema.$id)
+    }, props.items && props.items.map(DefaultArrayItem)), props.canAdd &&
+    /*#__PURE__*/
+    React.createElement(AddButton, {
+      className: "array-item-add",
+      onClick: props.onAddClick,
+      disabled: props.disabled || props.readonly
+    }))
+  );
+}
+
+function DefaultNormalArrayFieldTemplate(props) {
+  return (
+    /*#__PURE__*/
+    React.createElement("fieldset", {
+      className: props.className,
+      id: props.idSchema.$id
+    },
+    /*#__PURE__*/
+    React.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) &&
+    /*#__PURE__*/
+    React.createElement(ArrayFieldDescription, {
+      key: "array-field-description-".concat(props.idSchema.$id),
+      DescriptionField: props.DescriptionField,
+      idSchema: props.idSchema,
+      description: props.uiSchema["ui:description"] || props.schema.description
+    }),
+    /*#__PURE__*/
+    React.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 &&
+    /*#__PURE__*/
+    React.createElement(AddButton, {
+      className: "array-item-add",
+      onClick: props.onAddClick,
+      disabled: props.disabled || props.readonly
+    }))
+  );
+}
+
+function generateRowId() {
+  return 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,
+          registry = _this$props.registry;
+      var rootSchema = registry.rootSchema;
+      var itemSchema = schema.items;
+
+      if (isFixedItems(schema) && allowAdditionalItems(schema)) {
+        itemSchema = schema.additionalItems;
+      }
+
+      return 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 !includes(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 = 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,
+          registry = _this$props4.registry;
+      var rootSchema = registry.rootSchema;
+
+      if (!schema.hasOwnProperty("items")) {
+        var fields = registry.fields;
+        var UnsupportedField = fields.UnsupportedField;
+        return (
+          /*#__PURE__*/
+          React.createElement(UnsupportedField, {
+            schema: schema,
+            idSchema: idSchema,
+            reason: "Missing items definition"
+          })
+        );
+      }
+
+      if (isMultiSelect(schema, rootSchema)) {
+        // If array has enum or uniqueItems set to true, call renderMultiSelect() to render the default multiselect widget or a custom widget, if specified.
+        return this.renderMultiSelect();
+      }
+
+      if (isCustomWidget(uiSchema)) {
+        return this.renderCustomWidget();
+      }
+
+      if (isFixedItems(schema)) {
+        return this.renderFixedArray();
+      }
+
+      if (isFilesArray(schema, uiSchema, rootSchema)) {
+        return this.renderFiles();
+      }
+
+      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,
+          hideError = _this$props5.hideError,
+          autofocus = _this$props5.autofocus,
+          registry = _this$props5.registry,
+          onBlur = _this$props5.onBlur,
+          onFocus = _this$props5.onFocus,
+          idPrefix = _this$props5.idPrefix,
+          _this$props5$idSepara = _this$props5.idSeparator,
+          idSeparator = _this$props5$idSepara === void 0 ? "_" : _this$props5$idSepara,
+          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 = 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 = retrieveSchema(schema.items, rootSchema, item);
+          var itemErrorSchema = errorSchema ? errorSchema[index] : undefined;
+          var itemIdPrefix = idSchema.$id + idSeparator + index;
+          var itemIdSchema = toIdSchema(itemSchema, itemIdPrefix, rootSchema, item, idPrefix, idSeparator);
+          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,
+        hideError: hideError,
+        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 (
+        /*#__PURE__*/
+        React.createElement(Component, arrayProps)
+      );
+    }
+  }, {
+    key: "renderCustomWidget",
+    value: function renderCustomWidget() {
+      var _this$props6 = this.props,
+          schema = _this$props6.schema,
+          idSchema = _this$props6.idSchema,
+          uiSchema = _this$props6.uiSchema,
+          disabled = _this$props6.disabled,
+          readonly = _this$props6.readonly,
+          hideError = _this$props6.hideError,
+          required = _this$props6.required,
+          placeholder = _this$props6.placeholder,
+          autofocus = _this$props6.autofocus,
+          onBlur = _this$props6.onBlur,
+          onFocus = _this$props6.onFocus,
+          items = _this$props6.formData,
+          registry = _this$props6.registry,
+          rawErrors = _this$props6.rawErrors,
+          name = _this$props6.name;
+      var widgets = registry.widgets,
+          formContext = registry.formContext;
+      var title = schema.title || name;
+
+      var _getUiOptions2 = _objectSpread({}, getUiOptions(uiSchema)),
+          widget = _getUiOptions2.widget,
+          options = _objectWithoutProperties(_getUiOptions2, ["widget"]);
+
+      var Widget = getWidget(schema, widget, widgets);
+      return (
+        /*#__PURE__*/
+        React.createElement(Widget, {
+          id: idSchema && idSchema.$id,
+          multiple: true,
+          onChange: this.onSelectChange,
+          onBlur: onBlur,
+          onFocus: onFocus,
+          options: options,
+          schema: schema,
+          uiSchema: uiSchema,
+          registry: registry,
+          value: items,
+          disabled: disabled,
+          readonly: readonly,
+          hideError: hideError,
+          required: required,
+          label: title,
+          placeholder: placeholder,
+          formContext: formContext,
+          autofocus: autofocus,
+          rawErrors: rawErrors
+        })
+      );
+    }
+  }, {
+    key: "renderMultiSelect",
+    value: function renderMultiSelect() {
+      var _this$props7 = this.props,
+          schema = _this$props7.schema,
+          idSchema = _this$props7.idSchema,
+          uiSchema = _this$props7.uiSchema,
+          formData = _this$props7.formData,
+          disabled = _this$props7.disabled,
+          readonly = _this$props7.readonly,
+          required = _this$props7.required,
+          placeholder = _this$props7.placeholder,
+          autofocus = _this$props7.autofocus,
+          onBlur = _this$props7.onBlur,
+          onFocus = _this$props7.onFocus,
+          registry = _this$props7.registry,
+          rawErrors = _this$props7.rawErrors,
+          name = _this$props7.name;
+      var items = this.props.formData;
+      var widgets = registry.widgets,
+          rootSchema = registry.rootSchema,
+          formContext = registry.formContext;
+      var itemsSchema = retrieveSchema(schema.items, rootSchema, formData);
+      var title = schema.title || name;
+      var enumOptions = optionsList(itemsSchema);
+
+      var _getUiOptions$enumOpt = _objectSpread({}, getUiOptions(uiSchema), {
+        enumOptions: enumOptions
+      }),
+          _getUiOptions$enumOpt2 = _getUiOptions$enumOpt.widget,
+          widget = _getUiOptions$enumOpt2 === void 0 ? "select" : _getUiOptions$enumOpt2,
+          options = _objectWithoutProperties(_getUiOptions$enumOpt, ["widget"]);
+
+      var Widget = getWidget(schema, widget, widgets);
+      return (
+        /*#__PURE__*/
+        React.createElement(Widget, {
+          id: idSchema && idSchema.$id,
+          multiple: true,
+          onChange: this.onSelectChange,
+          onBlur: onBlur,
+          onFocus: onFocus,
+          options: options,
+          schema: schema,
+          uiSchema: uiSchema,
+          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$props8 = this.props,
+          schema = _this$props8.schema,
+          uiSchema = _this$props8.uiSchema,
+          idSchema = _this$props8.idSchema,
+          name = _this$props8.name,
+          disabled = _this$props8.disabled,
+          readonly = _this$props8.readonly,
+          autofocus = _this$props8.autofocus,
+          onBlur = _this$props8.onBlur,
+          onFocus = _this$props8.onFocus,
+          registry = _this$props8.registry,
+          rawErrors = _this$props8.rawErrors;
+      var title = schema.title || name;
+      var items = this.props.formData;
+      var widgets = registry.widgets,
+          formContext = registry.formContext;
+
+      var _getUiOptions3 = getUiOptions(uiSchema),
+          _getUiOptions3$widget = _getUiOptions3.widget,
+          widget = _getUiOptions3$widget === void 0 ? "files" : _getUiOptions3$widget,
+          options = _objectWithoutProperties(_getUiOptions3, ["widget"]);
+
+      var Widget = getWidget(schema, widget, widgets);
+      return (
+        /*#__PURE__*/
+        React.createElement(Widget, {
+          options: options,
+          id: idSchema && idSchema.$id,
+          multiple: true,
+          onChange: this.onSelectChange,
+          onBlur: onBlur,
+          onFocus: onFocus,
+          schema: schema,
+          uiSchema: uiSchema,
+          title: title,
+          value: items,
+          disabled: disabled,
+          readonly: readonly,
+          registry: registry,
+          formContext: formContext,
+          autofocus: autofocus,
+          rawErrors: rawErrors
+        })
+      );
+    }
+  }, {
+    key: "renderFixedArray",
+    value: function renderFixedArray() {
+      var _this3 = this;
+
+      var _this$props9 = this.props,
+          schema = _this$props9.schema,
+          uiSchema = _this$props9.uiSchema,
+          formData = _this$props9.formData,
+          errorSchema = _this$props9.errorSchema,
+          idPrefix = _this$props9.idPrefix,
+          _this$props9$idSepara = _this$props9.idSeparator,
+          idSeparator = _this$props9$idSepara === void 0 ? "_" : _this$props9$idSepara,
+          idSchema = _this$props9.idSchema,
+          name = _this$props9.name,
+          required = _this$props9.required,
+          disabled = _this$props9.disabled,
+          readonly = _this$props9.readonly,
+          autofocus = _this$props9.autofocus,
+          registry = _this$props9.registry,
+          onBlur = _this$props9.onBlur,
+          onFocus = _this$props9.onFocus,
+          rawErrors = _this$props9.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 retrieveSchema(item, rootSchema, formData[index]);
+      });
+      var additionalSchema = allowAdditionalItems(schema) ? 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 ? retrieveSchema(schema.additionalItems, rootSchema, item) : itemSchemas[index];
+          var itemIdPrefix = idSchema.$id + idSeparator + index;
+          var itemIdSchema = toIdSchema(itemSchema, itemIdPrefix, rootSchema, item, idPrefix, idSeparator);
+          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,
+        registry: registry,
+        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 (
+        /*#__PURE__*/
+        React.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$props10 = this.props,
+          disabled = _this$props10.disabled,
+          readonly = _this$props10.readonly,
+          uiSchema = _this$props10.uiSchema,
+          registry = _this$props10.registry;
+      var SchemaField = registry.fields.SchemaField;
+
+      var _getUiOptions4 = getUiOptions(uiSchema),
+          _getUiOptions4$ordera = _getUiOptions4.orderable,
+          orderable = _getUiOptions4$ordera === void 0 ? true : _getUiOptions4$ordera,
+          _getUiOptions4$remova = _getUiOptions4.removable,
+          removable = _getUiOptions4$remova === void 0 ? true : _getUiOptions4$remova;
+
+      var has = {
+        moveUp: orderable && canMoveUp,
+        moveDown: orderable && canMoveDown,
+        remove: removable && canRemove
+      };
+      has.toolbar = Object.keys(has).some(function (key) {
+        return has[key];
+      });
+      return {
+        children:
+        /*#__PURE__*/
+        React.createElement(SchemaField, {
+          index: index,
+          schema: itemSchema,
+          uiSchema: itemUiSchema,
+          formData: itemData,
+          errorSchema: itemErrorSchema,
+          idPrefix: this.props.idPrefix,
+          idSeparator: this.props.idSeparator,
+          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,
+          hideError: this.props.hideError,
+          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;
+}(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;
+}
+
+export default ArrayField;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/components/fields/ArrayField.js"],"names":["AddButton","IconButton","React","Component","includes","types","getWidget","getDefaultFormState","getUiOptions","isMultiSelect","isFilesArray","isFixedItems","allowAdditionalItems","isCustomWidget","optionsList","retrieveSchema","toIdSchema","nanoid","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","renderMultiSelect","renderCustomWidget","renderFixedArray","renderFiles","renderNormalArray","name","hideError","autofocus","onBlur","onFocus","idPrefix","idSeparator","rawErrors","ArrayFieldTemplate","formContext","itemsSchema","arrayProps","canAddItem","itemErrorSchema","itemIdPrefix","itemIdSchema","renderArrayFieldItem","canMoveUp","canMoveDown","itemData","itemUiSchema","placeholder","widgets","widget","options","Widget","onSelectChange","enumOptions","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","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  isCustomWidget,\n  optionsList,\n  retrieveSchema,\n  toIdSchema,\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 } = 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 { schema, uiSchema, idSchema, registry } = 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 (isMultiSelect(schema, rootSchema)) {\n      // If array has enum or uniqueItems set to true, call renderMultiSelect() to render the default multiselect widget or a custom widget, if specified.\n      return this.renderMultiSelect();\n    }\n    if (isCustomWidget(uiSchema)) {\n      return this.renderCustomWidget();\n    }\n    if (isFixedItems(schema)) {\n      return this.renderFixedArray();\n    }\n    if (isFilesArray(schema, uiSchema, rootSchema)) {\n      return this.renderFiles();\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      hideError,\n      autofocus,\n      registry,\n      onBlur,\n      onFocus,\n      idPrefix,\n      idSeparator = \"_\",\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 + idSeparator + index;\n        const itemIdSchema = toIdSchema(\n          itemSchema,\n          itemIdPrefix,\n          rootSchema,\n          item,\n          idPrefix,\n          idSeparator\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      hideError,\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  renderCustomWidget() {\n    const {\n      schema,\n      idSchema,\n      uiSchema,\n      disabled,\n      readonly,\n      hideError,\n      required,\n      placeholder,\n      autofocus,\n      onBlur,\n      onFocus,\n      formData: items,\n      registry,\n      rawErrors,\n      name,\n    } = this.props;\n    const { widgets, formContext } = registry;\n    const title = schema.title || name;\n\n    const { widget, ...options } = {\n      ...getUiOptions(uiSchema),\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        uiSchema={uiSchema}\n        registry={registry}\n        value={items}\n        disabled={disabled}\n        readonly={readonly}\n        hideError={hideError}\n        required={required}\n        label={title}\n        placeholder={placeholder}\n        formContext={formContext}\n        autofocus={autofocus}\n        rawErrors={rawErrors}\n      />\n    );\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,\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        uiSchema={uiSchema}\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,\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        uiSchema={uiSchema}\n        title={title}\n        value={items}\n        disabled={disabled}\n        readonly={readonly}\n        registry={registry}\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      idSeparator = \"_\",\n      idSchema,\n      name,\n      required,\n      disabled,\n      readonly,\n      autofocus,\n      registry,\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 + idSeparator + index;\n        const itemIdSchema = toIdSchema(\n          itemSchema,\n          itemIdPrefix,\n          rootSchema,\n          item,\n          idPrefix,\n          idSeparator\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      registry,\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 { disabled, readonly, uiSchema, registry } = this.props;\n    const {\n      fields: { SchemaField },\n    } = registry;\n    const { orderable = true, removable = true } = getUiOptions(uiSchema);\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          idPrefix={this.props.idPrefix}\n          idSeparator={this.props.idSeparator}\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          hideError={this.props.hideError}\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"]}