rsuite 6.0.0-canary-20250416 → 6.0.0-canary-20250507

package/esm/Navbar/Navbar.js

@@ -7,8 +7,7 @@ import NavbarToggle from "./NavbarToggle.js";
 import NavbarDrawer from "./NavbarDrawer.js";
 import Box from "../internals/Box/index.js";
 import { forwardRef } from "../internals/utils/index.js";
-import { useStyles, useEventCallback, useUniqueId } from "../internals/hooks/index.js";
-import { useCustom } from "../CustomProvider/index.js";
+import { useStyles, useCustom, useEventCallback, useUniqueId } from "../internals/hooks/index.js";
 import { NavbarContext } from "./NavbarContext.js";
 const Subcomponents = {
   Brand: NavbarBrand,

package/esm/Navbar/NavbarDropdownMenu.js

@@ -8,9 +8,8 @@ import PageNextIcon from '@rsuite/icons/PageNext';
 import Disclosure from "../internals/Disclosure/index.js";
 import NavContext from "../Nav/NavContext.js";
 import { mergeRefs } from "../internals/utils/index.js";
-import { useStyles } from "../internals/hooks/index.js";
+import { useStyles, useCustom } from "../internals/hooks/index.js";
 import { NavbarContext } from "./NavbarContext.js";
-import { useCustom } from "../CustomProvider/index.js";
 /**
  * @private this component is not supposed to be used directly
  *          Instead it's rendered by a <Nav.Menu> within a <Navbar>

package/esm/Navbar/NavbarToggle.d.ts

@@ -1,5 +1,10 @@
 import React from 'react';
-import { IconButtonProps } from '../IconButton';
-export type NavbarToggleProps = IconButtonProps;
-declare const NavbarToggle: React.ForwardRefExoticComponent<IconButtonProps & React.RefAttributes<any>>;
+import { BurgerProps } from '../internals/Burger';
+export interface NavbarToggleProps extends Omit<BurgerProps, 'onToggle'> {
+    /**
+     * Callback function that is called when the toggle is clicked.
+     */
+    onToggle?: (open: boolean) => void;
+}
+declare const NavbarToggle: React.ForwardRefExoticComponent<NavbarToggleProps & React.RefAttributes<any>>;
 export default NavbarToggle;

package/esm/Navbar/NavbarToggle.js

@@ -1,36 +1,31 @@
 'use client';
 import _extends from "@babel/runtime/helpers/esm/extends";
 import React, { useContext } from 'react';
-import IconButton from "../IconButton/index.js";
-import MenuIcon from '@rsuite/icons/Menu';
+import { Burger } from "../internals/Burger/index.js";
 import { useEventCallback } from "../internals/hooks/index.js";
-import { createComponent, createChainedFunction } from "../internals/utils/index.js";
+import { createChainedFunction } from "../internals/utils/index.js";
 import { NavbarContext } from "./NavbarContext.js";
