rsuite 5.60.2 → 5.62.0

package/esm/internals/Tree/types.d.ts

@@ -0,0 +1,69 @@
+/// <reference types="react" />
+import type { CheckStateType } from '@/internals/constants';
+/**
+ * Represents a single node in a tree.
+ */
+export interface TreeNode extends Record<string, any> {
+    /**
+     * Specifies whether the node is uncheckable.
+     */
+    uncheckable?: boolean;
+    /**
+     * The reference key of the node.
+     */
+    refKey?: string;
+    /**
+     * Specifies whether the node is checked.
+     */
+    check?: boolean;
+    /**
+     * The parent node of the current node.
+     */
+    parent?: TreeNode;
+    /**
+     * Specifies whether all child nodes are checked.
+     */
+    checkAll?: boolean;
+    /**
+     * Specifies whether the node is visible.
+     */
+    visible?: boolean;
+    /**
+     * Specifies whether the node is expanded.
+     */
+    expand?: boolean;
+    /**
+     * The layer of the node in the tree hierarchy.
+     */
+    layer?: number;
+    /**
+     * The label of the node.
+     */
+    label?: string | React.ReactNode;
+    /**
+     * The value of the node.
+     */
+    value?: string | number;
+    /**
+     * The property to group nodes by.
+     */
+    groupBy?: string;
+    /**
+     * The child nodes of the current node.
+     */
+    children?: TreeNode[];
+    /**
+     * Specifies whether the node has children.
+     */
+    hasChildren?: boolean;
+    /**
+     * The check state of the node.
+     */
+    checkState?: CheckStateType;
+}
+/**
+ * Represents a map of tree nodes.
+ */
+export interface TreeNodeMap {
+    [key: string]: TreeNode;
+}

package/esm/internals/Tree/utils/filterNodesOfTree.d.ts

@@ -0,0 +1,5 @@
+declare type HasChildren<T extends Record<string, unknown>> = T & {
+    children?: readonly HasChildren<T>[];
+};
+export declare function filterNodesOfTree<TItem extends HasChildren<Record<string, unknown>>>(data: readonly TItem[], check: (item: TItem) => boolean): TItem[];
+export {};

package/esm/internals/Tree/utils/filterNodesOfTree.js

@@ -0,0 +1,26 @@
+'use client';
+import clone from 'lodash/clone';
+export function filterNodesOfTree(data, check) {
+  var findNodes = function findNodes(nodes) {
+    if (nodes === void 0) {
+      nodes = [];
+    }
+    var nextNodes = [];
+    for (var i = 0; i < nodes.length; i += 1) {
+      if (Array.isArray(nodes[i].children)) {
+        var nextChildren = findNodes(nodes[i].children);
+        if (nextChildren.length) {
+          var _item = clone(nodes[i]);
+          _item.children = nextChildren;
+          nextNodes.push(_item);
+          continue;
+        }
+      }
+      if (check(nodes[i])) {
+        nextNodes.push(nodes[i]);
+      }
+    }
+    return nextNodes;
+  };
+  return findNodes(data);
+}

package/esm/internals/Tree/utils/findNodeOfTree.d.ts

@@ -0,0 +1 @@
+export declare function findNodeOfTree(data: any, check: any): any;

package/esm/internals/Tree/utils/findNodeOfTree.js

@@ -0,0 +1,22 @@
+'use client';
+export function findNodeOfTree(data, check) {
+  var findNode = function findNode(nodes) {
+    if (nodes === void 0) {
+      nodes = [];
+    }
+    for (var i = 0; i < nodes.length; i += 1) {
+      var item = nodes[i];
+      if (Array.isArray(item.children)) {
+        var node = findNode(item.children);
+        if (node) {
+          return node;
+        }
+      }
+      if (check(item)) {
+        return item;
+      }
+    }
+    return undefined;
+  };
+  return findNode(data);
+}

