rsuite 5.60.1 → 5.61.0

package/esm/TreePicker/hooks/useFocusState.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="react" />
+interface FocusStateProps {
+    target: React.RefObject<HTMLElement>;
+    value?: number | string | null | undefined;
+    focusActiveNode: () => void;
+    onEnter?: (node: HTMLElement) => void;
+    onExit?: (node: HTMLElement) => void;
+    onEntered?: (node: HTMLElement) => void;
+}
+declare function useFocusState(props: FocusStateProps): {
+    active: boolean;
+    focusItemValue: string | number | null | undefined;
+    setFocusItemValue: import("react").Dispatch<import("react").SetStateAction<string | number | null | undefined>>;
+    triggerProps: {
+        onEnter: (...args: any[]) => any;
+        onExit: (...args: any[]) => any;
+        onEntered: (...args: any[]) => any;
+    };
+};
+export default useFocusState;

package/esm/TreePicker/hooks/useFocusState.js

@@ -0,0 +1,48 @@
+'use client';
+import { useState } from 'react';
+import { useEventCallback } from '../../utils';
+function useFocusState(props) {
+  var target = props.target,
+    value = props.value,
+    focusActiveNode = props.focusActiveNode;
+  var _useState = useState(false),
+    active = _useState[0],
+    setActive = _useState[1];
+  var _useState2 = useState(null),
+    focusItemValue = _useState2[0],
+    setFocusItemValue = _useState2[1];
+  var focusTarget = useEventCallback(function () {
+    var _target$current;
+    (_target$current = target.current) === null || _target$current === void 0 ? void 0 : _target$current.focus();
+  });
+  var onEnter = useEventCallback(function (node) {
+    var _props$onEnter;
+    setActive(true);
+    (_props$onEnter = props.onEnter) === null || _props$onEnter === void 0 ? void 0 : _props$onEnter.call(props, node);
+  });
+  var onExit = useEventCallback(function (node) {
+    var _props$onExit;
+    setActive(false);
+    focusTarget();
+    (_props$onExit = props.onExit) === null || _props$onExit === void 0 ? void 0 : _props$onExit.call(props, node);
+  });
+  var onEntered = useEventCallback(function (node) {
+    var _props$onEntered;
+    if (value) {
+      setFocusItemValue(value);
+      focusActiveNode();
+    }
+    (_props$onEntered = props.onEntered) === null || _props$onEntered === void 0 ? void 0 : _props$onEntered.call(props, node);
+  });
+  return {
+    active: active,
+    focusItemValue: focusItemValue,
+    setFocusItemValue: setFocusItemValue,
+    triggerProps: {
+      onEnter: onEnter,
+      onExit: onExit,
+      onEntered: onEntered
+    }
+  };
+}
+export default useFocusState;

package/esm/index.d.ts

@@ -4,6 +4,8 @@ export { default as Heading } from './Heading';
 export type { HeadingProps } from './Heading';
 export { default as HeadingGroup } from './HeadingGroup';
 export type { HeadingGroupProps } from './HeadingGroup';
+export { default as Highlight } from './Highlight';
+export type { HighlightProps } from './Highlight';
 export { default as SafeAnchor } from './SafeAnchor';
 export type { SafeAnchorProps } from './SafeAnchor';
 export { default as Button } from './Button';

package/esm/index.js

@@ -4,6 +4,7 @@
 export { default as Text } from './Text';
 export { default as Heading } from './Heading';
 export { default as HeadingGroup } from './HeadingGroup';
+export { default as Highlight } from './Highlight';
 export { default as SafeAnchor } from './SafeAnchor';
 // Buttons
 // --------------------------------------------------------

package/esm/internals/Picker/Listbox.d.ts

@@ -1,35 +1,65 @@
 import React from 'react';
 import { ListProps, ListHandle } from '../../internals/Windowing';
-import { StandardProps, ItemDataType } from '../../@types/common';
+import { StandardProps, ItemDataType, DataProps } from '../../@types/common';
 import { RSUITE_PICKER_GROUP_KEY } from '../../internals/symbols';
 interface InnerItemDataType extends ItemDataType {
     [RSUITE_PICKER_GROUP_KEY]?: boolean;
 }
