rsuite 6.0.0-canary-20250424 → 6.0.0-canary-20250620

package/cjs/toaster/toaster.js

@@ -5,8 +5,7 @@ exports.__esModule = true;
 exports.default = void 0;
 var _ToastContainer = _interopRequireWildcard(require("./ToastContainer"));
 var _symbols = require("../internals/symbols");
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 const containers = new Map();
 
 /**
@@ -29,10 +28,7 @@ function getContainer(containerId, placement) {
   return containers.get(`${containerId}_${placement}`);
 }
 const toaster = message => toaster.push(message);
-toaster.push = function (message, options) {
-  if (options === void 0) {
-    options = {};
-  }
+toaster.push = (message, options = {}) => {
   const {
     placement = 'topCenter',
     container = _ToastContainer.defaultToasterContainer,

package/cjs/useDialog/Dialog.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { ModalProps } from '../Modal';
+export interface DialogProps extends ModalProps {
+    type: 'alert' | 'confirm' | 'prompt';
+    title?: React.ReactNode;
+    content?: React.ReactNode;
+    okText?: string;
+    cancelText?: string;
+    severity?: 'info' | 'success' | 'warning' | 'error';
+    defaultValue?: string;
+    validate?: (value: string) => [isValid: boolean, errorMessage?: string];
+    onClose?: (result?: any) => void;
+}
+declare const Dialog: import("../internals/types").InternalRefForwardingComponent<React.ElementType<any, keyof React.JSX.IntrinsicElements>, DialogProps, never> & Record<string, never>;
+export default Dialog;

package/cjs/useDialog/Dialog.js

@@ -0,0 +1,109 @@
+'use client';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.default = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _react = _interopRequireWildcard(require("react"));
+var _Modal = _interopRequireDefault(require("../Modal"));
+var _Button = _interopRequireDefault(require("../Button"));
+var _Input = _interopRequireDefault(require("../Input"));
+var _Text = _interopRequireDefault(require("../Text"));
+var _utils = require("../internals/utils");
+var _Stack = require("../Stack");
+var _hooks = require("../internals/hooks");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+const severityMap = {
+  info: 'blue',
+  success: 'green',
+  warning: 'orange',
+  error: 'red'
+};
+const Dialog = (0, _utils.forwardRef)((props, ref) => {
+  const {
+    getLocale,
+    propsWithDefaults
+  } = (0, _hooks.useCustom)('Dialog', props);
+  const locale = getLocale('Dialog');
+  const {
+    type,
+    title = type === 'alert' ? locale.alert : locale.confirm,
+    content,
+    okText = locale.ok,
+    cancelText = locale.cancel,
+    severity,
+    defaultValue = '',
+    validate,
+    onClose,
+    ...rest
+  } = propsWithDefaults;
+  const [isOpen, setIsOpen] = (0, _react.useState)(true);
+  const [validationError, setValidationError] = (0, _react.useState)();
+  const inputRef = (0, _react.useRef)(null);
+  const inputValue = (0, _react.useRef)(defaultValue);
+  const showCancelButton = type === 'confirm' || type === 'prompt';
+  (0, _react.useEffect)(() => {
+    if (type === 'prompt' && inputRef.current) {
+      inputRef.current.focus();
+    }
+  }, [type]);
+  const handleClose = (0, _react.useCallback)(result => {
+    setIsOpen(false);
+    setTimeout(() => {
+      onClose === null || onClose === void 0 || onClose(result);
+    }, 300);
+  }, [onClose]);
+  const handleConfirm = (0, _react.useCallback)(() => {
+    if (type === 'prompt') {
+      const value = inputValue.current;
+      if (validate) {
+        const [isValid, errorMessage] = validate(value);
+        if (!isValid) {
+          setValidationError(errorMessage || 'Invalid input');
+          return;
+        }
+      }
+      handleClose(value);
+    } else {
+      handleClose(true);
+    }
+  }, [type, inputValue, validate, handleClose]);
+  const handleInputKeyDown = (0, _react.useCallback)(event => {
+    if (event.key === 'Enter') {
+      handleConfirm();
+    }
+  }, [handleConfirm]);
+  return /*#__PURE__*/_react.default.createElement(_Modal.default, (0, _extends2.default)({
+    ref: ref,
+    open: isOpen,
+    size: "xs",
+    centered: true,
+    backdrop: "static"
+  }, rest), /*#__PURE__*/_react.default.createElement(_Modal.default.Header, {
+    closeButton: false
+  }, /*#__PURE__*/_react.default.createElement(_Modal.default.Title, null, title)), /*#__PURE__*/_react.default.createElement(_Modal.default.Body, null, /*#__PURE__*/_react.default.createElement(_Stack.VStack, null, type === 'prompt' ? /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement("label", {
+    htmlFor: "rs-prompt-input"
+  }, content), /*#__PURE__*/_react.default.createElement(_Input.default, {
+    w: "100%",
+    required: true,
+    ref: inputRef,
+    id: "rs-prompt-input",
+    defaultValue: defaultValue,
+    onChange: value => {
+      inputValue.current = value;
+      if (validationError) setValidationError(undefined);
+    },
+    onKeyDown: handleInputKeyDown
+  }), validationError && /*#__PURE__*/_react.default.createElement(_Text.default, {
+    color: "red"
+  }, validationError)) : content)), /*#__PURE__*/_react.default.createElement(_Modal.default.Footer, null, showCancelButton && /*#__PURE__*/_react.default.createElement(_Button.default, {
+    onClick: handleClose,
+    appearance: "subtle"
+  }, cancelText), /*#__PURE__*/_react.default.createElement(_Button.default, {
+    appearance: "primary",
+    onClick: handleConfirm,
+    color: severity ? severityMap[severity] : undefined
+  }, okText)));
+});
+var _default = exports.default = Dialog;

