rsuite 5.76.2 → 6.0.0-canary-20250103

package/esm/Form/Form.js

@@ -1,9 +1,6 @@
 'use client';
 import _extends from "@babel/runtime/helpers/esm/extends";
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-var _excluded = ["checkTrigger", "classPrefix", "errorFromContext", "formDefaultValue", "formValue", "formError", "fluid", "nestedField", "layout", "model", "readOnly", "plaintext", "className", "children", "disabled", "onSubmit", "onReset", "onCheck", "onError", "onChange"];
 import React from 'react';
-import PropTypes from 'prop-types';
 import { SchemaModel } from 'schema-typed';
 import FormControl from "../FormControl/index.js";
 import FormControlLabel from "../FormControlLabel/index.js";
@@ -11,7 +8,6 @@ import FormErrorMessage from "../FormErrorMessage/index.js";
 import FormGroup from "../FormGroup/index.js";
 import FormHelpText from "../FormHelpText/index.js";
 import { useEventCallback } from "../internals/hooks/index.js";
-import { oneOf } from "../internals/propTypes/index.js";
 import { FormValueProvider, FormProvider } from "./FormContext.js";
 import { useCustom } from "../CustomProvider/index.js";
 import useSchemaModel from "./hooks/useSchemaModel.js";
@@ -19,94 +15,93 @@ import useFormValidate from "./hooks/useFormValidate.js";
 import useFormValue from "./hooks/useFormValue.js";
 import useFormClassNames from "./hooks/useFormClassNames.js";
 import useFormRef from "./hooks/useFormRef.js";
-var defaultSchema = SchemaModel({});
+const defaultSchema = SchemaModel({});
 
 /**
  * The `Form` component is a form interface for collecting and validating user input.
  * @see https://rsuitejs.com/components/form
  */