-export interface ListboxProps<Multiple = false> extends StandardProps, Omit<React.HTMLAttributes<HTMLDivElement>, 'onSelect'> {
-    classPrefix: string;
-    data?: InnerItemDataType[];
-    group?: boolean;
+/**
+ * Props for the Listbox component.
+ */
+/**
+ * Props for the Listbox component.
+ * @template Multiple - Whether multiple selection is enabled.
+ */
+export interface ListboxProps<Multiple = false> extends StandardProps, Partial<DataProps<InnerItemDataType>>, Omit<React.HTMLAttributes<HTMLDivElement>, 'onSelect'> {
     groupBy?: string;
     disabledItemValues?: any[];
     activeItemValues?: any[];
     focusItemValue?: any;
     maxHeight?: number;
-    valueKey?: string;
-    labelKey?: string;
-    className?: string;
-    style?: React.CSSProperties;
     listItemAs: React.ElementType | string;
     listItemClassPrefix?: string;
     listItemProps?: any;
     rowHeight?: number;
+    /** */
     rowGroupHeight?: number;
+    /** */
     virtualized?: boolean;
+    /** */
     listProps?: Partial<ListProps>;
+    /** */
     listRef?: React.Ref<ListHandle>;
-    /** Custom selected option */
+    /**
+     * Query string for filtering.
+     */
+    query?: string;
+    /**
+     * Custom function to render a selected option.
+     * @param itemLabel - The label of the item.
+     * @param item - The selected item.
+     * @returns The rendered React node.
+     */
     renderMenuItem?: (itemLabel: React.ReactNode, item: any) => React.ReactNode;
+    /**
+     * Custom function to render a menu group.
+     * @param title - The title of the group.
+     * @param item - The group item.
+     * @returns The rendered React node.
+     */
     renderMenuGroup?: (title: React.ReactNode, item: any) => React.ReactNode;
+    /**
+     * Event handler for selecting an option.
+     * @param value - The selected value.
+     * @param item - The selected item.
+     * @param event - The mouse event.
+     * @param checked - The checked state (only applicable for multiple selection).
+     */
     onSelect?: Multiple extends true ? (value: any, item: any, event: React.MouseEvent, checked: boolean) => void : Multiple extends false ? (value: any, item: any, event: React.MouseEvent) => void : any;
+    /**
+     * Event handler for clicking on a group title.
+     * @param event - The mouse event.
+     */
     onGroupTitleClick?: (event: React.MouseEvent) => void;
 }
 export declare type ListboxComponent = React.ForwardRefExoticComponent<ListboxProps> & {

package/esm/internals/Picker/Listbox.js

@@ -19,11 +19,19 @@ import { mergeRefs, useClassNames, useMount, useEventCallback } from '../../util
 import ListItemGroup from './ListItemGroup';
 import { KEY_GROUP_TITLE } from '../../utils/getDataGroupBy';
 import useCombobox from './hooks/useCombobox';
+import Highlight from '../../Highlight';
 import { RSUITE_PICKER_GROUP_KEY } from '../../internals/symbols';
+
+/**
+ * Props for the Listbox component.
+ */
+/**
+ * Props for the Listbox component.
+ * @template Multiple - Whether multiple selection is enabled.
+ */
 var Listbox = /*#__PURE__*/React.forwardRef(function (props, ref) {
   var _props$data = props.data,
     data = _props$data === void 0 ? [] : _props$data,
-    group = props.group,
     groupBy = props.groupBy,
     _props$maxHeight = props.maxHeight,
     maxHeight = _props$maxHeight === void 0 ? 320 : _props$maxHeight,
@@ -50,17 +58,19 @@ var Listbox = /*#__PURE__*/React.forwardRef(function (props, ref) {
     rowHeight = _props$rowHeight === void 0 ? 36 : _props$rowHeight,
     _props$rowGroupHeight = props.rowGroupHeight,
     rowGroupHeight = _props$rowGroupHeight === void 0 ? 48 : _props$rowGroupHeight,
+    query = props.query,
     renderMenuGroup = props.renderMenuGroup,
     renderMenuItem = props.renderMenuItem,
     onGroupTitleClick = props.onGroupTitleClick,
     onSelect = props.onSelect,
-    rest = _objectWithoutPropertiesLoose(props, ["data", "group", "groupBy", "maxHeight", "activeItemValues", "disabledItemValues", "classPrefix", "valueKey", "labelKey", "virtualized", "listProps", "listRef", "className", "style", "focusItemValue", "listItemClassPrefix", "listItemAs", "listItemProps", "rowHeight", "rowGroupHeight", "renderMenuGroup", "renderMenuItem", "onGroupTitleClick", "onSelect"]);
+    rest = _objectWithoutPropertiesLoose(props, ["data", "groupBy", "maxHeight", "activeItemValues", "disabledItemValues", "classPrefix", "valueKey", "labelKey", "virtualized", "listProps", "listRef", "className", "style", "focusItemValue", "listItemClassPrefix", "listItemAs", "listItemProps", "rowHeight", "rowGroupHeight", "query", "renderMenuGroup", "renderMenuItem", "onGroupTitleClick", "onSelect"]);
   var _useClassNames = useClassNames(classPrefix),
     withClassPrefix = _useClassNames.withClassPrefix,
     prefix = _useClassNames.prefix,
     merge = _useClassNames.merge;
+  var groupable = typeof groupBy !== 'undefined';
   var classes = merge(className, withClassPrefix('items', {
-    grouped: group
+    grouped: groupable
   }));
   var _useCombobox = useCombobox(),
     id = _useCombobox.id,
@@ -87,7 +97,7 @@ var Listbox = /*#__PURE__*/React.forwardRef(function (props, ref) {
   });
   var getRowHeight = function getRowHeight(list, index) {
     var item = list[index];
-    if (group && item[RSUITE_PICKER_GROUP_KEY] && index !== 0) {
+    if (groupable && item[RSUITE_PICKER_GROUP_KEY] && index !== 0) {
       return rowGroupHeight;
     }
     return rowHeight;
@@ -113,16 +123,12 @@ var Listbox = /*#__PURE__*/React.forwardRef(function (props, ref) {
       scrollTop(container, Math.max(0, position.top - sHeight + 32));
     }
   }, [focusItemValue, menuBodyContainerRef, prefix]);
-  var filteredItems = group ? data.filter(function (item) {
+  var filteredItems = groupable ? data.filter(function (item) {
     var _item$parent;
     // Display group title items
     if (item[RSUITE_PICKER_GROUP_KEY]) return true;
 
     // Display items under the unfolded group
-    // FIXME-Doma
-    // `groupBy` is bound to be string when `group` is true
-    // because `group` is actually redundant as a prop
-    // It could simply be derived from `groupBy` value
     var groupValue = get(item, groupBy, '') || ( // FIXME-Doma
     // Usage of `item.parent` is strongly discouraged
     // It's only here for legacy support
@@ -139,7 +145,11 @@ var Listbox = /*#__PURE__*/React.forwardRef(function (props, ref) {
       itemData = _ref.item;
     var item = itemData || data[index];
     var value = item[valueKey];
-    var label = item[labelKey];
+    var itemLabel = item[labelKey];
+    var label = query ? /*#__PURE__*/React.createElement(Highlight, {
+      query: query,
+      as: "span"
+    }, itemLabel) : itemLabel;
     if (isUndefined(label) && !item[RSUITE_PICKER_GROUP_KEY]) {
       throw Error("labelKey \"" + labelKey + "\" is not defined in \"data\" : " + index);
     }
@@ -147,13 +157,9 @@ var Listbox = /*#__PURE__*/React.forwardRef(function (props, ref) {
     // Use `value` in keys when If `value` is string or number
     var itemKey = isString(value) || isNumber(value) ? value : index;
 
-    /**
-     * Render <ListboxGroup>
-     * when if `group` is enabled
-     */
-    if (group && item[RSUITE_PICKER_GROUP_KEY]) {
+    //  Render <ListboxGroup> component when `groupBy` is defined
+    if (groupable && item[RSUITE_PICKER_GROUP_KEY]) {
       var groupValue = item[KEY_GROUP_TITLE];
-      // TODO: grouped options should be owned by group
       return /*#__PURE__*/React.createElement(ListItemGroup, {
         style: style,
         classPrefix: 'picker-menu-group',

package/esm/internals/Picker/PickerIndicator.d.ts

@@ -4,7 +4,8 @@ interface PickerIndicatorProps {
     caretAs?: React.ElementType | null;
     onClose?: (event: React.MouseEvent<HTMLElement>) => void;
     showCleanButton?: boolean;
+    disabled?: boolean;
     as?: React.ElementType;
 }
-declare const PickerIndicator: ({ loading, caretAs, onClose, showCleanButton, as: Component }: PickerIndicatorProps) => JSX.Element;
+declare const PickerIndicator: ({ loading, caretAs, onClose, showCleanButton, as: Component, disabled }: PickerIndicatorProps) => JSX.Element;
 export default PickerIndicator;

package/esm/internals/Picker/PickerIndicator.js

@@ -11,7 +11,8 @@ var PickerIndicator = function PickerIndicator(_ref) {
     onClose = _ref.onClose,
     showCleanButton = _ref.showCleanButton,
     _ref$as = _ref.as,
-    Component = _ref$as === void 0 ? InputGroup.Addon : _ref$as;
+    Component = _ref$as === void 0 ? InputGroup.Addon : _ref$as,
+    disabled = _ref.disabled;
   var _useCustom = useCustom(),
     locale = _useCustom.locale;
   var _useClassNames = useClassNames('picker'),
@@ -23,7 +24,7 @@ var PickerIndicator = function PickerIndicator(_ref) {
         "data-testid": "spinner"
       });
     }
-    if (showCleanButton) {
+    if (showCleanButton && !disabled) {
       return /*#__PURE__*/React.createElement(CloseButton, {
         className: prefix('clean'),
         tabIndex: -1,
@@ -38,6 +39,9 @@ var PickerIndicator = function PickerIndicator(_ref) {
       className: prefix('caret-icon')
     });
   };
-  return /*#__PURE__*/React.createElement(Component, null, addon());
+  var props = Component === InputGroup.Addon ? {
+    disabled: disabled
+  } : undefined;
+  return /*#__PURE__*/React.createElement(Component, props, addon());
 };
 export default PickerIndicator;

package/esm/internals/Picker/hooks/useFocusItemValue.js

@@ -5,7 +5,7 @@ import isUndefined from 'lodash/isUndefined';
 import find from 'lodash/find';
 import { getHeight } from 'dom-lib';
 import { useEventCallback, shallowEqual } from '../../../utils';
-import { findNodeOfTree } from '../../../utils/treeUtils';
+import { findNodeOfTree } from '../../Tree/utils';
 import { onMenuKeyDown } from '../utils';
 /**
  * A hook that manages the focus state of the option.

package/esm/internals/Picker/hooks/usePickerRef.d.ts

@@ -1,13 +1,10 @@
 /// <reference types="react" />
 import type { OverlayTriggerHandle } from '../PickerToggleTrigger';
 import type { ListHandle } from '../../../internals/Windowing';
-export interface PickerDependentParameters {
-    inline?: boolean;
-}
 /**
  * A hook of the exposed method of Picker
  */
-declare function usePickerRef(ref: any, parmas?: PickerDependentParameters): {
+declare function usePickerRef(ref: any): {
     trigger: import("react").RefObject<OverlayTriggerHandle>;
     root: import("react").MutableRefObject<any>;
     overlay: import("react").RefObject<HTMLElement>;

package/esm/internals/Picker/hooks/usePickerRef.js

@@ -5,7 +5,7 @@ import { RSUITE_PICKER_TYPE } from '../../../internals/symbols';
 /**
  * A hook of the exposed method of Picker
  */
-function usePickerRef(ref, parmas) {
+function usePickerRef(ref) {
   var trigger = useRef(null);
   var root = useRef(null);
   var target = useRef(null);
@@ -13,8 +13,6 @@ function usePickerRef(ref, parmas) {
   var list = useRef(null);
   var searchInput = useRef(null);
   var treeView = useRef(null);
-  var _ref = parmas || {},
-    inline = _ref.inline;
   var handleOpen = useEventCallback(function () {
     var _trigger$current;
     trigger === null || trigger === void 0 ? void 0 : (_trigger$current = trigger.current) === null || _trigger$current === void 0 ? void 0 : _trigger$current.open();
@@ -28,25 +26,10 @@ function usePickerRef(ref, parmas) {
     trigger === null || trigger === void 0 ? void 0 : (_trigger$current3 = trigger.current) === null || _trigger$current3 === void 0 ? void 0 : _trigger$current3.updatePosition();
   });
   useImperativeHandle(ref, function () {
-    // Tree and CheckTree
-    if (inline) {
-      return {
-        get root() {
-          var _trigger$current$root, _trigger$current4;
-          return root !== null && root !== void 0 && root.current ? root === null || root === void 0 ? void 0 : root.current : (_trigger$current$root = trigger === null || trigger === void 0 ? void 0 : (_trigger$current4 = trigger.current) === null || _trigger$current4 === void 0 ? void 0 : _trigger$current4.root) !== null && _trigger$current$root !== void 0 ? _trigger$current$root : null;
-        },
-        get list() {
-          if (!(list !== null && list !== void 0 && list.current)) {
-            throw new Error('The list is not found, please set `virtualized` for the component.');
-          }
-          return list === null || list === void 0 ? void 0 : list.current;
-        }
-      };
-    }
     return {
       get root() {
-        var _ref2, _trigger$current5;
-        return (_ref2 = (root === null || root === void 0 ? void 0 : root.current) || (trigger === null || trigger === void 0 ? void 0 : (_trigger$current5 = trigger.current) === null || _trigger$current5 === void 0 ? void 0 : _trigger$current5.root)) !== null && _ref2 !== void 0 ? _ref2 : null;
+        var _ref, _trigger$current4;
+        return (_ref = (root === null || root === void 0 ? void 0 : root.current) || (trigger === null || trigger === void 0 ? void 0 : (_trigger$current4 = trigger.current) === null || _trigger$current4 === void 0 ? void 0 : _trigger$current4.root)) !== null && _ref !== void 0 ? _ref : null;
       },
       get overlay() {
         var _overlay$current;

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

@@ -1,7 +1,6 @@
 import { pickTriggerPropKeys, omitTriggerPropKeys, OverlayTriggerHandle, PositionChildProps } from './PickerToggleTrigger';
 import { PickerToggleProps } from './PickerToggle';
 import { PickerHandle, PickerComponent } from './types';
-export { default as TreeView } from './TreeView';
 export { default as Listbox } from './Listbox';
 export { default as ListItem } from './ListItem';
 export { default as ListItemGroup } from './ListItemGroup';

package/esm/internals/Picker/index.js

@@ -1,6 +1,5 @@
 'use client';
 import { pickTriggerPropKeys, omitTriggerPropKeys } from './PickerToggleTrigger';
-export { default as TreeView } from './TreeView';
 export { default as Listbox } from './Listbox';
 export { default as ListItem } from './ListItem';
 export { default as ListItemGroup } from './ListItemGroup';

package/esm/internals/Picker/utils.js

@@ -1,7 +1,7 @@
 'use client';
 import React from 'react';
 import trim from 'lodash/trim';
-import { findNodeOfTree } from '../../utils/treeUtils';
+import { findNodeOfTree } from '../Tree/utils';
 import { KEY_VALUES, reactToString } from '../../utils';
 var defaultNodeKeys = {
   valueKey: 'value',

package/esm/internals/{Picker → Tree}/TreeView.js

@@ -2,7 +2,7 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
 import React from 'react';
-import useCombobox from './hooks/useCombobox';
+import useCombobox from '../Picker/hooks/useCombobox';
 var TreeView = /*#__PURE__*/React.forwardRef(function (props, ref) {
   var children = props.children,
     treeRootClassName = props.treeRootClassName,

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

@@ -0,0 +1 @@
+export { default as TreeView } from './TreeView';

package/esm/internals/Tree/index.js

@@ -0,0 +1,2 @@
+'use client';
+export { default as TreeView } from './TreeView';

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/List.d.ts

@@ -1,5 +1,6 @@
 import { VariableSizeList, ListItemKeySelector, ListOnScrollProps, ListOnItemsRenderedProps } from 'react-window';
 import { WithAsProps, RsRefForwardingComponent } from '../../@types/common';
+export declare const defaultItemSize: () => number;
 export interface ListProps<T = any> extends WithAsProps {
     /**
      * @deprecated use itemSize instead

package/esm/internals/Windowing/List.js

@@ -4,6 +4,9 @@ import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWith
 import React, { useRef, useImperativeHandle, useCallback, useMemo } from 'react';
 import { VariableSizeList } from 'react-window';
 import { useCustom } from '../../utils';
+export var defaultItemSize = function defaultItemSize() {
+  return 36;
+};
 /**
  * This component renders a virtualized list of elements with either fixed or dynamic heights.
  *

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 List, defaultItemSize } from './List';
 export { FixedSizeList, VariableSizeList } from 'react-window';

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

@@ -0,0 +1 @@
+export { default as useFoucsVirtualListItem } from './useFoucsVirtualListItem';

package/esm/internals/hooks/index.js

@@ -0,0 +1,2 @@
+'use client';
+export { default as useFoucsVirtualListItem } from './useFoucsVirtualListItem';

package/esm/internals/hooks/useFoucsVirtualListItem.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.
+ */
+declare function useFoucsVirtualListItem<T extends HTMLElement>(focused?: boolean): import("react").RefObject<T>;
+export default useFoucsVirtualListItem;