package/cjs/useDialog/DialogContainer.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+export interface DialogContainerProps {
+    children?: React.ReactNode;
+}
+export interface DialogContainerInstance {
+    renderDialog: (dialog: React.ReactElement) => string | number;
+    removeDialog: (key: string | number) => void;
+    clearDialogs: () => void;
+}
+declare const DialogContainer: React.ForwardRefExoticComponent<DialogContainerProps & React.RefAttributes<DialogContainerInstance>>;
+export default DialogContainer;

package/cjs/useDialog/DialogContainer.js

@@ -0,0 +1,57 @@
+'use client';
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _utils = require("../internals/utils");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+const DialogContainer = /*#__PURE__*/(0, _react.forwardRef)((_, ref) => {
+  const [dialogs, setDialogs] = (0, _react.useState)([]);
+  const [isMounted, setIsMounted] = (0, _react.useState)(false);
+  const dialogsRef = (0, _react.useRef)([]);
+
+  // Only render on the client side to avoid hydration issues
+  (0, _react.useEffect)(() => {
+    setIsMounted(true);
+  }, []);
+  (0, _react.useImperativeHandle)(ref, () => ({
+    renderDialog: dialog => {
+      // Always generate a unique key using guid
+      const dialogKey = (0, _utils.guid)();
+      const nextDialogs = [...dialogsRef.current, {
+        key: dialogKey,
+        dialog
+      }];
+      dialogsRef.current = nextDialogs;
+      setDialogs(nextDialogs);
+      return dialogKey;
+    },
+    removeDialog: key => {
+      // Find if the dialog exists
+      const dialogExists = dialogsRef.current.some(item => item.key === key);
+      if (dialogExists) {
+        // Filter out the dialog with the matching key
+        const nextDialogs = dialogsRef.current.filter(item => item.key !== key);
+
+        // Update both the ref and state
+        dialogsRef.current = nextDialogs;
+        setDialogs(nextDialogs);
+      }
+    },
+    clearDialogs: () => {
+      dialogsRef.current = [];
+      setDialogs([]);
+    }
+  }));
+
+  // Only render Portal on the client side to avoid hydration issues
+  if (!isMounted) {
+    return null;
+  }
+  return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, dialogs.map(item => /*#__PURE__*/_react.default.createElement(_react.default.Fragment, {
+    key: item.key
+  }, item.dialog)));
+});
+DialogContainer.displayName = 'DialogContainer';
+var _default = exports.default = DialogContainer;