-var Form = /*#__PURE__*/React.forwardRef(function (props, ref) {
-  var _useCustom = useCustom('Form', props),
-    propsWithDefaults = _useCustom.propsWithDefaults;
-  var _propsWithDefaults$ch = propsWithDefaults.checkTrigger,
-    checkTrigger = _propsWithDefaults$ch === void 0 ? 'change' : _propsWithDefaults$ch,
-    _propsWithDefaults$cl = propsWithDefaults.classPrefix,
-    classPrefix = _propsWithDefaults$cl === void 0 ? 'form' : _propsWithDefaults$cl,
-    _propsWithDefaults$er = propsWithDefaults.errorFromContext,
-    errorFromContext = _propsWithDefaults$er === void 0 ? true : _propsWithDefaults$er,
-    _propsWithDefaults$fo = propsWithDefaults.formDefaultValue,
-    formDefaultValue = _propsWithDefaults$fo === void 0 ? {} : _propsWithDefaults$fo,
-    controlledFormValue = propsWithDefaults.formValue,
-    controlledFormError = propsWithDefaults.formError,
-    fluid = propsWithDefaults.fluid,
-    _propsWithDefaults$ne = propsWithDefaults.nestedField,
-    nestedField = _propsWithDefaults$ne === void 0 ? false : _propsWithDefaults$ne,
-    _propsWithDefaults$la = propsWithDefaults.layout,
-    layout = _propsWithDefaults$la === void 0 ? 'vertical' : _propsWithDefaults$la,
-    _propsWithDefaults$mo = propsWithDefaults.model,
-    formModel = _propsWithDefaults$mo === void 0 ? defaultSchema : _propsWithDefaults$mo,
-    readOnly = propsWithDefaults.readOnly,
-    plaintext = propsWithDefaults.plaintext,
-    className = propsWithDefaults.className,
-    children = propsWithDefaults.children,
-    disabled = propsWithDefaults.disabled,
-    onSubmit = propsWithDefaults.onSubmit,
-    onReset = propsWithDefaults.onReset,
-    onCheck = propsWithDefaults.onCheck,
-    onError = propsWithDefaults.onError,
-    onChange = propsWithDefaults.onChange,
-    rest = _objectWithoutPropertiesLoose(propsWithDefaults, _excluded);
-  var _useSchemaModel = useSchemaModel(formModel, nestedField),
-    getCombinedModel = _useSchemaModel.getCombinedModel,
-    pushFieldRule = _useSchemaModel.pushFieldRule,
-    removeFieldRule = _useSchemaModel.removeFieldRule;
-  var _useFormValue = useFormValue(controlledFormValue, {
-      formDefaultValue: formDefaultValue,
-      nestedField: nestedField
-    }),
-    formValue = _useFormValue.formValue,
-    onRemoveValue = _useFormValue.onRemoveValue,
-    setFieldValue = _useFormValue.setFieldValue,
-    resetFormValue = _useFormValue.resetFormValue;
-  var formValidateProps = {
-    formValue: formValue,
-    getCombinedModel: getCombinedModel,
-    onCheck: onCheck,
-    onError: onError,
-    nestedField: nestedField
+const Form = /*#__PURE__*/React.forwardRef(function Form(props, ref) {
+  const {
+    propsWithDefaults
+  } = useCustom('Form', props);
+  const {
+    checkTrigger = 'change',
+    classPrefix = 'form',
+    errorFromContext = true,
+    formDefaultValue = {},
+    formValue: controlledFormValue,
+    formError: controlledFormError,
+    fluid,
+    nestedField = false,
+    layout = 'vertical',
+    model: formModel = defaultSchema,
+    readOnly,
+    plaintext,
+    className,
+    children,
+    disabled,
+    onSubmit,
+    onReset,
+    onCheck,
+    onError,
+    onChange,
+    ...rest
+  } = propsWithDefaults;
+  const {
+    getCombinedModel,
+    pushFieldRule,
+    removeFieldRule
+  } = useSchemaModel(formModel, nestedField);
+  const {
+    formValue,
+    onRemoveValue,
+    setFieldValue,
+    resetFormValue
+  } = useFormValue(controlledFormValue, {
+    formDefaultValue,
+    nestedField
+  });
+  const formValidateProps = {
+    formValue,
+    getCombinedModel,
+    onCheck,
+    onError,
+    nestedField
   };
-  var _useFormValidate = useFormValidate(controlledFormError, formValidateProps),
-    formError = _useFormValidate.formError,
-    onRemoveError = _useFormValidate.onRemoveError,
-    check = _useFormValidate.check,
-    checkAsync = _useFormValidate.checkAsync,
-    checkForField = _useFormValidate.checkForField,
-    checkFieldForNextValue = _useFormValidate.checkFieldForNextValue,
-    checkForFieldAsync = _useFormValidate.checkForFieldAsync,
-    checkFieldAsyncForNextValue = _useFormValidate.checkFieldAsyncForNextValue,
-    cleanErrors = _useFormValidate.cleanErrors,
-    resetErrors = _useFormValidate.resetErrors,
-    cleanErrorForField = _useFormValidate.cleanErrorForField;
-  var classes = useFormClassNames({
-    classPrefix: classPrefix,
-    className: className,
-    fluid: fluid,
-    layout: layout,
-    readOnly: readOnly,
-    plaintext: plaintext,
-    disabled: disabled
+  const {
+    formError,
+    onRemoveError,
+    check,
+    checkAsync,
+    checkForField,
+    checkFieldForNextValue,
+    checkForFieldAsync,
+    checkFieldAsyncForNextValue,
+    cleanErrors,
+    resetErrors,
+    cleanErrorForField
+  } = useFormValidate(controlledFormError, formValidateProps);
+  const classes = useFormClassNames({
+    classPrefix,
+    className,
+    fluid,
+    layout,
+    readOnly,
+    plaintext,
+    disabled
   });
-  var submit = useEventCallback(function (event) {
+  const submit = useEventCallback(event => {
     // Check the form before submitting
     if (check()) {
       onSubmit === null || onSubmit === void 0 || onSubmit(formValue, event);
     }
   });
-  var reset = useEventCallback(function (event) {
+  const reset = useEventCallback(event => {
     resetErrors();
     onReset === null || onReset === void 0 || onReset(resetFormValue(), event);
   });
-  var handleSubmit = useEventCallback(function (event) {
+  const handleSubmit = useEventCallback(event => {
     var _event$preventDefault, _event$stopPropagatio;
     event === null || event === void 0 || (_event$preventDefault = event.preventDefault) === null || _event$preventDefault === void 0 || _event$preventDefault.call(event);
     event === null || event === void 0 || (_event$stopPropagatio = event.stopPropagation) === null || _event$stopPropagatio === void 0 || _event$stopPropagatio.call(event);
@@ -117,7 +112,7 @@ var Form = /*#__PURE__*/React.forwardRef(function (props, ref) {
     }
     submit(event);
   });
-  var handleReset = useEventCallback(function (event) {
+  const handleReset = useEventCallback(event => {
     var _event$preventDefault2, _event$stopPropagatio2;
     event === null || event === void 0 || (_event$preventDefault2 = event.preventDefault) === null || _event$preventDefault2 === void 0 || _event$preventDefault2.call(event);
     event === null || event === void 0 || (_event$stopPropagatio2 = event.stopPropagation) === null || _event$stopPropagatio2 === void 0 || _event$stopPropagatio2.call(event);
@@ -128,46 +123,46 @@ var Form = /*#__PURE__*/React.forwardRef(function (props, ref) {
     }
     reset(event);
   });
-  var imperativeMethods = {
-    check: check,
-    checkForField: checkForField,
-    checkAsync: checkAsync,
-    checkForFieldAsync: checkForFieldAsync,
-    cleanErrors: cleanErrors,
-    cleanErrorForField: cleanErrorForField,
-    reset: reset,
-    resetErrors: resetErrors,
-    submit: submit
+  const imperativeMethods = {
+    check,
+    checkForField,
+    checkAsync,
+    checkForFieldAsync,
+    cleanErrors,
+    cleanErrorForField,
+    reset,
+    resetErrors,
+    submit
   };
-  var formRef = useFormRef(ref, {
-    imperativeMethods: imperativeMethods
+  const formRef = useFormRef(ref, {
+    imperativeMethods
   });
-  var removeFieldValue = useEventCallback(function (name) {
-    var formValue = onRemoveValue(name);
+  const removeFieldValue = useEventCallback(name => {
+    const formValue = onRemoveValue(name);
     onChange === null || onChange === void 0 || onChange(formValue);
   });
-  var removeFieldError = useEventCallback(function (name) {
+  const removeFieldError = useEventCallback(name => {
     onRemoveError(name);
   });
-  var onFieldChange = useEventCallback(function (name, value, event) {
-    var nextFormValue = setFieldValue(name, value);
+  const onFieldChange = useEventCallback((name, value, event) => {
+    const nextFormValue = setFieldValue(name, value);
     onChange === null || onChange === void 0 || onChange(nextFormValue, event);
   });
-  var formContextValue = {
-    errorFromContext: errorFromContext,
-    checkTrigger: checkTrigger,
-    plaintext: plaintext,
-    readOnly: readOnly,
-    disabled: disabled,
-    formError: formError,
-    nestedField: nestedField,
-    pushFieldRule: pushFieldRule,
-    removeFieldValue: removeFieldValue,
-    removeFieldError: removeFieldError,
-    removeFieldRule: removeFieldRule,
-    onFieldChange: onFieldChange,
-    checkFieldForNextValue: checkFieldForNextValue,
-    checkFieldAsyncForNextValue: checkFieldAsyncForNextValue
+  const formContextValue = {
+    errorFromContext,
+    checkTrigger,
+    plaintext,
+    readOnly,
+    disabled,
+    formError,
+    nestedField,
+    pushFieldRule,
+    removeFieldValue,
+    removeFieldError,
+    removeFieldRule,
+    onFieldChange,
+    checkFieldForNextValue,
+    checkFieldAsyncForNextValue
   };
   return /*#__PURE__*/React.createElement("form", _extends({}, rest, {
     ref: formRef,
@@ -186,24 +181,4 @@ Form.ErrorMessage = FormErrorMessage;
 Form.Group = FormGroup;
 Form.HelpText = FormHelpText;
 Form.displayName = 'Form';
-Form.propTypes = {
-  className: PropTypes.string,
-  classPrefix: PropTypes.string,
-  children: PropTypes.node,
-  errorFromContext: PropTypes.bool,
-  layout: oneOf(['horizontal', 'vertical', 'inline']),
-  fluid: PropTypes.bool,
-  formValue: PropTypes.object,
-  formDefaultValue: PropTypes.object,
-  formError: PropTypes.object,
-  checkTrigger: oneOf(['change', 'blur', 'none']),
-  onChange: PropTypes.func,
-  onError: PropTypes.func,
-  onCheck: PropTypes.func,
-  onSubmit: PropTypes.func,
-  model: PropTypes.any,
-  readOnly: PropTypes.bool,
-  plaintext: PropTypes.bool,
-  disabled: PropTypes.bool
-};
 export default Form;

package/esm/Form/FormContext.js

@@ -1,9 +1,9 @@
 'use client';
 import React, { useContext } from 'react';
-export var FormContext = /*#__PURE__*/React.createContext({});
-export var FormValueContext = /*#__PURE__*/React.createContext({});
-export var FormProvider = FormContext.Provider;
-export var FormValueProvider = FormValueContext.Provider;
+export const FormContext = /*#__PURE__*/React.createContext({});
+export const FormValueContext = /*#__PURE__*/React.createContext({});
+export const FormProvider = FormContext.Provider;
+export const FormValueProvider = FormValueContext.Provider;
 export function useFormContext() {
   return useContext(FormContext);
 }

package/esm/Form/hooks/useFormClassNames.js

@@ -4,21 +4,22 @@ import { useClassNames } from "../../internals/hooks/index.js";
  * Take <Form> props and return className for <Form> styles
  */
 export default function useFormClassNames(_ref) {
-  var _ref$classPrefix = _ref.classPrefix,
-    classPrefix = _ref$classPrefix === void 0 ? 'form' : _ref$classPrefix,
-    className = _ref.className,
-    fluid = _ref.fluid,
-    _ref$layout = _ref.layout,
-    layout = _ref$layout === void 0 ? 'vertical' : _ref$layout,
-    readOnly = _ref.readOnly,
-    plaintext = _ref.plaintext,
-    disabled = _ref.disabled;
-  var _useClassNames = useClassNames(classPrefix),
-    withClassPrefix = _useClassNames.withClassPrefix,
-    merge = _useClassNames.merge;
+  let {
+    classPrefix = 'form',
+    className,
+    fluid,
+    layout = 'vertical',
+    readOnly,
+    plaintext,
+    disabled
+  } = _ref;
+  const {
+    withClassPrefix,
+    merge
+  } = useClassNames(classPrefix);
   return merge(className, withClassPrefix(layout, fluid && layout === 'vertical' ? 'fluid' : 'fixed-width', {
     readonly: readOnly,
-    disabled: disabled,
-    plaintext: plaintext
+    disabled,
+    plaintext
   }));
 }

package/esm/Form/hooks/useFormRef.js

@@ -1,13 +1,15 @@
 'use client';
-import _extends from "@babel/runtime/helpers/esm/extends";
 import { useRef, useImperativeHandle } from 'react';
 export default function useFormRef(ref, props) {
-  var rootRef = useRef(null);
-  var imperativeMethods = props.imperativeMethods;
-  useImperativeHandle(ref, function () {
-    return _extends({
-      root: rootRef.current
-    }, imperativeMethods);
+  const rootRef = useRef(null);
+  const {
+    imperativeMethods
+  } = props;
+  useImperativeHandle(ref, () => {
+    return {
+      root: rootRef.current,
+      ...imperativeMethods
+    };
   });
   return rootRef;
 }

package/esm/Form/hooks/useFormValidate.js

@@ -1,26 +1,22 @@
 'use client';
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-import _extends from "@babel/runtime/helpers/esm/extends";
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 import { useRef, useCallback } from 'react';
 import omit from 'lodash/omit';
 import set from 'lodash/set';
 import { useControlled, useEventCallback } from "../../internals/hooks/index.js";
 import { nameToPath } from "../../FormControl/utils.js";
 export default function useFormValidate(_formError, props) {
-  var formValue = props.formValue,
-    getCombinedModel = props.getCombinedModel,
-    onCheck = props.onCheck,
-    onError = props.onError,
-    nestedField = props.nestedField;
-  var _useControlled = useControlled(_formError, {}),
-    realFormError = _useControlled[0],
-    setFormError = _useControlled[1];
-  var checkOptions = {
+  const {
+    formValue,
+    getCombinedModel,
+    onCheck,
+    onError,
+    nestedField
+  } = props;
+  const [realFormError, setFormError] = useControlled(_formError, {});
+  const checkOptions = {
     nestedObject: nestedField
   };
-  var realFormErrorRef = useRef(realFormError);
+  const realFormErrorRef = useRef(realFormError);
   realFormErrorRef.current = realFormError;
 
   /**
@@ -28,13 +24,13 @@ export default function useFormValidate(_formError, props) {
    * The error message after verification is returned in the callback.
    * @param callback
    */
-  var check = useEventCallback(function (callback) {
-    var formError = {};
-    var errorCount = 0;
-    var model = getCombinedModel();
-    var _checkField = function checkField(key, type, value, formErrorObj) {
+  const check = useEventCallback(callback => {
+    const formError = {};
+    let errorCount = 0;
+    const model = getCombinedModel();
+    const checkField = (key, type, value, formErrorObj) => {
       model.setSchemaOptionsForAllType(formValue || {});
-      var checkResult = type.check(value, formValue, key);
+      const checkResult = type.check(value, formValue, key);
       if (checkResult.hasError === true) {
         errorCount += 1;
         formErrorObj[key] = (checkResult === null || checkResult === void 0 ? void 0 : checkResult.errorMessage) || checkResult;
@@ -42,20 +38,18 @@ export default function useFormValidate(_formError, props) {
 
       // Check nested object
       if (type !== null && type !== void 0 && type.objectTypeSchemaSpec) {
-        Object.entries(type.objectTypeSchemaSpec).forEach(function (_ref) {
-          var nestedKey = _ref[0],
-            nestedType = _ref[1];
+        Object.entries(type.objectTypeSchemaSpec).forEach(_ref => {
+          let [nestedKey, nestedType] = _ref;
           formErrorObj[key] = formErrorObj[key] || {
             object: {}
           };
-          _checkField(nestedKey, nestedType, value === null || value === void 0 ? void 0 : value[nestedKey], formErrorObj[key].object);
+          checkField(nestedKey, nestedType, value === null || value === void 0 ? void 0 : value[nestedKey], formErrorObj[key].object);
         });
       }
     };
-    Object.entries(model.getSchemaSpec()).forEach(function (_ref2) {
-      var key = _ref2[0],
-        type = _ref2[1];
-      _checkField(key, type, formValue[key], formError);
+    Object.entries(model.getSchemaSpec()).forEach(_ref2 => {
+      let [key, type] = _ref2;
+      checkField(key, type, formValue[key], formError);
     });
     setFormError(formError);
     onCheck === null || onCheck === void 0 || onCheck(formError);
@@ -66,10 +60,12 @@ export default function useFormValidate(_formError, props) {
     }
     return true;
   });
-  var checkFieldForNextValue = useEventCallback(function (fieldName, nextValue, callback) {
-    var model = getCombinedModel();
-    var resultOfCurrentField = model.checkForField(fieldName, nextValue, checkOptions);
-    var nextFormError = _extends({}, realFormError);
+  const checkFieldForNextValue = useEventCallback((fieldName, nextValue, callback) => {
+    const model = getCombinedModel();
+    const resultOfCurrentField = model.checkForField(fieldName, nextValue, checkOptions);
+    let nextFormError = {
+      ...realFormError
+    };
     /**
      * when using proxy of schema-typed, we need to use getCheckResult to get all errors,
      * but if nestedField is used, it is impossible to distinguish whether the nested object has an error here,
@@ -85,18 +81,19 @@ export default function useFormValidate(_formError, props) {
       }
       return !resultOfCurrentField.hasError;
     } else {
-      var allResults = model.getCheckResult();
-      var hasError = false;
-      Object.keys(allResults).forEach(function (key) {
-        var currentResult = allResults[key];
+      const allResults = model.getCheckResult();
+      let hasError = false;
+      Object.keys(allResults).forEach(key => {
+        const currentResult = allResults[key];
         if (currentResult.hasError) {
           nextFormError[key] = currentResult.errorMessage || currentResult;
           hasError = true;
         } else {
           // eslint-disable-next-line @typescript-eslint/no-unused-vars
-          var _nextFormError = nextFormError,
-            _ = _nextFormError[key],
-            rest = _objectWithoutPropertiesLoose(_nextFormError, [key].map(_toPropertyKey));
+          const {
+            [key]: _,
+            ...rest
+          } = nextFormError;
           nextFormError = rest;
         }
       });
@@ -114,25 +111,25 @@ export default function useFormValidate(_formError, props) {
    * @param fieldName
    * @param callback
    */
-  var checkForField = useEventCallback(function (fieldName, callback) {
+  const checkForField = useEventCallback((fieldName, callback) => {
     return checkFieldForNextValue(fieldName, formValue || {}, callback);
   });
 
   /**
    * Check form data asynchronously and return a Promise
    */
-  var checkAsync = useEventCallback(function () {
-    var promises = [];
-    var keys = [];
-    var model = getCombinedModel();
-    Object.keys(model.getSchemaSpec()).forEach(function (key) {
+  const checkAsync = useEventCallback(() => {
+    const promises = [];
+    const keys = [];
+    const model = getCombinedModel();
+    Object.keys(model.getSchemaSpec()).forEach(key => {
       keys.push(key);
       promises.push(model.checkForFieldAsync(key, formValue || {}, checkOptions));
     });
-    return Promise.all(promises).then(function (values) {
-      var formError = {};
-      var errorCount = 0;
-      for (var i = 0; i < values.length; i++) {
+    return Promise.all(promises).then(values => {
+      const formError = {};
+      let errorCount = 0;
+      for (let i = 0; i < values.length; i++) {
         if (values[i].hasError) {
           errorCount += 1;
           formError[keys[i]] = values[i].errorMessage;
@@ -145,14 +142,16 @@ export default function useFormValidate(_formError, props) {
       }
       return {
         hasError: errorCount > 0,
-        formError: formError
+        formError
       };
     });
   });
-  var checkFieldAsyncForNextValue = useEventCallback(function (fieldName, nextValue) {
-    var model = getCombinedModel();
-    return model.checkForFieldAsync(fieldName, nextValue, checkOptions).then(function (resultOfCurrentField) {
-      var nextFormError = _extends({}, realFormError);
+  const checkFieldAsyncForNextValue = useEventCallback((fieldName, nextValue) => {
+    const model = getCombinedModel();
+    return model.checkForFieldAsync(fieldName, nextValue, checkOptions).then(resultOfCurrentField => {
+      let nextFormError = {
+        ...realFormError
+      };
       /**
        * when using proxy of schema-typed, we need to use getCheckResult to get all errors,
        * but if nestedField is used, it is impossible to distinguish whether the nested object has an error here,
@@ -168,18 +167,19 @@ export default function useFormValidate(_formError, props) {
         }
         return resultOfCurrentField;
       } else {
-        var allResults = model.getCheckResult();
-        var hasError = false;
-        Object.keys(allResults).forEach(function (key) {
-          var currentResult = allResults[key];
+        const allResults = model.getCheckResult();
+        let hasError = false;
+        Object.keys(allResults).forEach(key => {
+          const currentResult = allResults[key];
           if (currentResult.hasError) {
             nextFormError[key] = currentResult.errorMessage || currentResult;
             hasError = true;
           } else {
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            var _nextFormError2 = nextFormError,
-              _ = _nextFormError2[key],
-              rest = _objectWithoutPropertiesLoose(_nextFormError2, [key].map(_toPropertyKey));
+            const {
+              [key]: _,
+              ...rest
+            } = nextFormError;
             nextFormError = rest;
           }
         });
@@ -197,43 +197,43 @@ export default function useFormValidate(_formError, props) {
    * Asynchronously check form fields and return Promise
    * @param fieldName
    */
-  var checkForFieldAsync = useEventCallback(function (fieldName) {
+  const checkForFieldAsync = useEventCallback(fieldName => {
     return checkFieldAsyncForNextValue(fieldName, formValue || {});
   });
-  var onRemoveError = useCallback(function (name) {
+  const onRemoveError = useCallback(name => {
     /**
      * when this function is called when the children component is unmount,
      * it's an old render frame so use Ref to get future error
      */
-    var formError = omit(realFormErrorRef.current, [nestedField ? nameToPath(name) : name]);
+    const formError = omit(realFormErrorRef.current, [nestedField ? nameToPath(name) : name]);
     realFormErrorRef.current = formError;
     setFormError(formError);
     onCheck === null || onCheck === void 0 || onCheck(formError);
     return formError;
   }, [nestedField, onCheck, setFormError]);
-  var cleanErrors = useEventCallback(function () {
+  const cleanErrors = useEventCallback(() => {
     setFormError({});
   });
-  var resetErrors = useEventCallback(function (formError) {
+  const resetErrors = useEventCallback(function (formError) {
     if (formError === void 0) {
       formError = {};
     }
     setFormError(formError);
   });
-  var cleanErrorForField = useEventCallback(function (fieldName) {
+  const cleanErrorForField = useEventCallback(fieldName => {
     setFormError(omit(realFormError, [nestedField ? nameToPath(fieldName) : fieldName]));
   });
   return {
     formError: realFormError,
-    check: check,
-    checkForField: checkForField,
-    checkFieldForNextValue: checkFieldForNextValue,
-    checkAsync: checkAsync,
-    checkForFieldAsync: checkForFieldAsync,
-    checkFieldAsyncForNextValue: checkFieldAsyncForNextValue,
-    cleanErrors: cleanErrors,
-    resetErrors: resetErrors,
-    cleanErrorForField: cleanErrorForField,
-    onRemoveError: onRemoveError
+    check,
+    checkForField,
+    checkFieldForNextValue,
+    checkAsync,
+    checkForFieldAsync,
+    checkFieldAsyncForNextValue,
+    cleanErrors,
+    resetErrors,
+    cleanErrorForField,
+    onRemoveError
   };
 }