package/esm/internals/Tree/utils/getParentMap.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+/**
+ * Returns a WeakMap that maps each item in `items` to its parent
+ * indicated by `getChildren` function
+ */
+export declare function getParentMap<T extends Record<string, unknown>>(items: readonly T[], getChildren: (item: T) => readonly T[] | undefined): WeakMap<T, T>;
+/**
+ * Returns a Map that maps each item's "key", indicated by `getKey` function,
+ * to its parent indicated by `getChildren` function
+ *
+ * NOTICE:
+ * Using this function is discouraged.
+ * Use {@link getParentMap} whenever possible.
+ */
+export declare function getKeyParentMap<T = Record<string, unknown>, K = React.Key>(items: readonly T[], getKey: (item: T) => K, getChildren: (item: T) => readonly T[] | undefined): Map<K, T>;

package/esm/internals/Tree/utils/getParentMap.js

@@ -0,0 +1,47 @@
+'use client';
+function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+/**
+ * Returns a WeakMap that maps each item in `items` to its parent
+ * indicated by `getChildren` function
+ */
+export function getParentMap(items, getChildren) {
+  var map = new WeakMap();
+  for (var queue = [].concat(items); queue.length > 0;) {
+    var _item = queue.shift();
+    var children = getChildren(_item);
+    if (children) {
+      for (var _iterator = _createForOfIteratorHelperLoose(children), _step; !(_step = _iterator()).done;) {
+        var child = _step.value;
+        map.set(child, _item);
+        queue.push(child);
+      }
+    }
+  }
+  return map;
+}
+
+/**
+ * Returns a Map that maps each item's "key", indicated by `getKey` function,
+ * to its parent indicated by `getChildren` function
+ *
+ * NOTICE:
+ * Using this function is discouraged.
+ * Use {@link getParentMap} whenever possible.
+ */
+export function getKeyParentMap(items, getKey, getChildren) {
+  var map = new Map();
+  for (var queue = [].concat(items); queue.length > 0;) {
+    var _item2 = queue.shift();
+    var children = getChildren(_item2);
+    if (children) {
+      for (var _iterator2 = _createForOfIteratorHelperLoose(children), _step2; !(_step2 = _iterator2()).done;) {
+        var child = _step2.value;
+        map.set(getKey(child), _item2);
+        queue.push(child);
+      }
+    }
+  }
+  return map;
+}

package/esm/internals/Tree/utils/getPathTowardsItem.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Returns an array indicating the hierarchy path from root towards `target` item
+ */
+export declare function getPathTowardsItem<T>(target: T | undefined, getParent: (item: T) => T | undefined): T[];

package/esm/internals/Tree/utils/getPathTowardsItem.js

@@ -0,0 +1,12 @@
+'use client';
+/**
+ * Returns an array indicating the hierarchy path from root towards `target` item
+ */
+export function getPathTowardsItem(target, getParent) {
+  if (!target) return [];
+  var path = [target];
+  for (var parent = getParent(target); !!parent; parent = getParent(parent)) {
+    path.unshift(parent);
+  }
+  return path;
+}

package/esm/internals/Tree/utils/index.d.ts

@@ -0,0 +1,4 @@
+export { findNodeOfTree } from './findNodeOfTree';
+export { filterNodesOfTree } from './filterNodesOfTree';
+export { getPathTowardsItem } from './getPathTowardsItem';
+export { getParentMap, getKeyParentMap } from './getParentMap';

package/esm/internals/Tree/utils/index.js

@@ -0,0 +1,5 @@
+'use client';
+export { findNodeOfTree } from "./findNodeOfTree";
+export { filterNodesOfTree } from "./filterNodesOfTree";
+export { getPathTowardsItem } from "./getPathTowardsItem";
+export { getParentMap, getKeyParentMap } from "./getParentMap";

package/esm/internals/Windowing/AutoSizer.js

@@ -4,7 +4,8 @@ import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWith
 import React, { useState, useRef } from 'react';
 import { useCallback } from 'react';
 import getStyle from 'dom-lib/getStyle';
-import { mergeRefs, useElementResize, useMount } from '../../utils';
+import { useElementResize, useMount } from "../hooks";
+import { mergeRefs } from "../utils";
 /**
  * High-order component that automatically adjusts the width and height of a single child.
  *

package/esm/internals/Windowing/List.d.ts

@@ -1,5 +1,6 @@
 import { VariableSizeList, ListItemKeySelector, ListOnScrollProps, ListOnItemsRenderedProps } from 'react-window';
-import { WithAsProps, RsRefForwardingComponent } from '../../@types/common';
+import { WithAsProps, RsRefForwardingComponent } from '@/internals/types';
+export declare const defaultItemSize: () => number;
 export interface ListProps<T = any> extends WithAsProps {
     /**
      * @deprecated use itemSize instead
@@ -16,6 +17,10 @@ export interface ListProps<T = any> extends WithAsProps {
      * Scroll offset for initial render.
      */
     initialScrollOffset?: number;