package/cjs/useDialog/index.d.ts

@@ -0,0 +1,3 @@
+import useDialog from './useDialog';
+export default useDialog;
+export * from './useDialog';

package/cjs/useDialog/index.js

@@ -0,0 +1,15 @@
+'use client';
+"use strict";
+
+exports.__esModule = true;
+var _exportNames = {};
+exports.default = void 0;
+var _useDialog = _interopRequireWildcard(require("./useDialog"));
+Object.keys(_useDialog).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useDialog[key]) return;
+  exports[key] = _useDialog[key];
+});
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+var _default = exports.default = _useDialog.default;

package/cjs/useDialog/types.d.ts

@@ -0,0 +1,33 @@
+import type { ReactNode } from 'react';
+export interface AlertOptions {
+    /** Title of the dialog */
+    title?: ReactNode;
+    /** Text for OK button */
+    okText?: string;
+    /** Callback when dialog is closed */
+    onClose?: () => void;
+}
+export interface ConfirmOptions extends AlertOptions {
+    /** Severity of the dialog */
+    severity?: 'info' | 'success' | 'warning' | 'error';
+    /** Text for Cancel button */
+    cancelText?: string;
+}
+export interface PromptOptions extends AlertOptions {
+    /** Default value for the input */
+    defaultValue?: string;
+    /** Text for Cancel button */
+    cancelText?: string;
+    /** Validate function for prompt input */
+    validate?: (value: string) => [isValid: boolean, errorMessage?: string];
+}
+export interface OpenOptions<T = any> {
+    /** Callback when dialog is closed */
+    onClose?: (result?: T) => void;
+}
+export interface DialogInstance<T = any> {
+    key: number;
+    component: ReactNode;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+}

package/cjs/useDialog/types.js

@@ -0,0 +1,4 @@
+'use client';
+"use strict";
+
+exports.__esModule = true;

package/cjs/useDialog/useDialog.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { AlertOptions, ConfirmOptions, OpenOptions, PromptOptions } from './types';
+/**
+ * A hook that provides methods to show dialogs.
+ * @see https://rsuitejs.com/components/use-dialog
+ */
+export declare function useDialog(): {
+    alert: (message: React.ReactNode, options?: AlertOptions) => Promise<any>;
+    confirm: (message: React.ReactNode, options?: ConfirmOptions) => Promise<any>;
+    prompt: (message: React.ReactNode, options?: PromptOptions) => Promise<any>;
+    open: <P extends object>(as: React.ComponentType<P & {
+        onClose: (result?: any) => void;
+    }>, payload?: P | undefined, options?: OpenOptions) => Promise<any>;
+};
+export default useDialog;

package/cjs/useDialog/useDialog.js

