@rjsf/semantic-ui 4.2.3 → 5.0.0-beta.10

package/dist/semantic-ui.cjs.development.js

@@ -2,125 +2,101 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
 var core = require('@rjsf/core');
 var semanticUiReact = require('semantic-ui-react');
-var React = _interopDefault(require('react'));
-var PropTypes = _interopDefault(require('prop-types'));
+var React = require('react');
+var utils = require('@rjsf/utils');
 var nanoid = require('nanoid');
-var _ = _interopDefault(require('lodash'));
-
-function _extends() {
-  _extends = Object.assign || function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
-
-    return target;
-  };
-
-  return _extends.apply(this, arguments);
-}
-
-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 AddButton(props) {
-  return React.createElement(semanticUiReact.Button, _extends({}, props, {
+var map = require('lodash/map');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+var map__default = /*#__PURE__*/_interopDefaultLegacy(map);
+
+function AddButton(_ref) {
+  let {
+    uiSchema,
+    color,
+    ...props
+  } = _ref;
+  return /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Button, {
+    title: "Add Item",
+    color: color,
+    ...props,
     icon: true,
-    size: "tiny",
-    labelPosition: "left"
-  }), React.createElement(semanticUiReact.Icon, {
+    size: "tiny"
+  }, /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Icon, {
     name: "plus"
-  }), "Add Item");
+  }));
 }
 
-/**
- * Extract props meant for semantic UI components from props that are
- * passed to Widgets, Templates and Fields.
- * @param {Object} params
- * @param {Object?} params.formContext
- * @param {Object?} params.uiSchema
- * @param {Object?} params.options
- * @param {Object?} params.defaultSchemaProps
- * @param {Object?} params.defaultContextProps
- * @returns {any}
+/**
+ * Extract props meant for semantic UI components from props that are
+ * passed to Widgets, Templates and Fields.
+ * @param {Object} params
+ * @param {Object?} params.formContext
+ * @param {Object?} params.uiSchema
+ * @param {Object?} params.options
+ * @param {Object?} params.defaultSchemaProps
+ * @param {Object?} params.defaultContextProps
+ * @returns {any}
  */
 
 function getSemanticProps(_ref) {
-  var _ref$formContext = _ref.formContext,
-      formContext = _ref$formContext === void 0 ? {} : _ref$formContext,
-      _ref$uiSchema = _ref.uiSchema,
-      uiSchema = _ref$uiSchema === void 0 ? {} : _ref$uiSchema,
-      _ref$options = _ref.options,
-      options = _ref$options === void 0 ? {} : _ref$options,
-      _ref$defaultSchemaPro = _ref.defaultSchemaProps,
-      defaultSchemaProps = _ref$defaultSchemaPro === void 0 ? {
-    fluid: true,
-    inverted: false
-  } : _ref$defaultSchemaPro,
-      _ref$defaultContextPr = _ref.defaultContextProps,
-      defaultContextProps = _ref$defaultContextPr === void 0 ? {} : _ref$defaultContextPr;
-  var formContextProps = formContext.semantic;
-  var schemaProps = uiSchema["ui:options"] && uiSchema["ui:options"].semantic;
-  var optionProps = options.semantic; // formContext props should overide other props
-
-  return Object.assign({}, _extends({}, defaultSchemaProps && defaultSchemaProps), _extends({}, defaultContextProps && defaultContextProps), schemaProps, optionProps, formContextProps);
+  let {
+    formContext = {},
+    uiSchema = {},
+    options = {},
+    defaultSchemaProps = {
+      fluid: true,
+      inverted: false
+    },
+    defaultContextProps = {}
+  } = _ref;
+  const formContextProps = formContext.semantic;
+  const schemaProps = utils.getUiOptions(uiSchema).semantic;
+  const optionProps = options.semantic; // formContext props should overide other props
+
+  return Object.assign({}, { ...defaultSchemaProps
+  }, { ...defaultContextProps
+  }, schemaProps, optionProps, formContextProps);
 }
-/**
- * Extract error props meant for semantic UI components from props that are
- * passed to Widgets, Templates and Fields.
- * @param {Object} params
- * @param {Object?} params.formContext
- * @param {Object?} params.uiSchema
- * @param {Object?} params.defaultProps
- * @returns {any}
+/**
+ * Extract error props meant for semantic UI components from props that are
+ * passed to Widgets, Templates and Fields.
+ * @param {Object} params
+ * @param {Object?} params.formContext
+ * @param {Object?} params.uiSchema
+ * @param {Object?} params.defaultProps
+ * @returns {any}
  */
 
 function getSemanticErrorProps(_ref2) {
-  var _ref2$formContext = _ref2.formContext,
-      formContext = _ref2$formContext === void 0 ? {} : _ref2$formContext,
-      _ref2$uiSchema = _ref2.uiSchema,
-      uiSchema = _ref2$uiSchema === void 0 ? {} : _ref2$uiSchema,
-      _ref2$options = _ref2.options,
-      options = _ref2$options === void 0 ? {} : _ref2$options,
-      _ref2$defaultProps = _ref2.defaultProps,
-      defaultProps = _ref2$defaultProps === void 0 ? {
-    size: 'small',
-    pointing: 'above'
-  } : _ref2$defaultProps;
-  var formContextProps = formContext.semantic && formContext.semantic.errorOptions;
-  var schemaProps = uiSchema["ui:options"] && uiSchema["ui:options"].semantic && uiSchema["ui:options"].semantic.errorOptions;
-  var optionProps = options.semantic && options.semantic.errorOptions;
-  return Object.assign({}, _extends({}, defaultProps && defaultProps), schemaProps, optionProps, formContextProps);
+  let {
+    formContext = {},
+    uiSchema = {},
+    options = {},
+    defaultProps = {
+      size: "small",
+      pointing: "above"
+    }
+  } = _ref2;
+  const formContextProps = formContext.semantic && formContext.semantic.errorOptions;
+  const semanticOptions = utils.getUiOptions(uiSchema).semantic;
+  const schemaProps = semanticOptions && semanticOptions.errorOptions;
+  const optionProps = options.semantic && options.semantic.errorOptions;
+  return Object.assign({}, { ...defaultProps
+  }, schemaProps, optionProps, formContextProps);
 }
