rsuite 5.60.2 → 5.62.0

package/esm/internals/hooks/useFocusVirtualListItem.js

@@ -0,0 +1,22 @@
+'use client';
+import { useRef, useEffect } from 'react';
+
+/**
+ * Virtualized list loses focus when scrolling or clicking options, causing the component to re-render.
+ * To solve this problem, we need to refocus on the selected option after the component is re-rendered.
+ */
+export function useFocusVirtualListItem(focused) {
+  var itemRef = useRef(null);
+  useEffect(function () {
+    if (!focused) {
+      return;
+    }
+    if (document.activeElement !== itemRef.current) {
+      var _itemRef$current;
+      // Focus on the selected option.
+      (_itemRef$current = itemRef.current) === null || _itemRef$current === void 0 ? void 0 : _itemRef$current.focus();
+    }
+  }, [focused]);
+  return itemRef;
+}
+export default useFocusVirtualListItem;

package/esm/internals/hooks/useInternalId.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Used for generating unique ID for DOM elements
+ */
+export declare function useInternalId(namespace?: string): string;
+export default useInternalId;

package/esm/{utils → internals/hooks}/useInternalId.js

@@ -5,11 +5,12 @@ import uniqueId from 'lodash/uniqueId';
 /**
  * Used for generating unique ID for DOM elements
  */
-export default function useInternalId(namespace) {
+export function useInternalId(namespace) {
   var idRef = useRef();
   if (!idRef.current) {
     idRef.current = uniqueId("internal://" + namespace);
   }
   useDebugValue(idRef.current);
   return idRef.current;
-}
+}
+export default useInternalId;

package/esm/internals/hooks/useIsMounted.d.ts

@@ -0,0 +1,2 @@
+export declare function useIsMounted(): () => boolean;
+export default useIsMounted;

package/esm/{utils → internals/hooks}/useIsMounted.js

@@ -1,6 +1,6 @@
 'use client';
 import { useCallback, useEffect, useRef } from 'react';
-function useIsMounted() {
+export function useIsMounted() {
   var isMounted = useRef(false);
   useEffect(function () {
     isMounted.current = true;

package/{cjs/utils → esm/internals/hooks}/useIsomorphicLayoutEffect.d.ts

@@ -1,3 +1,3 @@
 import { useEffect } from 'react';
-declare const useIsomorphicLayoutEffect: typeof useEffect;
+export declare const useIsomorphicLayoutEffect: typeof useEffect;
 export default useIsomorphicLayoutEffect;

package/esm/internals/hooks/useIsomorphicLayoutEffect.js

@@ -0,0 +1,4 @@
+'use client';
+import { useEffect, useLayoutEffect } from 'react';
+export var useIsomorphicLayoutEffect = typeof window !== 'undefined' ? useLayoutEffect : useEffect;
+export default useIsomorphicLayoutEffect;

package/esm/{utils → internals/hooks}/useMap.d.ts

@@ -4,3 +4,4 @@ export declare function useMap<K, V>(): {
     set(key: K, value: V): void;
     clear(): void;
 };
+export default useMap;

package/esm/{utils → internals/hooks}/useMap.js

@@ -26,4 +26,5 @@ export function useMap() {
       }
     };
   }, [map]);
-}
+}
+export default useMap;

package/esm/internals/hooks/useMount.d.ts

@@ -0,0 +1,2 @@
+export declare const useMount: (callback: () => void) => void;
+export default useMount;

package/esm/{utils → internals/hooks}/useMount.js

@@ -1,6 +1,6 @@
 'use client';
 import { useEffect, useRef } from 'react';
