@rjsf/semantic-ui 4.2.0 → 4.2.1

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

@@ -0,0 +1,1607 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@rjsf/core'), require('semantic-ui-react'), require('react'), require('prop-types'), require('nanoid'), require('lodash-es')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@rjsf/core', 'semantic-ui-react', 'react', 'prop-types', 'nanoid', 'lodash-es'], factory) :
+  (global = global || self, factory(global['@rjsf/semantic-ui'] = {}, global.core, global.semanticUiReact, global.React, global.PropTypes, global.nanoid, global._));
+}(this, (function (exports, core, semanticUiReact, React, PropTypes, nanoid, _) { 'use strict';
+
+  React = React && Object.prototype.hasOwnProperty.call(React, 'default') ? React['default'] : React;
+  PropTypes = PropTypes && Object.prototype.hasOwnProperty.call(PropTypes, 'default') ? PropTypes['default'] : PropTypes;
+  _ = _ && Object.prototype.hasOwnProperty.call(_, 'default') ? _['default'] : _;
+
+  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, {
+      icon: true,
+      size: "tiny",
+      labelPosition: "left"
+    }), React.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}
+   */
+
+  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);
+  }
+  /**
+   * 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);
+  }
+  /**
+   * 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) {
+    if (omit === void 0) {
+      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
+    // returning them as a string
+
+    return [].concat(new Set(classList.filter(function (cn) {
+      return !omit.includes(cn);
+    }))).join(" ");
+  }
+  /**
+   *
+   * @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;
+  }
+
+  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
+
+
+  function DefaultArrayItem(props) {
+    return React.createElement("div", {
+      className: "array-item",
+      key: props.key
+    }, React.createElement(MaybeWrap, {
+      wrap: props.wrapItem,
+      component: semanticUiReact.Segment
+    }, React.createElement(semanticUiReact.Grid, {
+      style: !isInitialArrayItem(props) ? _extends({}, gridStyle(!props.horizontalButtons), {
+        alignItems: "center"
+      }) : gridStyle(!props.horizontalButtons)
+    }, React.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, {
+      size: "mini",
+      vertical: !props.horizontalButtons
+    }, (props.hasMoveUp || props.hasMoveDown) && React.createElement(semanticUiReact.Button, {
+      icon: "angle up",
+      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",
+      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",
+      className: "array-item-remove",
+      tabIndex: "-1",
+      disabled: props.disabled || props.readOnly,
+      onClick: props.onDropIndexClick(props.index)
+    }))))));
+  } // 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,
+      idSchema: idSchema,
+      uiSchema: uiSchema,
+      title: fieldTitle,
+      required: required
+    }), fieldDescription && React.createElement(ArrayFieldDescription, {
+      key: "array-field-description-" + idSchema.$id,
+      DescriptionField: DescriptionField,
+      idSchema: idSchema,
+      description: 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 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
+      }
+    });
+    var horizontalButtons = semanticProps.horizontalButtons,
+        wrapItem = semanticProps.wrapItem;
+    var itemProps = {
+      horizontalButtons: horizontalButtons,
+      wrapItem: wrapItem
+    };
+
+    if (isFixedItems(schema)) {
+      return React.createElement(DefaultFixedArrayFieldTemplate, _extends({}, props, {
+        itemProps: itemProps
+      }));
+    }
+
+    return React.createElement(DefaultNormalArrayFieldTemplate, _extends({}, props, {
+      itemProps: itemProps
+    }));
+  }
+
+  /* eslint-disable react/no-array-index-key */
+  /**
+   *
+   * @param errors
+   * @returns {*}
+   * @constructor
+   */
+
+  function ErrorList(_ref) {
+    var errors = _ref.errors;
+    return React.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);
+    })));
+  }
+
+  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 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);
+    }
+  }
+
+  TitleField.defaultProps = {
+    options: {
+      semantic: {
+        inverted: false,
+        dividing: true
+      }
+    }
+  };
+  TitleField.propTypes = {
+    options: PropTypes.object
+  };
+
+  var Fields = {
+    DescriptionField: DescriptionField,
+    TitleField: TitleField
+  };
+
+  /* eslint-disable react/prop-types */
+  /**
+   * @return {null}
+   */
+
+  function HelpField(_ref) {
+    var helpText = _ref.helpText,
+        id = _ref.id;
+
+    if (helpText) {
+      return React.createElement(semanticUiReact.Message, {
+        size: "mini",
+        info: true,
+        id: id,
+        content: helpText
+      });
+    }
+
+    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;
+
+    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
+        });
+      })));
+    }
+
+    return null;
+  }
+
+  RawErrors.defaultProps = {
+    options: {
+      pointing: "above",
+      size: "small"
+    }
+  };
+  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);
+
+    if (!additional) {
+      return React.createElement(React.Fragment, null, children);
+    }
+
+    var handleBlur = function handleBlur(_ref2) {
+      var target = _ref2.target;
+      return onKeyChange(target.value);
+    };
+
+    return React.createElement("div", {
+      className: classNames,
+      key: id + "-key"
+    }, React.createElement(semanticUiReact.Grid, {
+      columns: "equal"
+    }, React.createElement(semanticUiReact.Grid.Row, null, React.createElement(semanticUiReact.Grid.Column, {
+      className: "form-additional"
+    }, React.createElement(semanticUiReact.Form.Group, {
+      widths: "equal",
+      grouped: true
+    }, React.createElement(semanticUiReact.Form.Input, {
+      className: "form-group",
+      hasFeedback: true,
+      fluid: true,
+      htmlFor: "" + id,
+      label: keyLabel,
+      required: required,
+      defaultValue: label,
+      disabled: disabled || readonlyAsDisabled && readonly,
+      id: "" + id,
+      name: "" + id,
+      onBlur: !readonly ? handleBlur : undefined,
+      style: wrapperStyle,
+      type: "text"
+    }))), React.createElement(semanticUiReact.Grid.Column, {
+      className: "form-additional",
+      verticalAlign: "middle"
+    }, children), React.createElement(semanticUiReact.Grid.Column, null, React.createElement(semanticUiReact.Button, {
+      size: "mini",
+      icon: "trash",
+      className: "array-item-remove",
+      tabIndex: "-1",
+      disabled: disabled || readonly,
+      onClick: onDropPropertyClick(label)
+    })))));
+  };
+
+  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;
+
+  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,
+      defaultSchemaProps: {
+        inverted: false
+      }
+    });
+    var displayLabel = getDisplayLabel(schema, uiSchema
+    /* TODO: , rootSchema */
+    );
+
+    var _onChange = function _onChange(event, data) {
+      return onChange && onChange(data.checked);
+    };
+
+    var _onBlur = function _onBlur() {
+      return onBlur && onBlur(id, value);
+    };
+
+    var _onFocus = function _onFocus() {
+      return onFocus && onFocus(id, value);
+    };
+
+    var checked = value == "true" || value == true;
+    return React.createElement(semanticUiReact.Form.Checkbox, _extends({
+      id: id,
+      disabled: disabled || readonly,
+      autoFocus: autofocus
+    }, semanticProps, {
+      checked: typeof value === "undefined" ? false : checked,
+      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
+    // 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);
+    });
+  }
+
+  function deselectValue(value, selected) {
+    return selected.filter(function (v) {
+      return 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,
+      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));
+        }
+      };
+    };
+
+    var _onBlur = function _onBlur() {
+      return onBlur && onBlur(id, value);
+    };
+
+    var _onFocus = function _onFocus() {
+      return onFocus && onFocus(id, value);
+    };
+
+    var 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, {
+        checked: checked,
+        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
+    }); // eslint-disable-next-line no-shadow
+
+    var _onChange = function _onChange(event, _ref) {
+      var eventValue = _ref.value;
+      return onChange && onChange(schema.type === "boolean" ? eventValue !== "false" : eventValue);
+    };
+
+    var _onBlur = function _onBlur() {
+      return onBlur && onBlur(id, value);
+    };
+
+    var _onFocus = function _onFocus() {
+      return onFocus && onFocus(id, value);
+    };
+
+    var 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({
+        required: required,
+        control: semanticUiReact.Radio,
+        name: name
+      }, semanticProps, {
+        onFocus: _onFocus,
+        onBlur: _onBlur,
+        label: "" + option.label,
+        value: "" + option.value,
+        key: option.value + "-" + i,
+        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,
+      defaultSchemaProps: {
+        fluid: true
+      }
+    }); // 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);
+    };
+
+    return React.createElement(React.Fragment, null, React.createElement(semanticUiReact.Input, _extends({
+      id: id,
+      key: id,
+      name: name,
+      type: "range",
+      required: required,
+      disabled: disabled || readonly
+    }, rangeSpec(schema), semanticProps, {
+      value: value || "",
+      onChange: _onChange,
+      onBlur: _onBlur,
+      onFocus: _onFocus
+    })), React.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 {*}
+   */
+
+  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;
+      return {
+        disabled: disabledOptions.indexOf(value) !== -1,
+        key: label,
+        text: label,
+        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,
+      defaultSchemaProps: {
+        inverted: "false",
+        selection: true,
+        fluid: true,
+        scrolling: true,
+        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));
+    }; // eslint-disable-next-line no-shadow
+
+
+    var _onBlur = function _onBlur(_ref3) {
+      var value = _ref3.target.value;
+      return onBlur && onBlur(id, processValue(schema, value));
+    };
+
+    var _onFocus = function _onFocus(_ref4) {
+      var value = _ref4.target.value;
+      return onFocus && onFocus(id, processValue(schema, value));
+    };
+
+    return React.createElement(semanticUiReact.Form.Dropdown, _extends({
+      key: id,
+      name: name,
+      label: label || schema.title,
+      multiple: typeof multiple === "undefined" ? false : multiple,
+      value: typeof value === "undefined" ? emptyValue : value,
+      disabled: disabled,
+      placeholder: placeholder
+    }, semanticProps, {
+      required: required,
+      autoFocus: autofocus,
+      readOnly: readonly,
+      options: dropdownOptions,
+      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,
+      defaultSchemaProps: {
+        inverted: false
+      }
+    }); // 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$2(schema, uiSchema
+    /* TODO: , rootSchema */
+    );
+    return React.createElement(semanticUiReact.Form.TextArea, _extends({
+      id: id,
+      key: id,
+      label: displayLabel ? label || schema.title : false,
+      placeholder: placeholder,
+      autoFocus: autofocus,
+      required: required,
+      disabled: disabled || readonly,
+      name: name
+    }, semanticProps, {
+      value: value || "",
+      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
+  };
+
+  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)
+  };
+
+  var SemanticUIForm = /*#__PURE__*/core.withTheme(Theme);
+
+  exports.ArrayFieldTemplate = ArrayFieldTemplate;
+  exports.FieldTemplate = FieldTemplate;
+  exports.Fields = Fields;
+  exports.ObjectFieldTemplate = ObjectFieldTemplate;
+  exports.SemanticUIForm = SemanticUIForm;
+  exports.Theme = Theme;
+  exports.Widgets = Widgets;
+  exports.default = SemanticUIForm;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+//# sourceMappingURL=semantic-ui.umd.development.js.map