@@ -0,0 +1,126 @@
+'use client';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.default = void 0;
+exports.useDialog = useDialog;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _react = _interopRequireWildcard(require("react"));
+var _canUseDOM = _interopRequireDefault(require("dom-lib/canUseDOM"));
+var _Dialog = _interopRequireDefault(require("./Dialog"));
+var _CustomContext = require("../internals/Provider/CustomContext");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * Options for creating a dialog
+ */
+
+const useDialogContainer = () => {
+  const context = (0, _react.useContext)(_CustomContext.CustomContext);
+  const dialogContainerRef = (0, _react.useRef)(null);
+  (0, _react.useEffect)(() => {
+    if (_canUseDOM.default && !(context !== null && context !== void 0 && context.dialogContainer)) {
+      console.warn('Warning: useDialog is being used outside of a CustomProvider. ' + 'Please wrap your application with <CustomProvider> to ensure proper functionality.');
+    }
+  }, [context]);
+  (0, _react.useEffect)(() => {
+    var _context$dialogContai;
+    if (_canUseDOM.default && context !== null && context !== void 0 && (_context$dialogContai = context.dialogContainer) !== null && _context$dialogContai !== void 0 && _context$dialogContai.current) {
+      dialogContainerRef.current = context.dialogContainer.current;
+    }
+  }, [context]);
+  return dialogContainerRef;
+};
+
+/**
+ * A hook that provides methods to show dialogs.
+ * @see https://rsuitejs.com/components/use-dialog
+ */
+function useDialog() {
+  const dialogContainerRef = useDialogContainer();
+  const createDialog = (0, _react.useCallback)((content, options) => {
+    const {
+      type,
+      title,
+      okText,
+      cancelText,
+      severity,
+      defaultValue,
+      validate
+    } = options;
+    let isDialogClosed = false;
+    let dialogKey = null;
+    return new Promise(resolve => {
+      const handleClose = result => {
+        if (isDialogClosed) {
+          return;
+        }
+        isDialogClosed = true;
+        if (_canUseDOM.default && dialogContainerRef.current && dialogKey !== null) {
+          dialogContainerRef.current.removeDialog(dialogKey);
+        }
+        resolve(result);
+      };
+      let dialogComponent;
+      if (type === 'custom' && options.as) {
+        const {
+          as: Component,
+          props
+        } = options;
+        dialogComponent = /*#__PURE__*/_react.default.createElement(Component, (0, _extends2.default)({
+          onClose: handleClose
+        }, props));
+      } else {
+        dialogComponent = /*#__PURE__*/_react.default.createElement(_Dialog.default, {
+          type: type,
+          title: title,
+          content: content,
+          okText: okText,
+          cancelText: cancelText,
+          onClose: handleClose,
+          defaultValue: defaultValue || '',
+          severity: severity,
+          validate: validate
+        });
+      }
+      if (_canUseDOM.default && dialogContainerRef.current) {
+        dialogKey = dialogContainerRef.current.renderDialog(dialogComponent);
+      }
+    });
+  }, []);
+  const alert = (0, _react.useCallback)((message, options) => {
+    return createDialog(message, {
+      ...options,
+      type: 'alert'
+    });
+  }, [createDialog]);
+  const confirm = (0, _react.useCallback)((message, options) => {
+    return createDialog(message, {
+      ...options,
+      type: 'confirm'
+    });
+  }, [createDialog]);
+  const prompt = (0, _react.useCallback)((message, options = {}) => {
+    return createDialog(message, {
+      ...options,
+      type: 'prompt'
+    });
+  }, [createDialog]);
+  const open = (0, _react.useCallback)((as, payload, options) => {
+    return createDialog(null, {
+      ...options,
+      as,
+      type: 'custom',
+      props: {
+        payload
+      }
+    });
+  }, [createDialog]);
+  return {
+    alert,
+    confirm,
+    prompt,
+    open
+  };
+}
+var _default = exports.default = useDialog;

package/cjs/{FormControl → useFormControl}/hooks/useField.d.ts

@@ -4,15 +4,15 @@ interface FieldProps {
     formValue?: Record<string, any>;
     formError?: Record<string, any>;
     value: any;
-    nestedField: boolean;
+    nestedField?: boolean;
     errorMessage: React.ReactNode;
     errorFromContext?: boolean;
 }
