@rjsf/semantic-ui 5.11.2 → 5.12.0

package/dist/semantic-ui.esm.js

@@ -1,134 +1,89 @@
-import { withTheme } from '@rjsf/core';
-import { Button, Icon, Segment, Grid, Form, Message, Label, List, Header, Radio, Input } from 'semantic-ui-react';
-import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
-import { TranslatableString, getUiOptions, getTemplate, isFixedItems, UI_OPTIONS_KEY, getInputProps, labelValue, examplesId, ariaDescribedByIds, errorId, helpId, titleId, descriptionId, canExpand, getSubmitButtonOptions, ADDITIONAL_PROPERTY_FLAG, schemaRequiresTrueValue, enumOptionsIsSelected, optionId, enumOptionsSelectValue, enumOptionsDeselectValue, enumOptionsValueForIndex, rangeSpec, enumOptionsIndexForValue } from '@rjsf/utils';
-import { nanoid } from 'nanoid';
-import { createElement } from 'react';
-import map from 'lodash-es/map';
+// src/SemanticUIForm/SemanticUIForm.ts
+import { withTheme } from "@rjsf/core";
 
-/** The `AddButton` renders a button that represent the `Add` action on a form
- */
+// src/Theme/Theme.ts
+import { Form as SuiForm } from "semantic-ui-react";
+
+// src/AddButton/AddButton.tsx
+import { Button, Icon } from "semantic-ui-react";
+import { TranslatableString } from "@rjsf/utils";
+import { jsx } from "react/jsx-runtime";
 function AddButton({
   uiSchema,
   registry,
   color,
   ...props
 }) {
-  const {
-    translateString
-  } = registry;
-  return jsx(Button, {
-    title: translateString(TranslatableString.AddItemButton),
-    color: color,
-    ...props,
-    icon: true,
-    size: 'tiny',
-    children: jsx(Icon, {
-      name: 'plus'
-    })
-  });
+  const { translateString } = registry;
+  return /* @__PURE__ */ jsx(
+    Button,
+    {
+      title: translateString(TranslatableString.AddItemButton),
+      color,
+      ...props,
+      icon: true,
+      size: "tiny",
+      children: /* @__PURE__ */ jsx(Icon, { name: "plus" })
+    }
+  );
 }
 
-/**
- * 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}
- */
+// src/ArrayFieldItemTemplate/ArrayFieldItemTemplate.tsx
+import {
+  getUiOptions as getUiOptions2
+} from "@rjsf/utils";
+import { Button as Button2, Grid, Segment } from "semantic-ui-react";
+
+// src/util.tsx
+import {
+  getUiOptions
+} from "@rjsf/utils";
+import { jsx as jsx2 } from "react/jsx-runtime";
 function getSemanticProps({
   formContext = {},
   uiSchema = {},
   options = {},
-  defaultSchemaProps = {
-    fluid: true,
-    inverted: false
-  },
+  defaultSchemaProps = { fluid: true, inverted: false },
   defaultContextProps = {}
 }) {
   const formContextProps = formContext.semantic;
   const schemaProps = getUiOptions(uiSchema).semantic;
   const optionProps = options.semantic;
-  // formContext props should overide other props
-  return Object.assign({}, {
-    ...defaultSchemaProps
-  }, {
-    ...defaultContextProps
-  }, schemaProps, optionProps, formContextProps);
+  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}
- */
 function getSemanticErrorProps({
   formContext = {},
   uiSchema = {},
   options = {},
-  defaultProps = {
-    size: 'small',
-    pointing: 'above'
-  }
+  defaultProps = { size: "small", pointing: "above" }
 }) {
   const formContextProps = formContext.semantic && formContext.semantic.errorOptions;
   const semanticOptions = getUiOptions(uiSchema).semantic;
   const schemaProps = semanticOptions && semanticOptions.errorOptions;
   const optionProps = options.semantic && options.semantic.errorOptions;
-  return Object.assign({}, {
-    ...defaultProps
-  }, schemaProps, optionProps, formContextProps);
+  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}
- */
 function cleanClassNames(classNameArr, omit = []) {
-  // Split each arg on whitespace, and add it to an array. Skip false-y args
-  // like "" and undefined.
   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 [...new Set(classList.filter(cn => !omit.includes(cn)))].join(' ');
+  return [...new Set(classList.filter((cn) => !omit.includes(cn)))].join(" ");
 }