-/**
- * Combine multiple strings containing class names into a single string,
- * removing duplicates. E.g.
- * cleanClassNames('bar', 'baz bar', 'x y ', undefined)
- * // 'bar baz x y'
- * @param {Array} classNameArr
- * @param {Array} omit
- * @returns {string}
+/**
+ * Combine multiple strings containing class names into a single string,
+ * removing duplicates. E.g.
+ * cleanClassNames('bar', 'baz bar', 'x y ', undefined)
+ * // 'bar baz x y'
+ * @param {Array} classNameArr
+ * @param {Array} omit
+ * @returns {string}
  */
 
 function cleanClassNames(classNameArr, omit) {
@@ -130,432 +106,615 @@ function cleanClassNames(classNameArr, omit) {
 
   // Split each arg on whitespace, and add it to an array. Skip false-y args
   // like "" and undefined.
-  var classList = classNameArr.filter(Boolean).reduce(function (previous, current) {
-    return previous.concat(current.trim().split(/\s+/));
-  }, []); // Remove any class names from omit, and make the rest unique before
+  const classList = classNameArr.filter(Boolean).reduce((previous, current) => previous.concat(current.trim().split(/\s+/)), []); // Remove any class names from omit, and make the rest unique before
   // returning them as a string
 
-  return [].concat(new Set(classList.filter(function (cn) {
-    return !omit.includes(cn);
-  }))).join(" ");
+  return [...new Set(classList.filter(cn => !omit.includes(cn)))].join(" ");
 }
-/**
- *
- * @param {boolean} wrap
- * @param Component
- * @param {Object} props
- * @returns {*}
- * @constructor
+/**
+ *
+ * @param {boolean} wrap
+ * @param Component
+ * @param {Object} props
+ * @returns {*}
+ * @constructor
  */
 
 function MaybeWrap(_ref3) {
-  var wrap = _ref3.wrap,
-      _ref3$component = _ref3.component,
-      Component = _ref3$component === void 0 ? "div" : _ref3$component,
-      props = _objectWithoutPropertiesLoose(_ref3, ["wrap", "component"]);
-
-  return wrap ? React.createElement(Component, props) : props.children;
+  let {
+    wrap,
+    component: Component = "div",
+    ...props
+  } = _ref3;
+  return wrap ? /*#__PURE__*/React__default["default"].createElement(Component, { ...props
+  }) : props.children;
 }
 
-var isFixedItems = core.utils.isFixedItems;
-
-var ArrayFieldTitle = function ArrayFieldTitle(_ref) {
-  var TitleField = _ref.TitleField,
-      idSchema = _ref.idSchema,
-      uiSchema = _ref.uiSchema,
-      title = _ref.title;
-
-  if (!title) {
-    return null;
-  }
-
-  var id = idSchema.$id + "__title";
-  return React.createElement(TitleField, {
-    id: id,
-    title: title,
-    options: uiSchema["ui:options"]
-  });
-};
-
-function ArrayFieldDescription(_ref2) {
-  var DescriptionField = _ref2.DescriptionField,
-      idSchema = _ref2.idSchema,
-      description = _ref2.description;
-
-  if (!description) {
-    // See #312: Ensure compatibility with old versions of React.
-    return null;
-  }
-
-  var id = idSchema.$id + "__description";
-  return React.createElement(DescriptionField, {
-    id: id,
-    description: description
-  });
-}
-
-var gridStyle = function gridStyle(vertical) {
-  return {
-    display: "grid",
-    gridTemplateColumns: "1fr " + (vertical ? 65 : 110) + "px"
-  };
-}; // checks if its the first array item
-
-
-function isInitialArrayItem(props) {
-  // no underscore because im not sure if we want to import a library here
-  var idSchema = props.children.props.idSchema;
-  return idSchema.target && idSchema.conditions;
-} // Used in the two templates
-
+const gridStyle = vertical => ({
+  display: "grid",
+  gridTemplateColumns: "1fr " + (vertical ? 65 : 110) + "px"
+});
 
-function DefaultArrayItem(props) {
-  return React.createElement("div", {
-    className: "array-item",
-    key: props.key
-  }, React.createElement(MaybeWrap, {
-    wrap: props.wrapItem,
+const ArrayFieldItemTemplate = props => {
+  const {
+    children,
+    disabled,
+    hasToolbar,
+    hasMoveDown,
+    hasMoveUp,
+    hasRemove,
+    index,
+    onDropIndexClick,
+    onReorderClick,
+    readonly,
+    uiSchema,
+    registry
+  } = props;
+  const {
+    MoveDownButton,
+    MoveUpButton,
+    RemoveButton
+  } = registry.templates.ButtonTemplates;
+  const uiOptions = utils.getUiOptions(uiSchema); // Pull the semantic props out of the uiOptions that were put in via the ArrayFieldTemplate
+
+  const {
+    horizontalButtons = false,
+    wrapItem = false
+  } = uiOptions.semantic;
+  return /*#__PURE__*/React__default["default"].createElement("div", {
+    className: "array-item"
+  }, /*#__PURE__*/React__default["default"].createElement(MaybeWrap, {
+    wrap: wrapItem,
     component: semanticUiReact.Segment
-  }, React.createElement(semanticUiReact.Grid, {
-    style: !isInitialArrayItem(props) ? _extends({}, gridStyle(!props.horizontalButtons), {
+  }, /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Grid, {
+    style: index !== 0 ? { ...gridStyle(!horizontalButtons),
       alignItems: "center"
-    }) : gridStyle(!props.horizontalButtons)
-  }, React.createElement(semanticUiReact.Grid.Column, {
+    } : gridStyle(!horizontalButtons)
+  }, /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Grid.Column, {
     width: 16,
     verticalAlign: "middle"
-  }, props.children), props.hasToolbar && React.createElement(semanticUiReact.Grid.Column, null, (props.hasMoveUp || props.hasMoveDown || props.hasRemove) && React.createElement(semanticUiReact.Button.Group, {
+  }, children), hasToolbar && /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Grid.Column, null, (hasMoveUp || hasMoveDown || hasRemove) && /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Button.Group, {
     size: "mini",
-    vertical: !props.horizontalButtons
-  }, (props.hasMoveUp || props.hasMoveDown) && React.createElement(semanticUiReact.Button, {
-    icon: "angle up",
+    vertical: !horizontalButtons
+  }, (hasMoveUp || hasMoveDown) && /*#__PURE__*/React__default["default"].createElement(MoveUpButton, {
     className: "array-item-move-up",
-    tabIndex: "-1",
-    disabled: props.disabled || props.readOnly || !props.hasMoveUp,
-    onClick: props.onReorderClick(props.index, props.index - 1)
-  }), (props.hasMoveUp || props.hasMoveDown) && React.createElement(semanticUiReact.Button, {
-    icon: "angle down",
+    disabled: disabled || readonly || !hasMoveUp,
+    onClick: onReorderClick(index, index - 1),
+    uiSchema: uiSchema
+  }), (hasMoveUp || hasMoveDown) && /*#__PURE__*/React__default["default"].createElement(MoveDownButton, {
     className: "array-item-move-down",
-    tabIndex: "-1",
-    disabled: props.disabled || props.readOnly || !props.hasMoveDown,
-    onClick: props.onReorderClick(props.index, props.index + 1)
-  }), props.hasRemove && React.createElement(semanticUiReact.Button, {
-    icon: "trash",
+    disabled: disabled || readonly || !hasMoveDown,
+    onClick: onReorderClick(index, index + 1),
+    uiSchema: uiSchema
+  }), hasRemove && /*#__PURE__*/React__default["default"].createElement(RemoveButton, {
     className: "array-item-remove",
-    tabIndex: "-1",
-    disabled: props.disabled || props.readOnly,
-    onClick: props.onDropIndexClick(props.index)
+    disabled: disabled || readonly,
+    onClick: onDropIndexClick(index),
+    uiSchema: uiSchema
   }))))));
-} // Used for arrays that are represented as multiple selection fields
-// (displayed as a multi select or checkboxes)
-
-
-function DefaultFixedArrayFieldTemplate(_ref3) {
-  var uiSchema = _ref3.uiSchema,
-      idSchema = _ref3.idSchema,
-      canAdd = _ref3.canAdd,
-      className = _ref3.className,
-      classNames = _ref3.classNames,
-      disabled = _ref3.disabled,
-      items = _ref3.items,
-      onAddClick = _ref3.onAddClick,
-      readOnly = _ref3.readOnly,
-      required = _ref3.required,
-      schema = _ref3.schema,
-      title = _ref3.title,
-      TitleField = _ref3.TitleField,
-      itemProps = _ref3.itemProps;
-  var fieldTitle = uiSchema["ui:title"] || title;
-  var fieldDescription = uiSchema["ui:description"] || schema.description;
-  return React.createElement("div", {
-    className: cleanClassNames([className, classNames])
-  }, React.createElement(ArrayFieldTitle, {
-    key: "array-field-title-" + idSchema.$id,
-    TitleField: TitleField,
-    idSchema: idSchema,
-    uiSchema: uiSchema,
-    title: fieldTitle,
-    required: required
-  }), fieldDescription && React.createElement("div", {
-    className: "field-description",
-    key: "field-description-" + idSchema.$id
-  }, fieldDescription), React.createElement("div", {
-    key: "array-item-list-" + idSchema.$id
-  }, React.createElement("div", {
-    className: "row array-item-list"
-  }, items && items.map(function (p) {
-    return DefaultArrayItem(_extends({}, p, itemProps));
-  })), canAdd && React.createElement("div", {
-    style: {
-      marginTop: "1rem",
-      position: "relative",
-      textAlign: "right"
-    }
-  }, React.createElement(AddButton, {
-    onClick: onAddClick,
-    disabled: disabled || readOnly
-  }))));
-}
+};
 
-function DefaultNormalArrayFieldTemplate(_ref4) {
-  var uiSchema = _ref4.uiSchema,
-      idSchema = _ref4.idSchema,
-      canAdd = _ref4.canAdd,
-      className = _ref4.className,
-      classNames = _ref4.classNames,
-      disabled = _ref4.disabled,
-      DescriptionField = _ref4.DescriptionField,
-      items = _ref4.items,
-      onAddClick = _ref4.onAddClick,
-      readOnly = _ref4.readOnly,
-      required = _ref4.required,
-      schema = _ref4.schema,
-      title = _ref4.title,
-      TitleField = _ref4.TitleField,
-      itemProps = _ref4.itemProps;
-  var fieldTitle = uiSchema["ui:title"] || title;
-  var fieldDescription = uiSchema["ui:description"] || schema.description;
-  return React.createElement("div", {
-    className: cleanClassNames([className, classNames, "sortable-form-fields"])
-  }, React.createElement(ArrayFieldTitle, {
-    key: "array-field-title-" + idSchema.$id,
-    TitleField: TitleField,
+function ArrayFieldTemplate(_ref) {
+  let {
+    uiSchema,
+    idSchema,
+    canAdd,
+    className,
+    // classNames, This is not part of the type, so it is likely never passed in
+    disabled,
+    formContext,
+    items,
+    onAddClick,
+    // options, This is not part of the type, so it is likely never passed in
+    readonly,
+    required,
+    schema,
+    title,
+    registry
+  } = _ref;
+  const semanticProps = getSemanticProps({
+    uiSchema,
+    formContext,
+    defaultSchemaProps: {
+      horizontalButtons: false,
+      wrapItem: false
+    }
+  });
+  const {
+    horizontalButtons,
+    wrapItem
+  } = semanticProps;
+  const semantic = {
+    horizontalButtons,
+    wrapItem
+  };
+  const uiOptions = utils.getUiOptions(uiSchema);
+  const ArrayFieldDescriptionTemplate = utils.getTemplate("ArrayFieldDescriptionTemplate", registry, uiOptions);
+  const ArrayFieldItemTemplate = utils.getTemplate("ArrayFieldItemTemplate", registry, uiOptions);
+  const ArrayFieldTitleTemplate = utils.getTemplate("ArrayFieldTitleTemplate", registry, uiOptions); // Button templates are not overridden in the uiSchema
+
+  const {
+    ButtonTemplates: {
+      AddButton
+    }
+  } = registry.templates;
+  const fieldTitle = uiOptions.title || title;
+  const fieldDescription = uiOptions.description || schema.description;
+  return /*#__PURE__*/React__default["default"].createElement("div", {
+    className: cleanClassNames([className, utils.isFixedItems(schema) ? "" : "sortable-form-fields"])
+  }, /*#__PURE__*/React__default["default"].createElement(ArrayFieldTitleTemplate, {
     idSchema: idSchema,
-    uiSchema: uiSchema,
     title: fieldTitle,
-    required: required
-  }), fieldDescription && React.createElement(ArrayFieldDescription, {
-    key: "array-field-description-" + idSchema.$id,
-    DescriptionField: DescriptionField,
+    uiSchema: uiSchema,
+    required: required,
+    registry: registry
+  }), fieldDescription && /*#__PURE__*/React__default["default"].createElement(ArrayFieldDescriptionTemplate, {
     idSchema: idSchema,
-    description: fieldDescription
-  }), React.createElement("div", {
+    description: fieldDescription,
+    uiSchema: uiSchema,
+    registry: registry
+  }), /*#__PURE__*/React__default["default"].createElement("div", {
     key: "array-item-list-" + idSchema.$id
-  }, React.createElement("div", {
+  }, /*#__PURE__*/React__default["default"].createElement("div", {
     className: "row array-item-list"
-  }, items && items.map(function (p) {
-    return DefaultArrayItem(_extends({}, p, itemProps));
-  })), canAdd && React.createElement("div", {
+  }, items && items.map(_ref2 => {
+    let {
+      key,
+      uiSchema: itemUiSchema = {},
+      ...props
+    } = _ref2;
+    // Merge in the semantic props from the ArrayFieldTemplate into each of the items
+    const mergedUiSchema = { ...itemUiSchema,
+      [utils.UI_OPTIONS_KEY]: { ...itemUiSchema[utils.UI_OPTIONS_KEY],
+        semantic
+      }
+    };
+    return /*#__PURE__*/React__default["default"].createElement(ArrayFieldItemTemplate, {
+      key: key,
+      ...props,
+      uiSchema: mergedUiSchema
+    });
+  })), canAdd && /*#__PURE__*/React__default["default"].createElement("div", {
     style: {
       marginTop: "1rem",
       position: "relative",
       textAlign: "right"
     }
-  }, React.createElement(AddButton, {
+  }, /*#__PURE__*/React__default["default"].createElement(AddButton, {
     onClick: onAddClick,
-    disabled: disabled || readOnly
+    disabled: disabled || readonly,
+    uiSchema: uiSchema
   }))));
 }
 
-function ArrayFieldTemplate(props) {
-  var options = props.options,
-      schema = props.schema,
-      uiSchema = props.uiSchema,
-      formContext = props.formContext;
-  var semanticProps = getSemanticProps({
-    options: options,
-    uiSchema: uiSchema,
-    formContext: formContext,
-    defaultSchemaProps: {
-      horizontalButtons: false,
-      wrapItem: false
-    }
+function BaseInputTemplate(props) {
+  const {
+    id,
+    placeholder,
+    label,
+    value,
+    required,
+    readonly,
+    disabled,
+    onChange,
+    onBlur,
+    onFocus,
+    autofocus,
+    options,
+    schema,
+    uiSchema,
+    formContext,
+    type,
+    registry,
+    rawErrors = []
+  } = props;
+  const inputProps = utils.getInputProps(schema, type, options);
+  const semanticProps = getSemanticProps({
+    uiSchema,
+    formContext,
+    options
   });
-  var horizontalButtons = semanticProps.horizontalButtons,
-      wrapItem = semanticProps.wrapItem;
-  var itemProps = {
-    horizontalButtons: horizontalButtons,
-    wrapItem: wrapItem
+  const {
+    schemaUtils
+  } = registry;
+
+  const _onChange = _ref => {
+    let {
+      target: {
+        value
+      }
+    } = _ref;
+    return onChange(value === "" ? options.emptyValue : value);
   };
 
-  if (isFixedItems(schema)) {
-    return React.createElement(DefaultFixedArrayFieldTemplate, _extends({}, props, {
-      itemProps: itemProps
-    }));
+  const _onBlur = () => onBlur && onBlur(id, value);
+
+  const _onFocus = () => onFocus && onFocus(id, value);
+
+  const displayLabel = schemaUtils.getDisplayLabel(schema, uiSchema);
+  return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Form.Input, {
+    key: id,
+    id: id,
+    name: id,
+    placeholder: placeholder,
+    ...inputProps,
+    label: displayLabel ? label || schema.title : false,
+    required: required,
+    autoFocus: autofocus,
+    disabled: disabled || readonly,
+    list: schema.examples ? "examples_" + id : undefined,
+    ...semanticProps,
+    value: value || value === 0 ? value : "",
+    error: rawErrors.length > 0,
+    onChange: _onChange,
+    onBlur: _onBlur,
+    onFocus: _onFocus
+  }), schema.examples && /*#__PURE__*/React__default["default"].createElement("datalist", {
+    id: "examples_" + id
+  }, schema.examples.concat(schema.default ? [schema.default] : []).map(example => {
+    return /*#__PURE__*/React__default["default"].createElement("option", {
+      key: example,
+      value: example
+    });
+  })));
+}
+
+function DescriptionField(_ref) {
+  let {
+    description,
+    id
+  } = _ref;
+
+  if (!description) {
+    return null;
   }
 
-  return React.createElement(DefaultNormalArrayFieldTemplate, _extends({}, props, {
-    itemProps: itemProps
-  }));
+  return /*#__PURE__*/React__default["default"].createElement("p", {
+    id: id,
+    className: "sui-description"
+  }, description);
 }
 
-/* eslint-disable react/no-array-index-key */
-/**
- *
- * @param errors
- * @returns {*}
- * @constructor
+/**
+ *
+ * @param errors
+ * @returns {*}
+ * @constructor
  */
 
 function ErrorList(_ref) {
-  var errors = _ref.errors;
-  return React.createElement(semanticUiReact.Message, {
+  let {
+    errors
+  } = _ref;
+  return /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Message, {
     negative: true
-  }, React.createElement(semanticUiReact.Message.Header, null, "Errors"), React.createElement(semanticUiReact.Message.List, null, errors.map(function (error, index) {
-    return React.createElement(semanticUiReact.Message.Item, {
-      key: "error-" + index
-    }, error.stack);
-  })));
+  }, /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Message.Header, null, "Errors"), /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Message.List, null, errors.map((error, index) => /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Message.Item, {
+    key: "error-" + index
+  }, error.stack))));
 }
 
-ErrorList.propTypes = {
-  errors: PropTypes.array
-};
-
-/* eslint-disable react/prop-types */
-
-function DescriptionField(_ref) {
-  var className = _ref.className,
-      description = _ref.description;
-
-  if (description) {
-    return React.createElement("p", {
-      className: className || "sui-description"
-    }, description);
-  }
+function IconButton(props) {
+  const {
+    icon,
+    iconType,
+    color,
+    className,
+    uiSchema,
+    ...otherProps
+  } = props;
+  return /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Button, {
+    icon: icon,
+    size: iconType,
+    color: color,
+    className: className,
+    ...otherProps
+  });
 }
-
-function TitleField(_ref) {
-  var title = _ref.title,
-      options = _ref.options;
-  var semantic = options.semantic;
-
-  if (title) {
-    return React.createElement(semanticUiReact.Header, _extends({}, semantic, {
-      as: "h5"
-    }), title);
-  }
+function MoveDownButton(props) {
+  return /*#__PURE__*/React__default["default"].createElement(IconButton, {
+    title: "Move down",
+    ...props,
+    icon: "angle down"
+  });
+}
+function MoveUpButton(props) {
+  return /*#__PURE__*/React__default["default"].createElement(IconButton, {
+    title: "Move up",
+    ...props,
+    icon: "angle up"
+  });
+}
+function RemoveButton(props) {
+  return /*#__PURE__*/React__default["default"].createElement(IconButton, {
+    title: "Remove",
+    ...props,
+    icon: "trash"
+  });
 }
 
-TitleField.defaultProps = {
+const DEFAULT_OPTIONS$1 = {
   options: {
-    semantic: {
-      inverted: false,
-      dividing: true
-    }
+    pointing: "above",
+    size: "small"
   }
 };
-TitleField.propTypes = {
-  options: PropTypes.object
-};
+/**
+ *
+ * @param errors
+ * @param displayError
+ * @returns {*}
+ * @constructor
+ * @return {null}
+ */
 
-var Fields = {
-  DescriptionField: DescriptionField,
-  TitleField: TitleField
-};
+function FieldErrorTemplate(_ref) {
+  let {
+    errors,
+    idSchema,
+    uiSchema,
+    registry
+  } = _ref;
+  const {
+    formContext
+  } = registry;
+  const options = getSemanticErrorProps({
+    formContext,
+    uiSchema,
+    defaultProps: DEFAULT_OPTIONS$1
+  });
+  const {
+    pointing,
+    size
+  } = options;
 
-/* eslint-disable react/prop-types */
-/**
- * @return {null}
+  if (errors && errors.length > 0) {
+    const id = idSchema.$id + "__error";
+    return /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Label, {
+      id: id,
+      color: "red",
+      pointing: pointing || "above",
+      size: size || "small",
+      basic: true
+    }, /*#__PURE__*/React__default["default"].createElement(semanticUiReact.List, {
+      bulleted: true
+    }, errors.map(error => /*#__PURE__*/React__default["default"].createElement(semanticUiReact.List.Item, {
+      key: nanoid.nanoid()
+    }, error))));
+  }
+
+  return null;
+}
+
+/**
+ * @return {null}
  */
 
-function HelpField(_ref) {
-  var helpText = _ref.helpText,
-      id = _ref.id;
+function FieldHelpTemplate(_ref) {
+  let {
+    help,
+    idSchema
+  } = _ref;
 
-  if (helpText) {
-    return React.createElement(semanticUiReact.Message, {
+  if (help) {
+    const id = idSchema.$id + "__help";
+    return /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Message, {
       size: "mini",
       info: true,
       id: id,
-      content: helpText
+      content: help
     });
   }
 
   return null;
 }
 
-HelpField.propTypes = {
-  helpText: PropTypes.string,
-  id: PropTypes.string
-};
-
-/* eslint-disable react/no-array-index-key */
-/**
- *
- * @param errors
- * @param displayError
- * @returns {*}
- * @constructor
- * @return {null}
- */
-
-function RawErrors(_ref) {
-  var errors = _ref.errors,
-      options = _ref.options;
-  var pointing = options.pointing,
-      size = options.size;
+function FieldTemplate(_ref) {
+  let {
+    id,
+    children,
+    classNames,
+    displayLabel,
+    label,
+    errors,
+    help,
+    hidden,
+    rawDescription,
+    registry,
+    uiSchema,
+    ...props
+  } = _ref;
+  const semanticProps = getSemanticProps(props);
+  const {
+    wrapLabel,
+    wrapContent
+  } = semanticProps;
+  const uiOptions = utils.getUiOptions(uiSchema);
+  const WrapIfAdditionalTemplate = utils.getTemplate("WrapIfAdditionalTemplate", registry, uiOptions);
+  const DescriptionFieldTemplate = utils.getTemplate("DescriptionFieldTemplate", registry, uiOptions);
 
-  if (errors && errors.length > 0) {
-    return React.createElement(semanticUiReact.Label, {
-      color: "red",
-      pointing: pointing || "above",
-      size: size || "small",
-      basic: true
-    }, React.createElement(semanticUiReact.List, {
-      bulleted: true
-    }, errors.map(function (error) {
-      return React.createElement(semanticUiReact.List.Item, {
-        key: nanoid.nanoid(),
-        content: error
-      });
-    })));
+  if (hidden) {
+    return /*#__PURE__*/React__default["default"].createElement("div", {
+      style: {
+        display: "none"
+      }
+    }, children);
   }
 
-  return null;
+  return /*#__PURE__*/React__default["default"].createElement(WrapIfAdditionalTemplate, {
+    classNames: classNames,
+    id: id,
+    label: label,
+    registry: registry,
+    uiSchema: uiSchema,
+    ...props
+  }, /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Form.Group, {
+    key: id,
+    widths: "equal",
+    grouped: true
+  }, /*#__PURE__*/React__default["default"].createElement(MaybeWrap, {
+    wrap: wrapContent,
+    className: "sui-field-content"
+  }, children, displayLabel && rawDescription && /*#__PURE__*/React__default["default"].createElement(MaybeWrap, {
+    wrap: wrapLabel,
+    className: "sui-field-label"
+  }, rawDescription && /*#__PURE__*/React__default["default"].createElement(DescriptionFieldTemplate, {
+    id: id + "-description",
+    description: rawDescription,
+    registry: registry
+  })), help, errors)));
 }
 
-RawErrors.defaultProps = {
-  options: {
-    pointing: "above",
-    size: "small"
+function ObjectFieldTemplate(_ref) {
+  let {
+    description,
+    onAddClick,
+    title,
+    properties,
+    disabled,
+    readonly,
+    required,
+    uiSchema,
+    schema,
+    formData,
+    idSchema,
+    registry
+  } = _ref;
+  const uiOptions = utils.getUiOptions(uiSchema);
+  const TitleFieldTemplate = utils.getTemplate("TitleFieldTemplate", registry, uiOptions);
+  const DescriptionFieldTemplate = utils.getTemplate("DescriptionFieldTemplate", registry, uiOptions); // Button templates are not overridden in the uiSchema
+
+  const {
+    ButtonTemplates: {
+      AddButton
+    }
+  } = registry.templates;
+  const fieldTitle = uiOptions.title || title;
+  const fieldDescription = uiOptions.description || description;
+  return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, fieldTitle && /*#__PURE__*/React__default["default"].createElement(TitleFieldTemplate, {
+    id: idSchema.$id + "-title",
+    title: fieldTitle,
+    required: required,
+    uiSchema: uiSchema,
+    registry: registry
+  }), fieldDescription && /*#__PURE__*/React__default["default"].createElement(DescriptionFieldTemplate, {
+    id: idSchema.$id + "-description",
+    description: fieldDescription,
+    registry: registry
+  }), properties.map(prop => prop.content), utils.canExpand(schema, uiSchema, formData) && /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Grid.Column, {
+    width: 16,
+    verticalAlign: "middle"
+  }, /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Grid.Row, null, /*#__PURE__*/React__default["default"].createElement("div", {
+    style: {
+      marginTop: "1rem",
+      position: "relative",
+      textAlign: "right"
+    }
+  }, /*#__PURE__*/React__default["default"].createElement(AddButton, {
+    onClick: onAddClick(schema),
+    disabled: disabled || readonly,
+    uiSchema: uiSchema
+  })))));
+}
+
+var SubmitButton = (_ref => {
+  let {
+    uiSchema
+  } = _ref;
+  const {
+    submitText,
+    norender,
+    props: submitButtonProps
+  } = utils.getSubmitButtonOptions(uiSchema);
+
+  if (norender) {
+    return null;
   }
+
+  return /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Button, {
+    type: "submit",
+    primary: true,
+    ...submitButtonProps
+  }, submitText);
+});
+
+const DEFAULT_OPTIONS = {
+  inverted: false,
+  dividing: true
 };
-RawErrors.propTypes = {
-  options: PropTypes.object,
-  errors: PropTypes.array
-};
 
-var ADDITIONAL_PROPERTY_FLAG = core.utils.ADDITIONAL_PROPERTY_FLAG;
-
-var WrapIfAdditional = function WrapIfAdditional(_ref) {
-  var children = _ref.children,
-      classNames = _ref.classNames,
-      disabled = _ref.disabled,
-      formContext = _ref.formContext,
-      id = _ref.id,
-      label = _ref.label,
-      onDropPropertyClick = _ref.onDropPropertyClick,
-      onKeyChange = _ref.onKeyChange,
-      readonly = _ref.readonly,
-      required = _ref.required,
-      schema = _ref.schema;
-  var _formContext$readonly = formContext.readonlyAsDisabled,
-      readonlyAsDisabled = _formContext$readonly === void 0 ? true : _formContext$readonly,
-      wrapperStyle = formContext.wrapperStyle;
-  var keyLabel = label + " Key"; // i18n ?
-
-  var additional = schema.hasOwnProperty(ADDITIONAL_PROPERTY_FLAG);
+function TitleField(_ref) {
+  let {
+    id,
+    title,
+    uiSchema
+  } = _ref;
+  const semanticProps = getSemanticProps({
+    uiSchema,
+    defaultSchemaProps: DEFAULT_OPTIONS
+  });
+
+  if (!title) {
+    return null;
+  }
+
+  return /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Header, {
+    id: id,
+    ...semanticProps,
+    as: "h5"
+  }, title);
+}
+
+const WrapIfAdditionalTemplate = _ref => {
+  let {
+    children,
+    classNames,
+    disabled,
+    id,
+    label,
+    onDropPropertyClick,
+    onKeyChange,
+    readonly,
+    required,
+    schema,
+    uiSchema,
+    registry
+  } = _ref;
+  // Button templates are not overridden in the uiSchema
+  const {
+    RemoveButton
+  } = registry.templates.ButtonTemplates;
+  const {
+    readonlyAsDisabled = true,
+    wrapperStyle
+  } = registry.formContext;
+  const keyLabel = label + " Key"; // i18n ?
+
+  const additional = (utils.ADDITIONAL_PROPERTY_FLAG in schema);
 
   if (!additional) {
-    return React.createElement(React.Fragment, null, children);
+    return /*#__PURE__*/React__default["default"].createElement("div", {
+      className: classNames
+    }, children);
   }
 
-  var handleBlur = function handleBlur(_ref2) {
-    var target = _ref2.target;
+  const handleBlur = _ref2 => {
+    let {
+      target
+    } = _ref2;
     return onKeyChange(target.value);
   };
 
-  return React.createElement("div", {
+  return /*#__PURE__*/React__default["default"].createElement("div", {
     className: classNames,
     key: id + "-key"
-  }, React.createElement(semanticUiReact.Grid, {
+  }, /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Grid, {
     columns: "equal"
-  }, React.createElement(semanticUiReact.Grid.Row, null, React.createElement(semanticUiReact.Grid.Column, {
+  }, /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Grid.Row, null, /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Grid.Column, {
     className: "form-additional"
-  }, React.createElement(semanticUiReact.Form.Group, {
+  }, /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Form.Group, {
     widths: "equal",
     grouped: true
-  }, React.createElement(semanticUiReact.Form.Input, {
+  }, /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Form.Input, {
     className: "form-group",
     hasFeedback: true,
     fluid: true,
@@ -569,518 +728,367 @@ var WrapIfAdditional = function WrapIfAdditional(_ref) {
     onBlur: !readonly ? handleBlur : undefined,
     style: wrapperStyle,
     type: "text"
-  }))), React.createElement(semanticUiReact.Grid.Column, {
+  }))), /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Grid.Column, {
     className: "form-additional",
     verticalAlign: "middle"
-  }, children), React.createElement(semanticUiReact.Grid.Column, null, React.createElement(semanticUiReact.Button, {
-    size: "mini",
-    icon: "trash",
+  }, children), /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Grid.Column, null, /*#__PURE__*/React__default["default"].createElement(RemoveButton, {
+    iconType: "mini",
     className: "array-item-remove",
-    tabIndex: "-1",
     disabled: disabled || readonly,
-    onClick: onDropPropertyClick(label)
+    onClick: onDropPropertyClick(label),
+    uiSchema: uiSchema
   })))));
 };
 
-function FieldTemplate(_ref) {
-  var id = _ref.id,
-      children = _ref.children,
-      classNames = _ref.classNames,
-      displayLabel = _ref.displayLabel,
-      label = _ref.label,
-      _ref$rawErrors = _ref.rawErrors,
-      rawErrors = _ref$rawErrors === void 0 ? [] : _ref$rawErrors,
-      rawHelp = _ref.rawHelp,
-      hidden = _ref.hidden,
-      rawDescription = _ref.rawDescription,
-      props = _objectWithoutPropertiesLoose(_ref, ["id", "children", "className", "classNames", "displayLabel", "label", "rawErrors", "rawHelp", "hidden", "rawDescription"]);
-
-  var semanticProps = getSemanticProps(props);
-  var wrapLabel = semanticProps.wrapLabel,
-      wrapContent = semanticProps.wrapContent;
-  var errorOptions = getSemanticErrorProps(props);
-
-  if (hidden) {
-    return children;
-  }
-
-  return React.createElement(WrapIfAdditional, _extends({
-    classNames: classNames,
-    id: id,
-    label: label
-  }, props), React.createElement(semanticUiReact.Form.Group, {
-    key: id,
-    widths: "equal",
-    grouped: true
-  }, React.createElement(MaybeWrap, {
-    wrap: wrapContent,
-    className: "sui-field-content"
-  }, children, displayLabel && rawDescription && React.createElement(MaybeWrap, {
-    wrap: wrapLabel,
-    className: "sui-field-label"
-  }, rawDescription && React.createElement(DescriptionField, {
-    description: rawDescription
-  })), React.createElement(HelpField, {
-    helpText: rawHelp,
-    id: id + "__help"
-  }), React.createElement(RawErrors, {
-    errors: rawErrors,
-    options: errorOptions
-  }))));
-}
-
-/* eslint-disable react/prop-types */
-var canExpand = core.utils.canExpand;
-
-function ObjectFieldTemplate(_ref) {
-  var DescriptionField = _ref.DescriptionField,
-      description = _ref.description,
-      TitleField = _ref.TitleField,
-      onAddClick = _ref.onAddClick,
-      title = _ref.title,
-      properties = _ref.properties,
-      disabled = _ref.disabled,
-      readOnly = _ref.readOnly,
-      required = _ref.required,
-      uiSchema = _ref.uiSchema,
-      schema = _ref.schema,
-      formData = _ref.formData,
-      idSchema = _ref.idSchema;
-  var fieldTitle = uiSchema["ui:title"] || title;
-  var fieldDescription = uiSchema["ui:description"] || description;
-  return React.createElement(React.Fragment, null, fieldTitle && React.createElement(TitleField, {
-    id: idSchema.$id + "-title",
-    title: fieldTitle,
-    options: uiSchema["ui:options"],
-    required: required
-  }), fieldDescription && React.createElement(DescriptionField, {
-    id: idSchema.$id + "-description",
-    description: fieldDescription
-  }), properties.map(function (prop) {
-    return prop.content;
-  }), canExpand(schema, uiSchema, formData) && React.createElement(semanticUiReact.Grid.Column, {
-    width: 16,
-    verticalAlign: "middle"
-  }, React.createElement(semanticUiReact.Grid.Row, null, React.createElement("div", {
-    style: {
-      marginTop: "1rem",
-      position: "relative",
-      textAlign: "right"
-    }
-  }, React.createElement(AddButton, {
-    onClick: onAddClick(schema),
-    disabled: disabled || readOnly
-  })))));
-}
-
-var getDisplayLabel = core.utils.getDisplayLabel;
+const Templates = {
+  ArrayFieldItemTemplate,
+  ArrayFieldTemplate,
+  BaseInputTemplate,
+  ButtonTemplates: {
+    AddButton,
+    MoveDownButton,
+    MoveUpButton,
+    RemoveButton,
+    SubmitButton
+  },
+  DescriptionFieldTemplate: DescriptionField,
+  ErrorListTemplate: ErrorList,
+  FieldErrorTemplate,
+  FieldHelpTemplate,
+  FieldTemplate,
+  ObjectFieldTemplate,
+  TitleFieldTemplate: TitleField,
+  WrapIfAdditionalTemplate
+};
 
 function CheckboxWidget(props) {
-  var id = props.id,
-      value = props.value,
-      required = props.required,
-      disabled = props.disabled,
-      readonly = props.readonly,
-      label = props.label,
-      autofocus = props.autofocus,
-      onChange = props.onChange,
-      onBlur = props.onBlur,
-      options = props.options,
-      onFocus = props.onFocus,
-      formContext = props.formContext,
-      schema = props.schema,
-      uiSchema = props.uiSchema;
-  var semanticProps = getSemanticProps({
-    options: options,
-    formContext: formContext,
-    schema: schema,
-    uiSchema: uiSchema,
+  const {
+    id,
+    value,
+    required,
+    disabled,
+    readonly,
+    label,
+    autofocus,
+    onChange,
+    onBlur,
+    options,
+    onFocus,
+    formContext,
+    schema,
+    uiSchema,
+    registry,
+    rawErrors = []
+  } = props;
+  const semanticProps = getSemanticProps({
+    options,
+    formContext,
+    uiSchema,
     defaultSchemaProps: {
       inverted: false
     }
   });
-  var displayLabel = getDisplayLabel(schema, uiSchema
-  /* TODO: , rootSchema */
-  );
+  const {
+    schemaUtils
+  } = registry;
+  const displayLabel = schemaUtils.getDisplayLabel(schema, uiSchema);
 
-  var _onChange = function _onChange(event, data) {
-    return onChange && onChange(data.checked);
-  };
+  const _onChange = (_, data) => onChange && onChange(data.checked);
 
-  var _onBlur = function _onBlur() {
-    return onBlur && onBlur(id, value);
-  };
+  const _onBlur = () => onBlur && onBlur(id, value);
 
-  var _onFocus = function _onFocus() {
-    return onFocus && onFocus(id, value);
-  };
+  const _onFocus = () => onFocus && onFocus(id, value);
 
-  var checked = value == "true" || value == true;
-  return React.createElement(semanticUiReact.Form.Checkbox, _extends({
+  const checked = value == "true" || value == true;
+  return /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Form.Checkbox, {
     id: id,
+    name: id,
     disabled: disabled || readonly,
-    autoFocus: autofocus
-  }, semanticProps, {
+    autoFocus: autofocus,
+    ...semanticProps,
     checked: typeof value === "undefined" ? false : checked,
+    error: rawErrors.length > 0,
     onChange: _onChange,
     onBlur: _onBlur,
     onFocus: _onFocus,
     required: required,
     label: displayLabel ? label || schema.title : false
-  }));
+  });
 }
 
 function selectValue(value, selected, all) {
-  var at = all.indexOf(value);
-  var updated = selected.slice(0, at).concat(value, selected.slice(at)); // As inserting values at predefined index positions doesn't work with empty
+  const at = all.indexOf(value);
+  const updated = selected.slice(0, at).concat(value, selected.slice(at)); // As inserting values at predefined index positions doesn't work with empty
   // arrays, we need to reorder the updated selection to match the initial order
 
-  return updated.sort(function (a, b) {
-    return all.indexOf(a) > all.indexOf(b);
-  });
+  return updated.sort((a, b) => all.indexOf(a) > all.indexOf(b));
 }
 
 function deselectValue(value, selected) {
-  return selected.filter(function (v) {
-    return v !== value;
-  });
+  return selected.filter(v => v !== value);
 }
 
 function CheckboxesWidget(props) {
-  var id = props.id,
-      disabled = props.disabled,
-      options = props.options,
-      value = props.value,
-      autofocus = props.autofocus,
-      readonly = props.readonly,
-      onChange = props.onChange,
-      onBlur = props.onBlur,
-      onFocus = props.onFocus,
-      formContext = props.formContext,
-      schema = props.schema,
-      uiSchema = props.uiSchema;
-  var enumOptions = options.enumOptions,
-      enumDisabled = options.enumDisabled,
-      inline = options.inline;
-  var title = schema.title;
-  var semanticProps = getSemanticProps({
-    options: options,
-    formContext: formContext,
-    schema: schema,
-    uiSchema: uiSchema,
+  const {
+    id,
+    disabled,
+    options,
+    value,
+    autofocus,
+    readonly,
+    onChange,
+    onBlur,
+    onFocus,
+    formContext,
+    schema,
+    uiSchema,
+    rawErrors = [],
+    registry
+  } = props;
+  const TitleFieldTemplate = utils.getTemplate("TitleFieldTemplate", registry, options);
+  const {
+    enumOptions,
+    enumDisabled,
+    inline
+  } = options;
+  const {
+    title
+  } = schema;
+  const semanticProps = getSemanticProps({
+    options,
+    formContext,
+    uiSchema,
     defaultSchemaProps: {
       inverted: false
     }
   });
 
-  var _onChange = function _onChange(option) {
-    return function (_ref) {
-      var checked = _ref.target.checked;
-      // eslint-disable-next-line no-shadow
-      var all = enumOptions.map(function (_ref2) {
-        var value = _ref2.value;
-        return value;
-      });
-
-      if (checked) {
-        onChange(selectValue(option.value, value, all));
-      } else {
-        onChange(deselectValue(option.value, value));
+  const _onChange = option => _ref => {
+    let {
+      target: {
+        checked
       }
-    };
+    } = _ref;
+    // eslint-disable-next-line no-shadow
+    const all = enumOptions ? enumOptions.map(_ref2 => {
+      let {
+        value
+      } = _ref2;
+      return value;
+    }) : [];
+
+    if (checked) {
+      onChange(selectValue(option.value, value, all));
+    } else {
+      onChange(deselectValue(option.value, value));
+    }
   };
 
-  var _onBlur = function _onBlur() {
-    return onBlur && onBlur(id, value);
-  };
+  const _onBlur = () => onBlur && onBlur(id, value);
 
-  var _onFocus = function _onFocus() {
-    return onFocus && onFocus(id, value);
-  };
+  const _onFocus = () => onFocus && onFocus(id, value);
 
-  var inlineOption = inline ? {
+  const inlineOption = inline ? {
     inline: true
   } : {
     grouped: true
   };
-  return React.createElement(React.Fragment, null, title && React.createElement(TitleField, {
-    title: title
-  }), React.createElement(semanticUiReact.Form.Group, inlineOption, enumOptions.map(function (option, index) {
-    var checked = value.indexOf(option.value) !== -1;
-    var itemDisabled = enumDisabled && enumDisabled.indexOf(option.value) !== -1;
-    return React.createElement(semanticUiReact.Form.Checkbox, _extends({
-      id: id + "_" + index,
-      key: id + "_" + index,
-      label: option.label
-    }, semanticProps, {
+  return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, title && /*#__PURE__*/React__default["default"].createElement(TitleFieldTemplate, {
+    id: id + "-title",
+    title: title,
+    uiSchema: uiSchema,
+    registry: registry
+  }), /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Form.Group, {
+    id: id,
+    name: id,
+    ...inlineOption
+  }, Array.isArray(enumOptions) && enumOptions.map((option, index) => {
+    const checked = value.indexOf(option.value) !== -1;
+    const itemDisabled = Array.isArray(enumDisabled) && enumDisabled.indexOf(option.value) !== -1;
+    return /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Form.Checkbox, {
+      id: id + "-" + option.value,
+      name: id,
+      key: option.value,
+      label: option.label,
+      ...semanticProps,
       checked: checked,
+      error: rawErrors.length > 0,
       disabled: disabled || itemDisabled || readonly,
       autoFocus: autofocus && index === 0,
       onChange: _onChange(option),
       onBlur: _onBlur,
       onFocus: _onFocus
-    }));
+    });
   })));
 }
 
-var getDisplayLabel$1 = core.utils.getDisplayLabel;
-
-function PasswordWidget(props) {
-  var id = props.id,
-      required = props.required,
-      readonly = props.readonly,
-      disabled = props.disabled,
-      label = props.label,
-      name = props.name,
-      value = props.value,
-      onChange = props.onChange,
-      onBlur = props.onBlur,
-      onFocus = props.onFocus,
-      autofocus = props.autofocus,
-      options = props.options,
-      schema = props.schema,
-      uiSchema = props.uiSchema,
-      formContext = props.formContext;
-  var semanticProps = getSemanticProps({
-    schema: schema,
-    uiSchema: uiSchema,
-    formContext: formContext,
-    options: options
-  }); // eslint-disable-next-line no-shadow
-
-  var _onChange = function _onChange(_ref) {
-    var value = _ref.target.value;
-    return onChange && onChange(value === "" ? options.emptyValue : value);
-  };
-
-  var _onBlur = function _onBlur() {
-    return onBlur && onBlur(id, value);
-  };
-
-  var _onFocus = function _onFocus() {
-    return onFocus && onFocus(id, value);
-  };
-
-  var displayLabel = getDisplayLabel$1(schema, uiSchema
-  /* TODO: , rootSchema */
-  );
-  return React.createElement(semanticUiReact.Form.Input, _extends({
-    id: id,
-    key: id,
-    label: displayLabel ? label || schema.title : false,
-    autoFocus: autofocus,
-    required: required,
-    disabled: disabled || readonly,
-    name: name
-  }, semanticProps, {
-    type: "password",
-    value: value || "",
-    onChange: _onChange,
-    onBlur: _onBlur,
-    onFocus: _onFocus
-  }));
-}
-
 function RadioWidget(props) {
-  var id = props.id,
-      value = props.value,
-      required = props.required,
-      disabled = props.disabled,
-      readonly = props.readonly,
-      onChange = props.onChange,
-      onBlur = props.onBlur,
-      onFocus = props.onFocus,
-      schema = props.schema,
-      options = props.options,
-      formContext = props.formContext,
-      uiSchema = props.uiSchema; // Generating a unique field name to identify this set of radio buttons
-
-  var name = Math.random().toString();
-  var enumOptions = options.enumOptions,
-      enumDisabled = options.enumDisabled;
-  var semanticProps = getSemanticProps({
-    formContext: formContext,
-    options: options,
-    uiSchema: uiSchema
+  const {
+    id,
+    value,
+    required,
+    disabled,
+    readonly,
+    onChange,
+    onBlur,
+    onFocus,
+    schema,
+    options,
+    formContext,
+    uiSchema,
+    rawErrors = []
+  } = props;
+  const {
+    enumOptions,
+    enumDisabled
+  } = options;
+  const semanticProps = getSemanticProps({
+    formContext,
+    options,
+    uiSchema
   }); // eslint-disable-next-line no-shadow
 
-  var _onChange = function _onChange(event, _ref) {
-    var eventValue = _ref.value;
+  const _onChange = (_, _ref) => {
+    let {
+      value: eventValue
+    } = _ref;
     return onChange && onChange(schema.type === "boolean" ? eventValue !== "false" : eventValue);
   };
 
-  var _onBlur = function _onBlur() {
-    return onBlur && onBlur(id, value);
-  };
+  const _onBlur = () => onBlur && onBlur(id, value);
 
-  var _onFocus = function _onFocus() {
-    return onFocus && onFocus(id, value);
-  };
+  const _onFocus = () => onFocus && onFocus(id, value);
 
-  var inlineOption = options.inline ? {
+  const inlineOption = options.inline ? {
     inline: true
   } : {
     grouped: true
   };
-  return React.createElement(semanticUiReact.Form.Group, inlineOption, enumOptions.map(function (option, i) {
-    var itemDisabled = enumDisabled && enumDisabled.indexOf(option.value) !== -1;
-    return React.createElement(semanticUiReact.Form.Field, _extends({
+  return /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Form.Group, { ...inlineOption
+  }, Array.isArray(enumOptions) && enumOptions.map(option => {
+    const itemDisabled = Array.isArray(enumDisabled) && enumDisabled.indexOf(option.value) !== -1;
+    return /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Form.Field, {
       required: required,
       control: semanticUiReact.Radio,
-      name: name
-    }, semanticProps, {
+      id: id + "-" + option.value,
+      name: id,
+      ...semanticProps,
       onFocus: _onFocus,
       onBlur: _onBlur,
       label: "" + option.label,
       value: "" + option.value,
-      key: option.value + "-" + i,
+      error: rawErrors.length > 0,
+      key: option.value,
       checked: value == option.value,
       onChange: _onChange,
       disabled: disabled || itemDisabled || readonly
-    }));
+    });
   }));
 }
 
-var rangeSpec = core.utils.rangeSpec;
-
 function RangeWidget(props) {
-  var id = props.id,
-      name = props.name,
-      value = props.value,
-      required = props.required,
-      readonly = props.readonly,
-      disabled = props.disabled,
-      onChange = props.onChange,
-      onBlur = props.onBlur,
-      onFocus = props.onFocus,
-      options = props.options,
-      schema = props.schema,
-      uiSchema = props.uiSchema,
-      formContext = props.formContext;
-  var semanticProps = getSemanticProps({
-    formContext: formContext,
-    options: options,
-    uiSchema: uiSchema,
+  const {
+    id,
+    value,
+    required,
+    readonly,
+    disabled,
+    onChange,
+    onBlur,
+    onFocus,
+    options,
+    schema,
+    uiSchema,
+    formContext,
+    rawErrors = []
+  } = props;
+  const semanticProps = getSemanticProps({
+    formContext,
+    options,
+    uiSchema,
     defaultSchemaProps: {
       fluid: true
     }
   }); // eslint-disable-next-line no-shadow
 
-  var _onChange = function _onChange(_ref) {
-    var value = _ref.target.value;
+  const _onChange = _ref => {
+    let {
+      target: {
+        value
+      }
+    } = _ref;
     return onChange && onChange(value === "" ? options.emptyValue : value);
   };
 
-  var _onBlur = function _onBlur() {
-    return onBlur && onBlur(id, value);
-  };
+  const _onBlur = () => onBlur && onBlur(id, value);
 
-  var _onFocus = function _onFocus() {
-    return onFocus && onFocus(id, value);
-  };
+  const _onFocus = () => onFocus && onFocus(id, value);
 
-  return React.createElement(React.Fragment, null, React.createElement(semanticUiReact.Input, _extends({
+  return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Input, {
     id: id,
     key: id,
-    name: name,
+    name: id,
     type: "range",
     required: required,
-    disabled: disabled || readonly
-  }, rangeSpec(schema), semanticProps, {
+    disabled: disabled || readonly,
+    ...utils.rangeSpec(schema),
+    ...semanticProps,
     value: value || "",
+    error: rawErrors.length > 0,
     onChange: _onChange,
     onBlur: _onBlur,
     onFocus: _onFocus
-  })), React.createElement("span", null, value));
+  }), /*#__PURE__*/React__default["default"].createElement("span", null, value));
 }
 
-var asNumber = core.utils.asNumber,
-    guessType = core.utils.guessType;
-var nums = /*#__PURE__*/new Set(["number", "integer"]);
-/**
- * * Returns and creates an array format required for semantic drop down
- * @param {array} enumOptions- array of items for the dropdown
- * @param {array} enumDisabled - array of enum option values to disable
- * @returns {*}
+/**
+ * * Returns and creates an array format required for semantic drop down
+ * @param {array} enumOptions- array of items for the dropdown
+ * @param {array} enumDisabled - array of enum option values to disable
+ * @returns {*}
  */
 
 function createDefaultValueOptionsForDropDown(enumOptions, enumDisabled) {
-  var disabledOptions = enumDisabled || [];
-  var options = []; // eslint-disable-next-line no-shadow
-
-  options = _.map(enumOptions, function (_ref) {
-    var label = _ref.label,
-        value = _ref.value;
+  const disabledOptions = enumDisabled || [];
+  const options = map__default["default"](enumOptions, _ref => {
+    let {
+      label,
+      value
+    } = _ref;
     return {
       disabled: disabledOptions.indexOf(value) !== -1,
       key: label,
       text: label,
-      value: value
+      value
     };
   });
   return options;
 }
-/**
- * This is a silly limitation in the DOM where option change event values are
- * always retrieved as strings.
- */
-
-
-var processValue = function processValue(schema, value) {
-  // "enum" is a reserved word, so only "type" and "items" can be destructured
-  var type = schema.type,
-      items = schema.items;
-
-  if (value === "") {
-    return undefined;
-  } else if (type === "array" && items && nums.has(items.type)) {
-    return value.map(asNumber);
-  } else if (type === "boolean") {
-    return value === "true" || value === true;
-  } else if (type === "number") {
-    return asNumber(value);
-  } // If type is undefined, but an enum is present, try and infer the type from
-  // the enum values
-
-
-  if (schema.enum) {
-    if (schema.enum.every(function (x) {
-      return guessType(x) === "number";
-    })) {
-      return asNumber(value);
-    } else if (schema.enum.every(function (x) {
-      return guessType(x) === "boolean";
-    })) {
-      return value === "true";
-    }
-  }
-
-  return value;
-};
 
 function SelectWidget(props) {
-  var schema = props.schema,
-      uiSchema = props.uiSchema,
-      formContext = props.formContext,
-      id = props.id,
-      options = props.options,
-      name = props.name,
-      label = props.label,
-      required = props.required,
-      disabled = props.disabled,
-      readonly = props.readonly,
-      value = props.value,
-      multiple = props.multiple,
-      placeholder = props.placeholder,
-      autofocus = props.autofocus,
-      onChange = props.onChange,
-      onBlur = props.onBlur,
-      onFocus = props.onFocus;
-  var semanticProps = getSemanticProps({
-    schema: schema,
-    uiSchema: uiSchema,
-    formContext: formContext,
-    options: options,
+  const {
+    schema,
+    uiSchema,
+    formContext,
+    id,
+    options,
+    label,
+    required,
+    disabled,
+    readonly,
+    value,
+    multiple,
+    placeholder,
+    autofocus,
+    onChange,
+    onBlur,
+    onFocus,
+    rawErrors = []
+  } = props;
+  const semanticProps = getSemanticProps({
+    uiSchema,
+    formContext,
+    options,
     defaultSchemaProps: {
       inverted: "false",
       selection: true,
@@ -1089,37 +1097,51 @@ function SelectWidget(props) {
       upward: false
     }
   });
-  var enumDisabled = options.enumDisabled,
-      enumOptions = options.enumOptions;
-  var emptyValue = multiple ? [] : "";
-  var dropdownOptions = createDefaultValueOptionsForDropDown(enumOptions, enumDisabled);
-
-  var _onChange = function _onChange(event, // eslint-disable-next-line no-shadow
-  _ref2) {
-    var value = _ref2.value;
-    return onChange && onChange(processValue(schema, value));
+  const {
+    enumDisabled,
+    enumOptions
+  } = options;
+  const emptyValue = multiple ? [] : "";
+  const dropdownOptions = createDefaultValueOptionsForDropDown(enumOptions, enumDisabled);
+
+  const _onChange = (_, _ref2) => {
+    let {
+      value
+    } = _ref2;
+    return onChange && onChange(utils.processSelectValue(schema, value, options));
   }; // eslint-disable-next-line no-shadow
 
 
-  var _onBlur = function _onBlur(_ref3) {
-    var value = _ref3.target.value;
-    return onBlur && onBlur(id, processValue(schema, value));
+  const _onBlur = (_, _ref3) => {
+    let {
+      target: {
+        value
+      }
+    } = _ref3;
+    return onBlur && onBlur(id, utils.processSelectValue(schema, value, options));
   };
 
-  var _onFocus = function _onFocus(_ref4) {
-    var value = _ref4.target.value;
-    return onFocus && onFocus(id, processValue(schema, value));
+  const _onFocus = (_, _ref4) => {
+    let {
+      // eslint-disable-next-line no-shadow
+      target: {
+        value
+      }
+    } = _ref4;
+    return onFocus && onFocus(id, utils.processSelectValue(schema, value, options));
   };
 
-  return React.createElement(semanticUiReact.Form.Dropdown, _extends({
+  return /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Form.Dropdown, {
     key: id,
-    name: name,
+    id: id,
+    name: id,
     label: label || schema.title,
     multiple: typeof multiple === "undefined" ? false : multiple,
     value: typeof value === "undefined" ? emptyValue : value,
+    error: rawErrors.length > 0,
     disabled: disabled,
-    placeholder: placeholder
-  }, semanticProps, {
+    placeholder: placeholder,
+    ...semanticProps,
     required: required,
     autoFocus: autofocus,
     readOnly: readonly,
@@ -1127,480 +1149,93 @@ function SelectWidget(props) {
     onChange: _onChange,
     onBlur: _onBlur,
     onFocus: _onFocus
-  }));
+  });
 }
 
-var getDisplayLabel$2 = core.utils.getDisplayLabel;
-
 function TextareaWidget(props) {
-  var id = props.id,
-      placeholder = props.placeholder,
-      value = props.value,
-      required = props.required,
-      disabled = props.disabled,
-      autofocus = props.autofocus,
-      label = props.label,
-      name = props.name,
-      readonly = props.readonly,
-      onBlur = props.onBlur,
-      onFocus = props.onFocus,
-      onChange = props.onChange,
-      options = props.options,
-      schema = props.schema,
-      uiSchema = props.uiSchema,
-      formContext = props.formContext;
-  var semanticProps = getSemanticProps({
-    formContext: formContext,
-    options: options,
+  const {
+    id,
+    placeholder,
+    value,
+    required,
+    disabled,
+    autofocus,
+    label,
+    readonly,
+    onBlur,
+    onFocus,
+    onChange,
+    options,
+    schema,
+    uiSchema,
+    formContext,
+    registry,
+    rawErrors = []
+  } = props;
+  const semanticProps = getSemanticProps({
+    formContext,
+    options,
     defaultSchemaProps: {
       inverted: false
     }
-  }); // eslint-disable-next-line no-shadow
-
-  var _onChange = function _onChange(_ref) {
-    var value = _ref.target.value;
+  });
+  const {
+    schemaUtils
+  } = registry; // eslint-disable-next-line no-shadow
+
+  const _onChange = _ref => {
+    let {
+      target: {
+        value
+      }
+    } = _ref;
     return onChange && onChange(value === "" ? options.emptyValue : value);
   };
 
-  var _onBlur = function _onBlur() {
-    return onBlur && onBlur(id, value);
-  };
+  const _onBlur = () => onBlur && onBlur(id, value);
 
-  var _onFocus = function _onFocus() {
-    return onFocus && onFocus(id, value);
-  };
+  const _onFocus = () => onFocus && onFocus(id, value);
 
-  var displayLabel = getDisplayLabel$2(schema, uiSchema
-  /* TODO: , rootSchema */
-  );
-  return React.createElement(semanticUiReact.Form.TextArea, _extends({
+  const displayLabel = schemaUtils.getDisplayLabel(schema, uiSchema);
+  return /*#__PURE__*/React__default["default"].createElement(semanticUiReact.Form.TextArea, {
     id: id,
     key: id,
+    name: id,
     label: displayLabel ? label || schema.title : false,
     placeholder: placeholder,
     autoFocus: autofocus,
     required: required,
     disabled: disabled || readonly,
-    name: name
-  }, semanticProps, {
+    ...semanticProps,
     value: value || "",
+    error: rawErrors.length > 0,
     rows: options.rows || 5,
     onChange: _onChange,
     onBlur: _onBlur,
     onFocus: _onFocus
-  }));
-}
-
-var getDisplayLabel$3 = core.utils.getDisplayLabel;
-
-function TextWidget(props) {
-  var id = props.id,
-      placeholder = props.placeholder,
-      name = props.name,
-      label = props.label,
-      value = props.value,
-      required = props.required,
-      readonly = props.readonly,
-      disabled = props.disabled,
-      onChange = props.onChange,
-      onBlur = props.onBlur,
-      onFocus = props.onFocus,
-      autofocus = props.autofocus,
-      options = props.options,
-      schema = props.schema,
-      uiSchema = props.uiSchema,
-      formContext = props.formContext;
-  var semanticProps = getSemanticProps({
-    formContext: formContext,
-    options: options,
-    uiSchema: uiSchema
-  }); // eslint-disable-next-line no-shadow
-
-  var _onChange = function _onChange(_ref) {
-    var value = _ref.target.value;
-    return onChange(value === "" ? options.emptyValue : value);
-  };
-
-  var _onBlur = function _onBlur() {
-    return onBlur && onBlur(id, value);
-  };
-
-  var _onFocus = function _onFocus() {
-    return onFocus && onFocus(id, value);
-  };
-
-  var displayLabel = getDisplayLabel$3(schema, uiSchema
-  /* TODO: , rootSchema */
-  );
-  return React.createElement(semanticUiReact.Form.Input, _extends({
-    key: id,
-    id: id,
-    placeholder: placeholder,
-    type: schema.type === 'string' ? 'text' : "" + schema.type,
-    label: displayLabel ? label || schema.title : false,
-    required: required,
-    autoFocus: autofocus,
-    disabled: disabled || readonly,
-    name: name
-  }, semanticProps, {
-    value: value || value === 0 ? value : "",
-    onChange: _onChange,
-    onBlur: _onBlur,
-    onFocus: _onFocus
-  }));
-}
-
-var getDisplayLabel$4 = core.utils.getDisplayLabel;
-
-function UpDownWidget(props) {
-  var id = props.id,
-      name = props.name,
-      label = props.label,
-      value = props.value,
-      required = props.required,
-      readonly = props.readonly,
-      disabled = props.disabled,
-      onChange = props.onChange,
-      onBlur = props.onBlur,
-      onFocus = props.onFocus,
-      autofocus = props.autofocus,
-      options = props.options,
-      schema = props.schema,
-      uiSchema = props.uiSchema,
-      formContext = props.formContext;
-  var semanticProps = getSemanticProps({
-    formContext: formContext,
-    options: options,
-    uiSchema: uiSchema
-  }); // eslint-disable-next-line no-shadow
-
-  var _onChange = function _onChange(_ref) {
-    var value = _ref.target.value;
-    return onChange && onChange(value);
-  };
-
-  var _onBlur = function _onBlur() {
-    return onBlur && onBlur(id, value);
-  };
-
-  var _onFocus = function _onFocus() {
-    return onFocus && onFocus(id, value);
-  };
-
-  var displayLabel = getDisplayLabel$4(schema, uiSchema
-  /* TODO: , rootSchema */
-  );
-  return React.createElement(React.Fragment, null, React.createElement(semanticUiReact.Form.Input, _extends({
-    id: id,
-    key: id,
-    autoFocus: autofocus,
-    required: required,
-    type: "number",
-    label: displayLabel ? label || schema.title : false,
-    disabled: disabled || readonly,
-    name: name
-  }, semanticProps, {
-    value: value || value === 0 ? value : "",
-    onChange: _onChange,
-    onBlur: _onBlur,
-    onFocus: _onFocus
-  })));
-}
-
-var getDisplayLabel$5 = core.utils.getDisplayLabel;
-
-function DateWidget(props) {
-  var id = props.id,
-      required = props.required,
-      readonly = props.readonly,
-      disabled = props.disabled,
-      name = props.name,
-      label = props.label,
-      value = props.value,
-      onChange = props.onChange,
-      onBlur = props.onBlur,
-      onFocus = props.onFocus,
-      autofocus = props.autofocus,
-      options = props.options,
-      formContext = props.formContext,
-      schema = props.schema,
-      uiSchema = props.uiSchema;
-  var semanticProps = getSemanticProps({
-    uiSchema: uiSchema,
-    schema: schema,
-    formContext: formContext,
-    options: options
-  });
-
-  var _onChange = function _onChange(_ref) {
-    var value = _ref.target.value;
-    return onChange && onChange(value);
-  };
-
-  var _onBlur = function _onBlur() {
-    return onBlur && onBlur(id, value);
-  };
-
-  var _onFocus = function _onFocus() {
-    return onFocus && onFocus(id, value);
-  };
-
-  var displayLabel = getDisplayLabel$5(schema, uiSchema
-  /* TODO: , rootSchema */
-  );
-  return React.createElement(semanticUiReact.Form.Input, _extends({
-    key: id,
-    id: id,
-    type: "date",
-    label: displayLabel ? label || schema.title : false,
-    required: required,
-    autoFocus: autofocus,
-    disabled: disabled || readonly,
-    name: name
-  }, semanticProps, {
-    value: value || value === 0 ? value : "",
-    onChange: _onChange,
-    onBlur: _onBlur,
-    onFocus: _onFocus
-  }));
-}
-
-var localToUTC = core.utils.localToUTC,
-    utcToLocal = core.utils.utcToLocal,
-    getDisplayLabel$6 = core.utils.getDisplayLabel;
-
-function DateTimeWidget(props) {
-  var id = props.id,
-      required = props.required,
-      readonly = props.readonly,
-      disabled = props.disabled,
-      name = props.name,
-      label = props.label,
-      schema = props.schema,
-      uiSchema = props.uiSchema,
-      value = props.value,
-      onChange = props.onChange,
-      onBlur = props.onBlur,
-      onFocus = props.onFocus,
-      autofocus = props.autofocus,
-      options = props.options,
-      formContext = props.formContext;
-  var semanticProps = getSemanticProps({
-    uiSchema: uiSchema,
-    schema: schema,
-    formContext: formContext,
-    options: options
   });
-
-  var _onChange = function _onChange(_ref) {
-    var value = _ref.target.value;
-    return onChange && onChange(localToUTC(value));
-  };
-
-  var _onBlur = function _onBlur() {
-    return onBlur && onBlur(id, value);
-  };
-
-  var _onFocus = function _onFocus() {
-    return onFocus && onFocus(id, value);
-  };
-
-  var dateValue = utcToLocal(value);
-  var displayLabel = getDisplayLabel$6(schema, uiSchema
-  /* TODO: , rootSchema */
-  );
-  return React.createElement(semanticUiReact.Form.Input, _extends({
-    key: id,
-    id: id,
-    type: "datetime-local",
-    label: displayLabel ? label || schema.title : false,
-    required: required,
-    autoFocus: autofocus,
-    disabled: disabled || readonly,
-    name: name
-  }, semanticProps, {
-    value: dateValue,
-    onChange: _onChange,
-    onBlur: _onBlur,
-    onFocus: _onFocus
-  }));
-}
-
-var getDisplayLabel$7 = core.utils.getDisplayLabel;
-
-function EmailWidget(props) {
-  var id = props.id,
-      required = props.required,
-      readonly = props.readonly,
-      disabled = props.disabled,
-      name = props.name,
-      label = props.label,
-      schema = props.schema,
-      uiSchema = props.uiSchema,
-      value = props.value,
-      onChange = props.onChange,
-      onBlur = props.onBlur,
-      onFocus = props.onFocus,
-      autofocus = props.autofocus,
-      options = props.options,
-      formContext = props.formContext;
-  var semanticProps = getSemanticProps({
-    schema: schema,
-    uiSchema: uiSchema,
-    formContext: formContext,
-    options: options
-  }); // eslint-disable-next-line no-shadow
-
-  var _onChange = function _onChange(_ref) {
-    var value = _ref.target.value;
-    return onChange(value === "" ? options.emptyValue : value);
-  };
-
-  var _onBlur = function _onBlur() {
-    return onBlur && onBlur(id, value);
-  };
-
-  var _onFocus = function _onFocus() {
-    return onFocus && onFocus(id, value);
-  };
-
-  var displayLabel = getDisplayLabel$7(schema, uiSchema
-  /* TODO: , rootSchema */
-  );
-  return React.createElement(semanticUiReact.Form.Input, _extends({
-    key: id,
-    id: id,
-    type: "email",
-    label: displayLabel ? label || schema.title : false,
-    required: required,
-    autoFocus: autofocus,
-    disabled: disabled || readonly,
-    name: name
-  }, semanticProps, {
-    value: value || value === 0 ? value : "",
-    onChange: _onChange,
-    onBlur: _onBlur,
-    onFocus: _onFocus
-  }));
-}
-
-var getDisplayLabel$8 = core.utils.getDisplayLabel;
-
-function URLWidget(props) {
-  var id = props.id,
-      name = props.name,
-      label = props.label,
-      value = props.value,
-      required = props.required,
-      readonly = props.readonly,
-      disabled = props.disabled,
-      onChange = props.onChange,
-      onBlur = props.onBlur,
-      onFocus = props.onFocus,
-      autofocus = props.autofocus,
-      options = props.options,
-      schema = props.schema,
-      uiSchema = props.uiSchema,
-      formContext = props.formContext;
-  var semanticProps = getSemanticProps({
-    formContext: formContext,
-    options: options,
-    uiSchema: uiSchema
-  }); // eslint-disable-next-line no-shadow
-
-  var _onChange = function _onChange(_ref) {
-    var value = _ref.target.value;
-    return onChange(value === "" ? options.emptyValue : value);
-  };
-
-  var _onBlur = function _onBlur() {
-    return onBlur && onBlur(id, value);
-  };
-
-  var _onFocus = function _onFocus() {
-    return onFocus && onFocus(id, value);
-  };
-
-  var displayLabel = getDisplayLabel$8(schema, uiSchema
-  /* TODO: , rootSchema */
-  );
-  return React.createElement(semanticUiReact.Form.Input, _extends({
-    key: id,
-    id: id,
-    type: "url",
-    label: displayLabel ? label || schema.title : false,
-    required: required,
-    autoFocus: autofocus,
-    disabled: disabled || readonly,
-    name: name
-  }, semanticProps, {
-    value: value || value === 0 ? value : "",
-    onChange: _onChange,
-    onBlur: _onBlur,
-    onFocus: _onFocus
-  }));
 }
 
-var getSubmitButtonOptions = core.utils.getSubmitButtonOptions;
-var SubmitButton = (function (_ref) {
-  var uiSchema = _ref.uiSchema;
-
-  var _getSubmitButtonOptio = getSubmitButtonOptions(uiSchema),
-      submitText = _getSubmitButtonOptio.submitText,
-      norender = _getSubmitButtonOptio.norender,
-      submitButtonProps = _getSubmitButtonOptio.props;
-
-  if (norender) {
-    return null;
-  }
-
-  return React.createElement(semanticUiReact.Button, _extends({
-    type: "submit",
-    primary: true
-  }, submitButtonProps), submitText);
-});
-
 var Widgets = {
-  CheckboxWidget: CheckboxWidget,
-  CheckboxesWidget: CheckboxesWidget,
-  DateWidget: DateWidget,
-  DateTimeWidget: DateTimeWidget,
-  PasswordWidget: PasswordWidget,
-  EmailWidget: EmailWidget,
-  URLWidget: URLWidget,
-  RadioWidget: RadioWidget,
-  RangeWidget: RangeWidget,
-  SelectWidget: SelectWidget,
-  TextareaWidget: TextareaWidget,
-  TextWidget: TextWidget,
-  UpDownWidget: UpDownWidget,
-  SubmitButton: SubmitButton
+  CheckboxWidget,
+  CheckboxesWidget,
+  RadioWidget,
+  RangeWidget,
+  SelectWidget,
+  TextareaWidget
 };
 
-var getDefaultRegistry = core.utils.getDefaultRegistry;
-
-var _getDefaultRegistry = /*#__PURE__*/getDefaultRegistry(),
-    fields = _getDefaultRegistry.fields,
-    widgets = _getDefaultRegistry.widgets;
-
-var Theme = {
-  ArrayFieldTemplate: ArrayFieldTemplate,
-  ErrorList: ErrorList,
-  fields: /*#__PURE__*/_extends({}, fields, Fields),
-  FieldTemplate: FieldTemplate,
-  ObjectFieldTemplate: ObjectFieldTemplate,
-  _internalFormWrapper: semanticUiReact.Form,
-  widgets: /*#__PURE__*/_extends({}, widgets, Widgets)
+const Theme = {
+  templates: Templates,
+  widgets: Widgets,
+  _internalFormWrapper: semanticUiReact.Form
 };
 
-var SemanticUIForm = /*#__PURE__*/core.withTheme(Theme);
+const SemanticUIForm = /*#__PURE__*/core.withTheme(Theme);
 
-exports.ArrayFieldTemplate = ArrayFieldTemplate;
-exports.FieldTemplate = FieldTemplate;
-exports.Fields = Fields;
-exports.ObjectFieldTemplate = ObjectFieldTemplate;
-exports.SemanticUIForm = SemanticUIForm;
+exports.Form = SemanticUIForm;
+exports.Templates = Templates;
 exports.Theme = Theme;
 exports.Widgets = Widgets;
-exports.default = SemanticUIForm;
+exports["default"] = SemanticUIForm;
 //# sourceMappingURL=semantic-ui.cjs.development.js.map