+    /**
+     * The shadow of the content when scrolling
+     */
+    scrollShadow?: boolean;
     /**
      * By default, lists will use an item's index as its key. This is okay if:
      *

package/esm/internals/Windowing/List.js

@@ -1,9 +1,20 @@
 'use client';
-import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _extends from "@babel/runtime/helpers/esm/extends";
 import React, { useRef, useImperativeHandle, useCallback, useMemo } from 'react';
 import { VariableSizeList } from 'react-window';
-import { useCustom } from '../../utils';
+import { useCustom } from "../hooks";
+import ScrollView from "../ScrollView";
+export var defaultItemSize = function defaultItemSize() {
+  return 36;
+};
+var OuterElementType = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  return /*#__PURE__*/React.createElement(ScrollView, _extends({
+    scrollShadow: true,
+    ref: ref
+  }, props));
+});
+
 /**
  * This component renders a virtualized list of elements with either fixed or dynamic heights.
  *
@@ -14,7 +25,8 @@ var List = /*#__PURE__*/React.forwardRef(function (props, ref) {
     _props$as = props.as,
     Component = _props$as === void 0 ? VariableSizeList : _props$as,
     itemSizeProp = props.itemSize,
-    rest = _objectWithoutPropertiesLoose(props, ["rowHeight", "as", "itemSize"]);
+    scrollShadow = props.scrollShadow,
+    rest = _objectWithoutPropertiesLoose(props, ["rowHeight", "as", "itemSize", "scrollShadow"]);
   var listRef = useRef(null);
   var _useCustom = useCustom(),
     rtl = _useCustom.rtl;
@@ -58,6 +70,8 @@ var List = /*#__PURE__*/React.forwardRef(function (props, ref) {
   return /*#__PURE__*/React.createElement(Component, _extends({
     ref: listRef,
     direction: rtl ? 'rtl' : 'ltr'
-  }, compatibleProps));
+  }, compatibleProps, {
+    outerElementType: scrollShadow ? OuterElementType : undefined
+  }));
 });
 export default List;

package/esm/internals/Windowing/index.d.ts

@@ -1,5 +1,5 @@
 export { default as AutoSizer } from './AutoSizer';
-export { default as List } from './List';
+export { default as List, defaultItemSize } from './List';
 export { FixedSizeList, VariableSizeList } from 'react-window';
 export type { ListChildComponentProps } from 'react-window';
 export type { ListProps, ListHandle } from './List';

package/esm/internals/Windowing/index.js

@@ -1,4 +1,4 @@
 'use client';
-export { default as AutoSizer } from './AutoSizer';
-export { default as List } from './List';
+export { default as AutoSizer } from "./AutoSizer";
+export { default as List, defaultItemSize } from "./List";
 export { FixedSizeList, VariableSizeList } from 'react-window';

package/{cjs/utils/constants.d.ts → esm/internals/constants/index.d.ts}

@@ -15,8 +15,6 @@ export declare enum CHECK_STATE {
     INDETERMINATE = 2
 }
 export declare type CheckStateType = CHECK_STATE.UNCHECK | CHECK_STATE.CHECK | CHECK_STATE.INDETERMINATE;
-export declare const TREE_NODE_PADDING = 16;
-export declare const TREE_NODE_ROOT_PADDING = 12;
 /**
  * Tree Node Drag Type
  */

package/esm/{utils/constants.js → internals/constants/index.js}

@@ -17,9 +17,6 @@ export var CHECK_STATE;
   CHECK_STATE[CHECK_STATE["CHECK"] = 1] = "CHECK";
   CHECK_STATE[CHECK_STATE["INDETERMINATE"] = 2] = "INDETERMINATE";
 })(CHECK_STATE || (CHECK_STATE = {}));
-export var TREE_NODE_PADDING = 16;
-export var TREE_NODE_ROOT_PADDING = 12;
-
 /**
  * Tree Node Drag Type
  */

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