-declare function useField(props: FieldProps): {
+export declare function useField(props: FieldProps): {
     fieldValue: any;
     fieldError: import("react").ReactNode;
     setFieldValue: (fieldName: string, fieldValue: any) => {
         [x: string]: any;
     };
 };
-export default useField;
+export {};

package/cjs/{FormControl → useFormControl}/hooks/useField.js

@@ -3,11 +3,11 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 exports.__esModule = true;
-exports.default = void 0;
-var _react = require("react");
+exports.useField = useField;
 var _get = _interopRequireDefault(require("lodash/get"));
 var _set = _interopRequireDefault(require("lodash/set"));
-var _utils = require("../utils");
+var _react = require("react");
+var _nameToPath = require("../utils/nameToPath");
 function getErrorMessage(error) {
   var _error$array;
   if (typeof error === 'string') {
@@ -48,7 +48,7 @@ function useField(props) {
       return errorMessage;
     }
     if (nestedField) {
-      return getErrorMessage((0, _get.default)(formError, (0, _utils.nameToPath)(name)));
+      return getErrorMessage((0, _get.default)(formError, (0, _nameToPath.nameToPath)(name)));
     }
     const fieldError = formError === null || formError === void 0 ? void 0 : formError[name];
     if (typeof fieldError === 'string') {
@@ -72,5 +72,4 @@ function useField(props) {
     fieldError,
     setFieldValue
   };
-}
-var _default = exports.default = useField;
+}

package/cjs/useFormControl/hooks/useRegisterModel.d.ts

@@ -0,0 +1,2 @@
+import type { CheckType } from 'schema-typed';
+export declare function useRegisterModel(name: string, rule?: CheckType<unknown, any>): void;

package/cjs/{FormControl → useFormControl}/hooks/useRegisterModel.js

@@ -2,7 +2,7 @@
 "use strict";
 
 exports.__esModule = true;
-exports.default = void 0;
+exports.useRegisterModel = useRegisterModel;
 var _react = require("react");
 var _FormContext = require("../../Form/FormContext");
 function useRegisterModel(name, rule) {
@@ -18,5 +18,4 @@ function useRegisterModel(name, rule) {
       removeFieldRule === null || removeFieldRule === void 0 || removeFieldRule(name);
     };
   }, [name, pushFieldRule, removeFieldRule]);
-}
-var _default = exports.default = useRegisterModel;
+}

package/cjs/useFormControl/index.d.ts

@@ -0,0 +1,4 @@
+import useFormControl from './useFormControl';
+export type { UseFormControlProps } from './useFormControl';
+export { useFormControl };
+export default useFormControl;

package/cjs/useFormControl/index.js

@@ -0,0 +1,11 @@
+'use client';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.default = void 0;
+var _useFormControl = _interopRequireDefault(require("./useFormControl"));
+exports.useFormControl = _useFormControl.default;
+// export types
+// export hooks
+var _default = exports.default = _useFormControl.default;

package/cjs/useFormControl/useFormControl.d.ts

@@ -0,0 +1,38 @@
+import React from 'react';
+import type { CheckType } from 'schema-typed';
+import type { CheckTriggerType } from '../internals/types';
+export interface UseFormControlProps {
+    /** The name of form field */
+    name: string;
+    /** The current value (controlled) */
+    value?: any;
+    /** The data validation trigger type */
+    checkTrigger?: CheckTriggerType;
+    /** Show error messages */
+    errorMessage?: React.ReactNode;
+    /** Asynchronous check value */
+    checkAsync?: boolean;
+    /** Remove field value and error message when component is unmounted */
+    shouldResetWithUnmount?: boolean;
+    /** Validation rule */
+    rule?: CheckType<unknown, any>;
+}
+/**
+ * Hook for accessing form control functionality.
+ * Must be used within a Form component.
+ *
+ * @param props The form control properties
+ * @returns Form control functionality for the specified field
+ */
+export declare function useFormControl(props: UseFormControlProps): {
+    value: any;
+    error: React.ReactNode;
+    plaintext: boolean | undefined;
+    readOnly: boolean | undefined;
+    disabled: boolean | undefined;
+    onChange: (...args: any[]) => any;
+    onCheck: (...args: any[]) => any;
+    onBlur: (...args: any[]) => any;
+    setValue: (value: any, shouldValidate?: boolean) => void;
+};
+export default useFormControl;