-/**
- *
- * @param {boolean} wrap
- * @param Component
- * @param {Object} props
- * @returns {*}
- * @constructor
- */
-function MaybeWrap({
-  wrap,
-  component: Component = 'div',
-  ...props
-}) {
-  return wrap ? jsx(Component, {
-    ...props
-  }) : props.children;
+function MaybeWrap({ wrap, component: Component = "div", ...props }) {
+  return wrap ? /* @__PURE__ */ jsx2(Component, { ...props }) : props.children;
 }
 
-const gridStyle = vertical => ({
-  display: 'grid',
+// src/ArrayFieldItemTemplate/ArrayFieldItemTemplate.tsx
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
+var gridStyle = (vertical) => ({
+  display: "grid",
   gridTemplateColumns: `1fr ${vertical ? 65 : 150}px`
 });
-/** The `ArrayFieldItemTemplate` component is the template used to render an items of an array.
- *
- * @param props - The `ArrayFieldTemplateItemType` props for the component
- */
 function ArrayFieldItemTemplate(props) {
   const {
     children,
@@ -146,72 +101,64 @@ function ArrayFieldItemTemplate(props) {
     uiSchema,
     registry
   } = props;
-  const {
-    CopyButton,
-    MoveDownButton,
-    MoveUpButton,
-    RemoveButton
-  } = registry.templates.ButtonTemplates;
-  const uiOptions = getUiOptions(uiSchema);
-  // Pull the semantic props out of the uiOptions that were put in via the ArrayFieldTemplate
-  const {
-    horizontalButtons = true,
-    wrapItem = false
-  } = uiOptions.semantic;
-  return jsx("div", {
-    className: 'array-item',
-    children: jsx(MaybeWrap, {
-      wrap: wrapItem,
-      component: Segment,
-      children: jsxs(Grid, {
-        style: {
-          ...gridStyle(!horizontalButtons),
-          alignItems: 'center'
-        },
-        children: [jsx(Grid.Column, {
-          width: 16,
-          verticalAlign: 'middle',
-          children: children
-        }), hasToolbar && jsx(Grid.Column, {
-          children: (hasMoveUp || hasMoveDown || hasRemove) && jsxs(Button.Group, {
-            size: 'mini',
-            vertical: !horizontalButtons,
-            children: [(hasMoveUp || hasMoveDown) && jsx(MoveUpButton, {
-              className: 'array-item-move-up',
-              disabled: disabled || readonly || !hasMoveUp,
-              onClick: onReorderClick(index, index - 1),
-              uiSchema: uiSchema,
-              registry: registry
-            }), (hasMoveUp || hasMoveDown) && jsx(MoveDownButton, {
-              className: 'array-item-move-down',
-              disabled: disabled || readonly || !hasMoveDown,
-              onClick: onReorderClick(index, index + 1),
-              uiSchema: uiSchema,
-              registry: registry
-            }), hasCopy && jsx(CopyButton, {
-              className: 'array-item-copy',
-              disabled: disabled || readonly,
-              onClick: onCopyIndexClick(index),
-              uiSchema: uiSchema,
-              registry: registry
-            }), hasRemove && jsx(RemoveButton, {
-              className: 'array-item-remove',
-              disabled: disabled || readonly,
-              onClick: onDropIndexClick(index),
-              uiSchema: uiSchema,
-              registry: registry
-            })]
-          })
-        })]
-      })
-    })
-  });
+  const { CopyButton: CopyButton2, MoveDownButton: MoveDownButton2, MoveUpButton: MoveUpButton2, RemoveButton: RemoveButton2 } = registry.templates.ButtonTemplates;
+  const uiOptions = getUiOptions2(uiSchema);
+  const { horizontalButtons = true, wrapItem = false } = uiOptions.semantic;
+  return /* @__PURE__ */ jsx3("div", { className: "array-item", children: /* @__PURE__ */ jsx3(MaybeWrap, { wrap: wrapItem, component: Segment, children: /* @__PURE__ */ jsxs(Grid, { style: { ...gridStyle(!horizontalButtons), alignItems: "center" }, children: [
+    /* @__PURE__ */ jsx3(Grid.Column, { width: 16, verticalAlign: "middle", children }),
+    hasToolbar && /* @__PURE__ */ jsx3(Grid.Column, { children: (hasMoveUp || hasMoveDown || hasRemove) && /* @__PURE__ */ jsxs(Button2.Group, { size: "mini", vertical: !horizontalButtons, children: [
+      (hasMoveUp || hasMoveDown) && /* @__PURE__ */ jsx3(
+        MoveUpButton2,
+        {
+          className: "array-item-move-up",
+          disabled: disabled || readonly || !hasMoveUp,
+          onClick: onReorderClick(index, index - 1),
+          uiSchema,
+          registry
+        }
+      ),
+      (hasMoveUp || hasMoveDown) && /* @__PURE__ */ jsx3(
+        MoveDownButton2,
+        {
+          className: "array-item-move-down",
+          disabled: disabled || readonly || !hasMoveDown,
+          onClick: onReorderClick(index, index + 1),
+          uiSchema,
+          registry
+        }
+      ),
+      hasCopy && /* @__PURE__ */ jsx3(
+        CopyButton2,
+        {
+          className: "array-item-copy",
+          disabled: disabled || readonly,
+          onClick: onCopyIndexClick(index),
+          uiSchema,
+          registry
+        }
+      ),
+      hasRemove && /* @__PURE__ */ jsx3(
+        RemoveButton2,
+        {
+          className: "array-item-remove",
+          disabled: disabled || readonly,
+          onClick: onDropIndexClick(index),
+          uiSchema,
+          registry
+        }
+      )
+    ] }) })
+  ] }) }) });
 }
 
-/** The `ArrayFieldTemplate` component is the template used to render all items in an array.
- *
- * @param props - The `ArrayFieldTemplateItemType` props for the component
- */
+// src/ArrayFieldTemplate/ArrayFieldTemplate.tsx
+import {
+  getTemplate,
+  getUiOptions as getUiOptions3,
+  isFixedItems,
+  UI_OPTIONS_KEY
+} from "@rjsf/utils";
+import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
 function ArrayFieldTemplate(props) {
   const {
     uiSchema,
@@ -233,88 +180,86 @@ function ArrayFieldTemplate(props) {
   const semanticProps = getSemanticProps({
     uiSchema,
     formContext,
-    defaultSchemaProps: {
-      horizontalButtons: true,
-      wrapItem: false
-    }
+    defaultSchemaProps: { horizontalButtons: true, wrapItem: false }
   });
+  const { horizontalButtons, wrapItem } = semanticProps;
+  const semantic = { horizontalButtons, wrapItem };
+  const uiOptions = getUiOptions3(uiSchema);
+  const ArrayFieldDescriptionTemplate = getTemplate(
+    "ArrayFieldDescriptionTemplate",
+    registry,
+    uiOptions
+  );
+  const ArrayFieldItemTemplate2 = getTemplate(
+    "ArrayFieldItemTemplate",
+    registry,
+    uiOptions
+  );
+  const ArrayFieldTitleTemplate = getTemplate(
+    "ArrayFieldTitleTemplate",
+    registry,
+    uiOptions
+  );
   const {
-    horizontalButtons,
-    wrapItem
-  } = semanticProps;
-  const semantic = {
-    horizontalButtons,
-    wrapItem
-  };
-  const uiOptions = getUiOptions(uiSchema);
-  const ArrayFieldDescriptionTemplate = getTemplate('ArrayFieldDescriptionTemplate', registry, uiOptions);
-  const ArrayFieldItemTemplate = getTemplate('ArrayFieldItemTemplate', registry, uiOptions);
-  const ArrayFieldTitleTemplate = getTemplate('ArrayFieldTitleTemplate', registry, uiOptions);
-  // Button templates are not overridden in the uiSchema
-  const {
-    ButtonTemplates: {
-      AddButton
-    }
+    ButtonTemplates: { AddButton: AddButton2 }
   } = registry.templates;
-  return jsxs("div", {
-    className: cleanClassNames([className, isFixedItems(schema) ? '' : 'sortable-form-fields']),
-    children: [jsx(ArrayFieldTitleTemplate, {
-      idSchema: idSchema,
-      title: uiOptions.title || title,
-      schema: schema,
-      uiSchema: uiSchema,
-      required: required,
-      registry: registry
-    }), jsx(ArrayFieldDescriptionTemplate, {
-      idSchema: idSchema,
-      description: uiOptions.description || schema.description,
-      schema: schema,
-      uiSchema: uiSchema,
-      registry: registry
-    }), jsxs("div", {
-      children: [jsx("div", {
-        className: 'row array-item-list',
-        children: items && items.map(({
-          key,
-          uiSchema: itemUiSchema = {},
-          ...props
-        }) => {
-          // Merge in the semantic props from the ArrayFieldTemplate into each of the items
-          const mergedUiSchema = {
-            ...itemUiSchema,
-            [UI_OPTIONS_KEY]: {
-              ...itemUiSchema[UI_OPTIONS_KEY],
-              semantic
-            }
-          };
-          return jsx(ArrayFieldItemTemplate, {
-            ...props,
-            uiSchema: mergedUiSchema
-          }, key);
-        })
-      }), canAdd && jsx("div", {
-        style: {
-          marginTop: '1rem',
-          position: 'relative',
-          textAlign: 'right'
-        },
-        children: jsx(AddButton, {
-          onClick: onAddClick,
-          disabled: disabled || readonly,
-          uiSchema: uiSchema,
-          registry: registry
-        })
-      })]
-    }, `array-item-list-${idSchema.$id}`)]
-  });
+  return /* @__PURE__ */ jsxs2("div", { className: cleanClassNames([className, isFixedItems(schema) ? "" : "sortable-form-fields"]), children: [
+    /* @__PURE__ */ jsx4(
+      ArrayFieldTitleTemplate,
+      {
+        idSchema,
+        title: uiOptions.title || title,
+        schema,
+        uiSchema,
+        required,
+        registry
+      }
+    ),
+    /* @__PURE__ */ jsx4(
+      ArrayFieldDescriptionTemplate,
+      {
+        idSchema,
+        description: uiOptions.description || schema.description,
+        schema,
+        uiSchema,
+        registry
+      }
+    ),
+    /* @__PURE__ */ jsxs2("div", { children: [
+      /* @__PURE__ */ jsx4("div", { className: "row array-item-list", children: items && items.map(({ key, uiSchema: itemUiSchema = {}, ...props2 }) => {
+        const mergedUiSchema = {
+          ...itemUiSchema,
+          [UI_OPTIONS_KEY]: {
+            ...itemUiSchema[UI_OPTIONS_KEY],
+            semantic
+          }
+        };
+        return /* @__PURE__ */ jsx4(ArrayFieldItemTemplate2, { ...props2, uiSchema: mergedUiSchema }, key);
+      }) }),
+      canAdd && /* @__PURE__ */ jsx4(
+        "div",
+        {
+          style: {
+            marginTop: "1rem",
+            position: "relative",
+            textAlign: "right"
+          },
+          children: /* @__PURE__ */ jsx4(AddButton2, { onClick: onAddClick, disabled: disabled || readonly, uiSchema, registry })
+        }
+      )
+    ] }, `array-item-list-${idSchema.$id}`)
+  ] });
 }
 
-/** The `BaseInputTemplate` is the template to use to render the basic `<input>` component for the `core` theme.
- * It is used as the template for rendering many of the <input> based widgets that differ by `type` and callbacks only.
- * It can be customized/overridden for other themes or individual implementations as needed.
- *
- * @param props - The `WidgetProps` for this template
- */
+// src/BaseInputTemplate/BaseInputTemplate.tsx
+import { Form } from "semantic-ui-react";
+import {
+  ariaDescribedByIds,
+  examplesId,
+  getInputProps,
+  labelValue
+} from "@rjsf/utils";
+import { Fragment, jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
 function BaseInputTemplate(props) {
   const {
     id,
@@ -343,224 +288,151 @@ function BaseInputTemplate(props) {
     formContext,
     options
   });
-  const _onChange = ({
-    target: {
-      value
-    }
-  }) => onChange(value === '' ? options.emptyValue : value);
+  const _onChange = ({ target: { value: value2 } }) => onChange(value2 === "" ? options.emptyValue : value2);
   const _onBlur = () => onBlur && onBlur(id, value);
   const _onFocus = () => onFocus && onFocus(id, value);
-  return jsxs(Fragment, {
-    children: [jsx(Form.Input, {
-      id: id,
-      name: id,
-      placeholder: placeholder,
-      ...inputProps,
-      label: labelValue(label || undefined, hideLabel, false),
-      required: required,
-      autoFocus: autofocus,
-      disabled: disabled || readonly,
-      list: schema.examples ? examplesId(id) : undefined,
-      ...semanticProps,
-      value: value || value === 0 ? value : '',
-      error: rawErrors.length > 0,
-      onChange: onChangeOverride || _onChange,
-      onBlur: _onBlur,
-      onFocus: _onFocus,
-      "aria-describedby": ariaDescribedByIds(id, !!schema.examples)
-    }, id), Array.isArray(schema.examples) && jsx("datalist", {
-      id: examplesId(id),
-      children: schema.examples.concat(schema.default && !schema.examples.includes(schema.default) ? [schema.default] : []).map(example => {
-        return jsx("option", {
-          value: example
-        }, example);
-      })
-    })]
-  });
+  return /* @__PURE__ */ jsxs3(Fragment, { children: [
+    /* @__PURE__ */ jsx5(
+      Form.Input,
+      {
+        id,
+        name: id,
+        placeholder,
+        ...inputProps,
+        label: labelValue(label || void 0, hideLabel, false),
+        required,
+        autoFocus: autofocus,
+        disabled: disabled || readonly,
+        list: schema.examples ? examplesId(id) : void 0,
+        ...semanticProps,
+        value: value || value === 0 ? value : "",
+        error: rawErrors.length > 0,
+        onChange: onChangeOverride || _onChange,
+        onBlur: _onBlur,
+        onFocus: _onFocus,
+        "aria-describedby": ariaDescribedByIds(id, !!schema.examples)
+      },
+      id
+    ),
+    Array.isArray(schema.examples) && /* @__PURE__ */ jsx5("datalist", { id: examplesId(id), children: schema.examples.concat(schema.default && !schema.examples.includes(schema.default) ? [schema.default] : []).map((example) => {
+      return /* @__PURE__ */ jsx5("option", { value: example }, example);
+    }) })
+  ] });
 }
 
-/** The `DescriptionField` is the template to use to render the description of a field
- *
- * @param props - The `DescriptionFieldProps` for this component
- */
+// src/DescriptionField/DescriptionField.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
 function DescriptionField(props) {
-  const {
-    id,
-    description
-  } = props;
+  const { id, description } = props;
   if (!description) {
     return null;
   }
-  return jsx("p", {
-    id: id,
-    className: 'sui-description',
-    children: description
-  });
+  return /* @__PURE__ */ jsx6("p", { id, className: "sui-description", children: description });
 }
 
-/** The `ErrorList` component is the template that renders the all the errors associated with the fields in the `Form`
- *
- * @param props - The `ErrorListProps` for this component
- */
+// src/ErrorList/ErrorList.tsx
+import { Message } from "semantic-ui-react";
+import { TranslatableString as TranslatableString2 } from "@rjsf/utils";
+import { jsx as jsx7, jsxs as jsxs4 } from "react/jsx-runtime";
 function ErrorList({
   errors,
   registry
 }) {
-  const {
-    translateString
-  } = registry;
-  return jsxs(Message, {
-    negative: true,
-    children: [jsx(Message.Header, {
-      children: translateString(TranslatableString.ErrorsLabel)
-    }), jsx(Message.List, {
-      children: errors.map((error, index) => jsx(Message.Item, {
-        children: error.stack
-      }, `error-${index}`))
-    })]
-  });
+  const { translateString } = registry;
+  return /* @__PURE__ */ jsxs4(Message, { negative: true, children: [
+    /* @__PURE__ */ jsx7(Message.Header, { children: translateString(TranslatableString2.ErrorsLabel) }),
+    /* @__PURE__ */ jsx7(Message.List, { children: errors.map((error, index) => /* @__PURE__ */ jsx7(Message.Item, { children: error.stack }, `error-${index}`)) })
+  ] });
 }
 
+// src/IconButton/IconButton.tsx
+import { Button as Button3 } from "semantic-ui-react";
+import { TranslatableString as TranslatableString3 } from "@rjsf/utils";
+import { jsx as jsx8 } from "react/jsx-runtime";
 function IconButton(props) {
-  const {
-    icon,
-    iconType,
-    color,
-    className,
-    uiSchema,
-    registry,
-    ...otherProps
-  } = props;
-  return jsx(Button, {
-    icon: icon,
-    size: iconType,
-    color: color,
-    className: className,
-    ...otherProps
-  });
+  const { icon, iconType, color, className, uiSchema, registry, ...otherProps } = props;
+  return /* @__PURE__ */ jsx8(
+    Button3,
+    {
+      icon,
+      size: iconType,
+      color,
+      className,
+      ...otherProps
+    }
+  );
 }
 function CopyButton(props) {
   const {
-    registry: {
-      translateString
-    }
+    registry: { translateString }
   } = props;
-  return jsx(IconButton, {
-    title: translateString(TranslatableString.CopyButton),
-    ...props,
-    icon: 'copy'
-  });
+  return /* @__PURE__ */ jsx8(IconButton, { title: translateString(TranslatableString3.CopyButton), ...props, icon: "copy" });
 }
 function MoveDownButton(props) {
   const {
-    registry: {
-      translateString
-    }
+    registry: { translateString }
   } = props;
-  return jsx(IconButton, {
-    title: translateString(TranslatableString.MoveDownButton),
-    ...props,
-    icon: 'angle down'
-  });
+  return /* @__PURE__ */ jsx8(IconButton, { title: translateString(TranslatableString3.MoveDownButton), ...props, icon: "angle down" });
 }
 function MoveUpButton(props) {
   const {
-    registry: {
-      translateString
-    }
+    registry: { translateString }
   } = props;
-  return jsx(IconButton, {
-    title: translateString(TranslatableString.MoveUpButton),
-    ...props,
-    icon: 'angle up'
-  });
+  return /* @__PURE__ */ jsx8(IconButton, { title: translateString(TranslatableString3.MoveUpButton), ...props, icon: "angle up" });
 }
 function RemoveButton(props) {
   const {
-    registry: {
-      translateString
-    }
+    registry: { translateString }
   } = props;
-  return jsx(IconButton, {
-    title: translateString(TranslatableString.RemoveButton),
-    ...props,
-    icon: 'trash'
-  });
+  return /* @__PURE__ */ jsx8(IconButton, { title: translateString(TranslatableString3.RemoveButton), ...props, icon: "trash" });
 }
 
-const DEFAULT_OPTIONS$1 = {
+// src/FieldErrorTemplate/FieldErrorTemplate.tsx
+import { errorId } from "@rjsf/utils";
+import { nanoid } from "nanoid";
+import { Label, List } from "semantic-ui-react";
+import { jsx as jsx9 } from "react/jsx-runtime";
+var DEFAULT_OPTIONS = {
   options: {
-    pointing: 'above',
-    size: 'small'
+    pointing: "above",
+    size: "small"
   }
 };
-/** The `FieldErrorTemplate` component renders the errors local to the particular field
- *
- * @param props - The `FieldErrorProps` for the errors being rendered
- */
-function FieldErrorTemplate({
-  errors,
-  idSchema,
-  uiSchema,
-  registry
-}) {
-  const {
-    formContext
-  } = registry;
+function FieldErrorTemplate({ errors, idSchema, uiSchema, registry }) {
+  const { formContext } = registry;
   const options = getSemanticErrorProps({
     formContext,
     uiSchema,
-    defaultProps: DEFAULT_OPTIONS$1
+    defaultProps: DEFAULT_OPTIONS
   });
-  const {
-    pointing,
-    size
-  } = options;
+  const { pointing, size } = options;
   if (errors && errors.length > 0) {
     const id = errorId(idSchema);
-    return jsx(Label, {
-      id: id,
-      color: 'red',
-      pointing: pointing || 'above',
-      size: size || 'small',
-      basic: true,
-      children: jsx(List, {
-        bulleted: true,
-        children: errors.map(error => jsx(List.Item, {
-          children: error
-        }, nanoid()))
-      })
-    });
+    return /* @__PURE__ */ jsx9(Label, { id, color: "red", pointing: pointing || "above", size: size || "small", basic: true, children: /* @__PURE__ */ jsx9(List, { bulleted: true, children: errors.map((error) => /* @__PURE__ */ jsx9(List.Item, { children: error }, nanoid())) }) });
   }
   return null;
 }
 
-/** The `FieldHelpTemplate` component renders any help desired for a field
- *
- * @param props - The `FieldHelpProps` to be rendered
- */
+// src/FieldHelpTemplate/FieldHelpTemplate.tsx
+import { Message as Message2 } from "semantic-ui-react";
+import { helpId } from "@rjsf/utils";
+import { jsx as jsx10 } from "react/jsx-runtime";
 function FieldHelpTemplate(props) {
-  const {
-    idSchema,
-    help
-  } = props;
+  const { idSchema, help } = props;
   if (help) {
     const id = helpId(idSchema);
-    return jsx(Message, {
-      size: 'mini',
-      info: true,
-      id: id,
-      content: help
-    });
+    return /* @__PURE__ */ jsx10(Message2, { size: "mini", info: true, id, content: help });
   }
   return null;
 }
 
-/** The `FieldTemplate` component is the template used by `SchemaField` to render any field. It renders the field
- * content, (label, description, children, errors and help) inside of a `WrapIfAdditional` component.
- *
- * @param props - The `FieldTemplateProps` for this component
- */
+// src/FieldTemplate/FieldTemplate.tsx
+import {
+  getTemplate as getTemplate2,
+  getUiOptions as getUiOptions4
+} from "@rjsf/utils";
+import { Form as Form2 } from "semantic-ui-react";
+import { jsx as jsx11, jsxs as jsxs5 } from "react/jsx-runtime";
 function FieldTemplate(props) {
   const {
     id,
@@ -580,51 +452,47 @@ function FieldTemplate(props) {
     ...otherProps
   } = props;
   const semanticProps = getSemanticProps(otherProps);
-  const {
-    wrapLabel,
-    wrapContent
-  } = semanticProps;
-  const uiOptions = getUiOptions(uiSchema);
-  const WrapIfAdditionalTemplate = getTemplate('WrapIfAdditionalTemplate', registry, uiOptions);
+  const { wrapLabel, wrapContent } = semanticProps;
+  const uiOptions = getUiOptions4(uiSchema);
+  const WrapIfAdditionalTemplate2 = getTemplate2(
+    "WrapIfAdditionalTemplate",
+    registry,
+    uiOptions
+  );
   if (hidden) {
-    return jsx("div", {
-      style: {
-        display: 'none'
-      },
-      children: children
-    });
+    return /* @__PURE__ */ jsx11("div", { style: { display: "none" }, children });
   }
-  return jsx(WrapIfAdditionalTemplate, {
-    classNames: classNames,
-    style: style,
-    id: id,
-    label: label,
-    registry: registry,
-    schema: schema,
-    uiSchema: uiSchema,
-    ...otherProps,
-    children: jsx(Form.Group, {
-      widths: 'equal',
-      grouped: true,
-      children: jsxs(MaybeWrap, {
-        wrap: wrapContent,
-        className: 'sui-field-content',
-        children: [children, displayLabel && rawDescription && jsx(MaybeWrap, {
-          wrap: wrapLabel,
-          className: 'sui-field-label',
-          children: description
-        }), help, errors]
-      })
-    }, id)
-  });
+  return /* @__PURE__ */ jsx11(
+    WrapIfAdditionalTemplate2,
+    {
+      classNames,
+      style,
+      id,
+      label,
+      registry,
+      schema,
+      uiSchema,
+      ...otherProps,
+      children: /* @__PURE__ */ jsx11(Form2.Group, { widths: "equal", grouped: true, children: /* @__PURE__ */ jsxs5(MaybeWrap, { wrap: wrapContent, className: "sui-field-content", children: [
+        children,
+        displayLabel && rawDescription && /* @__PURE__ */ jsx11(MaybeWrap, { wrap: wrapLabel, className: "sui-field-label", children: description }),
+        help,
+        errors
+      ] }) }, id)
+    }
+  );
 }
 
-/** The `ObjectFieldTemplate` is the template to use to render all the inner properties of an object along with the
- * title and description if available. If the object is expandable, then an `AddButton` is also rendered after all
- * the properties.
- *
- * @param props - The `ObjectFieldTemplateProps` for this component
- */
+// src/ObjectFieldTemplate/ObjectFieldTemplate.tsx
+import { Grid as Grid2 } from "semantic-ui-react";
+import {
+  canExpand,
+  descriptionId,
+  getTemplate as getTemplate3,
+  getUiOptions as getUiOptions5,
+  titleId
+} from "@rjsf/utils";
+import { Fragment as Fragment2, jsx as jsx12, jsxs as jsxs6 } from "react/jsx-runtime";
 function ObjectFieldTemplate(props) {
   const {
     description,
@@ -640,80 +508,80 @@ function ObjectFieldTemplate(props) {
     idSchema,
     registry
   } = props;
-  const uiOptions = getUiOptions(uiSchema);
-  const TitleFieldTemplate = getTemplate('TitleFieldTemplate', registry, uiOptions);
-  const DescriptionFieldTemplate = getTemplate('DescriptionFieldTemplate', registry, uiOptions);
-  // Button templates are not overridden in the uiSchema
+  const uiOptions = getUiOptions5(uiSchema);
+  const TitleFieldTemplate = getTemplate3("TitleFieldTemplate", registry, uiOptions);
+  const DescriptionFieldTemplate = getTemplate3(
+    "DescriptionFieldTemplate",
+    registry,
+    uiOptions
+  );
   const {
-    ButtonTemplates: {
-      AddButton
-    }
+    ButtonTemplates: { AddButton: AddButton2 }
   } = registry.templates;
-  return jsxs(Fragment, {
-    children: [title && jsx(TitleFieldTemplate, {
-      id: titleId(idSchema),
-      title: title,
-      required: required,
-      schema: schema,
-      uiSchema: uiSchema,
-      registry: registry
-    }), description && jsx(DescriptionFieldTemplate, {
-      id: descriptionId(idSchema),
-      description: description,
-      schema: schema,
-      uiSchema: uiSchema,
-      registry: registry
-    }), properties.map(prop => prop.content), canExpand(schema, uiSchema, formData) && jsx(Grid.Column, {
-      width: 16,
-      verticalAlign: 'middle',
-      children: jsx(Grid.Row, {
-        children: jsx("div", {
-          style: {
-            marginTop: '1rem',
-            position: 'relative',
-            textAlign: 'right'
-          },
-          children: jsx(AddButton, {
+  return /* @__PURE__ */ jsxs6(Fragment2, { children: [
+    title && /* @__PURE__ */ jsx12(
+      TitleFieldTemplate,
+      {
+        id: titleId(idSchema),
+        title,
+        required,
+        schema,
+        uiSchema,
+        registry
+      }
+    ),
+    description && /* @__PURE__ */ jsx12(
+      DescriptionFieldTemplate,
+      {
+        id: descriptionId(idSchema),
+        description,
+        schema,
+        uiSchema,
+        registry
+      }
+    ),
+    properties.map((prop) => prop.content),
+    canExpand(schema, uiSchema, formData) && /* @__PURE__ */ jsx12(Grid2.Column, { width: 16, verticalAlign: "middle", children: /* @__PURE__ */ jsx12(Grid2.Row, { children: /* @__PURE__ */ jsx12(
+      "div",
+      {
+        style: {
+          marginTop: "1rem",
+          position: "relative",
+          textAlign: "right"
+        },
+        children: /* @__PURE__ */ jsx12(
+          AddButton2,
+          {
             onClick: onAddClick(schema),
             disabled: disabled || readonly,
-            uiSchema: uiSchema,
-            registry: registry
-          })
-        })
-      })
-    })]
-  });
+            uiSchema,
+            registry
+          }
+        )
+      }
+    ) }) })
+  ] });
 }
 
-/** The `SubmitButton` renders a button that represent the `Submit` action on a form
- */
-function SubmitButton({
-  uiSchema
-}) {
-  const {
-    submitText,
-    norender,
-    props: submitButtonProps = {}
-  } = getSubmitButtonOptions(uiSchema);
+// src/SubmitButton/SubmitButton.tsx
+import { Button as Button4 } from "semantic-ui-react";
+import { getSubmitButtonOptions } from "@rjsf/utils";
+import { jsx as jsx13 } from "react/jsx-runtime";
+function SubmitButton({ uiSchema }) {
+  const { submitText, norender, props: submitButtonProps = {} } = getSubmitButtonOptions(uiSchema);
   if (norender) {
     return null;
   }
-  return jsx(Button, {
-    type: 'submit',
-    primary: true,
-    ...submitButtonProps,
-    children: submitText
-  });
+  return /* @__PURE__ */ jsx13(Button4, { type: "submit", primary: true, ...submitButtonProps, children: submitText });
 }
 
-const DEFAULT_OPTIONS = {
+// src/TitleField/TitleField.tsx
+import { Header } from "semantic-ui-react";
+import { jsx as jsx14 } from "react/jsx-runtime";
+var DEFAULT_OPTIONS2 = {
   inverted: false,
   dividing: true
 };
-/** The `TitleField` is the template to use to render the title of a field
- *
- * @param props - The `TitleFieldProps` for this component
- */
 function TitleField({
   id,
   title,
@@ -721,24 +589,21 @@ function TitleField({
 }) {
   const semanticProps = getSemanticProps({
     uiSchema,
-    defaultSchemaProps: DEFAULT_OPTIONS
+    defaultSchemaProps: DEFAULT_OPTIONS2
   });
   if (!title) {
     return null;
   }
-  return jsx(Header, {
-    id: id,
-    ...semanticProps,
-    as: 'h5',
-    children: title
-  });
+  return /* @__PURE__ */ jsx14(Header, { id, ...semanticProps, as: "h5", children: title });
 }
 
-/** The `WrapIfAdditional` component is used by the `FieldTemplate` to rename, or remove properties that are
- * part of an `additionalProperties` part of a schema.
- *
- * @param props - The `WrapIfAdditionalProps` for this component
- */
+// src/WrapIfAdditionalTemplate/WrapIfAdditionalTemplate.tsx
+import {
+  ADDITIONAL_PROPERTY_FLAG,
+  TranslatableString as TranslatableString4
+} from "@rjsf/utils";
+import { Form as Form3, Grid as Grid3 } from "semantic-ui-react";
+import { jsx as jsx15, jsxs as jsxs7 } from "react/jsx-runtime";
 function WrapIfAdditionalTemplate(props) {
   const {
     children,
@@ -755,76 +620,50 @@ function WrapIfAdditionalTemplate(props) {
     uiSchema,
     registry
   } = props;
-  const {
-    templates,
-    translateString
-  } = registry;
-  // Button templates are not overridden in the uiSchema
-  const {
-    RemoveButton
-  } = templates.ButtonTemplates;
-  const keyLabel = translateString(TranslatableString.KeyLabel, [label]);
-  const {
-    readonlyAsDisabled = true,
-    wrapperStyle
-  } = registry.formContext;
-  const additional = (ADDITIONAL_PROPERTY_FLAG in schema);
+  const { templates, translateString } = registry;
+  const { RemoveButton: RemoveButton2 } = templates.ButtonTemplates;
+  const keyLabel = translateString(TranslatableString4.KeyLabel, [label]);
+  const { readonlyAsDisabled = true, wrapperStyle } = registry.formContext;
+  const additional = ADDITIONAL_PROPERTY_FLAG in schema;
   if (!additional) {
-    return jsx("div", {
-      className: classNames,
-      style: style,
-      children: children
-    });
+    return /* @__PURE__ */ jsx15("div", { className: classNames, style, children });
   }
-  const handleBlur = ({
-    target
-  }) => onKeyChange(target.value);
-  return jsx("div", {
-    className: classNames,
-    style: style,
-    children: jsx(Grid, {
-      columns: 'equal',
-      children: jsxs(Grid.Row, {
-        children: [jsx(Grid.Column, {
-          className: 'form-additional',
-          children: jsx(Form.Group, {
-            widths: 'equal',
-            grouped: true,
-            children: jsx(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'
-            })
-          })
-        }), jsx(Grid.Column, {
-          className: 'form-additional',
-          verticalAlign: 'middle',
-          children: children
-        }), jsx(Grid.Column, {
-          children: jsx(RemoveButton, {
-            iconType: 'mini',
-            className: 'array-item-remove',
-            disabled: disabled || readonly,
-            onClick: onDropPropertyClick(label),
-            uiSchema: uiSchema,
-            registry: registry
-          })
-        })]
-      })
-    })
-  }, `${id}-key`);
+  const handleBlur = ({ target }) => onKeyChange(target.value);
+  return /* @__PURE__ */ jsx15("div", { className: classNames, style, children: /* @__PURE__ */ jsx15(Grid3, { columns: "equal", children: /* @__PURE__ */ jsxs7(Grid3.Row, { children: [
+    /* @__PURE__ */ jsx15(Grid3.Column, { className: "form-additional", children: /* @__PURE__ */ jsx15(Form3.Group, { widths: "equal", grouped: true, children: /* @__PURE__ */ jsx15(
+      Form3.Input,
+      {
+        className: "form-group",
+        hasFeedback: true,
+        fluid: true,
+        htmlFor: `${id}`,
+        label: keyLabel,
+        required,
+        defaultValue: label,
+        disabled: disabled || readonlyAsDisabled && readonly,
+        id: `${id}`,
+        name: `${id}`,
+        onBlur: !readonly ? handleBlur : void 0,
+        style: wrapperStyle,
+        type: "text"
+      }
+    ) }) }),
+    /* @__PURE__ */ jsx15(Grid3.Column, { className: "form-additional", verticalAlign: "middle", children }),
+    /* @__PURE__ */ jsx15(Grid3.Column, { children: /* @__PURE__ */ jsx15(
+      RemoveButton2,
+      {
+        iconType: "mini",
+        className: "array-item-remove",
+        disabled: disabled || readonly,
+        onClick: onDropPropertyClick(label),
+        uiSchema,
+        registry
+      }
+    ) })
+  ] }) }) }, `${id}-key`);
 }
 
+// src/Templates/Templates.ts
 function generateTemplates() {
   return {
     ArrayFieldItemTemplate,
@@ -848,20 +687,25 @@ function generateTemplates() {
     WrapIfAdditionalTemplate
   };
 }
-var Templates = /*#__PURE__*/generateTemplates();
+var Templates_default = generateTemplates();
 
-/** The `CheckBoxWidget` is a widget for rendering boolean properties.
- *  It is typically used to represent a boolean.
- *
- * @param props - The `WidgetProps` for this component
- */
+// src/CheckboxWidget/CheckboxWidget.tsx
+import {
+  ariaDescribedByIds as ariaDescribedByIds2,
+  descriptionId as descriptionId2,
+  getTemplate as getTemplate4,
+  labelValue as labelValue2,
+  schemaRequiresTrueValue
+} from "@rjsf/utils";
+import { Form as Form4 } from "semantic-ui-react";
+import { Fragment as Fragment3, jsx as jsx16, jsxs as jsxs8 } from "react/jsx-runtime";
 function CheckboxWidget(props) {
   const {
     id,
     value,
     disabled,
     readonly,
-    label = '',
+    label = "",
     hideLabel,
     autofocus,
     onChange,
@@ -879,49 +723,64 @@ function CheckboxWidget(props) {
     formContext,
     uiSchema,
     defaultSchemaProps: {
-      inverted: 'false'
+      inverted: "false"
     }
   });
-  const DescriptionFieldTemplate = getTemplate('DescriptionFieldTemplate', registry, options);
-  // Because an unchecked checkbox will cause html5 validation to fail, only add
-  // the "required" attribute if the field value must be "true", due to the
-  // "const" or "enum" keywords
+  const DescriptionFieldTemplate = getTemplate4(
+    "DescriptionFieldTemplate",
+    registry,
+    options
+  );
   const required = schemaRequiresTrueValue(schema);
   const _onChange = (_, data) => onChange && onChange(data.checked);
   const _onBlur = () => onBlur && onBlur(id, value);
   const _onFocus = () => onFocus && onFocus(id, value);
-  const checked = value == 'true' || value == true;
+  const checked = value == "true" || value == true;
   const description = options.description ?? schema.description;
-  return jsxs(Fragment, {
-    children: [!hideLabel && !!description && jsx(DescriptionFieldTemplate, {
-      id: descriptionId(id),
-      description: description,
-      schema: schema,
-      uiSchema: uiSchema,
-      registry: registry
-    }), jsx(Form.Checkbox, {
-      id: id,
-      name: id,
-      disabled: disabled || readonly,
-      autoFocus: autofocus,
-      ...semanticProps,
-      checked: typeof value === 'undefined' ? false : checked,
-      error: rawErrors.length > 0,
-      onChange: _onChange,
-      onBlur: _onBlur,
-      onFocus: _onFocus,
-      required: required,
-      label: labelValue(label, hideLabel, false),
-      "aria-describedby": ariaDescribedByIds(id)
-    })]
-  });
+  return /* @__PURE__ */ jsxs8(Fragment3, { children: [
+    !hideLabel && !!description && /* @__PURE__ */ jsx16(
+      DescriptionFieldTemplate,
+      {
+        id: descriptionId2(id),
+        description,
+        schema,
+        uiSchema,
+        registry
+      }
+    ),
+    /* @__PURE__ */ jsx16(
+      Form4.Checkbox,
+      {
+        id,
+        name: id,
+        disabled: disabled || readonly,
+        autoFocus: autofocus,
+        ...semanticProps,
+        checked: typeof value === "undefined" ? false : checked,
+        error: rawErrors.length > 0,
+        onChange: _onChange,
+        onBlur: _onBlur,
+        onFocus: _onFocus,
+        required,
+        label: labelValue2(label, hideLabel, false),
+        "aria-describedby": ariaDescribedByIds2(id)
+      }
+    )
+  ] });
 }
 
-/** The `CheckboxesWidget` is a widget for rendering checkbox groups.
- *  It is typically used to represent an array of enums.
- *
- * @param props - The `WidgetProps` for this component
- */
+// src/CheckboxesWidget/CheckboxesWidget.tsx
+import { Form as Form5 } from "semantic-ui-react";
+import {
+  ariaDescribedByIds as ariaDescribedByIds3,
+  enumOptionsDeselectValue,
+  enumOptionsIsSelected,
+  enumOptionsSelectValue,
+  getTemplate as getTemplate5,
+  optionId,
+  titleId as titleId2
+} from "@rjsf/utils";
+import { Fragment as Fragment4, jsx as jsx17, jsxs as jsxs9 } from "react/jsx-runtime";
 function CheckboxesWidget(props) {
   const {
     id,
@@ -941,27 +800,18 @@ function CheckboxesWidget(props) {
     rawErrors = [],
     registry
   } = props;
-  const TitleFieldTemplate = getTemplate('TitleFieldTemplate', registry, options);
-  const {
-    enumOptions,
-    enumDisabled,
-    inline
-  } = options;
+  const TitleFieldTemplate = getTemplate5("TitleFieldTemplate", registry, options);
+  const { enumOptions, enumDisabled, inline } = options;
   const checkboxesValues = Array.isArray(value) ? value : [value];
   const semanticProps = getSemanticProps({
     options,
     formContext,
     uiSchema,
     defaultSchemaProps: {
-      inverted: 'false'
+      inverted: "false"
     }
   });
-  const _onChange = index => ({
-    target: {
-      checked
-    }
-  }) => {
-    // eslint-disable-next-line no-shadow
+  const _onChange = (index) => ({ target: { checked } }) => {
     if (checked) {
       onChange(enumOptionsSelectValue(index, checkboxesValues, enumOptions));
     } else {
@@ -970,49 +820,44 @@ function CheckboxesWidget(props) {
   };
   const _onBlur = () => onBlur(id, value);
   const _onFocus = () => onFocus(id, value);
-  const inlineOption = inline ? {
-    inline: true
-  } : {
-    grouped: true
-  };
-  return jsxs(Fragment, {
-    children: [!hideLabel && !!label && jsx(TitleFieldTemplate, {
-      id: titleId(id),
-      title: label,
-      schema: schema,
-      uiSchema: uiSchema,
-      registry: registry
-    }), jsx(Form.Group, {
-      id: id,
-      name: id,
-      ...inlineOption,
-      children: Array.isArray(enumOptions) && enumOptions.map((option, index) => {
-        const checked = enumOptionsIsSelected(option.value, checkboxesValues);
-        const itemDisabled = Array.isArray(enumDisabled) && enumDisabled.indexOf(option.value) !== -1;
-        return jsx(Form.Checkbox, {
+  const inlineOption = inline ? { inline: true } : { grouped: true };
+  return /* @__PURE__ */ jsxs9(Fragment4, { children: [
+    !hideLabel && !!label && /* @__PURE__ */ jsx17(TitleFieldTemplate, { id: titleId2(id), title: label, schema, uiSchema, registry }),
+    /* @__PURE__ */ jsx17(Form5.Group, { id, name: id, ...inlineOption, children: Array.isArray(enumOptions) && enumOptions.map((option, index) => {
+      const checked = enumOptionsIsSelected(option.value, checkboxesValues);
+      const itemDisabled = Array.isArray(enumDisabled) && enumDisabled.indexOf(option.value) !== -1;
+      return /* @__PURE__ */ jsx17(
+        Form5.Checkbox,
+        {
           id: optionId(id, index),
           name: id,
           label: option.label,
           ...semanticProps,
-          checked: checked,
+          checked,
           error: rawErrors.length > 0,
           disabled: disabled || itemDisabled || readonly,
           autoFocus: autofocus && index === 0,
           onChange: _onChange(index),
           onBlur: _onBlur,
           onFocus: _onFocus,
-          "aria-describedby": ariaDescribedByIds(id)
-        }, index);
-      })
-    })]
-  });
+          "aria-describedby": ariaDescribedByIds3(id)
+        },
+        index
+      );
+    }) })
+  ] });
 }
 
-/** The `RadioWidget` is a widget for rendering a radio group.
- *  It is typically used with a string property constrained with enum options.
- *
- * @param props - The `WidgetProps` for this component
- */
+// src/RadioWidget/RadioWidget.tsx
+import {
+  ariaDescribedByIds as ariaDescribedByIds4,
+  enumOptionsIsSelected as enumOptionsIsSelected2,
+  enumOptionsValueForIndex,
+  optionId as optionId2
+} from "@rjsf/utils";
+import { Form as Form6, Radio } from "semantic-ui-react";
+import { jsx as jsx18 } from "react/jsx-runtime";
+import { createElement } from "react";
 function RadioWidget(props) {
   const {
     id,
@@ -1028,37 +873,27 @@ function RadioWidget(props) {
     uiSchema,
     rawErrors = []
   } = props;
-  const {
-    enumOptions,
-    enumDisabled,
-    emptyValue
-  } = options;
+  const { enumOptions, enumDisabled, emptyValue } = options;
   const semanticProps = getSemanticProps({
     formContext,
     options,
     uiSchema
   });
-  const _onChange = (_, {
-    value: eventValue
-  }) => {
+  const _onChange = (_, { value: eventValue }) => {
     return onChange(enumOptionsValueForIndex(eventValue, enumOptions, emptyValue));
   };
   const _onBlur = () => onBlur(id, value);
   const _onFocus = () => onFocus(id, value);
-  const inlineOption = options.inline ? {
-    inline: true
-  } : {
-    grouped: true
-  };
-  return jsx(Form.Group, {
-    ...inlineOption,
-    children: Array.isArray(enumOptions) && enumOptions.map((option, index) => {
-      const checked = enumOptionsIsSelected(option.value, value);
-      const itemDisabled = Array.isArray(enumDisabled) && enumDisabled.indexOf(option.value) !== -1;
-      return /*#__PURE__*/createElement(Form.Field, {
-        required: required,
+  const inlineOption = options.inline ? { inline: true } : { grouped: true };
+  return /* @__PURE__ */ jsx18(Form6.Group, { ...inlineOption, children: Array.isArray(enumOptions) && enumOptions.map((option, index) => {
+    const checked = enumOptionsIsSelected2(option.value, value);
+    const itemDisabled = Array.isArray(enumDisabled) && enumDisabled.indexOf(option.value) !== -1;
+    return /* @__PURE__ */ createElement(
+      Form6.Field,
+      {
+        required,
         control: Radio,
-        id: optionId(id, index),
+        id: optionId2(id, index),
         name: id,
         ...semanticProps,
         onFocus: _onFocus,
@@ -1068,19 +903,18 @@ function RadioWidget(props) {
         value: String(index),
         error: rawErrors.length > 0,
         key: index,
-        checked: checked,
+        checked,
         disabled: disabled || itemDisabled || readonly,
-        "aria-describedby": ariaDescribedByIds(id)
-      });
-    })
-  });
+        "aria-describedby": ariaDescribedByIds4(id)
+      }
+    );
+  }) });
 }
 
-/** The `RangeWidget` component uses the `BaseInputTemplate` changing the type to `range` and wrapping the result
- * in a div, with the value along side it.
- *
- * @param props - The `WidgetProps` for this component
- */
+// src/RangeWidget/RangeWidget.tsx
+import { Input } from "semantic-ui-react";
+import { ariaDescribedByIds as ariaDescribedByIds5, rangeSpec } from "@rjsf/utils";
+import { Fragment as Fragment5, jsx as jsx19, jsxs as jsxs10 } from "react/jsx-runtime";
 function RangeWidget(props) {
   const {
     id,
@@ -1105,47 +939,46 @@ function RangeWidget(props) {
       fluid: true
     }
   });
-  // eslint-disable-next-line no-shadow
-  const _onChange = ({
-    target: {
-      value
-    }
-  }) => onChange && onChange(value === '' ? options.emptyValue : value);
+  const _onChange = ({ target: { value: value2 } }) => onChange && onChange(value2 === "" ? options.emptyValue : value2);
   const _onBlur = () => onBlur && onBlur(id, value);
   const _onFocus = () => onFocus && onFocus(id, value);
-  return jsxs(Fragment, {
-    children: [jsx(Input, {
-      id: id,
-      name: id,
-      type: 'range',
-      required: required,
-      disabled: disabled || readonly,
-      ...rangeSpec(schema),
-      ...semanticProps,
-      value: value || '',
-      error: rawErrors.length > 0,
-      onChange: _onChange,
-      onBlur: _onBlur,
-      onFocus: _onFocus,
-      "aria-describedby": ariaDescribedByIds(id)
-    }, id), jsx("span", {
-      children: value
-    })]
-  });
+  return /* @__PURE__ */ jsxs10(Fragment5, { children: [
+    /* @__PURE__ */ jsx19(
+      Input,
+      {
+        id,
+        name: id,
+        type: "range",
+        required,
+        disabled: disabled || readonly,
+        ...rangeSpec(schema),
+        ...semanticProps,
+        value: value || "",
+        error: rawErrors.length > 0,
+        onChange: _onChange,
+        onBlur: _onBlur,
+        onFocus: _onFocus,
+        "aria-describedby": ariaDescribedByIds5(id)
+      },
+      id
+    ),
+    /* @__PURE__ */ jsx19("span", { children: value })
+  ] });
 }
 
-/**
- * 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 {*}
- */
+// src/SelectWidget/SelectWidget.tsx
+import {
+  ariaDescribedByIds as ariaDescribedByIds6,
+  enumOptionsIndexForValue,
+  enumOptionsValueForIndex as enumOptionsValueForIndex2,
+  labelValue as labelValue3
+} from "@rjsf/utils";
+import map from "lodash/map";
+import { Form as Form7 } from "semantic-ui-react";
+import { jsx as jsx20 } from "react/jsx-runtime";
 function createDefaultValueOptionsForDropDown(enumOptions, enumDisabled) {
   const disabledOptions = enumDisabled || [];
-  const options = map(enumOptions, ({
-    label,
-    value
-  }, index) => ({
+  const options = map(enumOptions, ({ label, value }, index) => ({
     disabled: disabledOptions.indexOf(value) !== -1,
     key: label,
     text: label,
@@ -1153,11 +986,6 @@ function createDefaultValueOptionsForDropDown(enumOptions, enumDisabled) {
   }));
   return options;
 }
-/** The `SelectWidget` is a widget for rendering dropdowns.
- *  It is typically used with string properties constrained with enum options.
- *
- * @param props - The `WidgetProps` for this component
- */
 function SelectWidget(props) {
   const {
     uiSchema,
@@ -1183,60 +1011,52 @@ function SelectWidget(props) {
     formContext,
     options,
     defaultSchemaProps: {
-      inverted: 'false',
+      inverted: "false",
       selection: true,
       fluid: true,
       scrolling: true,
       upward: false
     }
   });
-  const {
-    enumDisabled,
-    enumOptions,
-    emptyValue: optEmptyVal
-  } = options;
-  const emptyValue = multiple ? [] : '';
+  const { enumDisabled, enumOptions, emptyValue: optEmptyVal } = options;
+  const emptyValue = multiple ? [] : "";
   const dropdownOptions = createDefaultValueOptionsForDropDown(enumOptions, enumDisabled);
-  const _onChange = (_, {
-    value
-  }) => onChange(enumOptionsValueForIndex(value, enumOptions, optEmptyVal));
-  // eslint-disable-next-line no-shadow
-  const _onBlur = (_, {
-    target: {
-      value
-    }
-  }) => onBlur(id, enumOptionsValueForIndex(value, enumOptions, optEmptyVal));
-  const _onFocus = (_, {
-    target: {
-      value
-    }
-  }) => onFocus(id, enumOptionsValueForIndex(value, enumOptions, optEmptyVal));
+  const _onChange = (_, { value: value2 }) => onChange(enumOptionsValueForIndex2(value2, enumOptions, optEmptyVal));
+  const _onBlur = (_, { target: { value: value2 } }) => onBlur(id, enumOptionsValueForIndex2(value2, enumOptions, optEmptyVal));
+  const _onFocus = (_, { target: { value: value2 } }) => onFocus(id, enumOptionsValueForIndex2(value2, enumOptions, optEmptyVal));
   const selectedIndexes = enumOptionsIndexForValue(value, enumOptions, multiple);
-  return jsx(Form.Dropdown, {
-    id: id,
-    name: id,
-    label: labelValue(label || undefined, hideLabel, false),
-    multiple: typeof multiple === 'undefined' ? false : multiple,
-    value: typeof value === 'undefined' ? emptyValue : selectedIndexes,
-    error: rawErrors.length > 0,
-    disabled: disabled,
-    placeholder: placeholder,
-    ...semanticProps,
-    required: required,
-    autoFocus: autofocus,
-    readOnly: readonly,
-    options: dropdownOptions,
-    onChange: _onChange,
-    onBlur: _onBlur,
-    onFocus: _onFocus,
-    "aria-describedby": ariaDescribedByIds(id)
-  }, id);
+  return /* @__PURE__ */ jsx20(
+    Form7.Dropdown,
+    {
+      id,
+      name: id,
+      label: labelValue3(label || void 0, hideLabel, false),
+      multiple: typeof multiple === "undefined" ? false : multiple,
+      value: typeof value === "undefined" ? emptyValue : selectedIndexes,
+      error: rawErrors.length > 0,
+      disabled,
+      placeholder,
+      ...semanticProps,
+      required,
+      autoFocus: autofocus,
+      readOnly: readonly,
+      options: dropdownOptions,
+      onChange: _onChange,
+      onBlur: _onBlur,
+      onFocus: _onFocus,
+      "aria-describedby": ariaDescribedByIds6(id)
+    },
+    id
+  );
 }
 
-/** The `TextareaWidget` is a widget for rendering input fields as textarea.
- *
- * @param props - The `WidgetProps` for this component
- */
+// src/TextareaWidget/TextareaWidget.tsx
+import {
+  ariaDescribedByIds as ariaDescribedByIds7,
+  labelValue as labelValue4
+} from "@rjsf/utils";
+import { Form as Form8 } from "semantic-ui-react";
+import { jsx as jsx21 } from "react/jsx-runtime";
 function TextareaWidget(props) {
   const {
     id,
@@ -1258,37 +1078,35 @@ function TextareaWidget(props) {
   const semanticProps = getSemanticProps({
     formContext,
     options,
-    defaultSchemaProps: {
-      inverted: 'false'
-    }
+    defaultSchemaProps: { inverted: "false" }
   });
-  // eslint-disable-next-line no-shadow
-  const _onChange = ({
-    target: {
-      value
-    }
-  }) => onChange && onChange(value === '' ? options.emptyValue : value);
+  const _onChange = ({ target: { value: value2 } }) => onChange && onChange(value2 === "" ? options.emptyValue : value2);
   const _onBlur = () => onBlur && onBlur(id, value);
   const _onFocus = () => onFocus && onFocus(id, value);
-  return jsx(Form.TextArea, {
-    id: id,
-    name: id,
-    label: labelValue(label || undefined, hideLabel, false),
-    placeholder: placeholder,
-    autoFocus: autofocus,
-    required: required,
-    disabled: disabled || readonly,
-    ...semanticProps,
-    value: value || '',
-    error: rawErrors.length > 0,
-    rows: options.rows || 5,
-    onChange: _onChange,
-    onBlur: _onBlur,
-    onFocus: _onFocus,
-    "aria-describedby": ariaDescribedByIds(id)
-  }, id);
+  return /* @__PURE__ */ jsx21(
+    Form8.TextArea,
+    {
+      id,
+      name: id,
+      label: labelValue4(label || void 0, hideLabel, false),
+      placeholder,
+      autoFocus: autofocus,
+      required,
+      disabled: disabled || readonly,
+      ...semanticProps,
+      value: value || "",
+      error: rawErrors.length > 0,
+      rows: options.rows || 5,
+      onChange: _onChange,
+      onBlur: _onBlur,
+      onFocus: _onFocus,
+      "aria-describedby": ariaDescribedByIds7(id)
+    },
+    id
+  );
 }
 
+// src/Widgets/Widgets.tsx
 function generateWidgets() {
   return {
     CheckboxWidget,
@@ -1299,21 +1117,35 @@ function generateWidgets() {
     TextareaWidget
   };
 }
-var Widgets = /*#__PURE__*/generateWidgets();
+var Widgets_default = generateWidgets();
 
+// src/Theme/Theme.ts
 function generateTheme() {
   return {
     templates: generateTemplates(),
     widgets: generateWidgets(),
-    _internalFormWrapper: Form
+    _internalFormWrapper: SuiForm
   };
 }
-var Theme = /*#__PURE__*/generateTheme();
+var Theme_default = generateTheme();
 
+// src/SemanticUIForm/SemanticUIForm.ts
 function generateForm() {
   return withTheme(generateTheme());
 }
-var SemanticUIForm = /*#__PURE__*/generateForm();
+var SemanticUIForm_default = generateForm();
 
-export { SemanticUIForm as Form, Templates, Theme, Widgets, SemanticUIForm as default, generateForm, generateTemplates, generateTheme, generateWidgets };
+// src/index.ts
+var src_default = SemanticUIForm_default;
+export {
+  SemanticUIForm_default as Form,
+  Templates_default as Templates,
+  Theme_default as Theme,
+  Widgets_default as Widgets,
+  src_default as default,
+  generateForm,
+  generateTemplates,
+  generateTheme,
+  generateWidgets
+};
 //# sourceMappingURL=semantic-ui.esm.js.map