@@ -0,0 +1,23 @@
+export { useClassNames } from './useClassNames';
+export { useClickOutside } from './useClickOutside';
+export { useControlled } from './useControlled';
+export { useCustom } from './useCustom';
+export { useElementResize } from './useElementResize';
+export { useEnsuredRef } from './useEnsuredRef';
+export { useEventCallback } from './useEventCallback';
+export { useEventListener } from './useEventListener';
+export { useFocus } from './useFocus';
+export { useFocusVirtualListItem } from './useFocusVirtualListItem';
+export { useInternalId } from './useInternalId';
+export { useIsMounted } from './useIsMounted';
+export { useIsomorphicLayoutEffect } from './useIsomorphicLayoutEffect';
+export { useMap } from './useMap';
+export { useMount } from './useMount';
+export { usePortal } from './usePortal';
+export { useRootClose } from './useRootClose';
+export { useTimeout } from './useTimeout';
+export { useToggleCaret } from './useToggleCaret';
+export { useUniqueId } from './useUniqueId';
+export { useUpdatedRef } from './useUpdatedRef';
+export { useUpdateEffect } from './useUpdateEffect';
+export { useWillUnmount } from './useWillUnmount';

package/esm/internals/hooks/index.js

@@ -0,0 +1,24 @@
+'use client';
+export { useClassNames } from "./useClassNames";
+export { useClickOutside } from "./useClickOutside";
+export { useControlled } from "./useControlled";
+export { useCustom } from "./useCustom";
+export { useElementResize } from "./useElementResize";
+export { useEnsuredRef } from "./useEnsuredRef";
+export { useEventCallback } from "./useEventCallback";
+export { useEventListener } from "./useEventListener";
+export { useFocus } from "./useFocus";
+export { useFocusVirtualListItem } from "./useFocusVirtualListItem";
+export { useInternalId } from "./useInternalId";
+export { useIsMounted } from "./useIsMounted";
+export { useIsomorphicLayoutEffect } from "./useIsomorphicLayoutEffect";
+export { useMap } from "./useMap";
+export { useMount } from "./useMount";
+export { usePortal } from "./usePortal";
+export { useRootClose } from "./useRootClose";
+export { useTimeout } from "./useTimeout";
+export { useToggleCaret } from "./useToggleCaret";
+export { useUniqueId } from "./useUniqueId";
+export { useUpdatedRef } from "./useUpdatedRef";
+export { useUpdateEffect } from "./useUpdateEffect";
+export { useWillUnmount } from "./useWillUnmount";

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

