rsuite 5.76.0 → 6.0.0-canary-20241227

package/esm/Tree/TreeView.js

@@ -1,7 +1,5 @@
 'use client';
 import _extends from "@babel/runtime/helpers/esm/extends";
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-var _excluded = ["as", "data", "style", "showIndentLine", "value", "locale", "height", "className", "searchable", "classPrefix", "searchKeyword", "searchBy", "draggable", "disabledItemValues", "loadingNodeValues", "flattenedNodes", "listProps", "listRef", "searchInputRef", "expandItemValues", "onSearch", "onSelect", "onSelectItem", "onChange", "onDragEnd", "onDragStart", "onDragEnter", "onDragLeave", "onDragOver", "onDrop", "onExpand", "onFocusItem", "onScroll"];
 import React, { useEffect, useMemo } from 'react';
 import isNil from 'lodash/isNil';
 import TreeViewNode from "./TreeNode.js";
@@ -28,240 +26,229 @@ import { useCustom } from "../CustomProvider/index.js";
  * Represents the props for the TreeView component.
  */
 
-var TreeView = /*#__PURE__*/React.forwardRef(function (props, ref) {
-  var _props$as = props.as,
-    Component = _props$as === void 0 ? 'div' : _props$as,
-    _props$data = props.data,
-    data = _props$data === void 0 ? [] : _props$data,
-    style = props.style,
-    showIndentLine = props.showIndentLine,
-    valueProp = props.value,
-    overrideLocale = props.locale,
-    _props$height = props.height,
-    height = _props$height === void 0 ? 360 : _props$height,
-    className = props.className,
-    _props$searchable = props.searchable,
-    searchable = _props$searchable === void 0 ? false : _props$searchable,
-    _props$classPrefix = props.classPrefix,
-    classPrefix = _props$classPrefix === void 0 ? 'tree' : _props$classPrefix,
-    searchKeyword = props.searchKeyword,
-    searchBy = props.searchBy,
-    draggable = props.draggable,
-    _props$disabledItemVa = props.disabledItemValues,
-    disabledItemValues = _props$disabledItemVa === void 0 ? [] : _props$disabledItemVa,
-    _props$loadingNodeVal = props.loadingNodeValues,
-    loadingNodeValues = _props$loadingNodeVal === void 0 ? [] : _props$loadingNodeVal,
-    _props$flattenedNodes = props.flattenedNodes,
-    flattenedNodes = _props$flattenedNodes === void 0 ? {} : _props$flattenedNodes,
-    listProps = props.listProps,
-    listRef = props.listRef,
-    searchInputRef = props.searchInputRef,
-    _props$expandItemValu = props.expandItemValues,
-    expandItemValues = _props$expandItemValu === void 0 ? [] : _props$expandItemValu,
-    onSearch = props.onSearch,
-    onSelect = props.onSelect,
-    onSelectItem = props.onSelectItem,
-    onChange = props.onChange,
-    onDragEnd = props.onDragEnd,
-    onDragStart = props.onDragStart,
-    onDragEnter = props.onDragEnter,
-    onDragLeave = props.onDragLeave,
-    onDragOver = props.onDragOver,
-    onDrop = props.onDrop,
-    onExpand = props.onExpand,
-    onFocusItem = props.onFocusItem,
-    onScroll = props.onScroll,
-    rest = _objectWithoutPropertiesLoose(props, _excluded);
-  var _useCustom = useCustom(),
-    getLocale = _useCustom.getLocale;
-  var _getLocale = getLocale('Combobox', overrideLocale),
-    searchPlaceholder = _getLocale.searchPlaceholder,
-    noResultsText = _getLocale.noResultsText;
-  var _useTreeContextProps = useTreeContextProps(),
-    valueKey = _useTreeContextProps.valueKey,
-    childrenKey = _useTreeContextProps.childrenKey,
-    scrollShadow = _useTreeContextProps.scrollShadow,
-    virtualized = _useTreeContextProps.virtualized;
-  var _useClassNames = useClassNames(classPrefix),
-    prefix = _useClassNames.prefix,
-    merge = _useClassNames.merge,
-    withClassPrefix = _useClassNames.withClassPrefix;
-  var handleSearchCallback = useEventCallback(function (value, _data, event) {
+const TreeView = /*#__PURE__*/React.forwardRef((props, ref) => {
+  const {
+    as: Component = 'div',
+    data = [],
+    style,
+    showIndentLine,
+    value: valueProp,
+    locale: overrideLocale,
+    height = 360,
+    className,
+    searchable = false,
+    classPrefix = 'tree',
+    searchKeyword,
+    searchBy,
+    draggable,
+    disabledItemValues = [],
+    loadingNodeValues = [],
+    flattenedNodes = {},
+    listProps,
+    listRef,
+    searchInputRef,
+    expandItemValues = [],
+    onSearch,
+    onSelect,
+    onSelectItem,
+    onChange,
+    onDragEnd,
+    onDragStart,
+    onDragEnter,
+    onDragLeave,
+    onDragOver,
+    onDrop,
+    onExpand,
+    onFocusItem,
+    onScroll,
+    ...rest
+  } = props;
+  const {
+    getLocale
+  } = useCustom();
+  const {
+    searchPlaceholder,
+    noResultsText
+  } = getLocale('Combobox', overrideLocale);
+  const {
+    valueKey,
+    childrenKey,
+    scrollShadow,
+    virtualized
+  } = useTreeContextProps();
+  const {
+    prefix,
+    merge,
+    withClassPrefix
+  } = useClassNames(classPrefix);
+  const handleSearchCallback = useEventCallback((value, _data, event) => {
     onSearch === null || onSearch === void 0 || onSearch(value, event);
   });
-  var _useTreeSearch = useTreeSearch({
-      callback: handleSearchCallback,
-      searchKeyword: searchKeyword,
-      data: data,
-      searchBy: searchBy
-    }),
-    filteredData = _useTreeSearch.filteredData,
-    keyword = _useTreeSearch.keyword,
-    setFilteredData = _useTreeSearch.setFilteredData,
-    handleSearch = _useTreeSearch.handleSearch;
-  var transformation = useVirtualizedTreeData(flattenedNodes, filteredData, {
-    expandItemValues: expandItemValues,
+  const {
+    filteredData,
+    keyword,
+    setFilteredData,
+    handleSearch
+  } = useTreeSearch({
+    callback: handleSearchCallback,
+    searchKeyword,
+    data,
+    searchBy
+  });
+  const transformation = useVirtualizedTreeData(flattenedNodes, filteredData, {
+    expandItemValues,
     searchKeyword: keyword
   });
-  var getFormattedNodes = function getFormattedNodes(render) {
+  const getFormattedNodes = render => {
     if (virtualized) {
-      return transformation().filter(function (n) {
-        return n.visible;
-      });
+      return transformation().filter(n => n.visible);
     }
-    return filteredData.map(function (dataItem, index) {
-      return render === null || render === void 0 ? void 0 : render(dataItem, index, 1);
-    }).filter(function (n) {
-      return n;
-    });
+    return filteredData.map((dataItem, index) => render === null || render === void 0 ? void 0 : render(dataItem, index, 1)).filter(n => n);
   };
-  useEffect(function () {
+  useEffect(() => {
     setFilteredData(data, keyword);
   }, [data, keyword, setFilteredData]);
 
   // TODO-Doma
   // Replace `getKeyParentMap` with `getParentMap`
-  var itemParentMap = useMemo(function () {
-    return getKeyParentMap(data, function (node) {
-      return node[valueKey];
-    }, function (node) {
-      return node[childrenKey];
-    });
-  }, [childrenKey, data, valueKey]);
-  var _useFocusTree = useFocusTree({
-      filteredData: filteredData,
-      disabledItemValues: disabledItemValues,
-      expandItemValues: expandItemValues,
-      searchKeyword: keyword,
-      flattenedNodes: flattenedNodes,
-      onFocused: onFocusItem,
-      onExpand: onExpand
-    }),
-    focusItemValue = _useFocusTree.focusItemValue,
-    setFocusItemValue = _useFocusTree.setFocusItemValue,
-    onTreeKeydown = _useFocusTree.onTreeKeydown,
-    treeNodesRefs = _useFocusTree.treeNodesRefs,
-    saveTreeNodeRef = _useFocusTree.saveTreeNodeRef,
-    treeViewRef = _useFocusTree.treeViewRef;
-  var _useTreeDrag = useTreeDrag({
-      flattenedNodes: flattenedNodes,
-      treeNodesRefs: treeNodesRefs,
-      draggable: draggable,
-      onDragStart: onDragStart,
-      onDragEnter: onDragEnter,
-      onDragOver: onDragOver,
-      onDragLeave: onDragLeave,
-      onDragEnd: onDragEnd,
-      onDrop: onDrop,
-      prefix: prefix
-    }),
-    dragNode = _useTreeDrag.dragNode,
-    dragOverNodeKey = _useTreeDrag.dragOverNodeKey,
-    dropNodePosition = _useTreeDrag.dropNodePosition,
-    dragEvents = _useTreeDrag.dragEvents;
-  var getTreeNodeProps = useTreeNodeProps({
+  const itemParentMap = useMemo(() => getKeyParentMap(data, node => node[valueKey], node => node[childrenKey]), [childrenKey, data, valueKey]);
+  const {
+    focusItemValue,
+    setFocusItemValue,
+    onTreeKeydown,
+    treeNodesRefs,
+    saveTreeNodeRef,
+    treeViewRef
+  } = useFocusTree({
+    filteredData,
+    disabledItemValues,
+    expandItemValues,
+    searchKeyword: keyword,
+    flattenedNodes,
+    onFocused: onFocusItem,
+    onExpand
+  });
+  const {
+    dragNode,
+    dragOverNodeKey,
+    dropNodePosition,
+    dragEvents
+  } = useTreeDrag({
+    flattenedNodes,
+    treeNodesRefs,
+    draggable,
+    onDragStart,
+    onDragEnter,
+    onDragOver,
+    onDragLeave,
+    onDragEnd,
+    onDrop,
+    prefix
+  });
+  const getTreeNodeProps = useTreeNodeProps({
     value: valueProp,
-    disabledItemValues: disabledItemValues,
-    loadingNodeValues: loadingNodeValues,
-    focusItemValue: focusItemValue,
-    keyword: keyword,
-    dragNode: dragNode,
-    dragOverNodeKey: dragOverNodeKey,
-    dropNodePosition: dropNodePosition
+    disabledItemValues,
+    loadingNodeValues,
+    focusItemValue,
+    keyword,
+    dragNode,
+    dragOverNodeKey,
+    dropNodePosition
   });
-  var handleSelect = useEventCallback(function (nodeData, event) {
+  const handleSelect = useEventCallback((nodeData, event) => {
     if (!nodeData) {
       return;
     }
-    var nextValue = nodeData[valueKey];
-    var path = getPathTowardsItem(nodeData, function (item) {
-      return itemParentMap.get(item[valueKey]);
-    });
+    const nextValue = nodeData[valueKey];
+    const path = getPathTowardsItem(nodeData, item => itemParentMap.get(item[valueKey]));
     setFocusItemValue(nextValue);
     onChange === null || onChange === void 0 || onChange(nextValue, event);
     onSelect === null || onSelect === void 0 || onSelect(nodeData, nextValue, event);
     onSelectItem === null || onSelectItem === void 0 || onSelectItem(nodeData, path);
   });
-  var selectActiveItem = useEventCallback(function (event) {
+  const selectActiveItem = useEventCallback(event => {
     if (isNil(focusItemValue)) return;
-    var activeItem = getActiveItem(focusItemValue, flattenedNodes, valueKey);
+    const activeItem = getActiveItem(focusItemValue, flattenedNodes, valueKey);
     handleSelect(activeItem, event);
   });
-  var handleTreeKeyDown = useEventCallback(function (event) {
+  const handleTreeKeyDown = useEventCallback(event => {
     onTreeKeydown(event);
     onMenuKeyDown(event, {
       enter: selectActiveItem
     });
   });
-  var _renderNode = function renderNode(node, index, layer) {
-    var visible = node.visible;
+  const renderNode = (node, index, layer) => {
+    const {
+      visible
+    } = node;
     if (!visible) {
       return null;
     }
-    var children = node[childrenKey];
-    var expanded = isExpand(keyword, expandItemValues.includes(node[valueKey]));
-    var hasChildren = keyword ? hasVisibleChildren(node, childrenKey) : Boolean(children);
-    var nodeProps = _extends({}, getTreeNodeProps(node, layer, index), dragEvents, {
-      expanded: expanded,
-      draggable: draggable,
-      onExpand: onExpand,
+    const children = node[childrenKey];
+    const expanded = isExpand(keyword, expandItemValues.includes(node[valueKey]));
+    const hasChildren = keyword ? hasVisibleChildren(node, childrenKey) : Boolean(children);
+    const nodeProps = {
+      ...getTreeNodeProps(node, layer, index),
+      ...dragEvents,
+      expanded,
+      draggable,
+      onExpand,
       onSelect: handleSelect,
-      hasChildren: hasChildren
-    });
+      hasChildren
+    };
     if (hasChildren) {
-      var _merge;
       layer += 1;
-      var childClassName = merge(prefix('node-children'), (_merge = {}, _merge[prefix('node-expanded')] = expanded, _merge));
+      const childClassName = merge(prefix('node-children'), {
+        [prefix('node-expanded')]: expanded
+      });
       return /*#__PURE__*/React.createElement("div", {
         className: childClassName,
         key: node[valueKey]
       }, /*#__PURE__*/React.createElement(TreeViewNode, _extends({}, nodeProps, {
-        ref: function ref(_ref) {
-          return saveTreeNodeRef(_ref, node.refKey);
-        }
+        ref: ref => saveTreeNodeRef(ref, node.refKey)
       })), /*#__PURE__*/React.createElement("div", {
         className: prefix('group'),
         role: "group"
-      }, children === null || children === void 0 ? void 0 : children.map(function (child, i) {
-        return _renderNode(child, i, layer);
-      }), showIndentLine && /*#__PURE__*/React.createElement(IndentLine, null)));
+      }, children === null || children === void 0 ? void 0 : children.map((child, i) => renderNode(child, i, layer)), showIndentLine && /*#__PURE__*/React.createElement(IndentLine, null)));
     }
     return /*#__PURE__*/React.createElement(TreeViewNode, _extends({
-      ref: function ref(_ref2) {
-        return saveTreeNodeRef(_ref2, node.refKey);
-      },
+      ref: ref => saveTreeNodeRef(ref, node.refKey),
       key: node[valueKey]
     }, nodeProps));
   };
-  var renderVirtualListNode = function renderVirtualListNode(_ref3) {
-    var index = _ref3.index,
-      style = _ref3.style,
-      data = _ref3.data;
-    var node = data[index];
-    var layer = node.layer,
-      visible = node.visible,
-      hasChildren = node.hasChildren;
-    var expanded = isExpand(keyword, expandItemValues.includes(node[valueKey]));
+  const renderVirtualListNode = _ref => {
+    let {
+      index,
+      style,
+      data
+    } = _ref;
+    const node = data[index];
+    const {
+      layer,
+      visible,
+      hasChildren
+    } = node;
+    const expanded = isExpand(keyword, expandItemValues.includes(node[valueKey]));
     if (!visible) {
       return null;
     }
-    var treeNodeProps = _extends({}, getTreeNodeProps(node, layer), dragEvents, {
-      expanded: expanded,
-      style: style,
-      onExpand: onExpand,
+    const treeNodeProps = {
+      ...getTreeNodeProps(node, layer),
+      ...dragEvents,
+      expanded,
+      style,
+      onExpand,
       onSelect: handleSelect,
-      hasChildren: hasChildren
-    });
+      hasChildren
+    };
     return visible && /*#__PURE__*/React.createElement(TreeViewNode, _extends({
-      ref: function ref(_ref4) {
-        return saveTreeNodeRef(_ref4, node.refKey);
-      }
+      ref: ref => saveTreeNodeRef(ref, node.refKey)
     }, treeNodeProps));
   };
-  var classes = merge(withClassPrefix({
-    virtualized: virtualized
+  const classes = merge(withClassPrefix({
+    virtualized
   }), className);
-  var formattedNodes = getFormattedNodes(_renderNode);
+  const formattedNodes = getFormattedNodes(renderNode);
   return /*#__PURE__*/React.createElement(Component, {
     ref: ref,
     className: classes,
@@ -287,8 +274,10 @@ var TreeView = /*#__PURE__*/React.forwardRef(function (props, ref) {
       height: 'auto'
     },
     className: prefix('virt-auto-sizer')
-  }, function (_ref5) {
-    var height = _ref5.height;
+  }, _ref2 => {
+    let {
+      height
+    } = _ref2;
     return /*#__PURE__*/React.createElement(List, _extends({
       ref: listRef,
       height: height,

package/esm/Tree/hooks/useExpandTree.js

@@ -5,19 +5,14 @@ import { useControlled, useEventCallback } from "../../internals/hooks/index.js"
 import { createConcatChildrenFunction } from "../../internals/Picker/index.js";
 import { getExpandItemValues, flattenTree } from "../utils/index.js";
 export function getDefaultExpandItemValues(data, options) {
-  var valueKey = options.valueKey,
-    defaultExpandAll = options.defaultExpandAll,
-    childrenKey = options.childrenKey,
-    _options$defaultExpan = options.defaultExpandItemValues,
-    defaultExpandItemValues = _options$defaultExpan === void 0 ? [] : _options$defaultExpan;
+  const {
+    valueKey,
+    defaultExpandAll,
+    childrenKey,
+    defaultExpandItemValues = []
+  } = options;
   if (defaultExpandAll) {
-    return flattenTree(data, function (item) {
-      return item[childrenKey] || [];
-    }).filter(function (item) {
-      return Array.isArray(item[childrenKey]) && item[childrenKey].length > 0;
-    }).map(function (item) {
-      return item[valueKey];
-    });
+    return flattenTree(data, item => item[childrenKey] || []).filter(item => Array.isArray(item[childrenKey]) && item[childrenKey].length > 0).map(item => item[valueKey]);
   }
   return defaultExpandItemValues;
 }
@@ -25,46 +20,46 @@ export function getDefaultExpandItemValues(data, options) {
  * Custom hook for managing tree expansion state.
  */
 function useExpandTree(data, props) {
-  var defaultExpandAll = props.defaultExpandAll,
-    valueKey = props.valueKey,
-    childrenKey = props.childrenKey,
-    defaultExpandItemValues = props.defaultExpandItemValues,
-    controlledExpandItemValues = props.controlledExpandItemValues,
-    onExpand = props.onExpand,
-    getChildren = props.getChildren,
-    appendChild = props.appendChild;
-  var _useControlled = useControlled(controlledExpandItemValues, getDefaultExpandItemValues(data, {
-      defaultExpandAll: defaultExpandAll,
-      valueKey: valueKey,
-      childrenKey: childrenKey,
-      defaultExpandItemValues: defaultExpandItemValues
-    })),
-    expandItemValues = _useControlled[0],
-    setExpandItemValues = _useControlled[1];
-  useEffect(function () {
+  const {
+    defaultExpandAll,
+    valueKey,
+    childrenKey,
+    defaultExpandItemValues,
+    controlledExpandItemValues,
+    onExpand,
+    getChildren,
+    appendChild
+  } = props;
+  const [expandItemValues, setExpandItemValues] = useControlled(controlledExpandItemValues, getDefaultExpandItemValues(data, {
+    defaultExpandAll,
+    valueKey,
+    childrenKey,
+    defaultExpandItemValues
+  }));
+  useEffect(() => {
     if (Array.isArray(controlledExpandItemValues)) {
       setExpandItemValues(controlledExpandItemValues);
     }
   }, [controlledExpandItemValues, setExpandItemValues]);
-  var handleExpandTreeNode = useEventCallback(function (node, expanded) {
-    var nextExpandItemValues = getExpandItemValues({
-      node: node,
+  const handleExpandTreeNode = useEventCallback((node, expanded) => {
+    const nextExpandItemValues = getExpandItemValues({
+      node,
       isExpand: !expanded,
-      expandItemValues: expandItemValues,
-      valueKey: valueKey
+      expandItemValues,
+      valueKey
     });
     setExpandItemValues(nextExpandItemValues);
     onExpand === null || onExpand === void 0 || onExpand(nextExpandItemValues, node, createConcatChildrenFunction(node, node[valueKey], {
-      valueKey: valueKey,
-      childrenKey: childrenKey
+      valueKey,
+      childrenKey
     }));
     if (isFunction(getChildren) && !node.expand && Array.isArray(node[childrenKey]) && node[childrenKey].length === 0) {
       appendChild(node, getChildren);
     }
   });
   return {
-    expandItemValues: expandItemValues,
-    handleExpandTreeNode: handleExpandTreeNode
+    expandItemValues,
+    handleExpandTreeNode
   };
 }
 export default useExpandTree;

package/esm/Tree/hooks/useFlattenTree.js

@@ -1,5 +1,4 @@
 'use client';
-import _extends from "@babel/runtime/helpers/esm/extends";
 import { useCallback, useRef, useEffect } from 'react';
 import omit from 'lodash/omit';
 import isNil from 'lodash/isNil';
@@ -11,61 +10,61 @@ import useForceUpdate from "./useForceUpdate.js";
  *
  */
 function useFlattenTree(data, options) {
-  var value = options.value,
-    labelKey = options.labelKey,
-    valueKey = options.valueKey,
-    childrenKey = options.childrenKey,
-    _options$uncheckableI = options.uncheckableItemValues,
-    uncheckableItemValues = _options$uncheckableI === void 0 ? [] : _options$uncheckableI,
-    cascade = options.cascade,
-    multiple = options.multiple,
-    callback = options.callback;
-  var forceUpdate = useForceUpdate();
-  var flattenedNodes = useRef({});
-  var updateTreeNodeCheckState = useCallback(function (value) {
+  const {
+    value,
+    labelKey,
+    valueKey,
+    childrenKey,
+    uncheckableItemValues = [],
+    cascade,
+    multiple,
+    callback
+  } = options;
+  const forceUpdate = useForceUpdate();
+  const flattenedNodes = useRef({});
+  const updateTreeNodeCheckState = useCallback(function (value) {
     if (value === void 0) {
       value = [];
     }
     // Reset values to false
-    Object.keys(flattenedNodes.current).forEach(function (refKey) {
-      var node = flattenedNodes.current[refKey];
+    Object.keys(flattenedNodes.current).forEach(refKey => {
+      const node = flattenedNodes.current[refKey];
       if (cascade && !isNil(node.parent) && !isNil(node.parent.refKey)) {
         node.check = flattenedNodes.current[node.parent.refKey].check;
       } else {
         node.check = false;
       }
-      value.forEach(function (nodeVal) {
-        if (shallowEqual(flattenedNodes.current[refKey][valueKey], nodeVal) && !uncheckableItemValues.some(function (uncheckableValue) {
-          return shallowEqual(nodeVal, uncheckableValue);
-        })) {
+      value.forEach(nodeVal => {
+        if (shallowEqual(flattenedNodes.current[refKey][valueKey], nodeVal) && !uncheckableItemValues.some(uncheckableValue => shallowEqual(nodeVal, uncheckableValue))) {
           flattenedNodes.current[refKey].check = true;
         }
       });
     });
   }, [cascade, uncheckableItemValues, valueKey]);
-  var flattenTreeData = useCallback(function (treeData, parent, layer) {
+  const flattenTreeData = useCallback(function (treeData, parent, layer) {
     if (layer === void 0) {
       layer = 1;
     }
     if (!Array.isArray(treeData) || treeData.length === 0) {
       return [];
     }
-    treeData.map(function (node) {
-      var _extends2;
-      var value = node[valueKey];
+    treeData.map(node => {
+      const value = node[valueKey];
       /**
        * because the value of the node's type is string or number,
        * so it can used as the key of the object directly
        * to avoid number value is converted to string. 1 and '1' will be convert to '1'
        * we used `String_` or `Number_` prefix
        */
-      var refKey = formatNodeRefKey(value);
+      const refKey = formatNodeRefKey(value);
       node.refKey = refKey;
-      flattenedNodes.current[refKey] = _extends((_extends2 = {
-        layer: layer
-      }, _extends2[labelKey] = node[labelKey], _extends2[valueKey] = node[valueKey], _extends2.uncheckable = uncheckableItemValues.some(function (value) {
-        return shallowEqual(node[valueKey], value);
-      }), _extends2), node);
+      flattenedNodes.current[refKey] = {
+        layer,
+        [labelKey]: node[labelKey],
+        [valueKey]: node[valueKey],
+        uncheckable: uncheckableItemValues.some(value => shallowEqual(node[valueKey], value)),
+        ...node
+      };
       if (parent) {
         flattenedNodes.current[refKey].parent = omit(parent, 'parent', 'children');
       }
@@ -74,13 +73,13 @@ function useFlattenTree(data, options) {
     callback === null || callback === void 0 || callback(flattenedNodes.current);
     forceUpdate();
   }, [callback, forceUpdate, valueKey, labelKey, uncheckableItemValues, childrenKey]);
-  useEffect(function () {
+  useEffect(() => {
     // when data is changed, should clear the flattenedNodes, avoid duplicate keys
     flattenedNodes.current = {};
     flattenTreeData(data);
   }, [data]); // eslint-disable-line react-hooks/exhaustive-deps
 
-  useEffect(function () {
+  useEffect(() => {
     if (multiple) {
       updateTreeNodeCheckState(value);
       forceUpdate();

package/esm/Tree/hooks/useFocusTree.d.ts

@@ -17,7 +17,7 @@ declare function useFocusTree(props: UseFocusTreeProps<TreeNode>): {
     focusTreeFirstNode: (...args: any[]) => any;
     focusItemValue: string | number | null | undefined;
     treeNodesRefs: {};
-    saveTreeNodeRef: (ref: import("react").Ref<any>, refKey?: string | undefined) => void;
+    saveTreeNodeRef: (ref: any, refKey?: string | undefined) => void;
     setFocusItemValue: import("react").Dispatch<import("react").SetStateAction<string | number | null | undefined>>;
     onTreeKeydown: (...args: any[]) => any;
 };