@saas-ui/forms 2.0.0-next.3 → 2.0.0-next.6

package/dist/index.js

@@ -1,14 +1,16 @@
 'use strict';
 
-var React8 = require('react');
-var utils = require('@chakra-ui/utils');
+var React11 = require('react');
 var reactHookForm = require('react-hook-form');
+var jsxRuntime = require('react/jsx-runtime');
 var react = require('@chakra-ui/react');
-var icons = require('@chakra-ui/icons');
-var reactUtils = require('@chakra-ui/react-utils');
 var core = require('@saas-ui/core');
+var icons = require('@saas-ui/core/icons');
+var utils = require('@chakra-ui/utils');
+var reactUtils = require('@chakra-ui/react-utils');
 
-function _interopNamespaceDefault(e) {
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
   var n = Object.create(null);
   if (e) {
     Object.keys(e).forEach(function (k) {
@@ -25,70 +27,74 @@ function _interopNamespaceDefault(e) {
   return Object.freeze(n);
 }
 
-var React8__namespace = /*#__PURE__*/_interopNamespaceDefault(React8);
+var React11__namespace = /*#__PURE__*/_interopNamespace(React11);
 
-// src/display-field.tsx
+// src/form-context.tsx
+var FormContext = React11.createContext(null);
+var useFormContext = () => {
+  const context = React11.useContext(FormContext);
+  const hookContext = reactHookForm.useFormContext();
+  if (!context) {
+    throw new Error("FormProvider must be used within a Form component");
+  }
+  return {
+    ...hookContext,
+    ...context
+  };
+};
+var useFieldProps = (name) => {
+  var _a;
+  const parsedName = name == null ? void 0 : name.replace(/\.[0-9]/g, ".$");
+  const context = useFormContext();
+  return (_a = context == null ? void 0 : context.fields) == null ? void 0 : _a[parsedName];
+};
+var FormProvider = (props) => {
+  const { children, fieldResolver, schema, fields, ...rest } = props;
+  return /* @__PURE__ */ jsxRuntime.jsx(reactHookForm.FormProvider, { ...rest, children: /* @__PURE__ */ jsxRuntime.jsx(FormContext.Provider, { value: { fieldResolver, schema, fields }, children }) });
+};
 var DisplayField = ({
   name,
   label,
   placeholder,
   ...props
 }) => {
-  return /* @__PURE__ */ React8__namespace.createElement(react.FormControl, {
-    ...props
-  }, label ? /* @__PURE__ */ React8__namespace.createElement(react.FormLabel, {
-    htmlFor: name
-  }, label) : null, /* @__PURE__ */ React8__namespace.createElement(react.Text, {
-    fontSize: "md"
-  }, /* @__PURE__ */ React8__namespace.createElement(FormValue, {
-    name
-  })));
+  return /* @__PURE__ */ jsxRuntime.jsxs(react.FormControl, { ...props, children: [
+    label ? /* @__PURE__ */ jsxRuntime.jsx(react.FormLabel, { htmlFor: name, children: label }) : null,
+    /* @__PURE__ */ jsxRuntime.jsx(react.Text, { fontSize: "md", children: /* @__PURE__ */ jsxRuntime.jsx(FormValue, { name }) })
+  ] });
 };
-if (utils.__DEV__) {
-  DisplayField.displayName = "DisplayField";
-}
+DisplayField.displayName = "DisplayField";
 var FormValue = ({ name }) => {
-  const { getValues } = reactHookForm.useFormContext();
+  const { getValues } = useFormContext();
   return getValues(name) || null;
 };
-if (utils.__DEV__) {
-  FormValue.displayName = "FormValue";
-}
+FormValue.displayName = "FormValue";
 var NumberInput = react.forwardRef((props, ref) => {
-  const { hideStepper, incrementIcon, decrementIcon, ...rest } = props;
-  return /* @__PURE__ */ React8__namespace.createElement(react.NumberInput, {
-    ...rest,
-    ref
-  }, /* @__PURE__ */ React8__namespace.createElement(react.NumberInputField, null), !hideStepper && /* @__PURE__ */ React8__namespace.createElement(react.NumberInputStepper, null, /* @__PURE__ */ React8__namespace.createElement(react.NumberIncrementStepper, {
-    children: incrementIcon
-  }), /* @__PURE__ */ React8__namespace.createElement(react.NumberDecrementStepper, {
-    children: decrementIcon
-  })));
+  const {
+    hideStepper,
+    incrementIcon = /* @__PURE__ */ jsxRuntime.jsx(core.ChevronUpIcon, {}),
+    decrementIcon = /* @__PURE__ */ jsxRuntime.jsx(core.ChevronDownIcon, {}),
+    ...rest
+  } = props;
+  return /* @__PURE__ */ jsxRuntime.jsxs(react.NumberInput, { ...rest, ref, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(react.NumberInputField, {}),
+    !hideStepper && /* @__PURE__ */ jsxRuntime.jsxs(react.NumberInputStepper, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(react.NumberIncrementStepper, { children: incrementIcon }),
+      /* @__PURE__ */ jsxRuntime.jsx(react.NumberDecrementStepper, { children: decrementIcon })
+    ] })
+  ] });
 });
 NumberInput.defaultProps = {
   hideStepper: false
 };
-if (utils.__DEV__) {
-  NumberInput.displayName = "NumberInput";
-}
+NumberInput.displayName = "NumberInput";
 var InputRightButton = react.forwardRef(
   (props, ref) => {
-    return /* @__PURE__ */ React8__namespace.createElement(react.InputRightElement, {
-      w: "auto",
-      px: "1",
-      py: "1",
-      alignItems: "stretch"
-    }, /* @__PURE__ */ React8__namespace.createElement(react.Button, {
-      ref,
-      height: "auto",
-      ...props
-    }));
+    return /* @__PURE__ */ jsxRuntime.jsx(react.InputRightElement, { w: "auto", px: "1", py: "1", alignItems: "stretch", children: /* @__PURE__ */ jsxRuntime.jsx(react.Button, { ref, height: "auto", ...props }) });
   }
 );
 InputRightButton.id = "InputRightElement";
 InputRightButton.displayName = "InputRightButton";
-
-// src/password-input/password-input.tsx
 var PasswordInput = react.forwardRef(
   (props, ref) => {
     const {
@@ -99,219 +105,285 @@ var PasswordInput = react.forwardRef(
       width,
       size,
       variant,
+      leftAddon,
       ...inputProps
     } = props;
-    const [show, setShow] = React8.useState(false);
+    const [show, setShow] = React11.useState(false);
     const handleClick = () => setShow(!show);
     const label = show ? "Hide password" : "Show password";
     let icon;
     if (show) {
-      icon = viewIcon || /* @__PURE__ */ React8.createElement(icons.ViewIcon, null);
+      icon = viewIcon || /* @__PURE__ */ jsxRuntime.jsx(icons.ViewIcon, {});
     } else {
-      icon = viewOffIcon || /* @__PURE__ */ React8.createElement(icons.ViewOffIcon, null);
+      icon = viewOffIcon || /* @__PURE__ */ jsxRuntime.jsx(icons.ViewOffIcon, {});
     }
     const groupProps = {
       width: w || width,
       size,
       variant
     };
-    return /* @__PURE__ */ React8.createElement(react.InputGroup, {
-      ...groupProps
-    }, /* @__PURE__ */ React8.createElement(react.Input, {
-      ...inputProps,
-      ref,
-      type: show ? "text" : "password",
-      autoComplete: show ? "off" : autoComplete
-    }), /* @__PURE__ */ React8.createElement(InputRightButton, {
-      onClick: handleClick,
-      "aria-label": label,
-      variant: "ghost"
-    }, icon));
+    return /* @__PURE__ */ jsxRuntime.jsxs(react.InputGroup, { ...groupProps, children: [
+      leftAddon,
+      /* @__PURE__ */ jsxRuntime.jsx(
+        react.Input,
+        {
+          ...inputProps,
+          ref,
+          type: show ? "text" : "password",
+          autoComplete: show ? "off" : autoComplete
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        InputRightButton,
+        {
+          onClick: handleClick,
+          "aria-label": label,
+          variant: "ghost",
+          children: icon
+        }
+      )
+    ] });
   }
 );
-if (utils.__DEV__) {
-  PasswordInput.displayName = "PasswordInput";
-}
+PasswordInput.displayName = "PasswordInput";
+var mapNestedFields = (name, children) => {
+  return React11__namespace.Children.map(children, (child) => {
+    if (React11__namespace.isValidElement(child) && child.props.name) {
+      let childName = child.props.name;
+      if (childName.includes(".")) {
+        childName = childName.replace(/^.*\.(.*)/, "$1");
+      } else if (childName.includes(".$")) {
+        childName = childName.replace(/^.*\.\$(.*)/, "$1");
+      }
+      return React11__namespace.cloneElement(child, {
+        ...child.props,
+        name: `${name}.${childName}`
+      });
+    }
+    return child;
+  });
+};
+var mapOptions = (options) => {
+  return options.map((option) => {
+    if (typeof option === "string") {
+      return {
+        label: option,
+        value: option
+      };
+    }
+    return option;
+  });
+};
 var RadioInput = react.forwardRef(
-  ({ options, spacing, direction, ...props }, ref) => {
+  ({ options: optionsProp, spacing, direction, ...props }, ref) => {
     const { onBlur, onChange, ...groupProps } = props;
-    return /* @__PURE__ */ React8__namespace.createElement(react.RadioGroup, {
-      onChange,
-      ...groupProps
-    }, /* @__PURE__ */ React8__namespace.createElement(react.Stack, {
-      spacing,
-      direction
-    }, options.map(({ value, label, ...radioProps }, i) => {
-      return /* @__PURE__ */ React8__namespace.createElement(react.Radio, {
-        key: i,
-        onBlur,
-        value,
-        ref,
-        ...radioProps
-      }, label || value);
-    })));
+    const options = mapOptions(optionsProp);
+    return /* @__PURE__ */ jsxRuntime.jsx(react.RadioGroup, { onChange, ...groupProps, children: /* @__PURE__ */ jsxRuntime.jsx(react.Stack, { spacing, direction, children: options.map(({ value, label, ...radioProps }, i) => {
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        react.Radio,
+        {
+          onBlur,
+          value,
+          ref,
+          ...radioProps,
+          children: label || value
+        },
+        i
+      );
+    }) }) });
   }
 );
-if (utils.__DEV__) {
-  RadioInput.displayName = "RadioInput";
-}
-var SelectButton = react.forwardRef((props, ref) => {
-  const styles = react.useMultiStyleConfig("Input", props);
-  const focusStyles = styles.field._focusVisible;
-  const height = styles.field.h || styles.field.height;
-  const buttonStyles = {
-    fontWeight: "normal",
-    textAlign: "left",
-    color: "inherit",
-    _active: {
-      bg: "transparent"
-    },
-    minH: height,
-    _focus: focusStyles,
-    _expanded: focusStyles,
-    ...styles.field,
-    h: "auto"
-  };
-  return /* @__PURE__ */ React8__namespace.createElement(react.MenuButton, {
-    as: react.Button,
-    ...props,
-    ref,
-    sx: buttonStyles
-  });
+RadioInput.displayName = "RadioInput";
+var [SelectProvider, useSelectContext] = reactUtils.createContext({
+  strict: true
 });
-if (utils.__DEV__) {
-  SelectButton.displayName = "SelectButton";
-}
-var Select = react.forwardRef((props, ref) => {
+var useSelect = (props) => {
   const {
     name,
-    options,
-    children,
-    onChange,
-    defaultValue,
     value,
+    defaultValue,
+    onChange,
+    multiple,
     placeholder,
+    options: optionsProp,
     isDisabled,
-    leftIcon,
-    rightIcon = /* @__PURE__ */ React8__namespace.createElement(icons.ChevronDownIcon, null),
-    multiple,
-    size,
-    variant,
-    menuListProps,
-    renderValue = (value2) => value2 == null ? void 0 : value2.join(", "),
-    ...rest
+    renderValue = (value2) => typeof value2 === "string" ? value2 : value2 == null ? void 0 : value2.join(", ")
   } = props;
-  const menuProps = react.omitThemingProps(rest);
-  const [currentValue, setCurrentValue] = React8__namespace.useState(value || defaultValue);
+  const [currentValue, setCurrentValue] = react.useControllableState({
+    value,
+    defaultValue,
+    onChange
+  });
   const controlProps = react.useFormControl({ name });
+  const options = React11__namespace.default.useMemo(
+    () => optionsProp && mapOptions(optionsProp),
+    [optionsProp]
+  );
   const handleChange = (value2) => {
     setCurrentValue(value2);
-    onChange == null ? void 0 : onChange(value2);
   };
-  const buttonProps = {
-    isDisabled,
-    leftIcon,
-    rightIcon,
-    size,
-    variant
-  };
-  const getDisplayValue = React8__namespace.useCallback(
+  const getDisplayValue = React11__namespace.default.useCallback(
     (value2) => {
       if (!options) {
         return value2;
       }
       for (const option of options) {
-        if (option.label && option.value === value2) {
-          return option.label;
+        if (option.value === value2) {
+          return option.label || option.value;
         }
       }
       return value2;
     },
     [options]
   );
-  const displayValue = currentValue ? (Array.isArray(currentValue) ? currentValue : [currentValue]).map(
-    getDisplayValue
-  ) : [];
-  return /* @__PURE__ */ React8__namespace.createElement(react.Menu, {
-    ...menuProps,
-    closeOnSelect: !multiple
-  }, /* @__PURE__ */ React8__namespace.createElement(react.chakra.div, {
-    className: utils.cx("sui-select")
-  }, /* @__PURE__ */ React8__namespace.createElement(SelectButton, {
-    ref,
-    ...buttonProps
-  }, renderValue(displayValue) || placeholder), /* @__PURE__ */ React8__namespace.createElement(react.MenuList, {
-    maxH: "60vh",
-    overflowY: "auto",
-    ...menuListProps
-  }, /* @__PURE__ */ React8__namespace.createElement(react.MenuOptionGroup, {
-    defaultValue: defaultValue || value,
-    onChange: handleChange,
-    type: multiple ? "checkbox" : "radio"
-  }, options ? options.map(({ value: value2, label, ...rest2 }, i) => /* @__PURE__ */ React8__namespace.createElement(react.MenuItemOption, {
-    key: i,
-    value: value2,
-    ...rest2
-  }, label || value2)) : children)), /* @__PURE__ */ React8__namespace.createElement(react.chakra.input, {
-    ...controlProps,
-    name,
-    type: "hidden",
+  const displayValue = React11__namespace.default.useMemo(
+    () => currentValue ? (Array.isArray(currentValue) ? currentValue : [currentValue]).map(
+      getDisplayValue
+    ) : [],
+    [currentValue, getDisplayValue]
+  );
+  return {
+    defaultValue,
     value: currentValue,
-    className: "saas-select__input"
-  })));
+    displayValue,
+    renderValue,
+    onChange: handleChange,
+    options,
+    multiple,
+    controlProps,
+    placeholder,
+    isDisabled
+  };
+};
+var SelectButton = react.forwardRef(
+  (props, ref) => {
+    var _a, _b, _c, _d, _e;
+    const styles = react.useMultiStyleConfig("SuiSelect", props);
+    const {
+      displayValue,
+      renderValue,
+      placeholder,
+      isDisabled: isSelectDisabled
+    } = useSelectContext();
+    const {
+      isInvalid,
+      isReadOnly,
+      isDisabled,
+      isFocused,
+      isRequired,
+      id,
+      onBlur,
+      onFocus
+    } = react.useFormControlContext();
+    const { rightIcon = /* @__PURE__ */ jsxRuntime.jsx(core.ChevronDownIcon, {}), ...rest } = props;
+    const focusStyles = (_a = styles.field) == null ? void 0 : _a._focusVisible;
+    const readOnlyStyles = (_b = styles.field) == null ? void 0 : _b._readOnly;
+    const invalid = (_c = styles.field) == null ? void 0 : _c._invalid;
+    const height = ((_d = styles.field) == null ? void 0 : _d.h) || ((_e = styles.field) == null ? void 0 : _e.height);
+    const buttonStyles = {
+      fontWeight: "normal",
+      textAlign: "left",
+      color: "inherit",
+      _active: {
+        bg: "transparent"
+      },
+      minH: height,
+      _focus: focusStyles,
+      _expanded: focusStyles,
+      _readOnly: readOnlyStyles,
+      _invalid: invalid,
+      ...styles.field,
+      h: "auto"
+    };
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      react.MenuButton,
+      {
+        as: react.Button,
+        id,
+        ...rest,
+        onFocus,
+        onBlur,
+        isDisabled: isDisabled || isSelectDisabled,
+        "data-invalid": utils.dataAttr(isInvalid),
+        "data-read-only": utils.dataAttr(isReadOnly),
+        "data-focus": utils.dataAttr(isFocused),
+        "data-required": utils.dataAttr(isRequired),
+        rightIcon,
+        ref,
+        sx: buttonStyles,
+        children: renderValue(displayValue) || placeholder
+      }
+    );
+  }
+);
+SelectButton.displayName = "SelectButton";
+var Select = react.forwardRef((props, ref) => {
+  const { name, children, isDisabled, multiple, ...rest } = props;
+  const menuProps = react.omitThemingProps(rest);
+  const context = useSelect(props);
+  const { value, controlProps } = context;
+  return /* @__PURE__ */ jsxRuntime.jsx(SelectProvider, { value: context, children: /* @__PURE__ */ jsxRuntime.jsx(react.Menu, { ...menuProps, closeOnSelect: !multiple, children: /* @__PURE__ */ jsxRuntime.jsxs(react.chakra.div, { className: utils.cx("sui-select"), children: [
+    children,
+    /* @__PURE__ */ jsxRuntime.jsx(
+      react.chakra.input,
+      {
+        ...controlProps,
+        ref,
+        name,
+        type: "hidden",
+        value: value || "",
+        className: "saas-select__input"
+      }
+    )
+  ] }) }) });
 });
-if (utils.__DEV__) {
-  Select.displayName = "Select";
-}
+var SelectList = (props) => {
+  const { defaultValue, value, options, multiple, onChange } = useSelectContext();
+  return /* @__PURE__ */ jsxRuntime.jsx(react.MenuList, { maxH: "100vh", overflowY: "auto", ...props, children: /* @__PURE__ */ jsxRuntime.jsx(
+    react.MenuOptionGroup,
+    {
+      defaultValue: defaultValue || value,
+      value,
+      onChange,
+      type: multiple ? "checkbox" : "radio",
+      children: options ? options.map(({ value: value2, label, ...rest }, i) => /* @__PURE__ */ jsxRuntime.jsx(SelectOption, { value: value2, ...rest, children: label || value2 }, i)) : props.children
+    }
+  ) });
+};
+Select.displayName = "Select";
+var SelectOption = react.forwardRef(
+  (props, ref) => {
+    return /* @__PURE__ */ jsxRuntime.jsx(react.MenuItemOption, { ref, ...props });
+  }
+);
+SelectOption.id = "MenuItemOption";
+SelectOption.displayName = "SelectOption";
 var NativeSelect = react.forwardRef(
   ({ options, children, ...props }, ref) => {
-    return /* @__PURE__ */ React8__namespace.createElement(react.Select, {
-      ref,
-      ...props
-    }, children || (options == null ? void 0 : options.map(({ value, label }) => {
-      return /* @__PURE__ */ React8__namespace.createElement("option", {
-        key: value,
-        value
-      }, label || value);
-    })));
+    return /* @__PURE__ */ jsxRuntime.jsx(react.Select, { ref, ...props, children: children || (options == null ? void 0 : options.map(({ value, label }) => {
+      return /* @__PURE__ */ jsxRuntime.jsx("option", { value, children: label || value }, value);
+    })) });
   }
 );
-if (utils.__DEV__) {
-  NativeSelect.displayName = "NativeSelect";
-}
-
-// src/field.tsx
-var inputTypes = {};
-var defaultInputType = "text";
-var getInput = (type) => {
-  return inputTypes[type] || inputTypes[defaultInputType];
-};
+NativeSelect.displayName = "NativeSelect";
 var getError = (name, formState) => {
   return reactHookForm.get(formState.errors, name);
 };
 var BaseField = (props) => {
   const { name, label, help, hideLabel, children, ...controlProps } = props;
-  const { formState } = reactHookForm.useFormContext();
+  const { formState } = useFormContext();
   const error = getError(name, formState);
-  return /* @__PURE__ */ React8__namespace.createElement(react.FormControl, {
-    ...controlProps,
-    isInvalid: !!error
-  }, label && !hideLabel ? /* @__PURE__ */ React8__namespace.createElement(react.FormLabel, null, label) : null, /* @__PURE__ */ React8__namespace.createElement(react.Box, null, children, help && !(error == null ? void 0 : error.message) ? /* @__PURE__ */ React8__namespace.createElement(react.FormHelperText, null, help) : null, (error == null ? void 0 : error.message) && /* @__PURE__ */ React8__namespace.createElement(react.FormErrorMessage, null, error == null ? void 0 : error.message)));
+  return /* @__PURE__ */ jsxRuntime.jsxs(react.FormControl, { ...controlProps, isInvalid: !!error, children: [
+    label && !hideLabel ? /* @__PURE__ */ jsxRuntime.jsx(react.FormLabel, { children: label }) : null,
+    /* @__PURE__ */ jsxRuntime.jsxs(react.Box, { children: [
+      children,
+      help && !(error == null ? void 0 : error.message) ? /* @__PURE__ */ jsxRuntime.jsx(react.FormHelperText, { children: help }) : null,
+      (error == null ? void 0 : error.message) && /* @__PURE__ */ jsxRuntime.jsx(react.FormErrorMessage, { children: error == null ? void 0 : error.message })
+    ] })
+  ] });
 };
-if (utils.__DEV__) {
-  BaseField.displayName = "BaseField";
-}
-var Field = React8__namespace.forwardRef(
-  (props, ref) => {
-    const { type = defaultInputType } = props;
-    const InputComponent = getInput(type);
-    return /* @__PURE__ */ React8__namespace.createElement(InputComponent, {
-      ref,
-      ...props
-    });
-  }
-);
-var createField = (InputComponent, { displayName, hideLabel, BaseField: BaseField2 }) => {
+BaseField.displayName = "BaseField";
+var _createField = (InputComponent, { displayName, hideLabel, BaseField: BaseField2 }) => {
   const Field2 = react.forwardRef((props, ref) => {
     const {
       id,
@@ -329,24 +401,31 @@ var createField = (InputComponent, { displayName, hideLabel, BaseField: BaseFiel
       required: isRequired,
       ...rules
     };
-    return /* @__PURE__ */ React8__namespace.createElement(BaseField2, {
-      id,
-      name,
-      label,
-      help,
-      hideLabel,
-      isDisabled,
-      isInvalid,
-      isReadOnly,
-      isRequired
-    }, /* @__PURE__ */ React8__namespace.createElement(InputComponent, {
-      ref,
-      id,
-      name,
-      label: hideLabel ? label : void 0,
-      rules: inputRules,
-      ...inputProps
-    }));
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      BaseField2,
+      {
+        id,
+        name,
+        label,
+        help,
+        hideLabel,
+        isDisabled,
+        isInvalid,
+        isReadOnly,
+        isRequired,
+        children: /* @__PURE__ */ jsxRuntime.jsx(
+          InputComponent,
+          {
+            ref,
+            id,
+            name,
+            label: hideLabel ? label : void 0,
+            rules: inputRules,
+            ...inputProps
+          }
+        )
+      }
+    );
   });
   Field2.displayName = displayName;
   return Field2;
@@ -354,298 +433,194 @@ var createField = (InputComponent, { displayName, hideLabel, BaseField: BaseFiel
 var withControlledInput = (InputComponent) => {
   return react.forwardRef(
     ({ name, rules, ...inputProps }, ref) => {
-      const { control } = reactHookForm.useFormContext();
-      return /* @__PURE__ */ React8__namespace.createElement(reactHookForm.Controller, {
-        name,
-        control,
-        rules,
-        render: ({ field: { ref: _ref, ...field } }) => /* @__PURE__ */ React8__namespace.createElement(InputComponent, {
-          ...field,
-          ...inputProps,
-          onChange: utils.callAllHandlers(inputProps.onChange, field.onChange),
-          onBlur: utils.callAllHandlers(inputProps.onBlur, field.onBlur),
-          ref: react.useMergeRefs(ref, _ref)
-        })
-      });
+      const { control } = useFormContext();
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        reactHookForm.Controller,
+        {
+          name,
+          control,
+          rules,
+          render: ({ field: { ref: _ref, ...field } }) => /* @__PURE__ */ jsxRuntime.jsx(
+            InputComponent,
+            {
+              ...field,
+              ...inputProps,
+              onChange: utils.callAllHandlers(inputProps.onChange, field.onChange),
+              onBlur: utils.callAllHandlers(inputProps.onBlur, field.onBlur),
+              ref: react.useMergeRefs(ref, _ref)
+            }
+          )
+        }
+      );
     }
   );
 };
 var withUncontrolledInput = (InputComponent) => {
   return react.forwardRef(
     ({ name, rules, ...inputProps }, ref) => {
-      const { register } = reactHookForm.useFormContext();
+      const { register } = useFormContext();
       const { ref: _ref, ...field } = register(name, rules);
-      return /* @__PURE__ */ React8__namespace.createElement(InputComponent, {
-        ...field,
-        ...inputProps,
-        onChange: utils.callAllHandlers(inputProps.onChange, field.onChange),
-        onBlur: utils.callAllHandlers(inputProps.onBlur, field.onBlur),
-        ref: react.useMergeRefs(ref, _ref)
-      });
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        InputComponent,
+        {
+          ...field,
+          ...inputProps,
+          onChange: utils.callAllHandlers(inputProps.onChange, field.onChange),
+          onBlur: utils.callAllHandlers(inputProps.onBlur, field.onBlur),
+          ref: react.useMergeRefs(ref, _ref)
+        }
+      );
     }
   );
 };
-var registerFieldType = (type, component, options) => {
+var createField = (component, options) => {
+  var _a;
   let InputComponent;
   if (options == null ? void 0 : options.isControlled) {
     InputComponent = withControlledInput(component);
   } else {
     InputComponent = withUncontrolledInput(component);
   }
-  const Field2 = createField(InputComponent, {
-    displayName: `${type.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("")}Field`,
+  const Field2 = _createField(InputComponent, {
+    displayName: `${(_a = component.displayName) != null ? _a : "Custom"}Field`,
     hideLabel: options == null ? void 0 : options.hideLabel,
     BaseField: (options == null ? void 0 : options.BaseField) || BaseField
   });
-  inputTypes[type] = Field2;
   return Field2;
 };
-var InputField = registerFieldType(
-  "text",
+var InputField = createField(
   react.forwardRef(({ type = "text", leftAddon, rightAddon, size, ...rest }, ref) => {
-    const input = /* @__PURE__ */ React8__namespace.createElement(react.Input, {
-      type,
-      size,
-      ...rest,
-      ref
-    });
+    const input = /* @__PURE__ */ jsxRuntime.jsx(react.Input, { type, size, ...rest, ref });
     if (leftAddon || rightAddon) {
-      return /* @__PURE__ */ React8__namespace.createElement(react.InputGroup, {
-        size
-      }, leftAddon, input, rightAddon);
+      return /* @__PURE__ */ jsxRuntime.jsxs(react.InputGroup, { size, children: [
+        leftAddon,
+        input,
+        rightAddon
+      ] });
     }
     return input;
   })
 );
-var NumberInputField2 = registerFieldType(
-  "number",
+var NumberInputField2 = createField(
   NumberInput,
   {
     isControlled: true
   }
 );
-var PasswordInputField = registerFieldType(
-  "password",
-  react.forwardRef((props, ref) => /* @__PURE__ */ React8__namespace.createElement(PasswordInput, {
-    ref,
-    ...props
-  }))
-);
-var TextareaField = registerFieldType(
-  "textarea",
-  react.Textarea
+var PasswordInputField = createField(
+  react.forwardRef((props, ref) => /* @__PURE__ */ jsxRuntime.jsx(PasswordInput, { ref, ...props }))
 );
-var SwitchField = registerFieldType(
-  "switch",
+var TextareaField = createField(react.Textarea);
+var SwitchField = createField(
   react.forwardRef(({ type, value, ...rest }, ref) => {
-    return /* @__PURE__ */ React8__namespace.createElement(react.Switch, {
-      isChecked: !!value,
-      ...rest,
-      ref
-    });
+    return /* @__PURE__ */ jsxRuntime.jsx(react.Switch, { isChecked: !!value, ...rest, ref });
   }),
   {
     isControlled: true
   }
 );
-var SelectField = registerFieldType("select", Select, {
-  isControlled: true
-});
-var CheckboxField = registerFieldType(
-  "checkbox",
-  react.forwardRef(({ label, type, ...props }, ref) => {
-    return /* @__PURE__ */ React8__namespace.createElement(react.Checkbox, {
-      ref,
-      ...props
-    }, label);
+var SelectField = createField(
+  react.forwardRef((props, ref) => {
+    return /* @__PURE__ */ jsxRuntime.jsxs(Select, { ref, ...props, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(SelectButton, {}),
+      /* @__PURE__ */ jsxRuntime.jsx(SelectList, {})
+    ] });
   }),
   {
-    hideLabel: true
+    isControlled: true
   }
 );
-var RadioField = registerFieldType(
-  "radio",
-  RadioInput,
+var CheckboxField = createField(
+  react.forwardRef(({ label, type, ...props }, ref) => {
+    return /* @__PURE__ */ jsxRuntime.jsx(react.Checkbox, { ref, ...props, children: label });
+  }),
   {
-    isControlled: true
+    hideLabel: true
   }
 );
-var NativeSelectField = registerFieldType(
-  "native-select",
-  NativeSelect,
-  { isControlled: true }
-);
-var PinField = registerFieldType(
-  "pin",
+var RadioField = createField(RadioInput, {
+  isControlled: true
+});
+var NativeSelectField = createField(NativeSelect, {
+  isControlled: true
+});
+var PinField = createField(
   react.forwardRef((props, ref) => {
     const { pinLength = 4, pinType, spacing, ...inputProps } = props;
     const inputs = [];
     for (let i = 0; i < pinLength; i++) {
-      inputs.push(/* @__PURE__ */ React8__namespace.createElement(react.PinInputField, {
-        key: i,
-        ref
-      }));
+      inputs.push(/* @__PURE__ */ jsxRuntime.jsx(react.PinInputField, { ref }, i));
     }
-    return /* @__PURE__ */ React8__namespace.createElement(react.HStack, {
-      spacing
-    }, /* @__PURE__ */ React8__namespace.createElement(react.PinInput, {
-      ...inputProps,
-      type: pinType
-    }, inputs));
+    return /* @__PURE__ */ jsxRuntime.jsx(react.HStack, { spacing, children: /* @__PURE__ */ jsxRuntime.jsx(react.PinInput, { ...inputProps, type: pinType, children: inputs }) });
   }),
   {
     isControlled: true
   }
 );
-var mapFields = (schema) => schema && Object.entries(schema).map(([name, { items, label, title, ...field }]) => {
-  return {
-    ...field,
-    name,
-    label: label || title || name
-  };
-});
-var objectFieldResolver = (schema) => {
-  const getFields = () => {
-    return mapFields(schema);
-  };
-  const getNestedFields = (name) => {
-    var _a;
-    const field = utils.get(schema, name);
-    if (!field)
-      return [];
-    if (((_a = field.items) == null ? void 0 : _a.type) === "object") {
-      return mapFields(field.items.properties);
-    } else if (field.type === "object") {
-      return mapFields(field.properties);
-    }
-    return [field.items];
-  };
-  return { getFields, getNestedFields };
+var defaultFieldTypes = {
+  text: InputField,
+  email: InputField,
+  url: InputField,
+  phone: InputField,
+  number: NumberInputField2,
+  password: PasswordInputField,
+  textarea: TextareaField,
+  switch: SwitchField,
+  select: SelectField,
+  checkbox: CheckboxField,
+  radio: RadioField,
+  pin: PinField,
+  "native-select": NativeSelectField
 };
-
-// src/form.tsx
-var Form = react.forwardRef(
+var FieldsContext = React11__namespace.default.createContext(
+  null
+);
+var FieldsProvider = (props) => {
+  const fields = { ...defaultFieldTypes, ...props.value };
+  return /* @__PURE__ */ jsxRuntime.jsx(FieldsContext.Provider, { value: fields, children: props.children });
+};
+var useField = (type) => {
+  const context = React11__namespace.default.useContext(FieldsContext);
+  return (context == null ? void 0 : context[type]) || InputField;
+};
+var defaultInputType = "text";
+var Field = React11__namespace.forwardRef(
   (props, ref) => {
-    var _a;
-    const {
-      mode = "all",
-      resolver,
-      reValidateMode,
-      shouldFocusError,
-      shouldUnregister,
-      shouldUseNativeValidation,
-      criteriaMode,
-      delayError,
-      schema,
-      defaultValues,
-      values,
-      context,
-      resetOptions,
-      onChange,
-      onSubmit,
-      onError,
-      formRef,
-      children,
-      ...rest
-    } = props;
-    const form = {
-      mode,
-      resolver,
-      defaultValues,
-      values,
-      reValidateMode,
-      shouldFocusError,
-      shouldUnregister,
-      shouldUseNativeValidation,
-      criteriaMode,
-      delayError,
-      context,
-      resetOptions
-    };
-    if (schema && !resolver) {
-      form.resolver = (_a = Form.getResolver) == null ? void 0 : _a.call(Form, schema);
-    }
-    const methods = reactHookForm.useForm(form);
-    const { handleSubmit } = methods;
-    React8__namespace.useImperativeHandle(formRef, () => methods, [formRef, methods]);
-    React8__namespace.useEffect(() => {
-      let subscription;
-      if (onChange) {
-        subscription = methods.watch(onChange);
-      }
-      return () => subscription == null ? void 0 : subscription.unsubscribe();
-    }, [methods, onChange]);
-    const Field2 = React8__namespace.useMemo(
-      () => (props2) => /* @__PURE__ */ React8__namespace.createElement(Field, {
-        ...props2
-      }),
-      []
-    );
-    return /* @__PURE__ */ React8__namespace.createElement(reactHookForm.FormProvider, {
-      ...methods
-    }, /* @__PURE__ */ React8__namespace.createElement(react.chakra.form, {
-      ref,
-      onSubmit: handleSubmit(onSubmit, onError),
-      ...rest,
-      className: utils.cx("sui-form", props.className)
-    }, utils.runIfFn(children, {
-      Field: Field2,
-      ...methods
-    })));
+    const { type = defaultInputType, name } = props;
+    const overrides = useFieldProps(name);
+    const InputComponent = useField((overrides == null ? void 0 : overrides.type) || type);
+    return /* @__PURE__ */ jsxRuntime.jsx(InputComponent, { ref, ...props, ...overrides });
   }
 );
-Form.getFieldResolver = objectFieldResolver;
-Form.displayName = "Form";
-function createForm({ resolver }) {
-  const CreateForm = (props) => {
-    const { schema, ...rest } = props;
-    return /* @__PURE__ */ React8__namespace.createElement(Form, {
-      resolver: resolver == null ? void 0 : resolver(props.schema),
-      ...rest
-    });
-  };
-  return CreateForm;
-}
 var FormLayoutItem = ({ children }) => {
-  return /* @__PURE__ */ React8__namespace.createElement(react.chakra.div, null, children);
+  return /* @__PURE__ */ jsxRuntime.jsx(react.chakra.div, { children });
 };
-if (utils.__DEV__) {
-  FormLayoutItem.displayName = "FormLayoutItem";
-}
+FormLayoutItem.displayName = "FormLayoutItem";
 var FormLayout = ({ children, ...props }) => {
   var _a, _b, _c;
   const theme = react.useTheme();
-  const defaultProps = (_c = (_b = (_a = theme.components) == null ? void 0 : _a.FormLayout) == null ? void 0 : _b.defaultProps) != null ? _c : {
+  const defaultProps = (_c = (_b = (_a = theme.components) == null ? void 0 : _a.SuiFormLayout) == null ? void 0 : _b.defaultProps) != null ? _c : {
     spacing: 4
   };
   const gridProps = {
     ...defaultProps,
     ...props
   };
-  return /* @__PURE__ */ React8__namespace.createElement(react.SimpleGrid, {
-    ...gridProps,
-    className: utils.cx("sui-form__layout", props.className)
-  }, React8__namespace.Children.map(children, (child) => {
-    if (React8__namespace.isValidElement(child)) {
-      return /* @__PURE__ */ React8__namespace.createElement(FormLayoutItem, null, child);
-    }
-    return child;
-  }));
-};
-if (utils.__DEV__) {
-  FormLayout.displayName = "FormLayout";
-}
-var mapNestedFields = (name, children) => {
-  return React8__namespace.Children.map(children, (child) => {
-    if (React8__namespace.isValidElement(child) && child.props.name) {
-      return React8__namespace.cloneElement(child, {
-        ...child.props,
-        name: `${name}.${child.props.name}`
-      });
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    react.SimpleGrid,
+    {
+      ...gridProps,
+      className: utils.cx("sui-form__layout", props.className),
+      children: React11__namespace.Children.map(children, (child) => {
+        if (React11__namespace.isValidElement(child)) {
+          return /* @__PURE__ */ jsxRuntime.jsx(FormLayoutItem, { children: child });
+        }
+        return child;
+      })
     }
-    return child;
-  });
+  );
 };
+FormLayout.displayName = "FormLayout";
 var [ArrayFieldProvider, useArrayFieldContext] = reactUtils.createContext({
   name: "ArrayFieldContext"
 });
@@ -659,7 +634,7 @@ var useArrayField = ({
   min,
   max
 }) => {
-  const { control } = reactHookForm.useFormContext();
+  const { control } = useFormContext();
   const context = reactHookForm.useFieldArray({
     control,
     name,
@@ -674,9 +649,9 @@ var useArrayField = ({
   };
 };
 var useArrayFieldRow = ({ index }) => {
-  const { clearErrors } = reactHookForm.useFormContext();
+  const { clearErrors } = useFormContext();
   const { name, remove, fields } = useArrayFieldContext();
-  React8__namespace.useEffect(() => {
+  React11__namespace.useEffect(() => {
     clearErrors(name);
   }, []);
   return {
@@ -684,7 +659,7 @@ var useArrayFieldRow = ({ index }) => {
     isFirst: index === 0,
     isLast: index === fields.length - 1,
     name: `${name}.${index}`,
-    remove: React8__namespace.useCallback(() => {
+    remove: React11__namespace.useCallback(() => {
       clearErrors(name);
       remove(index);
     }, [index])
@@ -709,39 +684,29 @@ var useArrayFieldAddButton = () => {
     isDisabled
   };
 };
-
-// src/array-field.tsx
 var ArrayFieldRow = ({
   children,
   index,
   ...rowFieldsProps
 }) => {
-  return /* @__PURE__ */ React8__namespace.createElement(ArrayFieldRowContainer, {
-    index
-  }, /* @__PURE__ */ React8__namespace.createElement(ArrayFieldRowFields, {
-    ...rowFieldsProps
-  }, children), /* @__PURE__ */ React8__namespace.createElement(ArrayFieldRemoveButton, null));
+  return /* @__PURE__ */ jsxRuntime.jsxs(ArrayFieldRowContainer, { index, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(ArrayFieldRowFields, { ...rowFieldsProps, children }),
+    /* @__PURE__ */ jsxRuntime.jsx(ArrayFieldRemoveButton, {})
+  ] });
 };
-if (utils.__DEV__) {
-  ArrayFieldRow.displayName = "ArrayFieldRow";
-}
+ArrayFieldRow.displayName = "ArrayFieldRow";
 var ArrayFieldRowFields = ({
   children,
   ...layoutProps
 }) => {
   const { name } = useArrayFieldRowContext();
-  return /* @__PURE__ */ React8__namespace.createElement(FormLayout, {
-    flex: "1",
-    mr: "2",
-    ...layoutProps
-  }, mapNestedFields(name, children));
+  return /* @__PURE__ */ jsxRuntime.jsx(FormLayout, { flex: "1", mr: "2", ...layoutProps, children: mapNestedFields(name, children) });
 };
-if (utils.__DEV__) {
-  ArrayFieldRowFields.displayName = "ArrayFieldRowFields";
-}
+ArrayFieldRowFields.displayName = "ArrayFieldRowFields";
 var ArrayFieldRowContainer = ({
   children,
-  index
+  index,
+  ...rest
 }) => {
   const context = useArrayFieldRow({ index });
   const styles = {
@@ -751,61 +716,45 @@ var ArrayFieldRowContainer = ({
     width: "100%",
     mb: 4
   };
-  return /* @__PURE__ */ React8__namespace.createElement(ArrayFieldRowProvider, {
-    value: context
-  }, /* @__PURE__ */ React8__namespace.createElement(react.chakra.div, {
-    __css: styles
-  }, children));
+  return /* @__PURE__ */ jsxRuntime.jsx(ArrayFieldRowProvider, { value: context, children: /* @__PURE__ */ jsxRuntime.jsx(react.chakra.div, { ...rest, __css: styles, children }) });
 };
-if (utils.__DEV__) {
-  ArrayFieldRowContainer.displayName = "ArrayFieldRowContainer";
-}
+ArrayFieldRowContainer.displayName = "ArrayFieldRowContainer";
 var ArrayFieldRemoveButton = (props) => {
-  return /* @__PURE__ */ React8__namespace.createElement(react.Button, {
-    "aria-label": "Remove row",
-    ...useArrayFieldRemoveButton(),
-    ...props
-  }, props.children || /* @__PURE__ */ React8__namespace.createElement(icons.MinusIcon, null));
+  return /* @__PURE__ */ jsxRuntime.jsx(react.Button, { "aria-label": "Remove row", ...useArrayFieldRemoveButton(), ...props, children: props.children || /* @__PURE__ */ jsxRuntime.jsx(icons.MinusIcon, {}) });
 };
-if (utils.__DEV__) {
-  ArrayFieldRemoveButton.displayName = "ArrayFieldRemoveButton";
-}
+ArrayFieldRemoveButton.displayName = "ArrayFieldRemoveButton";
 var ArrayFieldAddButton = (props) => {
-  return /* @__PURE__ */ React8__namespace.createElement(react.Button, {
-    "aria-label": "Add row",
-    float: "right",
-    ...useArrayFieldAddButton(),
-    ...props
-  }, props.children || /* @__PURE__ */ React8__namespace.createElement(icons.AddIcon, null));
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    react.Button,
+    {
+      "aria-label": "Add row",
+      float: "right",
+      ...useArrayFieldAddButton(),
+      ...props,
+      children: props.children || /* @__PURE__ */ jsxRuntime.jsx(icons.PlusIcon, {})
+    }
+  );
 };
-if (utils.__DEV__) {
-  ArrayFieldAddButton.displayName = "ArrayFieldAddButton";
-}
+ArrayFieldAddButton.displayName = "ArrayFieldAddButton";
 var ArrayField = react.forwardRef(
   (props, ref) => {
     const { children, ...containerProps } = props;
-    return /* @__PURE__ */ React8__namespace.createElement(ArrayFieldContainer, {
-      ref,
-      ...containerProps
-    }, /* @__PURE__ */ React8__namespace.createElement(ArrayFieldRows, null, (fields) => /* @__PURE__ */ React8__namespace.createElement(React8__namespace.Fragment, null, fields.map(({ id }, index) => /* @__PURE__ */ React8__namespace.createElement(ArrayFieldRow, {
-      key: id,
-      index
-    }, children)))), /* @__PURE__ */ React8__namespace.createElement(ArrayFieldAddButton, null));
+    const rowFn = utils.isFunction(children) ? children : (fields) => /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: fields.map(({ id }, index) => /* @__PURE__ */ jsxRuntime.jsx(ArrayFieldRow, { index, children }, id)) || null });
+    return /* @__PURE__ */ jsxRuntime.jsxs(ArrayFieldContainer, { ref, ...containerProps, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(ArrayFieldRows, { children: rowFn }),
+      /* @__PURE__ */ jsxRuntime.jsx(ArrayFieldAddButton, {})
+    ] });
   }
 );
-if (utils.__DEV__) {
-  ArrayField.displayName = "ArrayField";
-}
+ArrayField.displayName = "ArrayField";
 var ArrayFieldRows = ({
   children
 }) => {
   const { fields } = useArrayFieldContext();
   return children(fields);
 };
-if (utils.__DEV__) {
-  ArrayFieldRows.displayName = "ArrayFieldRows";
-}
-var ArrayFieldContainer = React8__namespace.forwardRef(
+ArrayFieldRows.displayName = "ArrayFieldRows";
+var ArrayFieldContainer = React11__namespace.forwardRef(
   ({
     name,
     defaultValue,
@@ -822,74 +771,59 @@ var ArrayFieldContainer = React8__namespace.forwardRef(
       min,
       max
     });
-    React8__namespace.useImperativeHandle(ref, () => context, [ref, context]);
-    return /* @__PURE__ */ React8__namespace.createElement(ArrayFieldProvider, {
-      value: context
-    }, /* @__PURE__ */ React8__namespace.createElement(BaseField, {
-      name,
-      ...fieldProps
-    }, children));
+    React11__namespace.useImperativeHandle(ref, () => context, [ref, context]);
+    return /* @__PURE__ */ jsxRuntime.jsx(ArrayFieldProvider, { value: context, children: /* @__PURE__ */ jsxRuntime.jsx(BaseField, { name, ...fieldProps, children }) });
   }
 );
-if (utils.__DEV__) {
-  ArrayFieldContainer.displayName = "ArrayFieldContainer";
-}
+ArrayFieldContainer.displayName = "ArrayFieldContainer";
 var FormLegend = (props) => {
   const styles = react.useStyleConfig("SuiFormLegend");
-  return /* @__PURE__ */ React8__namespace.createElement(react.FormLabel, {
-    as: "legend",
-    sx: styles,
-    ...props
-  });
+  return /* @__PURE__ */ jsxRuntime.jsx(react.FormLabel, { as: "legend", sx: styles, ...props });
 };
 var ObjectField = (props) => {
   const { name, label, hideLabel, children, columns, spacing, ...fieldProps } = props;
-  return /* @__PURE__ */ React8__namespace.createElement(react.FormControl, {
-    name,
-    as: "fieldset",
-    ...fieldProps
-  }, /* @__PURE__ */ React8__namespace.createElement(FormLegend, {
-    display: hideLabel ? "none" : "block"
-  }, label), /* @__PURE__ */ React8__namespace.createElement(FormLayout, {
-    columns,
-    gridGap: spacing
-  }, mapNestedFields(name, children)));
+  return /* @__PURE__ */ jsxRuntime.jsxs(react.FormControl, { name, as: "fieldset", ...fieldProps, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(FormLegend, { display: hideLabel ? "none" : "block", children: label }),
+    /* @__PURE__ */ jsxRuntime.jsx(FormLayout, { columns, gridGap: spacing, children: mapNestedFields(name, children) })
+  ] });
 };
-if (utils.__DEV__) {
-  ObjectField.displayName = "ObjectField";
-}
+ObjectField.displayName = "ObjectField";
 var mapNestedFields2 = (resolver, name) => {
   var _a;
   return (_a = resolver.getNestedFields(name)) == null ? void 0 : _a.map(
-    ({ name: name2, type, ...nestedFieldProps }, i) => /* @__PURE__ */ React8__namespace.createElement(Field, {
-      key: name2 || i,
-      name: name2,
-      type,
-      ...nestedFieldProps
-    })
+    ({ name: name2, type, ...nestedFieldProps }, i) => /* @__PURE__ */ jsxRuntime.jsx(
+      Field,
+      {
+        name: name2,
+        type,
+        ...nestedFieldProps
+      },
+      name2 || i
+    )
   );
 };
-var Fields = ({
-  schema,
-  fieldResolver,
+var AutoFields = ({
+  schema: schemaProp,
+  fieldResolver: fieldResolverProp,
   focusFirstField,
   ...props
 }) => {
-  const resolver = React8__namespace.useMemo(
-    () => fieldResolver || Form.getFieldResolver(schema),
-    [schema, fieldResolver]
-  );
-  const fields = React8__namespace.useMemo(() => resolver.getFields(), [resolver]);
-  const form = reactHookForm.useFormContext();
-  React8__namespace.useEffect(() => {
+  const context = useFormContext();
+  const schema = schemaProp || context.schema;
+  const fieldResolver = fieldResolverProp || context.fieldResolver;
+  const resolver = React11__namespace.useMemo(() => fieldResolver, [schema, fieldResolver]);
+  const fields = React11__namespace.useMemo(() => resolver == null ? void 0 : resolver.getFields(), [resolver]);
+  const form = useFormContext();
+  React11__namespace.useEffect(() => {
     var _a;
-    if (focusFirstField && ((_a = fields[0]) == null ? void 0 : _a.name)) {
+    if (focusFirstField && ((_a = fields == null ? void 0 : fields[0]) == null ? void 0 : _a.name)) {
       form.setFocus(fields[0].name);
     }
   }, [schema, fieldResolver, focusFirstField]);
-  return /* @__PURE__ */ React8__namespace.createElement(FormLayout, {
-    ...props
-  }, fields.map(
+  if (!resolver) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(FormLayout, { ...props, children: fields == null ? void 0 : fields.map(
     ({
       name,
       type,
@@ -897,28 +831,15 @@ var Fields = ({
       ...fieldProps
     }) => {
       if (type === "array") {
-        return /* @__PURE__ */ React8__namespace.createElement(ArrayField, {
-          key: name,
-          name,
-          ...fieldProps
-        }, mapNestedFields2(resolver, name));
+        return /* @__PURE__ */ jsxRuntime.jsx(ArrayField, { name, ...fieldProps, children: mapNestedFields2(resolver, name) }, name);
       } else if (type === "object") {
-        return /* @__PURE__ */ React8__namespace.createElement(ObjectField, {
-          key: name,
-          name,
-          ...fieldProps
-        }, mapNestedFields2(resolver, name));
+        return /* @__PURE__ */ jsxRuntime.jsx(ObjectField, { name, ...fieldProps, children: mapNestedFields2(resolver, name) }, name);
       }
-      return /* @__PURE__ */ React8__namespace.createElement(Field, {
-        key: name,
-        name,
-        type,
-        ...fieldProps
-      });
+      return /* @__PURE__ */ jsxRuntime.jsx(Field, { name, type, ...fieldProps }, name);
     }
-  ));
+  ) });
 };
-Fields.displayName = "Fields";
+AutoFields.displayName = "Fields";
 var SubmitButton = react.forwardRef(
   (props, ref) => {
     const {
@@ -931,13 +852,17 @@ var SubmitButton = react.forwardRef(
     } = props;
     const { formState } = reactHookForm.useFormContext();
     const isDisabled = disableIfUntouched && !formState.isDirty || disableIfInvalid && !formState.isValid || isDisabledProp;
-    return /* @__PURE__ */ React8__namespace.createElement(react.Button, {
-      ...rest,
-      ref,
-      type: "submit",
-      isLoading: formState.isSubmitting || isLoading,
-      isDisabled
-    }, children);
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      react.Button,
+      {
+        ...rest,
+        ref,
+        type: "submit",
+        isLoading: formState.isSubmitting || isLoading,
+        isDisabled,
+        children
+      }
+    );
   }
 );
 SubmitButton.defaultProps = {
@@ -946,28 +871,6 @@ SubmitButton.defaultProps = {
   disableIfInvalid: false
 };
 SubmitButton.displayName = "SubmitButton";
-
-// src/auto-form.tsx
-var AutoForm = react.forwardRef(
-  (props, ref) => {
-    const {
-      schema,
-      submitLabel = "Submit",
-      fieldResolver,
-      children,
-      ...rest
-    } = props;
-    return /* @__PURE__ */ React8__namespace.createElement(Form, {
-      ...rest,
-      schema,
-      ref
-    }, /* @__PURE__ */ React8__namespace.createElement(FormLayout, null, /* @__PURE__ */ React8__namespace.createElement(Fields, {
-      schema,
-      fieldResolver
-    }), submitLabel && /* @__PURE__ */ React8__namespace.createElement(SubmitButton, null, submitLabel), children));
-  }
-);
-AutoForm.displayName = "AutoForm";
 var DisplayIf = ({
   children,
   name,
@@ -982,12 +885,94 @@ var DisplayIf = ({
     disabled: isDisabled,
     exact: isExact
   });
-  const context = reactHookForm.useFormContext();
+  const context = useFormContext();
   return condition(value, context) ? children : null;
 };
-if (utils.__DEV__) {
-  DisplayIf.displayName = "DisplayIf";
-}
+DisplayIf.displayName = "DisplayIf";
+var Form = react.forwardRef(
+  (props, ref) => {
+    const {
+      mode = "all",
+      resolver,
+      fieldResolver,
+      fields,
+      reValidateMode,
+      shouldFocusError,
+      shouldUnregister,
+      shouldUseNativeValidation,
+      criteriaMode,
+      delayError,
+      schema,
+      defaultValues,
+      values,
+      context,
+      resetOptions,
+      onChange,
+      onSubmit,
+      onError,
+      formRef,
+      children,
+      ...rest
+    } = props;
+    const form = {
+      mode,
+      resolver,
+      defaultValues,
+      values,
+      reValidateMode,
+      shouldFocusError,
+      shouldUnregister,
+      shouldUseNativeValidation,
+      criteriaMode,
+      delayError,
+      context,
+      resetOptions
+    };
+    const methods = reactHookForm.useForm(form);
+    const { handleSubmit } = methods;
+    React11__namespace.useImperativeHandle(formRef, () => methods, [formRef, methods]);
+    React11__namespace.useEffect(() => {
+      let subscription;
+      if (onChange) {
+        subscription = methods.watch(onChange);
+      }
+      return () => subscription == null ? void 0 : subscription.unsubscribe();
+    }, [methods, onChange]);
+    let _children = children;
+    if (!_children && fieldResolver) {
+      _children = /* @__PURE__ */ jsxRuntime.jsxs(FormLayout, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(AutoFields, {}),
+        /* @__PURE__ */ jsxRuntime.jsx(SubmitButton, { ...fields == null ? void 0 : fields.submit })
+      ] });
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      FormProvider,
+      {
+        ...methods,
+        schema,
+        fieldResolver,
+        fields,
+        children: /* @__PURE__ */ jsxRuntime.jsx(
+          react.chakra.form,
+          {
+            ref,
+            onSubmit: handleSubmit(onSubmit, onError),
+            ...rest,
+            className: utils.cx("sui-form", props.className),
+            children: utils.runIfFn(_children, {
+              Field,
+              DisplayIf,
+              ArrayField,
+              ObjectField,
+              ...methods
+            })
+          }
+        )
+      }
+    );
+  }
+);
+Form.displayName = "Form";
 var [StepFormProvider, useStepFormContext] = reactUtils.createContext({
   name: "StepFormContext",
   errorMessage: "useStepFormContext: `context` is undefined. Seems you forgot to wrap step form components in `<StepForm />`"
@@ -996,8 +981,8 @@ function useStepForm(props) {
   const { onChange, ...rest } = props;
   const stepper = core.useStepper(rest);
   const { activeStep, isLastStep, nextStep } = stepper;
-  const [steps, updateSteps] = React8__namespace.useState({});
-  const onSubmitStep = React8__namespace.useCallback(
+  const [steps, updateSteps] = React11__namespace.useState({});
+  const onSubmitStep = React11__namespace.useCallback(
     async (data) => {
       var _a, _b;
       try {
@@ -1018,7 +1003,7 @@ function useStepForm(props) {
     },
     [steps, activeStep, isLastStep]
   );
-  const getFormProps = React8__namespace.useCallback(() => {
+  const getFormProps = React11__namespace.useCallback(() => {
     const step = steps[activeStep];
     return {
       onSubmit: onSubmitStep,
@@ -1026,7 +1011,7 @@ function useStepForm(props) {
       resolver: step == null ? void 0 : step.resolver
     };
   }, [steps, onSubmitStep, activeStep]);
-  const updateStep = React8__namespace.useCallback(
+  const updateStep = React11__namespace.useCallback(
     (step) => {
       updateSteps((steps2) => {
         return {
@@ -1048,7 +1033,7 @@ function useFormStep(props) {
   const { name, schema, resolver, onSubmit } = props;
   const step = core.useStep({ name });
   const { steps, updateStep } = useStepFormContext();
-  React8__namespace.useEffect(() => {
+  React11__namespace.useEffect(() => {
     updateStep({ name, schema, resolver, onSubmit });
   }, [name, schema]);
   return {
@@ -1056,95 +1041,114 @@ function useFormStep(props) {
     ...steps[name] || { name, schema }
   };
 }
-
-// src/step-form.tsx
-var StepForm = React8__namespace.forwardRef(
+var StepForm = React11__namespace.forwardRef(
   (props, ref) => {
     const { children, ...rest } = props;
     const stepper = useStepForm(props);
     const { getFormProps, ...ctx } = stepper;
-    const context = React8__namespace.useMemo(() => ctx, [ctx]);
-    return /* @__PURE__ */ React8__namespace.createElement(core.StepperProvider, {
-      value: context
-    }, /* @__PURE__ */ React8__namespace.createElement(StepFormProvider, {
-      value: context
-    }, /* @__PURE__ */ React8__namespace.createElement(Form, {
-      ref,
-      ...rest,
-      ...getFormProps()
-    }, utils.runIfFn(children, stepper))));
+    const context = React11__namespace.useMemo(() => ctx, [ctx]);
+    return /* @__PURE__ */ jsxRuntime.jsx(core.StepperProvider, { value: context, children: /* @__PURE__ */ jsxRuntime.jsx(StepFormProvider, { value: context, children: /* @__PURE__ */ jsxRuntime.jsx(Form, { ref, ...rest, ...getFormProps(), children: utils.runIfFn(children, stepper) }) }) });
   }
 );
 var FormStepper = (props) => {
   const { activeIndex, setIndex } = core.useStepperContext();
   const { children, orientation, variant, colorScheme, size, ...rest } = props;
-  const elements = React8__namespace.Children.map(children, (child) => {
-    if (React8__namespace.isValidElement(child) && (child == null ? void 0 : child.type) === FormStep) {
+  const elements = React11__namespace.Children.map(children, (child) => {
+    if (React11__namespace.isValidElement(child) && (child == null ? void 0 : child.type) === FormStep) {
       const { isCompleted } = useFormStep(child.props);
-      return /* @__PURE__ */ React8__namespace.createElement(core.StepperStep, {
-        name: child.props.name,
-        title: child.props.title,
-        isCompleted,
-        ...rest
-      }, child.props.children);
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        core.StepperStep,
+        {
+          name: child.props.name,
+          title: child.props.title,
+          isCompleted,
+          ...rest,
+          children: child.props.children
+        }
+      );
     }
     return child;
   });
-  const onChange = React8__namespace.useCallback((i) => {
+  const onChange = React11__namespace.useCallback((i) => {
     setIndex(i);
   }, []);
-  return /* @__PURE__ */ React8__namespace.createElement(core.StepperContainer, {
-    orientation,
-    step: activeIndex,
-    variant,
-    colorScheme,
-    size,
-    onChange
-  }, /* @__PURE__ */ React8__namespace.createElement(core.StepperSteps, {
-    mb: "4",
-    ...props
-  }, elements));
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    core.StepperContainer,
+    {
+      orientation,
+      step: activeIndex,
+      variant,
+      colorScheme,
+      size,
+      onChange,
+      children: /* @__PURE__ */ jsxRuntime.jsx(core.StepperSteps, { mb: "4", ...props, children: elements })
+    }
+  );
 };
 var FormStep = (props) => {
   const { name, schema, resolver, children, className, onSubmit, ...rest } = props;
   const step = useFormStep({ name, schema, resolver, onSubmit });
   const { isActive } = step;
-  return isActive ? /* @__PURE__ */ React8__namespace.createElement(react.chakra.div, {
-    ...rest,
-    className: utils.cx("sui-form__step", className)
-  }, children) : null;
+  return isActive ? /* @__PURE__ */ jsxRuntime.jsx(react.chakra.div, { ...rest, className: utils.cx("sui-form__step", className), children }) : null;
 };
-if (utils.__DEV__) {
-  FormStep.displayName = "FormStep";
-}
+FormStep.displayName = "FormStep";
 var PrevButton = (props) => {
   const { isFirstStep, isCompleted, prevStep } = core.useStepperContext();
-  return /* @__PURE__ */ React8__namespace.createElement(react.Button, {
-    isDisabled: isFirstStep || isCompleted,
-    label: "Back",
-    ...props,
-    className: utils.cx("sui-form__prev-button", props.className),
-    onClick: utils.callAllHandlers(props.onClick, prevStep)
-  });
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    react.Button,
+    {
+      isDisabled: isFirstStep || isCompleted,
+      label: "Back",
+      ...props,
+      className: utils.cx("sui-form__prev-button", props.className),
+      onClick: utils.callAllHandlers(props.onClick, prevStep)
+    }
+  );
 };
-if (utils.__DEV__) {
-  PrevButton.displayName = "PrevButton";
-}
+PrevButton.displayName = "PrevButton";
 var NextButton = (props) => {
   const { label = "Next", submitLabel = "Complete", ...rest } = props;
   const { isLastStep, isCompleted } = core.useStepperContext();
-  return /* @__PURE__ */ React8__namespace.createElement(SubmitButton, {
-    ...rest,
-    isDisabled: isCompleted,
-    className: utils.cx("sui-form__next-button", props.className)
-  }, isLastStep || isCompleted ? submitLabel : label);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    SubmitButton,
+    {
+      ...rest,
+      isDisabled: isCompleted,
+      className: utils.cx("sui-form__next-button", props.className),
+      children: isLastStep || isCompleted ? submitLabel : label
+    }
+  );
+};
+NextButton.displayName = "NextButton";
+var mapFields = (schema) => schema && Object.entries(schema).map(([name, { items, label, title, ...field }]) => {
+  return {
+    ...field,
+    name,
+    label: label || title || name
+    // json schema compatibility
+  };
+});
+var objectFieldResolver = (schema) => {
+  const getFields = () => {
+    return mapFields(schema);
+  };
+  const getNestedFields = (name) => {
+    var _a;
+    const field = utils.get(schema, name);
+    if (!field)
+      return [];
+    if (((_a = field.items) == null ? void 0 : _a.type) === "object") {
+      return mapFields(field.items.properties);
+    } else if (field.type === "object") {
+      return mapFields(field.properties);
+    }
+    return [field.items];
+  };
+  return { getFields, getNestedFields };
 };
-if (utils.__DEV__) {
-  NextButton.displayName = "NextButton";
-}
 var WatchField = (props) => {
   const { name, defaultValue, isDisabled, isExact } = props;
-  const form = reactHookForm.useFormContext();
+  const form = useFormContext();
   const field = reactHookForm.useWatch({
     name,
     defaultValue,
@@ -1153,15 +1157,33 @@ var WatchField = (props) => {
   });
   return props.children(field, form) || null;
 };
+function createForm({
+  resolver,
+  fieldResolver = objectFieldResolver,
+  fields
+} = {}) {
+  const CreateForm = react.forwardRef(
+    (props, ref) => {
+      const { schema, ...rest } = props;
+      return /* @__PURE__ */ jsxRuntime.jsx(FieldsProvider, { value: fields || {}, children: /* @__PURE__ */ jsxRuntime.jsx(
+        Form,
+        {
+          ref,
+          resolver: resolver == null ? void 0 : resolver(props.schema),
+          fieldResolver: fieldResolver == null ? void 0 : fieldResolver(schema),
+          ...rest
+        }
+      ) });
+    }
+  );
+  return CreateForm;
+}
+var Form2 = createForm();
 
 Object.defineProperty(exports, 'Controller', {
   enumerable: true,
   get: function () { return reactHookForm.Controller; }
 });
-Object.defineProperty(exports, 'FormProvider', {
-  enumerable: true,
-  get: function () { return reactHookForm.FormProvider; }
-});
 Object.defineProperty(exports, 'appendErrors', {
   enumerable: true,
   get: function () { return reactHookForm.appendErrors; }
@@ -1178,10 +1200,6 @@ Object.defineProperty(exports, 'useForm', {
   enumerable: true,
   get: function () { return reactHookForm.useForm; }
 });
-Object.defineProperty(exports, 'useFormContext', {
-  enumerable: true,
-  get: function () { return reactHookForm.useFormContext; }
-});
 Object.defineProperty(exports, 'useFormState', {
   enumerable: true,
   get: function () { return reactHookForm.useFormState; }
@@ -1200,16 +1218,18 @@ exports.ArrayFieldRowContainer = ArrayFieldRowContainer;
 exports.ArrayFieldRowFields = ArrayFieldRowFields;
 exports.ArrayFieldRowProvider = ArrayFieldRowProvider;
 exports.ArrayFieldRows = ArrayFieldRows;
-exports.AutoForm = AutoForm;
+exports.AutoFields = AutoFields;
 exports.BaseField = BaseField;
+exports.BaseForm = Form;
 exports.CheckboxField = CheckboxField;
 exports.DisplayField = DisplayField;
 exports.DisplayIf = DisplayIf;
 exports.Field = Field;
-exports.Fields = Fields;
-exports.Form = Form;
+exports.FieldsProvider = FieldsProvider;
+exports.Form = Form2;
 exports.FormLayout = FormLayout;
 exports.FormLegend = FormLegend;
+exports.FormProvider = FormProvider;
 exports.FormStep = FormStep;
 exports.FormStepper = FormStepper;
 exports.FormValue = FormValue;
@@ -1225,27 +1245,32 @@ exports.PasswordInputField = PasswordInputField;
 exports.PinField = PinField;
 exports.PrevButton = PrevButton;
 exports.RadioField = RadioField;
+exports.RadioInput = RadioInput;
 exports.Select = Select;
+exports.SelectButton = SelectButton;
 exports.SelectField = SelectField;
+exports.SelectList = SelectList;
+exports.SelectOption = SelectOption;
 exports.StepForm = StepForm;
 exports.StepFormProvider = StepFormProvider;
 exports.SubmitButton = SubmitButton;
 exports.SwitchField = SwitchField;
 exports.TextareaField = TextareaField;
 exports.WatchField = WatchField;
+exports.createField = createField;
 exports.createForm = createForm;
+exports.defaultFieldTypes = defaultFieldTypes;
 exports.objectFieldResolver = objectFieldResolver;
-exports.registerFieldType = registerFieldType;
 exports.useArrayField = useArrayField;
 exports.useArrayFieldAddButton = useArrayFieldAddButton;
 exports.useArrayFieldContext = useArrayFieldContext;
 exports.useArrayFieldRemoveButton = useArrayFieldRemoveButton;
 exports.useArrayFieldRow = useArrayFieldRow;
 exports.useArrayFieldRowContext = useArrayFieldRowContext;
+exports.useField = useField;
+exports.useFormContext = useFormContext;
 exports.useFormStep = useFormStep;
 exports.useStepForm = useStepForm;
 exports.useStepFormContext = useStepFormContext;
-exports.withControlledInput = withControlledInput;
-exports.withUncontrolledInput = withUncontrolledInput;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map