@@ -16,7 +16,7 @@ export interface ClassDictionary {
  *  - prefix: Add a prefix to className
  *  - rootPrefix
  */
-declare function useClassNames(str: string): {
+export declare function useClassNames(str: string): {
     withClassPrefix: (...classes: ClassValue[]) => string;
     merge: typeof classNames;
     prefix: (...classes: ClassValue[]) => string;

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

@@ -1,8 +1,8 @@
 'use client';
 import { useCallback, useContext } from 'react';
 import classNames from 'classnames';
-import { prefix as addPrefix } from './prefix';
-import { CustomContext } from '../CustomProvider/CustomProvider';
+import { prefix as addPrefix } from "../utils/prefix";
+import { CustomContext } from "../../CustomProvider/CustomProvider";
 
 // This is the only way I found to break circular references between ClassArray and ClassValue
 // https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
@@ -18,7 +18,7 @@ import { CustomContext } from '../CustomProvider/CustomProvider';
  *  - prefix: Add a prefix to className
  *  - rootPrefix
  */
-function useClassNames(str) {
+export function useClassNames(str) {
   var _ref = useContext(CustomContext) || {},
     _ref$classPrefix = _ref.classPrefix,
     classPrefix = _ref$classPrefix === void 0 ? 'rs' : _ref$classPrefix;

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

@@ -3,4 +3,5 @@ export interface UseClickOutsideOptions {
     isOutside: (event: MouseEvent) => boolean;
     handle: (event: MouseEvent) => void;
 }
-export default function useClickOutside({ enabled, isOutside, handle }: UseClickOutsideOptions): void;
+export declare function useClickOutside({ enabled, isOutside, handle }: UseClickOutsideOptions): void;
+export default useClickOutside;

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

@@ -1,6 +1,6 @@
 'use client';
 import { useEffect, useRef } from 'react';
-export default function useClickOutside(_ref) {
+export function useClickOutside(_ref) {
   var _ref$enabled = _ref.enabled,
     enabled = _ref$enabled === void 0 ? true : _ref$enabled,
     isOutside = _ref.isOutside,
@@ -26,4 +26,5 @@ export default function useClickOutside(_ref) {
       };
     }
   }, [enabled]);
-}
+}
+export default useClickOutside;

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

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 declare type InferDefined<T> = T extends infer U | undefined ? U : never;
 /**
  * A hook for controlled value management.
@@ -8,9 +7,5 @@ declare type InferDefined<T> = T extends infer U | undefined ? U : never;
  * @param defaultValue
  * @param formatValue
  */
-declare function useControlled<V = any, D = V>(controlledValue: V, defaultValue: D): [
-    V extends undefined ? D : InferDefined<V>,
-    (value: React.SetStateAction<V | null>) => void,
-    boolean
-];
+export declare function useControlled<V = any, D = V>(controlledValue: V, defaultValue: D): [V extends undefined ? D : InferDefined<V>, (value: React.SetStateAction<V | null>) => void, boolean];
 export default useControlled;

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

@@ -1,6 +1,5 @@
 'use client';
 import { useRef, useState, useCallback } from 'react';
-
 /**
  * A hook for controlled value management.
  * In the case of passing the controlled value, the controlled value is returned, otherwise the value in state is returned.
@@ -10,7 +9,7 @@ import { useRef, useState, useCallback } from 'react';
  * @param formatValue
  */
 
-function useControlled(controlledValue, defaultValue) {
+export function useControlled(controlledValue, defaultValue) {
   var controlledRef = useRef(false);
   controlledRef.current = controlledValue !== undefined;
   var _useState = useState(defaultValue),

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

@@ -0,0 +1,7 @@
+import { CustomValue } from '../../CustomProvider/CustomProvider';
+/**
+ * A hook to get custom configuration of `<CustomProvider>`
+ * @param keys
+ */
+export declare function useCustom<T = any>(keys?: string | string[], overrideLocale?: any): CustomValue<T>;
+export default useCustom;

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

@@ -1,9 +1,9 @@
 'use client';
 import _extends from "@babel/runtime/helpers/esm/extends";
 import { useContext, useCallback } from 'react';
-import defaultLocale from '../locales/default';
-import { CustomContext } from '../CustomProvider/CustomProvider';
-import { format, parse, isValid } from '../utils/dateUtils';
+import { format, parse, isValid } from "../utils/date";
+import defaultLocale from "../../locales/default";
+import { CustomContext } from "../../CustomProvider/CustomProvider";
 var mergeObject = function mergeObject(list) {
   return list.reduce(function (a, b) {
     a = _extends({}, a, b);
@@ -18,7 +18,7 @@ var getDefaultRTL = function getDefaultRTL() {
  * A hook to get custom configuration of `<CustomProvider>`
  * @param keys
  */
-function useCustom(keys, overrideLocale) {
+export function useCustom(keys, overrideLocale) {
   var _locale$Calendar2, _locale$Calendar4;
   var _useContext = useContext(CustomContext),
     _useContext$locale = _useContext.locale,

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

@@ -5,4 +5,5 @@
  * @param eventTarget The target to listen for events on
  * @param listener An event handler
  */
-export default function useElementResize(eventTarget: Element | null | (() => Element | null), listener: ResizeObserverCallback): void;
+export declare function useElementResize(eventTarget: Element | null | (() => Element | null), listener: ResizeObserverCallback): void;
+export default useElementResize;

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

@@ -9,7 +9,7 @@ import { ResizeObserver } from '@juggle/resize-observer';
  * @param eventTarget The target to listen for events on
  * @param listener An event handler
  */
-export default function useElementResize(eventTarget, listener) {
+export function useElementResize(eventTarget, listener) {
   var resizeObserver = useRef();
   useEffect(function () {
     if (!resizeObserver.current) {
@@ -24,4 +24,5 @@ export default function useElementResize(eventTarget, listener) {
       (_resizeObserver$curre = resizeObserver.current) === null || _resizeObserver$curre === void 0 ? void 0 : _resizeObserver$curre.disconnect();
     };
   }, [eventTarget, listener]);
-}
+}
+export default useElementResize;

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

@@ -20,4 +20,5 @@ import React from 'react';
  * });
  *
  */
-export default function useEnsuredRef<T = undefined>(ref: any): React.MutableRefObject<T | undefined>;
+export declare function useEnsuredRef<T = undefined>(ref: any): React.MutableRefObject<T | undefined>;
+export default useEnsuredRef;

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

@@ -22,10 +22,11 @@ import { useRef } from 'react';
  * });
  *
  */
-export default function useEnsuredRef(ref) {
+export function useEnsuredRef(ref) {
   var dumpRef = useRef();
   if (ref) {
     return ref;
   }
   return dumpRef;
-}
+}
+export default useEnsuredRef;

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

@@ -2,4 +2,5 @@
  * https://github.com/facebook/react/issues/14099#issuecomment-440013892
  * @param {function} fn
  */
-export default function useEventCallback(fn: any): (...args: any[]) => any;
+export declare function useEventCallback(fn: any): (...args: any[]) => any;
+export default useEventCallback;

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

@@ -5,7 +5,7 @@ import { useEffect, useCallback, useRef } from 'react';
  * https://github.com/facebook/react/issues/14099#issuecomment-440013892
  * @param {function} fn
  */
-export default function useEventCallback(fn) {
+export function useEventCallback(fn) {
   var ref = useRef(fn);
   useEffect(function () {
     ref.current = fn;
@@ -17,4 +17,5 @@ export default function useEventCallback(fn) {
     }
     return (_ref$current = ref.current) === null || _ref$current === void 0 ? void 0 : _ref$current.call.apply(_ref$current, [ref].concat(args));
   }, []);
-}
+}
+export default useEventCallback;

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

@@ -6,4 +6,5 @@
  * @param handler An event handler
  * @param capture Whether or not to listen during the capture event phase
  */
-export default function useEventListener<K extends keyof DocumentEventMap>(eventTarget: EventTarget | (() => EventTarget), event: K, listener: EventListenerOrEventListenerObject, capture?: boolean | AddEventListenerOptions): void;
+export declare function useEventListener<K extends keyof DocumentEventMap>(eventTarget: EventTarget | (() => EventTarget), event: K, listener: EventListenerOrEventListenerObject, capture?: boolean | AddEventListenerOptions): void;
+export default useEventListener;

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

@@ -10,7 +10,7 @@ import on from 'dom-lib/on';
  * @param handler An event handler
  * @param capture Whether or not to listen during the capture event phase
  */
-export default function useEventListener(eventTarget, event, listener, capture) {
+export function useEventListener(eventTarget, event, listener, capture) {
   if (capture === void 0) {
     capture = false;
   }
@@ -21,4 +21,5 @@ export default function useEventListener(eventTarget, event, listener, capture)
       controller === null || controller === void 0 ? void 0 : controller.off();
     };
   }, [eventTarget, event, listener, capture]);
-}
+}
+export default useEventListener;

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

@@ -1,5 +1,6 @@
 import React from 'react';
-export default function useFocus<E extends HTMLElement>(elementRef: React.RefObject<E>): {
+export declare function useFocus<E extends HTMLElement>(elementRef: React.RefObject<E>): {
     grab: () => void;
     release: (options?: FocusOptions) => void;
 };
+export default useFocus;

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

@@ -1,6 +1,6 @@
 'use client';
 import { useCallback, useRef } from 'react';
-export default function useFocus(elementRef) {
+export function useFocus(elementRef) {
   // When grabbing focus, keep track of previous activeElement
   // so that we can return focus later
   var previousActiveElementRef = useRef(null);
@@ -27,4 +27,5 @@ export default function useFocus(elementRef) {
     grab: grab,
     release: release
   };
-}
+}
+export default useFocus;

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

@@ -0,0 +1,7 @@
+/// <reference types="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 declare function useFocusVirtualListItem<T extends HTMLElement>(focused?: boolean): import("react").RefObject<T>;
+export default useFocusVirtualListItem;