-const Toggle = createComponent({
-  name: 'NavbarToggle',
-  componentAs: IconButton,
-  componentClassPrefix: 'navbar-toggle',
-  icon: /*#__PURE__*/React.createElement(MenuIcon, null)
-});
 const NavbarToggle = /*#__PURE__*/React.forwardRef((props, ref) => {
   const {
-    appearance: navbarAppearance,
     navbarId,
-    onToggle
+    open: contextOpen,
+    onToggle: onToggleContext
   } = useContext(NavbarContext) || {};
   const {
-    appearance = navbarAppearance === 'inverse' ? 'primary' : 'subtle',
+    open,
     onClick,
+    onToggle,
     ...rest
   } = props;
   const handleClick = useEventCallback(() => {
     onToggle === null || onToggle === void 0 || onToggle(true);
+    onToggleContext === null || onToggleContext === void 0 || onToggleContext(true);
   });
-  return /*#__PURE__*/React.createElement(Toggle, _extends({
+  return /*#__PURE__*/React.createElement(Burger, _extends({
     ref: ref,
-    appearance: appearance,
     onClick: createChainedFunction(handleClick, onClick),
-    "aria-controls": `${navbarId}-drawer`
+    "aria-controls": `${navbarId}-drawer`,
+    open: typeof open === 'boolean' ? open : contextOpen
   }, rest));
 });
 NavbarToggle.displayName = 'NavbarToggle';

package/esm/Notification/Notification.js

@@ -5,9 +5,8 @@ import useDelayedClosure from "../toaster/hooks/useDelayedClosure.js";
 import CloseButton from "../internals/CloseButton/index.js";
 import Box from "../internals/Box/index.js";
 import { MESSAGE_STATUS_ICONS } from "../internals/constants/statusIcons.js";
-import { useStyles, useIsMounted, useEventCallback } from "../internals/hooks/index.js";
+import { useStyles, useCustom, useIsMounted, useEventCallback } from "../internals/hooks/index.js";
 import { forwardRef, mergeRefs } from "../internals/utils/index.js";
-import { useCustom } from "../CustomProvider/index.js";
 /**
  * The `Notification` component is used to display global messages and notifications.
  *

package/{cjs/InputNumber/InputNumber.d.ts → esm/NumberInput/NumberInput.d.ts}

@@ -1,7 +1,7 @@
 import React from 'react';
 import { BoxProps } from '../internals/Box';
-import type { SanitizedInputProps, FormControlBaseProps, AppearanceType, Size } from '../internals/types';
-export interface InputNumberProps<T = number | string | null> extends Omit<SanitizedInputProps, 'value' | 'defaultValue' | 'prefix'>, BoxProps, FormControlBaseProps<T> {
+import type { SanitizedInputProps, FormControlBaseProps, AppearanceType, BasicSize } from '../internals/types';
+export interface NumberInputProps<T = number | string | null> extends Omit<SanitizedInputProps, 'value' | 'defaultValue' | 'prefix'>, BoxProps, FormControlBaseProps<T> {
     /**
      * Button can have different appearances
      */
@@ -41,27 +41,39 @@ export interface InputNumberProps<T = number | string | null> extends Omit<Sanit
     prefix?: React.ReactNode;
     /**
      * Sets the element displayed on the right side of the component
+     * @deprecated Use `suffix` instead.
      */
     postfix?: React.ReactNode;
+    /**
+     * Sets the element displayed on the right side of the component
+     */
+    suffix?: React.ReactNode;
     /**
      * An Input can have different sizes
      */
-    size?: Size;
+    size?: BasicSize;
     /**
      * Whether the value can be changed through the wheel event
      */
     scrollable?: boolean;
+    /**
+     * Show or hide control icons:
+     * - `true` (default): show default up/down buttons.
+     * - `false`: hide controls.
+     * - `(trigger) => ReactNode`: fully custom control per trigger ('up' | 'down').
+     */
+    controls?: boolean | ((trigger: 'up' | 'down') => React.ReactNode);
     /**
      * Callback function when wheel event is triggered
      */
     onWheel?: (event: React.WheelEvent) => void;
 }
 /**
- * The `InputNumber` component is used to enter a numerical value.
- * @see https://rsuitejs.com/components/input-number
+ * The `NumberInput` component is used to enter a numerical value.
+ * @see https://rsuitejs.com/components/number-input
  */
-declare const InputNumber: import("../internals/types").InternalRefForwardingComponent<import("../internals/types").InternalRefForwardingComponent<"div", import("../InputGroup/InputGroup").InputGroupProps, never> & {
+declare const NumberInput: import("../internals/types").InternalRefForwardingComponent<import("../internals/types").InternalRefForwardingComponent<"div", import("../InputGroup/InputGroup").InputGroupProps, never> & {
     Addon: import("../internals/types").InternalRefForwardingComponent<"span", import("../InputGroup/InputGroupAddon").InputGroupAddonProps, never> & Record<string, never>;
     Button: React.ForwardRefExoticComponent<import("../Button").ButtonProps & React.RefAttributes<any>>;
-}, InputNumberProps<string | number | null>, never> & Record<string, never>;
-export default InputNumber;
+}, NumberInputProps<string | number | null>, never> & Record<string, never>;
+export default NumberInput;

package/esm/NumberInput/NumberInput.js

@@ -0,0 +1,157 @@
+'use client';
+import _extends from "@babel/runtime/helpers/esm/extends";
+import React from 'react';
+import ArrowUpLineIcon from '@rsuite/icons/ArrowUpLine';
+import ArrowDownLineIcon from '@rsuite/icons/ArrowDownLine';
+import InputGroup from "../InputGroup/InputGroup.js";
+import InputGroupAddon from "../InputGroup/InputGroupAddon.js";
+import Input from "../Input/index.js";
+import Button from "../Button/index.js";
+import { useStyles, useCustom, useControlled, useEventCallback } from "../internals/hooks/index.js";
+import { forwardRef, partitionHTMLProps, createChainedFunction } from "../internals/utils/index.js";
+import { useNumberInputValue } from "./hooks/useNumberInputValue.js";
+import { useEvents } from "./hooks/useEvents.js";
+import { valueReachesMax, valueReachesMin } from "./utils/number.js";
+/**
+ * The `NumberInput` component is used to enter a numerical value.
+ * @see https://rsuitejs.com/components/number-input
+ */
+const NumberInput = forwardRef((props, ref) => {
+  const {
+    propsWithDefaults
+  } = useCustom('NumberInput', props);
+  const {
+    as,
+    className,
+    classPrefix = 'number-input',
+    controls = true,
+    disabled,
+    decimalSeparator,
+    formatter,
+    readOnly,
+    plaintext,
+    value: valueProp,
+    defaultValue,
+    size,
+    prefix: prefixElement,
+    postfix,
+    suffix = postfix,
+    step = 1,
+    buttonAppearance = 'subtle',
+    min: minProp,
+    max: maxProp,
+    scrollable = true,
+    onChange,
+    onWheel,
+    onBlur: onBlurProp,
+    onFocus: onFocusProp,
+    ...rest
+  } = propsWithDefaults;
+  const min = minProp !== null && minProp !== void 0 ? minProp : -Infinity;
+  const max = maxProp !== null && maxProp !== void 0 ? maxProp : Infinity;
+  const [value, setValue] = useControlled(valueProp, defaultValue);
+  const {
+    withPrefix,
+    merge,
+    prefix
+  } = useStyles(classPrefix);
+  const classes = merge(className, withPrefix());
+  const [htmlInputProps, restProps] = partitionHTMLProps(rest);
+  const onChangeValue = (currentValue, event) => {
+    if (currentValue !== value) {
+      setValue(currentValue);
+      onChange === null || onChange === void 0 || onChange(currentValue, event);
+    }
+  };
+  const {
+    inputRef,
+    isFocused,
+    onStepUp,
+    onStepDown,
+    onKeyDown,
+    onFocus,
+    onBlur
+  } = useEvents({
+    min: minProp,
+    max: maxProp,
+    step,
+    value,
+    scrollable,
+    disabled,
+    readOnly,
+    decimalSeparator,
+    onWheel,
+    onChangeValue
+  });
+  const handleChange = useEventCallback((value, event) => {
+    const separator = decimalSeparator || '.';
+    const escapedSeparator = separator.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
+
+    // Support both custom decimalSeparator and standard decimal point '.'
+    let regex;
+    if (separator !== '.') {
+      // Allow both the custom separator and the standard decimal point
+      regex = new RegExp(`^-?(?:\\d+)?([.${escapedSeparator}])?\\d*$`);
+    } else {
+      regex = new RegExp(`^-?(?:\\d+)?(${escapedSeparator})?\\d*$`);
+    }
+    if (!regex.test(value) && value !== '') {
+      return;
+    }
+    onChangeValue(value, event);
+  });
+  const inputValue = useNumberInputValue({
+    value,
+    isFocused,
+    formatter,
+    decimalSeparator
+  });
+  const input = /*#__PURE__*/React.createElement(Input, _extends({}, htmlInputProps, {
+    ref: plaintext ? ref : undefined,
+    inputRef: inputRef,
+    autoComplete: "off",
+    inputMode: "numeric",
+    step: step,
+    value: inputValue,
+    disabled: disabled,
+    readOnly: readOnly,
+    plaintext: plaintext,
+    onKeyDown: onKeyDown,
+    onChange: handleChange,
+    onBlur: createChainedFunction(onBlur, onBlurProp),
+    onFocus: createChainedFunction(onFocus, onFocusProp)
+  }));
+  if (plaintext) {
+    return input;
+  }
+  const stepUpDisabled = disabled || readOnly || valueReachesMax(value, max);
+  const stepDownDisabled = disabled || readOnly || valueReachesMin(value, min);
+  return /*#__PURE__*/React.createElement(InputGroup, _extends({
+    as: as,
+    ref: ref,
+    className: classes,
+    disabled: disabled,
+    size: size,
+    inside: true
+  }, restProps), prefixElement && /*#__PURE__*/React.createElement(InputGroupAddon, null, prefixElement), input, suffix && /*#__PURE__*/React.createElement(InputGroupAddon, null, suffix), controls && /*#__PURE__*/React.createElement("span", {
+    className: prefix('btn-group-vertical')
+  }, /*#__PURE__*/React.createElement(Button, {
+    tabIndex: -1,
+    appearance: buttonAppearance,
+    className: prefix('touchspin-up'),
+    onClick: onStepUp,
+    disabled: stepUpDisabled,
+    "aria-label": "Increment",
+    size: size
+  }, typeof controls === 'function' ? controls('up') : /*#__PURE__*/React.createElement(ArrowUpLineIcon, null)), /*#__PURE__*/React.createElement(Button, {
+    tabIndex: -1,
+    appearance: buttonAppearance,
+    className: prefix('touchspin-down'),
+    onClick: onStepDown,
+    disabled: stepDownDisabled,
+    "aria-label": "Decrement",
+    size: size
+  }, typeof controls === 'function' ? controls('down') : /*#__PURE__*/React.createElement(ArrowDownLineIcon, null))));
+});
+NumberInput.displayName = 'NumberInput';
+export default NumberInput;

package/esm/NumberInput/hooks/useEvents.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="react" />
+export interface UseEventsParams {
+    value?: number | string | null;
+    scrollable: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    min?: number;
+    max?: number;
+    step?: number;
+    decimalSeparator?: string;
+    onChangeValue: (currentValue: number | string, event: React.SyntheticEvent) => void;
+    onWheel?: (event: React.WheelEvent<HTMLInputElement>) => void;
+}
+export declare function useEvents(params: UseEventsParams): {
+    inputRef: import("react").RefObject<HTMLInputElement | null>;
+    isFocused: boolean;
+    onStepUp: (...args: any[]) => any;
+    onStepDown: (...args: any[]) => any;
+    onKeyDown: (...args: any[]) => any;
+    onBlur: (event: React.FocusEvent<HTMLInputElement>) => void;
+    onFocus: () => void;
+};

package/esm/NumberInput/hooks/useEvents.js

@@ -0,0 +1,110 @@
+'use client';
+import { useRef, useState, useCallback } from 'react';
+import { useEventCallback } from "../../internals/hooks/index.js";
+import { KEY_VALUES } from "../../internals/constants/index.js";
+import { clampValue, decimals } from "../utils/number.js";
+import { useWheelHandler } from "./useWheelHandler.js";
+export function useEvents(params) {
+  const inputRef = useRef(null);
+  const [isFocused, setIsFocused] = useState(false);
+  const {
+    value,
+    onChangeValue,
+    scrollable,
+    disabled,
+    readOnly,
+    onWheel: onWheelProp,
+    min,
+    max,
+    step = 1,
+    decimalSeparator
+  } = params;
+  const getSafeValue = value => clampValue(value, min, max);
+  const onStepUp = useEventCallback(event => {
+    const val = +(value || 0);
+    const bit = decimals(val, step);
+    onChangeValue(getSafeValue((val + step).toFixed(bit)), event);
+  });
+  const onStepDown = useEventCallback(event => {
+    const val = +(value || 0);
+    const bit = decimals(val, step);
+    onChangeValue(getSafeValue((val - step).toFixed(bit)), event);
+  });
+  const onKeyDown = useEventCallback(event => {
+    switch (event.key) {
+      case KEY_VALUES.UP:
+        event.preventDefault();
+        onStepUp(event);
+        break;
+      case KEY_VALUES.DOWN:
+        event.preventDefault();
+        onStepDown(event);
+        break;
+      case KEY_VALUES.HOME:
+        if (typeof min !== 'undefined') {
+          event.preventDefault();
+          onChangeValue(getSafeValue(min), event);
+        }
+        break;
+      case KEY_VALUES.END:
+        if (typeof max !== 'undefined') {
+          event.preventDefault();
+          onChangeValue(getSafeValue(max), event);
+        }
+        break;
+      default:
+        break;
+    }
+  });
+  const handleWheel = useEventCallback(event => {
+    if (!scrollable) {
+      event.preventDefault();
+      return;
+    }
+    if (!disabled && !readOnly && event.target === document.activeElement) {
+      event.preventDefault();
+      const delta = event.wheelDelta || -event.deltaY || -event.detail;
+      if (delta > 0) {
+        onStepDown(event);
+      }
+      if (delta < 0) {
+        onStepUp(event);
+      }
+    }
+    onWheelProp === null || onWheelProp === void 0 || onWheelProp(event);
+  });
+  const restoreDecimalSeparator = useCallback(value => {
+    if (decimalSeparator && value) {
+      // Handle both custom decimalSeparator and standard decimal point '.'
+      if (decimalSeparator !== '.') {
+        // Create a regex that matches both the custom separator and '.'
+        const separatorRegex = new RegExp(`[${decimalSeparator.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')}.]`, 'g');
+        return value.replace(separatorRegex, '.');
+      }
+      return value;
+    }
+    return value;
+  }, [decimalSeparator]);
+  const onBlur = event => {
+    var _event$target;
+    const value = restoreDecimalSeparator((_event$target = event.target) === null || _event$target === void 0 ? void 0 : _event$target.value);
+    const targetValue = Number.parseFloat(value);
+    onChangeValue(getSafeValue(targetValue), event);
+    setIsFocused(false);
+  };
+  const onFocus = () => {
+    setIsFocused(true);
+  };
+
+  // wheel events
+  useWheelHandler(inputRef, handleWheel, scrollable);
+  return {
+    inputRef,
+    isFocused,
+    onStepUp,
+    onStepDown,
+    onKeyDown,
+    onBlur,
+    onFocus
+  };
+}

package/esm/NumberInput/hooks/useNumberInputValue.d.ts

@@ -0,0 +1,7 @@
+export interface UseNumberInputValueParams {
+    value?: number | string | null;
+    isFocused: boolean;
+    formatter?: (value: number | string) => string;
+    decimalSeparator?: string;
+}
+export declare function useNumberInputValue(params: UseNumberInputValueParams): string | number;

package/esm/NumberInput/hooks/useNumberInputValue.js

@@ -0,0 +1,29 @@
+'use client';
+import { useMemo, useCallback } from 'react';
+import isNil from 'lodash/isNil';
+export function useNumberInputValue(params) {
+  const {
+    value,
+    isFocused,
+    formatter,
+    decimalSeparator
+  } = params;
+  const replaceDecimalSeparator = useCallback(val => {
+    if (decimalSeparator && val != null) {
+      return val.toString().replace('.', decimalSeparator);
+    }
+    return val;
+  }, [decimalSeparator]);
+  return useMemo(() => {
+    if (isNil(value)) {
+      return '';
+    }
+    if (isFocused) {
+      return replaceDecimalSeparator(value);
+    }
+    if (formatter) {
+      return formatter(value);
+    }
+    return replaceDecimalSeparator(value);
+  }, [formatter, isFocused, replaceDecimalSeparator, value]);
+}

package/esm/NumberInput/hooks/useWheelHandler.d.ts

@@ -0,0 +1,5 @@
+import { type RefObject } from 'react';
+/**
+ * Attach wheel listener to inputRef.
+ */
+export declare function useWheelHandler(inputRef: RefObject<HTMLInputElement | null>, handleWheel: (event: React.WheelEvent<HTMLInputElement>) => void, scrollable: boolean): void;

package/esm/NumberInput/hooks/useWheelHandler.js

@@ -0,0 +1,21 @@
+'use client';
+import { useEffect } from 'react';
+import on from 'dom-lib/on';
+
+/**
+ * Attach wheel listener to inputRef.
+ */
+export function useWheelHandler(inputRef, handleWheel, scrollable) {
+  useEffect(() => {
+    let wheelListener;
+    if (inputRef.current) {
+      wheelListener = on(inputRef.current, 'wheel', handleWheel, {
+        passive: false
+      });
+    }
+    return () => {
+      var _wheelListener;
+      (_wheelListener = wheelListener) === null || _wheelListener === void 0 || _wheelListener.off();
+    };
+  }, [inputRef, handleWheel, scrollable]);
+}

package/esm/NumberInput/index.d.ts

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

package/esm/NumberInput/index.js

@@ -0,0 +1,8 @@
+'use client';
+import NumberInput from "./NumberInput.js";
+
+// export types
+
+// export components
+export { NumberInput };
+export default NumberInput;

package/esm/NumberInput/utils/number.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Clamp a value within min/max and handle NaN as empty string.
+ */
+export declare function clampValue(value: number | string, min?: number, max?: number): string;
+export declare function decimals(...values: number[]): number;
+/**
+ * Disable the upper limit of the number.
+ * @param value
+ * @param max
+ */
+export declare function valueReachesMax(value: number | string | null | undefined, max: number): boolean;
+/**
+ * Disable the lower limit of the number.
+ * @param value
+ * @param min
+ */
+export declare function valueReachesMin(value: number | string | null | undefined, min: number): boolean;

package/esm/NumberInput/utils/number.js

@@ -0,0 +1,59 @@
+'use client';
+import isNil from 'lodash/isNil';
+/**
+ * Clamp a value within min/max and handle NaN as empty string.
+ */
+export function clampValue(value, min, max) {
+  const num = typeof value === 'string' ? parseFloat(value) : value;
+  if (Number.isNaN(num)) {
+    return '';
+  }
+  let result = num;
+  if (typeof max !== 'undefined' && result > max) {
+    result = max;
+  }
+  if (typeof min !== 'undefined' && result < min) {
+    result = min;
+  }
+  return result.toString();
+}
+function isNumber(value) {
+  return /(^-?|^\+?|^\d?)\d*\.\d+$/.test(value + '');
+}
+function getDecimalLength(value) {
+  if (isNumber(value)) {
+    return value.toString().split('.')[1].length;
+  }
+  return 0;
+}
+export function decimals() {
+  for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {
+    values[_key] = arguments[_key];
+  }
+  const lengths = values.map(getDecimalLength);
+  return Math.max(...lengths);
+}
+
+/**
+ * Disable the upper limit of the number.
+ * @param value
+ * @param max
+ */
+export function valueReachesMax(value, max) {
+  if (!isNil(value)) {
+    return +value >= max;
+  }
+  return false;
+}
+
+/**
+ * Disable the lower limit of the number.
+ * @param value
+ * @param min
+ */
+export function valueReachesMin(value, min) {
+  if (!isNil(value)) {
+    return +value <= min;
+  }
+  return false;
+}

package/esm/Pagination/LimitPicker.d.ts

@@ -1,12 +1,12 @@
 import { type SelectPickerProps } from '../SelectPicker';
 import { PaginationLocale } from '../locales';
-import type { OnChangeCallback, Size } from '../internals/types';
+import type { OnChangeCallback, BasicSize } from '../internals/types';
 interface LimitPickerProps extends Omit<SelectPickerProps<any>, 'locale' | 'disabled' | 'data'> {
     disabled?: boolean | ((eventKey: number | string) => boolean);
     limitOptions: number[];
     locale: PaginationLocale;
     limit: number;
-    size?: Size;
+    size?: BasicSize;
     prefix: (input: string) => string;
     onChangeLimit: OnChangeCallback<any>;
 }

package/esm/Pagination/Pagination.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import { BoxProps } from '../internals/Box';
-import type { Size } from '../internals/types';
+import type { BasicSize } from '../internals/types';
 import type { PaginationLocale } from '../locales';
 export interface PaginationProps extends BoxProps {
     /** Current page number */
@@ -30,7 +30,7 @@ export interface PaginationProps extends BoxProps {
     /** Custom locale */
     locale?: PaginationLocale;
     /** A pagination can have different sizes */
-    size?: Size;
+    size?: BasicSize;
     /** callback function for pagination clicked */
     onSelect?: (eventKey: string | number, event: React.MouseEvent) => void;
 }

package/esm/Pagination/Pagination.js

@@ -9,8 +9,7 @@ import PageEndIcon from '@rsuite/icons/PageEnd';
 import PaginationButton from "./PaginationButton.js";
 import Box from "../internals/Box/index.js";
 import { forwardRef } from "../internals/utils/index.js";
-import { useStyles } from "../internals/hooks/index.js";
-import { useCustom } from "../CustomProvider/index.js";
+import { useStyles, useCustom } from "../internals/hooks/index.js";
 const icons = {
   more: /*#__PURE__*/React.createElement(MoreIcon, null),
   first: /*#__PURE__*/React.createElement(PageTopIcon, null),

package/esm/Pagination/PaginationGroup.js

@@ -7,9 +7,8 @@ import Divider from "../Divider/index.js";
 import Input from "../Input/index.js";
 import LimitPicker from "./LimitPicker.js";
 import Box from "../internals/Box/index.js";
-import { useStyles, useControlled, useEventCallback } from "../internals/hooks/index.js";
+import { useStyles, useCustom, useControlled, useEventCallback } from "../internals/hooks/index.js";
 import { forwardRef, tplTransform } from "../internals/utils/index.js";
-import { useCustom } from "../CustomProvider/index.js";
 
 /**
  * The layout of the paging component.