rsuite 5.66.0 → 5.68.0

package/esm/DateInput/DateInput.js

@@ -1,12 +1,13 @@
 'use client';
 import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-var _excluded = ["format", "value", "defaultValue", "placeholder", "onChange", "onKeyDown", "onBlur", "onFocus"];
+var _excluded = ["format", "value", "defaultValue", "placeholder", "onChange", "onKeyDown", "onBlur", "onFocus", "onPaste"];
 import React, { useRef, useMemo } from 'react';
 import PropTypes from 'prop-types';
 import Input from "../Input/index.js";
 import { useCustom, useControlled, useEventCallback } from "../internals/hooks/index.js";
 import { mergeRefs } from "../internals/utils/index.js";
+import { isValid } from "../internals/utils/date/index.js";
 import { getInputSelectedState, validateDateTime, useInputSelection } from "./utils.js";
 import useDateInputState from "./hooks/useDateInputState.js";
 import useKeyboardInputEvent from "./hooks/useKeyboardInputEvent.js";
@@ -28,13 +29,15 @@ var DateInput = /*#__PURE__*/React.forwardRef(function (props, ref) {
     onKeyDown = props.onKeyDown,
     onBlur = props.onBlur,
     onFocus = props.onFocus,
+    onPaste = props.onPaste,
     rest = _objectWithoutPropertiesLoose(props, _excluded);
   var inputRef = useRef();
   var _useSelectedState = useSelectedState(),
     selectedState = _useSelectedState.selectedState,
     setSelectedState = _useSelectedState.setSelectedState;
   var _useCustom = useCustom('Calendar'),
-    locale = _useCustom.locale;
+    locale = _useCustom.locale,
+    parseDate = _useCustom.parseDate;
   var dateLocale = locale.dateLocale;
   var _useControlled = useControlled(valueProp, defaultValue),
     value = _useControlled[0],
@@ -49,6 +52,7 @@ var DateInput = /*#__PURE__*/React.forwardRef(function (props, ref) {
     dateField = _useDateInputState.dateField,
     setDateOffset = _useDateInputState.setDateOffset,
     setDateField = _useDateInputState.setDateField,
+    setNewDate = _useDateInputState.setNewDate,
     getDateField = _useDateInputState.getDateField,
     toDateString = _useDateInputState.toDateString,
     isEmptyValue = _useDateInputState.isEmptyValue;
@@ -162,6 +166,17 @@ var DateInput = /*#__PURE__*/React.forwardRef(function (props, ref) {
       reset();
     }
   });
+  var handlePaste = useEventCallback(function (event) {
+    var _event$clipboardData;
+    event.preventDefault();
+    var pasteText = (_event$clipboardData = event.clipboardData) === null || _event$clipboardData === void 0 ? void 0 : _event$clipboardData.getData('text');
+    var nextDate = parseDate(pasteText, formatStr);
+    if (isValid(nextDate)) {
+      handleChange(nextDate, event);
+      setNewDate(nextDate);
+    }
+    onPaste === null || onPaste === void 0 ? void 0 : onPaste(event);
+  });
   var onKeyboardInput = useKeyboardInputEvent({
     onSegmentChange: onSegmentChange,
     onSegmentValueChange: onSegmentValueChange,
@@ -189,6 +204,7 @@ var DateInput = /*#__PURE__*/React.forwardRef(function (props, ref) {
     ref: mergeRefs(inputRef, ref),
     onKeyDown: onKeyboardInput,
     onClick: handleClick,
+    onPaste: handlePaste,
     value: renderedValue,
     placeholder: placeholder || formatStr
   }, focusEventProps, rest));

package/esm/DateInput/hooks/useDateInputState.d.ts

@@ -131,6 +131,7 @@ export declare function useDateInputState({ formatStr, locale, date, isControlle
     };
     setDateOffset: (pattern: string, offset: number, callback?: ((newDate: Date | null) => void) | undefined) => void;
     setDateField: (pattern: string, value: number | null, callback?: ((newDate: Date | null) => void) | undefined) => void;
+    setNewDate: (value: Date | null) => void;
     getDateField: (pattern: string) => {
         name: any;
         value: any;

package/esm/DateInput/hooks/useDateInputState.js

@@ -1,5 +1,5 @@
 'use client';
-import { useEffect } from 'react';
+import { useCallback, useEffect } from 'react';
 import startCase from 'lodash/startCase';
 import { addDays, addMonths, addYears, addHours, addMinutes, addSeconds, format, isLastDayOfMonth, lastDayOfMonth, isValid } from "../../internals/utils/date/index.js";
 import { useDateField, patternMap } from "../DateField.js";
@@ -95,25 +95,26 @@ export function useDateInputState(_ref) {
     // if date is not valid, return uncontrolled date string
     return toDateString();
   };
+  var setNewDate = useCallback(function (value) {
+    dispatch({
+      type: 'setNewDate',
+      value: value
+    });
+  }, [dispatch]);
   useEffect(function () {
     if (isControlledDate) {
       if (date && isValid(date)) {
-        dispatch({
-          type: 'setNewDate',
-          value: date
-        });
+        setNewDate(date);
       } else if (date === null) {
-        dispatch({
-          type: 'setNewDate',
-          value: null
-        });
+        setNewDate(null);
       }
     }
-  }, [date, dispatch, isControlledDate]);
+  }, [date, dispatch, isControlledDate, setNewDate]);
   return {
     dateField: dateField,
     setDateOffset: setDateOffset,
     setDateField: setDateField,
+    setNewDate: setNewDate,
     getDateField: getDateField,
     toDateString: isControlledDate ? toControlledDateString : toDateString,
     isEmptyValue: isEmptyValue

package/esm/DateInput/hooks/useKeyboardInputEvent.js

@@ -28,6 +28,11 @@ export function useKeyboardInputEvent(_ref) {
         onSegmentValueChangeWithNumericKeys === null || onSegmentValueChangeWithNumericKeys === void 0 ? void 0 : onSegmentValueChangeWithNumericKeys(event);
         event.preventDefault();
       case (_key$match2 = key.match(/[a-z]/)) === null || _key$match2 === void 0 ? void 0 : _key$match2[0]:
+        // Determine whether the Ctrl or Command key is pressed, does not affect user copy and paste
+        if (event.ctrlKey || event.metaKey) {
+          break;
+        }
+
         // Prevent letters from being entered
         event.preventDefault();
         break;

package/esm/DateRangeInput/DateRangeInput.js

@@ -1,10 +1,11 @@
 'use client';
 import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-var _excluded = ["className", "classPrefix", "character", "format", "value", "defaultValue", "placeholder", "onChange", "onKeyDown", "onBlur", "onFocus"];
+var _excluded = ["className", "classPrefix", "character", "format", "value", "defaultValue", "placeholder", "onChange", "onKeyDown", "onBlur", "onFocus", "onPaste"];
 import React, { useState, useRef, useMemo } from 'react';
 import PropTypes from 'prop-types';
 import Input from "../Input/index.js";
+import { isValid } from "../internals/utils/date/index.js";
 import { useClassNames, useCustom, useControlled, useEventCallback } from "../internals/hooks/index.js";
 import { mergeRefs } from "../internals/utils/index.js";
 import { validateDateTime, useDateInputState, useInputSelection, useKeyboardInputEvent, useIsFocused, useSelectedState, useFieldCursor } from "../DateInput/index.js";
@@ -30,6 +31,7 @@ var DateRangeInput = /*#__PURE__*/React.forwardRef(function (props, ref) {
     onKeyDown = props.onKeyDown,
     onBlur = props.onBlur,
     onFocus = props.onFocus,
+    onPaste = props.onPaste,
     rest = _objectWithoutPropertiesLoose(props, _excluded);
   var _useClassNames = useClassNames(classPrefix),
     withClassPrefix = _useClassNames.withClassPrefix,
@@ -40,7 +42,8 @@ var DateRangeInput = /*#__PURE__*/React.forwardRef(function (props, ref) {
     selectedState = _useSelectedState.selectedState,
     setSelectedState = _useSelectedState.setSelectedState;
   var _useCustom = useCustom('Calendar'),
-    locale = _useCustom.locale;
+    locale = _useCustom.locale,
+    parseDate = _useCustom.parseDate;
   var rangeFormatStr = "" + formatStr + character + formatStr;
   var dateLocale = locale.dateLocale;
   var _useControlled = useControlled(valueProp, defaultValue),
@@ -211,6 +214,24 @@ var DateRangeInput = /*#__PURE__*/React.forwardRef(function (props, ref) {
       reset();
     }
   });
+  var handlePaste = useEventCallback(function (event) {
+    var _event$clipboardData;
+    event.preventDefault();
+    var pasteText = (_event$clipboardData = event.clipboardData) === null || _event$clipboardData === void 0 ? void 0 : _event$clipboardData.getData('text');
+    var _ref = pasteText.split(character).map(function (date) {
+        return parseDate(date, formatStr);
+      }),
+      start = _ref[0],
+      end = _ref[1];
+    if (isValid(start) && isValid(end)) {
+      var nextValue = [start, end];
+      onChange === null || onChange === void 0 ? void 0 : onChange(nextValue, event);
+      setValue(nextValue);
+      startDateState.setNewDate(start);
+      endDateState.setNewDate(end);
+    }
+    onPaste === null || onPaste === void 0 ? void 0 : onPaste(event);
+  });
   var onKeyboardInput = useKeyboardInputEvent({
     onSegmentChange: onSegmentChange,
     onSegmentValueChange: onSegmentValueChange,
@@ -227,6 +248,7 @@ var DateRangeInput = /*#__PURE__*/React.forwardRef(function (props, ref) {
     ref: mergeRefs(inputRef, ref),
     onKeyDown: onKeyboardInput,
     onClick: handleClick,
+    onPaste: handlePaste,
     value: renderedValue,
     placeholder: placeholder || rangeFormatStr
   }, focusEventProps, rest));

package/esm/Form/Form.js

@@ -74,12 +74,13 @@ var Form = /*#__PURE__*/React.forwardRef(function (props, ref) {
   };
   var _useFormValidate = useFormValidate(controlledFormError, formValidateProps),
     formError = _useFormValidate.formError,
-    setFieldError = _useFormValidate.setFieldError,
     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;
@@ -145,12 +146,6 @@ var Form = /*#__PURE__*/React.forwardRef(function (props, ref) {
   var removeFieldError = useEventCallback(function (name) {
     onRemoveError(name);
   });
-  var onFieldError = useEventCallback(function (name, checkResult) {
-    setFieldError(name, checkResult);
-  });
-  var onFieldSuccess = useEventCallback(function (name) {
-    removeFieldError(name);
-  });
   var onFieldChange = useEventCallback(function (name, value, event) {
     var nextFormValue = setFieldValue(name, value);
     onChange === null || onChange === void 0 ? void 0 : onChange(nextFormValue, event);
@@ -164,13 +159,12 @@ var Form = /*#__PURE__*/React.forwardRef(function (props, ref) {
     formError: formError,
     nestedField: nestedField,
     pushFieldRule: pushFieldRule,
-    getCombinedModel: getCombinedModel,
     removeFieldValue: removeFieldValue,
     removeFieldError: removeFieldError,
     removeFieldRule: removeFieldRule,
-    onFieldSuccess: onFieldSuccess,
     onFieldChange: onFieldChange,
-    onFieldError: onFieldError
+    checkFieldForNextValue: checkFieldForNextValue,
+    checkFieldAsyncForNextValue: checkFieldAsyncForNextValue
   };
   return /*#__PURE__*/React.createElement("form", _extends({}, rest, {
     ref: formRef,

package/esm/Form/FormContext.d.ts

@@ -1,6 +1,5 @@
 import React from 'react';
 import { TypeAttributes } from '../internals/types';
-import type { Schema, CheckResult } from 'schema-typed';
 import type { FieldRuleType } from './hooks/useSchemaModel';
 type RecordAny = Record<string, any>;
 interface TrulyFormContextValue<T = RecordAny, M = any, E = {
@@ -8,14 +7,13 @@ interface TrulyFormContextValue<T = RecordAny, M = any, E = {
 }> {
     formError: E;
     nestedField: boolean;
-    getCombinedModel: () => Schema;
     removeFieldValue: (name: string) => void;
     removeFieldError: (name: string) => void;
     removeFieldRule: (name: string) => void;
     pushFieldRule: (name: string, fieldRule: FieldRuleType) => void;
-    onFieldError: (name: string, fieldError: string | CheckResult) => void;
     onFieldChange: (name: string, value: any, event: React.SyntheticEvent) => void;
-    onFieldSuccess: (name: string) => void;
+    checkFieldForNextValue: (name: string, nextValue: Record<string, unknown>, callback?: (checkResult: Record<string, unknown>) => void) => boolean;
+    checkFieldAsyncForNextValue: (name: string, nextValue: Record<string, unknown>) => Promise<Record<string, unknown>>;
 }
 type ExternalPropsContextValue = {
     checkTrigger?: TypeAttributes.CheckTrigger;

package/esm/Form/hooks/useFormValidate.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="lodash" />
-import type { CheckResult } from 'schema-typed';
 export interface FormErrorProps {
     formValue: any;
     getCombinedModel: () => any;
@@ -11,11 +10,12 @@ export default function useFormValidate(formError: any, props: FormErrorProps):
     formError: any;
     check: (...args: any[]) => any;
     checkForField: (...args: any[]) => any;
+    checkFieldForNextValue: (...args: any[]) => any;
     checkAsync: (...args: any[]) => any;
     checkForFieldAsync: (...args: any[]) => any;
+    checkFieldAsyncForNextValue: (...args: any[]) => any;
     cleanErrors: (...args: any[]) => any;
     resetErrors: (...args: any[]) => any;
     cleanErrorForField: (...args: any[]) => any;
-    setFieldError: (fieldName: string, checkResult: string | CheckResult) => any;
     onRemoveError: (name: string) => import("lodash").Omit<any, string>;
 };

package/esm/Form/hooks/useFormValidate.js

@@ -1,5 +1,8 @@
 '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';
@@ -14,6 +17,9 @@ export default function useFormValidate(formError, props) {
   var _useControlled = useControlled(formError, {}),
     realFormError = _useControlled[0],
     setFormError = _useControlled[1];
+  var checkOptions = {
+    nestedObject: nestedField
+  };
   var realFormErrorRef = useRef(realFormError);
   realFormErrorRef.current = realFormError;
 
@@ -27,7 +33,7 @@ export default function useFormValidate(formError, props) {
     var errorCount = 0;
     var model = getCombinedModel();
     Object.keys(model.getSchemaSpec()).forEach(function (key) {
-      var checkResult = model.checkForField(key, formValue || {});
+      var checkResult = model.checkForField(key, formValue || {}, checkOptions);
       if (checkResult.hasError === true) {
         errorCount += 1;
         formError[key] = (checkResult === null || checkResult === void 0 ? void 0 : checkResult.errorMessage) || checkResult;
@@ -42,24 +48,56 @@ 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({}, formError);
+    /**
+     * 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,
+     * so nestedField does not support proxy here
+     */
+    if (nestedField) {
+      nextFormError = set(nextFormError, nameToPath(fieldName), resultOfCurrentField);
+      setFormError(nextFormError);
+      onCheck === null || onCheck === void 0 ? void 0 : onCheck(nextFormError);
+      callback === null || callback === void 0 ? void 0 : callback(resultOfCurrentField);
+      if (resultOfCurrentField.hasError) {
+        onError === null || onError === void 0 ? void 0 : onError(nextFormError);
+      }
+      return !resultOfCurrentField.hasError;
+    } else {
+      var allResults = model.getCheckResult();
+      var hasError = false;
+      Object.keys(allResults).forEach(function (key) {
+        var 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));
+          nextFormError = rest;
+        }
+      });
+      setFormError(nextFormError);
+      onCheck === null || onCheck === void 0 ? void 0 : onCheck(nextFormError);
+      callback === null || callback === void 0 ? void 0 : callback(resultOfCurrentField);
+      if (hasError) {
+        onError === null || onError === void 0 ? void 0 : onError(nextFormError);
+      }
+      return !hasError;
+    }
+  });
   /**
    * Check the data field
    * @param fieldName
    * @param callback
    */
   var checkForField = useEventCallback(function (fieldName, callback) {
-    var _extends2;
-    var model = getCombinedModel();
-    var checkResult = model.checkForField(fieldName, formValue || {});
-    var nextFormError = _extends({}, formError, (_extends2 = {}, _extends2[fieldName] = (checkResult === null || checkResult === void 0 ? void 0 : checkResult.errorMessage) || checkResult, _extends2));
-    setFormError(nextFormError);
-    onCheck === null || onCheck === void 0 ? void 0 : onCheck(nextFormError);
-    callback === null || callback === void 0 ? void 0 : callback(checkResult);
-    if (checkResult.hasError) {
-      onError === null || onError === void 0 ? void 0 : onError(nextFormError);
-    }
-    return !checkResult.hasError;
+    return checkFieldForNextValue(fieldName, formValue || {}, callback);
   });
 
   /**
@@ -71,7 +109,7 @@ export default function useFormValidate(formError, props) {
     var model = getCombinedModel();
     Object.keys(model.getSchemaSpec()).forEach(function (key) {
       keys.push(key);
-      promises.push(model.checkForFieldAsync(key, formValue || {}));
+      promises.push(model.checkForFieldAsync(key, formValue || {}, checkOptions));
     });
     return Promise.all(promises).then(function (values) {
       var formError = {};
@@ -93,23 +131,56 @@ export default function useFormValidate(formError, props) {
       };
     });
   });
+  var checkFieldAsyncForNextValue = useEventCallback(function (fieldName, nextValue) {
+    var model = getCombinedModel();
+    return model.checkForFieldAsync(fieldName, nextValue, checkOptions).then(function (resultOfCurrentField) {
+      var nextFormError = _extends({}, formError);
+      /**
+       * 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,
+       * so nestedField does not support proxy here
+       */
+
+      if (nestedField) {
+        nextFormError = set(nextFormError, nameToPath(fieldName), resultOfCurrentField);
+        onCheck === null || onCheck === void 0 ? void 0 : onCheck(nextFormError);
+        setFormError(nextFormError);
+        if (resultOfCurrentField.hasError) {
+          onError === null || onError === void 0 ? void 0 : onError(nextFormError);
+        }
+        return resultOfCurrentField;
+      } else {
+        var allResults = model.getCheckResult();
+        var hasError = false;
+        Object.keys(allResults).forEach(function (key) {
+          var 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));
+            nextFormError = rest;
+          }
+        });
+        setFormError(nextFormError);
+        onCheck === null || onCheck === void 0 ? void 0 : onCheck(nextFormError);
+        if (hasError) {
+          onError === null || onError === void 0 ? void 0 : onError(nextFormError);
+        }
+        return resultOfCurrentField;
+      }
+    });
+  });
 
   /**
    * Asynchronously check form fields and return Promise
    * @param fieldName
    */
   var checkForFieldAsync = useEventCallback(function (fieldName) {
-    var model = getCombinedModel();
-    return model.checkForFieldAsync(fieldName, formValue || {}).then(function (checkResult) {
-      var _extends3;
-      var nextFormError = _extends({}, formError, (_extends3 = {}, _extends3[fieldName] = checkResult.errorMessage, _extends3));
-      onCheck === null || onCheck === void 0 ? void 0 : onCheck(nextFormError);
-      setFormError(nextFormError);
-      if (checkResult.hasError) {
-        onError === null || onError === void 0 ? void 0 : onError(nextFormError);
-      }
-      return checkResult;
-    });
+    return checkFieldAsyncForNextValue(fieldName, formValue || {});
   });
   var onRemoveError = useCallback(function (name) {
     /**
@@ -122,14 +193,6 @@ export default function useFormValidate(formError, props) {
     onCheck === null || onCheck === void 0 ? void 0 : onCheck(formError);
     return formError;
   }, [nestedField, onCheck, setFormError]);
-  var setFieldError = useCallback(function (fieldName, checkResult) {
-    var _extends4;
-    var nextFormError = nestedField ? set(_extends({}, formError), nameToPath(fieldName), checkResult) : _extends({}, formError, (_extends4 = {}, _extends4[fieldName] = checkResult, _extends4));
-    setFormError(nextFormError);
-    onError === null || onError === void 0 ? void 0 : onError(nextFormError);
-    onCheck === null || onCheck === void 0 ? void 0 : onCheck(nextFormError);
-    return nextFormError;
-  }, [formError, nestedField, onCheck, onError, setFormError]);
   var cleanErrors = useEventCallback(function () {
     setFormError({});
   });
@@ -146,12 +209,13 @@ export default function useFormValidate(formError, props) {
     formError: realFormError,
     check: check,
     checkForField: checkForField,
+    checkFieldForNextValue: checkFieldForNextValue,
     checkAsync: checkAsync,
     checkForFieldAsync: checkForFieldAsync,
+    checkFieldAsyncForNextValue: checkFieldAsyncForNextValue,
     cleanErrors: cleanErrors,
     resetErrors: resetErrors,
     cleanErrorForField: cleanErrorForField,
-    setFieldError: setFieldError,
     onRemoveError: onRemoveError
   };
 }

package/esm/FormControl/FormControl.js

@@ -37,10 +37,9 @@ var FormControl = /*#__PURE__*/React.forwardRef(function (props, ref) {
     removeFieldValue = _useContext.removeFieldValue,
     removeFieldError = _useContext.removeFieldError,
     onFieldChange = _useContext.onFieldChange,
-    onFieldError = _useContext.onFieldError,
-    onFieldSuccess = _useContext.onFieldSuccess,
-    getCombinedModel = _useContext.getCombinedModel,
-    contextCheckTrigger = _useContext.checkTrigger;
+    contextCheckTrigger = _useContext.checkTrigger,
+    checkFieldForNextValue = _useContext.checkFieldForNextValue,
+    checkFieldAsyncForNextValue = _useContext.checkFieldAsyncForNextValue;
   var _props$as = props.as,
     Component = _props$as === void 0 ? 'div' : _props$as,
     _props$accepter = props.accepter,
@@ -115,27 +114,12 @@ var FormControl = /*#__PURE__*/React.forwardRef(function (props, ref) {
     onBlur === null || onBlur === void 0 ? void 0 : onBlur(event);
   });
   var handleFieldCheck = useEventCallback(function (value) {
-    var callbackEvents = function callbackEvents(checkResult) {
-      if (checkResult.hasError) {
-        var _errorMessage = checkResult.errorMessage;
-        var _fieldError = nestedField ? checkResult : _errorMessage || checkResult;
-        onFieldError === null || onFieldError === void 0 ? void 0 : onFieldError(name, _fieldError);
-      } else {
-        onFieldSuccess === null || onFieldSuccess === void 0 ? void 0 : onFieldSuccess(name);
-      }
-      return checkResult;
-    };
     var nextFormValue = setFieldValue(name, value);
-    var model = getCombinedModel();
-    var checkOptions = {
-      nestedObject: nestedField
-    };
     if (checkAsync) {
-      return model === null || model === void 0 ? void 0 : model.checkForFieldAsync(name, nextFormValue, checkOptions).then(function (checkResult) {
-        return callbackEvents(checkResult);
-      });
+      checkFieldAsyncForNextValue(name, nextFormValue);
+    } else {
+      checkFieldForNextValue(name, nextFormValue);
     }
-    return Promise.resolve(callbackEvents(model === null || model === void 0 ? void 0 : model.checkForField(name, nextFormValue, checkOptions)));
   });
   var fieldHasError = Boolean(fieldError);
 

package/esm/Nav/AdaptiveNavItem.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { NavItemProps } from './NavItem';
+/**
+ * The <Nav.Item> API
+ * When used as direct child of <Nav>, render the NavItem
+ * When used within a <Nav.Menu>, render the NavDropdownItem
+ */
+declare const AdaptiveNavItem: React.ForwardRefExoticComponent<NavItemProps<string | number> & React.RefAttributes<any>>;
+export default AdaptiveNavItem;

package/esm/Nav/AdaptiveNavItem.js

@@ -0,0 +1,83 @@
+'use client';
+import _extends from "@babel/runtime/helpers/esm/extends";
+import React, { useContext, useEffect } from 'react';
+import NavItem from "./NavItem.js";
+import { useInternalId } from "../internals/hooks/index.js";
+import { NavbarContext } from "../Navbar/Navbar.js";
+import { SidenavContext } from "../Sidenav/Sidenav.js";
+import NavContext from "./NavContext.js";
+import { NavMenuActionType, NavMenuContext } from "./NavMenu.js";
+import NavDropdownItem from "./NavDropdownItem.js";
+import NavbarDropdownItem from "../Navbar/NavbarDropdownItem.js";
+import SidenavDropdownItem from "../Sidenav/SidenavDropdownItem.js";
+import NavbarItem from "../Navbar/NavbarItem.js";
+import SidenavItem from "../Sidenav/SidenavItem.js";
+
+/**
+ * The <Nav.Item> API
+ * When used as direct child of <Nav>, render the NavItem
+ * When used within a <Nav.Menu>, render the NavDropdownItem
+ */
+var AdaptiveNavItem = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  var nav = useContext(NavContext);
+  if (!nav) {
+    throw new Error('<Nav.Item> must be rendered within a <Nav> component.');
+  }
+  var parentNavMenu = useContext(NavMenuContext);
+  var navbar = useContext(NavbarContext);
+  var sidenav = useContext(SidenavContext);
+  var _ref = parentNavMenu !== null && parentNavMenu !== void 0 ? parentNavMenu : [],
+    dispatch = _ref[1];
+  var _id = useInternalId('Nav.Item');
+  useEffect(function () {
+    if (dispatch) {
+      var _props$active;
+      dispatch({
+        type: NavMenuActionType.RegisterItem,
+        payload: {
+          _id: _id,
+          eventKey: props.eventKey,
+          active: (_props$active = props.active) !== null && _props$active !== void 0 ? _props$active : false
+        }
+      });
+      return function () {
+        dispatch({
+          type: NavMenuActionType.UnregisterItem,
+          payload: {
+            _id: _id
+          }
+        });
+      };
+    }
+  }, [dispatch, _id, props.eventKey, props.active]);
+  if (parentNavMenu) {
+    if (navbar) {
+      return /*#__PURE__*/React.createElement(NavbarDropdownItem, _extends({
+        ref: ref
+      }, props));
+    }
+    if (sidenav) {
+      return /*#__PURE__*/React.createElement(SidenavDropdownItem, _extends({
+        ref: ref
+      }, props));
+    }
+    return /*#__PURE__*/React.createElement(NavDropdownItem, _extends({
+      ref: ref
+    }, props));
+  }
+  if (navbar) {
+    return /*#__PURE__*/React.createElement(NavbarItem, _extends({
+      ref: ref
+    }, props));
+  }
+  if (sidenav) {
+    return /*#__PURE__*/React.createElement(SidenavItem, _extends({
+      ref: ref
+    }, props));
+  }
+  return /*#__PURE__*/React.createElement(NavItem, _extends({
+    ref: ref
+  }, props));
+});
+AdaptiveNavItem.displayName = 'Nav.Item';
+export default AdaptiveNavItem;