-var useMount = function useMount(callback) {
+export var useMount = function useMount(callback) {
   var mountRef = useRef(callback);
   mountRef.current = callback;
   useEffect(function () {

package/{cjs/utils → esm/internals/hooks}/usePortal.d.ts

@@ -3,7 +3,7 @@ interface PortalProps {
     container?: HTMLElement | (() => HTMLElement | null) | null;
     waitMount?: boolean;
 }
-declare function usePortal(props?: PortalProps): {
+export declare function usePortal(props?: PortalProps): {
     target: HTMLElement | null;
     Portal: ((props: any) => JSX.Element) | (({ children }: {
         children: React.ReactNode;

package/esm/{utils → internals/hooks}/usePortal.js

@@ -17,7 +17,7 @@ var MountedPortal = /*#__PURE__*/React.memo(function (_ref) {
   }
   return null;
 });
-function usePortal(props) {
+export function usePortal(props) {
   if (props === void 0) {
     props = {};
   }

package/{cjs/utils → esm/internals/hooks}/useRootClose.d.ts

@@ -16,5 +16,5 @@ interface Options {
  * @param param1
  * @todo Allow different behaviors based on whether clicked element is focusable
  */
-declare function useRootClose(onRootClose: React.ReactEventHandler | undefined, { disabled, triggerTarget, overlayTarget, listenEscape }: Options): void;
+export declare function useRootClose(onRootClose: React.ReactEventHandler | undefined, { disabled, triggerTarget, overlayTarget, listenEscape }: Options): void;
 export default useRootClose;

package/esm/{utils → internals/hooks}/useRootClose.js

@@ -3,7 +3,8 @@ import { useEffect, useCallback } from 'react';
 import contains from 'dom-lib/contains';
 import ownerDocument from 'dom-lib/ownerDocument';
 import on from 'dom-lib/on';
-import { getDOMNode, KEY_VALUES } from './';
+import getDOMNode from "../utils/getDOMNode";
+import { KEY_VALUES } from "../constants";
 function isLeftClickEvent(event) {
   return (event === null || event === void 0 ? void 0 : event.button) === 0;
 }
@@ -16,7 +17,7 @@ function isModifiedEvent(event) {
  * @param param1
  * @todo Allow different behaviors based on whether clicked element is focusable
  */
-function useRootClose(onRootClose, _ref) {
+export function useRootClose(onRootClose, _ref) {
   var disabled = _ref.disabled,
     triggerTarget = _ref.triggerTarget,
     overlayTarget = _ref.overlayTarget,

package/esm/{utils → internals/hooks}/useTimeout.d.ts

@@ -8,5 +8,5 @@ export interface UseTimeoutFnReturn {
  * @param ms Milliseconds of the timer
  * @param enabled Whether to open the timer
  */
-declare function useTimeout(fn: (() => void) | undefined, ms?: number, enabled?: boolean): UseTimeoutFnReturn;
+export declare function useTimeout(fn: (() => void) | undefined, ms?: number, enabled?: boolean): UseTimeoutFnReturn;
 export default useTimeout;

package/esm/{utils → internals/hooks}/useTimeout.js

@@ -6,7 +6,7 @@ import { useEffect, useRef, useCallback } from 'react';
  * @param ms Milliseconds of the timer
  * @param enabled Whether to open the timer
  */
-function useTimeout(fn, ms, enabled) {
+export function useTimeout(fn, ms, enabled) {
   if (ms === void 0) {
     ms = 0;
   }

package/esm/internals/hooks/useToggleCaret.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { TypeAttributes } from '@/internals/types';
+export declare function useToggleCaret(placement: TypeAttributes.Placement8 | TypeAttributes.Placement): import("react").FC<import("@rsuite/icons/lib/Icon").IconProps>;
+export default useToggleCaret;

package/esm/{utils → internals/hooks}/useToggleCaret.js

@@ -4,8 +4,8 @@ import AngleDownIcon from '@rsuite/icons/legacy/AngleDown';
 import AngleUpIcon from '@rsuite/icons/legacy/AngleUp';
 import AngleLeftIcon from '@rsuite/icons/legacy/AngleLeft';
 import AngleRightIcon from '@rsuite/icons/legacy/AngleRight';
-import useCustom from './useCustom';
-function useToggleCaret(placement) {
+import useCustom from "./useCustom";
+export function useToggleCaret(placement) {
   var _useCustom = useCustom('Dropdown'),
     rtl = _useCustom.rtl;
   return useMemo(function () {

package/esm/{utils → internals/hooks}/useUniqueId.d.ts

@@ -3,4 +3,5 @@
  *
  * @param idProp If id is provided, it will be used instead of generating a new one
  */
-export default function useUniqueId(prefix: string, idProp?: string): string;
+export declare function useUniqueId(prefix: string, idProp?: string): string;
+export default useUniqueId;

package/esm/{utils → internals/hooks}/useUniqueId.js

@@ -8,7 +8,7 @@ var reactUseId = React['useId'.toString()];
  *
  * @param idProp If id is provided, it will be used instead of generating a new one
  */
-export default function useUniqueId(prefix, idProp) {
+export function useUniqueId(prefix, idProp) {
   var idRef = React.useRef();
   if (reactUseId !== undefined) {
     return idProp !== null && idProp !== void 0 ? idProp : "" + prefix + reactUseId();
@@ -17,4 +17,5 @@ export default function useUniqueId(prefix, idProp) {
     idRef.current = uniqueId(prefix);
   }
   return idProp !== null && idProp !== void 0 ? idProp : idRef.current;
-}
+}
+export default useUniqueId;

package/esm/{utils → internals/hooks}/useUpdateEffect.d.ts

@@ -1,3 +1,3 @@
 import { useEffect } from 'react';
-declare const useUpdateEffect: typeof useEffect;
+export declare const useUpdateEffect: typeof useEffect;
 export default useUpdateEffect;

package/esm/{utils → internals/hooks}/useUpdateEffect.js

@@ -1,6 +1,6 @@
 'use client';
 import { useEffect, useRef } from 'react';
-var useUpdateEffect = function useUpdateEffect(effect, deps) {
+export var useUpdateEffect = function useUpdateEffect(effect, deps) {
   var isMounting = useRef(true);
   useEffect(function () {
     if (isMounting.current) {

package/{cjs/utils → esm/internals/hooks}/useUpdatedRef.d.ts

@@ -5,4 +5,5 @@
  * @param value The Ref value
  * @category refs
  */
-export default function useUpdatedRef<T>(value: T): import("react").MutableRefObject<T>;
+export declare function useUpdatedRef<T>(value: T): import("react").MutableRefObject<T>;
+export default useUpdatedRef;

package/esm/{utils → internals/hooks}/useUpdatedRef.js

@@ -7,8 +7,9 @@ import { useRef } from 'react';
  * @param value The Ref value
  * @category refs
  */
-export default function useUpdatedRef(value) {
+export function useUpdatedRef(value) {
   var valueRef = useRef(value);
   valueRef.current = value;
   return valueRef;
-}
+}
+export default useUpdatedRef;

package/{cjs/utils → esm/internals/hooks}/useWillUnmount.d.ts

@@ -4,4 +4,5 @@
  * @param fn Handler to run when the component unmounts
  * @category effects
  */
-export default function useWillUnmount(fn: () => void): void;
+export declare function useWillUnmount(fn: () => void): void;
+export default useWillUnmount;

package/esm/{utils → internals/hooks}/useWillUnmount.js

@@ -1,5 +1,5 @@
 'use client';
-import useUpdatedRef from './useUpdatedRef';
+import useUpdatedRef from "./useUpdatedRef";
 import { useEffect } from 'react';
 
 /**
@@ -8,7 +8,7 @@ import { useEffect } from 'react';
  * @param fn Handler to run when the component unmounts
  * @category effects
  */
-export default function useWillUnmount(fn) {
+export function useWillUnmount(fn) {
   var onUnmount = useUpdatedRef(fn);
 
   // eslint-disable-next-line react-hooks/exhaustive-deps
@@ -17,4 +17,5 @@ export default function useWillUnmount(fn) {
       return onUnmount.current();
     };
   }, []);
-}
+}
+export default useWillUnmount;

package/esm/internals/propTypes/deprecatePropType.js

@@ -1,7 +1,7 @@
 'use client';
 // Ref: https://github.com/thefrontside/deprecated-prop-type/blob/master/deprecated.js
 
-import warnOnce from '../../utils/warnOnce';
+import { warnOnce } from "../utils";
 
 /**
  * Prints deprecation message when user uses a deprecated prop

package/esm/internals/propTypes/index.js

@@ -1,7 +1,7 @@
 'use client';
 import PropTypes from 'prop-types';
-export { default as oneOf } from './oneOf';
-export { default as deprecatePropType, deprecatePropTypeNew } from './deprecatePropType';
+export { default as oneOf } from "./oneOf";
+export { default as deprecatePropType, deprecatePropTypeNew } from "./deprecatePropType";
 export function tupleType() {
   for (var _len = arguments.length, typeCheckers = new Array(_len), _key = 0; _key < _len; _key++) {
     typeCheckers[_key] = arguments[_key];

package/esm/{@types/common.d.ts → internals/types/index.d.ts}

@@ -88,6 +88,29 @@ export interface PickerBaseProps<L = any> extends WithAsProps, AnimationEventPro
     /** Custom render extra footer */
     renderExtraFooter?: () => React.ReactNode;
 }
+export interface DeprecatedPickerProps {
+    /**
+     * Custom menu class name
+     * @deprecated Use `popupClassName` instead
+     */
+    menuClassName?: string;
+    /**
+     * Custom menu style
+     * @deprecated Use `popupStyle` instead
+     */
+    menuStyle?: React.CSSProperties;
+    /**
+     * Picker menu auto width
+     *
+     * @deprecated Use `popupAutoWidth` instead
+     */
+    menuAutoWidth?: boolean;
+    /**
+     * Custom render tree
+     * @deprecated Use `renderTree` instead
+     */
+    renderMenu?: (menu: React.ReactNode) => React.ReactNode;
+}
 export interface FormControlBaseProps<ValueType = React.InputHTMLAttributes<HTMLInputElement>['value']> {
     /** Name of the form field */
     name?: string;
@@ -109,14 +132,28 @@ export interface FormControlBaseProps<ValueType = React.InputHTMLAttributes<HTML
     readOnly?: boolean;
 }
 export declare type ToArray<V> = V extends any[] ? V : V[];
+/**
+ * Represents the data properties for a component.
+ */
 export interface DataProps<TData> {
-    /** The data of component */
+    /**
+     * The data of the component.
+     */
     data: TData[];
-    /** Set option value 'key' in 'data' */
+    /**
+     * The key to use for setting the option value in the data.
+     * @default value
+     */
     valueKey?: string;
-    /** Set options to display the 'key' in 'data' */
+    /**
+     * The key to use for displaying the options in the data.
+     * @default label
+     */
     labelKey?: string;
-    /** Set children key in data */
+    /**
+     * The key to use for setting the children in the data.
+     * @default children
+     */
     childrenKey?: string;
 }
 export interface FormControlPickerProps<T = any, L = any, D = Record<string, any>, I = T> extends PickerBaseProps<L>, FormControlBaseProps<T>, DataProps<D> {

package/esm/internals/types/index.js

@@ -0,0 +1 @@
+'use client';

package/esm/{@types → internals/types}/utils.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="react" />
-export declare const tuple: <T extends string[]>(...args: T) => T;
 export declare type Partial<T> = {
     [P in keyof T]?: T[P];
 };

package/esm/internals/types/utils.js

@@ -0,0 +1 @@
+'use client';

package/esm/internals/utils/ReactChildren.d.ts

@@ -0,0 +1,65 @@
+import React from 'react';
+/**
+ * Finds the first child that satisfies the given condition.
+ * @param children - The children to search.
+ * @param func - The condition function.
+ * @param context - The context to use for the condition function.
+ * @returns The first child that satisfies the condition, or undefined if no child is found.
+ */
+export declare function find(children: React.ReactNode, func: any, context?: any): React.ReactNode;
+/**
+ * Maps over the children and applies the given function to each child.
+ * @param children - The children to map over.
+ * @param func - The function to apply to each child.
+ * @param context - The context to use for the function.
+ * @returns An array of the results of applying the function to each child.
+ */
+export declare function map(children: React.ReactNode, func: any, context?: any): any[];
+/**
+ * Maps over the children and clones each child element with the provided props.
+ * @param children - The children to clone and map over.
+ * @param func - The function to apply to each child element.
+ * @param context - The context to use for the function.
+ * @returns An array of the cloned and modified child elements.
+ */
+export declare function mapCloneElement(children: React.ReactNode, func: any, context?: any): any[];
+/**
+ * Returns the number of children.
+ * @param children - The children to count.
+ * @returns The number of children.
+ */
+export declare function count(children: React.ReactNode): number;
+/**
+ * Checks if any child satisfies the given condition.
+ * @param children - The children to check.
+ * @param func - The condition function.
+ * @param context - The context to use for the condition function.
+ * @returns True if any child satisfies the condition, false otherwise.
+ */
+declare function some(children: React.ReactNode, func: any, context?: any): boolean;
+/**
+ * Utility functions for working with React children.
+ */
+export declare const ReactChildren: {
+    /**
+     * Maps over the children and clones each child element with the provided props.
+     */
+    mapCloneElement: typeof mapCloneElement;
+    /**
+     * Returns the number of children.
+     */
+    count: typeof count;
+    /**
+     * Checks if any child satisfies the given condition.
+     */
+    some: typeof some;
+    /**
+     * Maps over the children and applies the given function to each child.
+     */
+    map: typeof map;
+    /**
+     * Finds the first child that satisfies the given condition.
+     */
+    find: typeof find;
+};
+export default ReactChildren;

package/esm/internals/utils/ReactChildren.js

@@ -0,0 +1,156 @@
+'use client';
+import _extends from "@babel/runtime/helpers/esm/extends";
+import React from 'react';
+
+/**
+ * Returns the type of the given object.
+ * @param object - The object to check.
+ * @returns The type of the object.
+ */
+function typeOf(object) {
+  if (typeof object === 'object' && object !== null) {
+    return object.type || object.$$typeof;
+  }
+}
+
+/**
+ * Checks if the given children is a React fragment.
+ * @param children - The children to check.
+ * @returns True if the children is a React fragment, false otherwise.
+ */
+function isFragment(children) {
+  return React.Children.count(children) === 1 && typeOf(children) === Symbol.for('react.fragment');
+}
+
+/**
+ * Flattens the given children into an array.
+ * @param children - The children to flatten.
+ * @returns The flattened array of children.
+ */
+function flatChildren(children) {
+  return React.Children.toArray(React.Children.map(children, function (child) {
+    if (isFragment(child)) {
+      var _child$props;
+      return React.Children.toArray(((_child$props = child.props) === null || _child$props === void 0 ? void 0 : _child$props.children) || []);
+    }
+    return child;
+  }));
+}
+
+/**
+ * Finds the first child that satisfies the given condition.
+ * @param children - The children to search.
+ * @param func - The condition function.
+ * @param context - The context to use for the condition function.
+ * @returns The first child that satisfies the condition, or undefined if no child is found.
+ */
+export function find(children, func, context) {
+  var index = 0;
+  var result;
+  React.Children.forEach(flatChildren(children), function (child) {
+    if (result) {
+      return;
+    }
+    index += 1;
+    if (func.call(context, child, index)) {
+      result = child;
+    }
+  });
+  return result;
+}
+
+/**
+ * Maps over the children and applies the given function to each child.
+ * @param children - The children to map over.
+ * @param func - The function to apply to each child.
+ * @param context - The context to use for the function.
+ * @returns An array of the results of applying the function to each child.
+ */
+export function map(children, func, context) {
+  var index = 0;
+  return React.Children.map(flatChildren(children), function (child) {
+    if (! /*#__PURE__*/React.isValidElement(child)) {
+      return child;
+    }
+    var handle = func.call(context, child, index);
+    index += 1;
+    return handle;
+  });
+}
+
+/**
+ * Maps over the children and clones each child element with the provided props.
+ * @param children - The children to clone and map over.
+ * @param func - The function to apply to each child element.
+ * @param context - The context to use for the function.
+ * @returns An array of the cloned and modified child elements.
+ */
+export function mapCloneElement(children, func, context) {
+  return map(children, function (child, index) {
+    return /*#__PURE__*/React.cloneElement(child, _extends({
+      key: index
+    }, func(child, index)));
+  }, context);
+}
+
+/**
+ * Returns the number of children.
+ * @param children - The children to count.
+ * @returns The number of children.
+ */
+export function count(children) {
+  return React.Children.count(flatChildren(children));
+}
+
+/**
+ * Checks if any child satisfies the given condition.
+ * @param children - The children to check.
+ * @param func - The condition function.
+ * @param context - The context to use for the condition function.
+ * @returns True if any child satisfies the condition, false otherwise.
+ */
+function some(children, func, context) {
+  var index = 0;
+  var result = false;
+  React.Children.forEach(flatChildren(children), function (child) {
+    if (result) {
+      return;
+    }
+    if (! /*#__PURE__*/React.isValidElement(child)) {
+      return;
+    }
+
+    /* eslint-disable */
+    if (func.call(context, child, index += 1)) {
+      result = true;
+    }
+  });
+  return result;
+}
+
+/**
+ * Utility functions for working with React children.
+ */
+export var ReactChildren = {
+  /**
+   * Maps over the children and clones each child element with the provided props.
+   */
+  mapCloneElement: mapCloneElement,
+  /**
+   * Returns the number of children.
+   */
+  count: count,
+  /**
+   * Checks if any child satisfies the given condition.
+   */
+  some: some,
+  /**
+   * Maps over the children and applies the given function to each child.
+   */
+  map: map,
+  /**
+   * Finds the first child that satisfies the given condition.
+   */
+  find: find
+};
+export default ReactChildren;

package/esm/internals/utils/attachParent.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Attaches a parent object to the given data object.
+ */
+export declare function attachParent<T>(data: T, parent: T): T;
+export default attachParent;

package/esm/{utils → internals/utils}/attachParent.js

@@ -1,4 +1,7 @@
 'use client';
+/**
+ * Attaches a parent object to the given data object.
+ */
 export function attachParent(data, parent) {
   // mark "parent" unenumable
   Object.defineProperty(data, 'parent', {
@@ -8,4 +11,5 @@ export function attachParent(data, parent) {
     configurable: true
   });
   return data;
-}
+}
+export default attachParent;

package/esm/internals/utils/composeFunctions.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Composes multiple functions into a single function.
+ *
+ * @example
+ * ```
+ * const a = () => console.log('a');
+ * const b = () => console.log('b');
+ * const c = () => console.log('c');
+ *
+ * const d = composeFunctions(a, b, c);
+ *
+ * d(); // a b c
+ * ```
+ */
+export declare function composeFunctions(...fns: any[]): (first: any) => any;
+export default composeFunctions;

package/esm/internals/utils/composeFunctions.js

@@ -0,0 +1,26 @@
+'use client';
+/**
+ * Composes multiple functions into a single function.
+ *
+ * @example
+ * ```
+ * const a = () => console.log('a');
+ * const b = () => console.log('b');
+ * const c = () => console.log('c');
+ *
+ * const d = composeFunctions(a, b, c);
+ *
+ * d(); // a b c
+ * ```
+ */
+export function composeFunctions() {
+  for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {
+    fns[_key] = arguments[_key];
+  }
+  return function (first) {
+    return fns.reduce(function (previousValue, fn) {
+      return fn(previousValue);
+    }, first);
+  };
+}
+export default composeFunctions;