rsuite 5.76.0 → 6.0.0-canary-20241227

package/esm/Tree/hooks/useTreeNodeRefs.js

@@ -5,14 +5,14 @@ import isNil from 'lodash/isNil';
 /**
  * Custom hook that manages references to tree nodes. */
 export default function useTreeNodeRefs() {
-  var treeNodeRefs = useRef({});
-  var saveTreeNodeRef = function saveTreeNodeRef(ref, refKey) {
+  const treeNodeRefs = useRef({});
+  const saveTreeNodeRef = (ref, refKey) => {
     if (!isNil(refKey)) {
       treeNodeRefs.current[refKey] = ref;
     }
   };
   return {
     treeNodesRefs: treeNodeRefs.current,
-    saveTreeNodeRef: saveTreeNodeRef
+    saveTreeNodeRef
   };
 }

package/esm/Tree/hooks/useTreeSearch.js

@@ -7,63 +7,58 @@ import { useItemDataKeys } from "../../internals/Tree/TreeProvider.js";
  * Custom hook for searching and filtering data in a tree structure.
  */
 export default function useTreeSearch(props) {
-  var _useItemDataKeys = useItemDataKeys(),
-    labelKey = _useItemDataKeys.labelKey,
-    childrenKey = _useItemDataKeys.childrenKey;
-  var searchKeyword = props.searchKeyword,
-    data = props.data,
-    searchBy = props.searchBy,
-    callback = props.callback;
-  var filterVisibleData = useCallback(function (data, searchKeyword) {
-    var setVisible = function setVisible(nodes) {
-      return nodes.forEach(function (item) {
-        item.visible = searchBy ? searchBy(searchKeyword, item[labelKey], item) : shouldDisplay(item[labelKey], searchKeyword);
-        if (isArray(item[childrenKey])) {
-          filterVisibleData(item[childrenKey], searchKeyword);
-          item[childrenKey].forEach(function (child) {
-            if (child.visible) {
-              item.visible = child.visible;
-            }
-          });
-        }
-      });
-    };
+  const {
+    labelKey,
+    childrenKey
+  } = useItemDataKeys();
+  const {
+    searchKeyword,
+    data,
+    searchBy,
+    callback
+  } = props;
+  const filterVisibleData = useCallback((data, searchKeyword) => {
+    const setVisible = nodes => nodes.forEach(item => {
+      item.visible = searchBy ? searchBy(searchKeyword, item[labelKey], item) : shouldDisplay(item[labelKey], searchKeyword);
+      if (isArray(item[childrenKey])) {
+        filterVisibleData(item[childrenKey], searchKeyword);
+        item[childrenKey].forEach(child => {
+          if (child.visible) {
+            item.visible = child.visible;
+          }
+        });
+      }
+    });
     setVisible(data);
     return data;
   }, [childrenKey, labelKey, searchBy]);
 
   // Use search keywords to filter options.
-  var _useState = useState(searchKeyword !== null && searchKeyword !== void 0 ? searchKeyword : ''),
-    keyword = _useState[0],
-    setSearchKeyword = _useState[1];
-  var _useState2 = useState(function () {
-      return filterVisibleData(data, keyword);
-    }),
-    filteredData = _useState2[0],
-    setFilteredData = _useState2[1];
-  var handleSearch = function handleSearch(searchKeyword, event) {
-    var filteredData = filterVisibleData(data, searchKeyword);
+  const [keyword, setSearchKeyword] = useState(searchKeyword !== null && searchKeyword !== void 0 ? searchKeyword : '');
+  const [filteredData, setFilteredData] = useState(() => filterVisibleData(data, keyword));
+  const handleSearch = (searchKeyword, event) => {
+    const filteredData = filterVisibleData(data, searchKeyword);
     setFilteredData(filteredData);
     setSearchKeyword(searchKeyword);
     if (event) {
       callback === null || callback === void 0 || callback(searchKeyword, filteredData, event);
     }
   };
-  useEffect(function () {
+  useEffect(() => {
     handleSearch(searchKeyword !== null && searchKeyword !== void 0 ? searchKeyword : '');
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [searchKeyword]);
-  useEffect(function () {
+  useEffect(() => {
     setSearchKeyword(searchKeyword !== null && searchKeyword !== void 0 ? searchKeyword : '');
   }, [searchKeyword, setSearchKeyword]);
-  var setVisibleData = useCallback(function (data, searchKeyword) {
+  const setVisibleData = useCallback((data, searchKeyword) => {
     setFilteredData(filterVisibleData(data, searchKeyword));
   }, [filterVisibleData]);
   return {
-    keyword: keyword,
-    filteredData: filteredData,
+    keyword,
+    filteredData,
     setFilteredData: setVisibleData,
-    setSearchKeyword: setSearchKeyword,
-    handleSearch: handleSearch
+    setSearchKeyword,
+    handleSearch
   };
 }

package/esm/Tree/hooks/useTreeWithChildren.js

@@ -6,54 +6,40 @@ import { findNodeOfTree } from "../../internals/Tree/utils/index.js";
  * Custom hook that provides functionality for managing a tree structure with children.
  */
 export default function useTreeWithChildren(data, options) {
-  var valueKey = options.valueKey,
-    childrenKey = options.childrenKey;
-  var _useState = useState([]),
-    loadingNodeValues = _useState[0],
-    setLoadingNodeValues = _useState[1];
-  var _useState2 = useState(data),
-    treeData = _useState2[0],
-    setTreeData = _useState2[1];
-  useEffect(function () {
+  const {
+    valueKey,
+    childrenKey
+  } = options;
+  const [loadingNodeValues, setLoadingNodeValues] = useState([]);
+  const [treeData, setTreeData] = useState(data);
+  useEffect(() => {
     setTreeData(data);
   }, [data]);
-  var concatChildren = useCallback(function (treeNode, children) {
-    var value = treeNode[valueKey];
-    treeNode = findNodeOfTree(data, function (item) {
-      return value === item[valueKey];
-    });
+  const concatChildren = useCallback((treeNode, children) => {
+    const value = treeNode[valueKey];
+    treeNode = findNodeOfTree(data, item => value === item[valueKey]);
     treeNode[childrenKey] = children;
-    var newData = data.concat([]);
+    const newData = data.concat([]);
     setTreeData(newData);
     return newData;
   }, [data, valueKey, childrenKey]);
-  var appendChild = useCallback(function (node, getChildren) {
-    setLoadingNodeValues(function (prev) {
-      return prev.concat(node[valueKey]);
-    });
-    var children = getChildren(node);
+  const appendChild = useCallback((node, getChildren) => {
+    setLoadingNodeValues(prev => prev.concat(node[valueKey]));
+    const children = getChildren(node);
     if (children instanceof Promise) {
-      children.then(function (res) {
-        var newData = concatChildren(node, res);
+      children.then(res => {
+        const newData = concatChildren(node, res);
         setTreeData(newData);
-        setLoadingNodeValues(function (prev) {
-          return prev.filter(function (item) {
-            return !shallowEqual(item, node[valueKey]);
-          });
-        });
+        setLoadingNodeValues(prev => prev.filter(item => !shallowEqual(item, node[valueKey])));
       });
     } else {
       setTreeData(concatChildren(node, children));
-      setLoadingNodeValues(function (prev) {
-        return prev.filter(function (item) {
-          return !shallowEqual(item, node[valueKey]);
-        });
-      });
+      setLoadingNodeValues(prev => prev.filter(item => !shallowEqual(item, node[valueKey])));
     }
   }, [concatChildren, valueKey]);
   return {
-    treeData: treeData,
-    loadingNodeValues: loadingNodeValues,
-    appendChild: appendChild
+    treeData,
+    loadingNodeValues,
+    appendChild
   };
 }

package/esm/Tree/hooks/useVirtualizedTreeData.js

@@ -1,5 +1,4 @@
 'use client';
-import _extends from "@babel/runtime/helpers/esm/extends";
 import { useCallback } from 'react';
 import intersection from 'lodash/intersection';
 import isUndefined from 'lodash/isUndefined';
@@ -18,34 +17,37 @@ function shouldShowNodeByParentExpanded(expandItemValues, parentKeys) {
   if (parentKeys === void 0) {
     parentKeys = [];
   }
-  var intersectionKeys = intersection(expandItemValues, parentKeys);
+  const intersectionKeys = intersection(expandItemValues, parentKeys);
   if (intersectionKeys.length === parentKeys.length) {
     return true;
   }
   return false;
 }
 function useVirtualizedTreeData(nodes, data, options) {
-  var _useItemDataKeys = useItemDataKeys(),
-    childrenKey = _useItemDataKeys.childrenKey,
-    valueKey = _useItemDataKeys.valueKey;
+  const {
+    childrenKey,
+    valueKey
+  } = useItemDataKeys();
 
   /**
    * Formats the virtualized tree data.
    */
-  return useCallback(function () {
-    var cascade = options.cascade,
-      searchKeyword = options.searchKeyword,
-      expandItemValues = options.expandItemValues;
-    return UNSAFE_flattenTree(data, childrenKey, function (node) {
-      var formatted = {};
-      var curNode = nodes === null || nodes === void 0 ? void 0 : nodes[node.refKey];
-      var parentKeys = getNodeParentKeys(nodes, curNode, valueKey);
+  return useCallback(() => {
+    const {
+      cascade,
+      searchKeyword,
+      expandItemValues
+    } = options;
+    return UNSAFE_flattenTree(data, childrenKey, node => {
+      let formatted = {};
+      const curNode = nodes === null || nodes === void 0 ? void 0 : nodes[node.refKey];
+      const parentKeys = getNodeParentKeys(nodes, curNode, valueKey);
       /**
        * When using virtualized,
        * if the parent node is collapsed, the child nodes should be hidden
        * avoid component height calculation errors
        */
-      var visible = curNode !== null && curNode !== void 0 && curNode.parent ? shouldShowNodeByParentExpanded(expandItemValues, parentKeys) : true;
+      let visible = curNode !== null && curNode !== void 0 && curNode.parent ? shouldShowNodeByParentExpanded(expandItemValues, parentKeys) : true;
 
       /**
        * when searching, every node default expand
@@ -55,20 +57,21 @@ function useVirtualizedTreeData(nodes, data, options) {
         visible = node.visible;
       }
       if (curNode) {
-        var checkState = !isUndefined(cascade) ? getNodeCheckState(curNode, {
-          cascade: cascade,
-          nodes: nodes,
-          childrenKey: childrenKey
+        const checkState = !isUndefined(cascade) ? getNodeCheckState(curNode, {
+          cascade,
+          nodes,
+          childrenKey
         }) : undefined;
-        formatted = _extends({}, node, {
+        formatted = {
+          ...node,
           check: curNode.check,
           uncheckable: curNode.uncheckable,
           hasChildren: !!node[childrenKey],
           layer: curNode.layer,
           parent: curNode.parent,
-          checkState: checkState,
-          visible: visible
-        });
+          checkState,
+          visible
+        };
       }
       return formatted;
     });

package/esm/Tree/types.js

@@ -2,7 +2,7 @@
 /**
  * Tree Node Drag Type
  */
-export var TREE_NODE_DROP_POSITION = /*#__PURE__*/function (TREE_NODE_DROP_POSITION) {
+export let TREE_NODE_DROP_POSITION = /*#__PURE__*/function (TREE_NODE_DROP_POSITION) {
   TREE_NODE_DROP_POSITION[TREE_NODE_DROP_POSITION["DRAG_OVER"] = 0] = "DRAG_OVER";
   TREE_NODE_DROP_POSITION[TREE_NODE_DROP_POSITION["DRAG_OVER_TOP"] = 1] = "DRAG_OVER_TOP";
   TREE_NODE_DROP_POSITION[TREE_NODE_DROP_POSITION["DRAG_OVER_BOTTOM"] = 2] = "DRAG_OVER_BOTTOM";

package/esm/Tree/utils/flattenTree.js

@@ -1,13 +1,10 @@
 'use client';
-function _createForOfIteratorHelperLoose(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (t) return (t = t.call(r)).next.bind(t); if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var o = 0; return function () { return o >= r.length ? { done: !0 } : { done: !1, value: r[o++] }; }; } 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(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 import { attachParent } from "../../internals/utils/index.js";
 
 /**
  * Strategy for walking the tree.
  */
-export var WalkTreeStrategy = /*#__PURE__*/function (WalkTreeStrategy) {
+export let WalkTreeStrategy = /*#__PURE__*/function (WalkTreeStrategy) {
   WalkTreeStrategy[WalkTreeStrategy["DFS"] = 0] = "DFS";
   WalkTreeStrategy[WalkTreeStrategy["BFS"] = 1] = "BFS";
   return WalkTreeStrategy;
@@ -20,15 +17,11 @@ export function flattenTree(rootNodes, getChildren, walkStrategy) {
   if (walkStrategy === void 0) {
     walkStrategy = WalkTreeStrategy.BFS;
   }
-  var result = [];
+  const result = [];
   if (walkStrategy === WalkTreeStrategy.BFS) {
-    walkTreeBfs(rootNodes, getChildren, function (node) {
-      return result.push(node);
-    });
+    walkTreeBfs(rootNodes, getChildren, node => result.push(node));
   } else if (walkStrategy === WalkTreeStrategy.DFS) {
-    walkTreeDfs(rootNodes, getChildren, function (node) {
-      return result.push(node);
-    });
+    walkTreeDfs(rootNodes, getChildren, node => result.push(node));
   }
   return result;
 }
@@ -37,12 +30,12 @@ export function flattenTree(rootNodes, getChildren, walkStrategy) {
  * Walks the tree in a breadth-first search (BFS) manner.
  */
 export function walkTreeBfs(rootNodes, getChildren, callback) {
-  for (var queue = [].concat(rootNodes); queue.length > 0;) {
-    var node = queue.shift();
+  for (const queue = [...rootNodes]; queue.length > 0;) {
+    const node = queue.shift();
     callback(node);
-    var children = getChildren(node);
+    const children = getChildren(node);
     if (children) {
-      queue.push.apply(queue, children);
+      queue.push(...children);
     }
   }
 }
@@ -51,10 +44,9 @@ export function walkTreeBfs(rootNodes, getChildren, callback) {
  * Walks the tree in a depth-first search (DFS) manner.
  */
 export function walkTreeDfs(rootNodes, getChildren, callback) {
-  for (var _iterator = _createForOfIteratorHelperLoose(rootNodes), _step; !(_step = _iterator()).done;) {
-    var node = _step.value;
+  for (const node of rootNodes) {
     callback(node);
-    var children = getChildren(node);
+    const children = getChildren(node);
     if (children) {
       walkTreeDfs(children, getChildren, callback);
     }
@@ -70,19 +62,19 @@ export function UNSAFE_flattenTree(tree, childrenKey, executor) {
   if (childrenKey === void 0) {
     childrenKey = 'children';
   }
-  var flattenData = [];
-  var _traverse = function traverse(data, parent) {
+  const flattenData = [];
+  const traverse = (data, parent) => {
     if (!Array.isArray(data)) {
       return;
     }
-    data.forEach(function (item, index) {
-      var node = typeof executor === 'function' ? executor(item, index) : item;
+    data.forEach((item, index) => {
+      const node = typeof executor === 'function' ? executor(item, index) : item;
       flattenData.push(attachParent(node, parent));
       if (item[childrenKey]) {
-        _traverse(item[childrenKey], item);
+        traverse(item[childrenKey], item);
       }
     });
   };
-  _traverse(tree, null);
+  traverse(tree, null);
   return flattenData;
 }

package/esm/Tree/utils/focusableTree.js

@@ -1,34 +1,34 @@
 'use client';
 import { shallowEqual } from "../../internals/utils/index.js";
 // Active tree node selector
-var SELECTED_TREEITEM_SELECTOR = '[role="treeitem"][aria-selected="true"]';
+const SELECTED_TREEITEM_SELECTOR = '[role="treeitem"][aria-selected="true"]';
 
 /**
  * Retrieves the focusable items from the filtered data based on the provided props.
  * Excludes nodes that are not visible or are disabled.
  */
-export var getFocusableItems = function getFocusableItems(filteredData, props, isSearching) {
-  var disabledItemValues = props.disabledItemValues,
-    valueKey = props.valueKey,
-    childrenKey = props.childrenKey,
-    expandItemValues = props.expandItemValues;
-  var items = [];
-  var _loop = function loop(nodes) {
-    nodes.forEach(function (node) {
-      var disabled = disabledItemValues.some(function (disabledItem) {
-        return shallowEqual(disabledItem, node[valueKey]);
-      });
+export const getFocusableItems = (filteredData, props, isSearching) => {
+  const {
+    disabledItemValues,
+    valueKey,
+    childrenKey,
+    expandItemValues
+  } = props;
+  const items = [];
+  const loop = nodes => {
+    nodes.forEach(node => {
+      const disabled = disabledItemValues.some(disabledItem => shallowEqual(disabledItem, node[valueKey]));
       if (!disabled && node.visible) {
         items.push(node);
       }
       // always expand when searching
-      var expand = isSearching ? true : expandItemValues.includes(node[valueKey]);
+      const expand = isSearching ? true : expandItemValues.includes(node[valueKey]);
       if (node[childrenKey] && expand) {
-        _loop(node[childrenKey]);
+        loop(node[childrenKey]);
       }
     });
   };
-  _loop(filteredData);
+  loop(filteredData);
   return items;
 };
 
@@ -36,9 +36,9 @@ export var getFocusableItems = function getFocusableItems(filteredData, props, i
  * Returns the index of the active item in the focusItems array.
  *
  */
-var getActiveIndex = function getActiveIndex(focusItemValue, focusItems, valueKey) {
-  var activeIndex = -1;
-  focusItems.forEach(function (item, index) {
+const getActiveIndex = (focusItemValue, focusItems, valueKey) => {
+  let activeIndex = -1;
+  focusItems.forEach((item, index) => {
     if (shallowEqual(item[valueKey], focusItemValue)) {
       activeIndex = index;
     }
@@ -49,11 +49,9 @@ var getActiveIndex = function getActiveIndex(focusItemValue, focusItems, valueKe
 /**
  * Retrieves the active item from the flattened nodes based on the provided focus item value.
  */
-export var getActiveItem = function getActiveItem(focusItemValue, flattenedNodes, valueKey) {
-  var nodeData = null;
-  var activeNode = Object.values(flattenedNodes).find(function (node) {
-    return shallowEqual(node[valueKey], focusItemValue);
-  });
+export const getActiveItem = (focusItemValue, flattenedNodes, valueKey) => {
+  let nodeData = null;
+  const activeNode = Object.values(flattenedNodes).find(node => shallowEqual(node[valueKey], focusItemValue));
   if (activeNode) {
     nodeData = activeNode;
   }
@@ -64,25 +62,27 @@ export var getActiveItem = function getActiveItem(focusItemValue, flattenedNodes
  * Focuses on a specific tree node element.
  *
  */
-export var focusTreeNode = function focusTreeNode(refKey, treeNodeRefs) {
+export const focusTreeNode = (refKey, treeNodeRefs) => {
   var _treeItem$focus;
-  var treeItem = treeNodeRefs[refKey];
+  const treeItem = treeNodeRefs[refKey];
   treeItem === null || treeItem === void 0 || (_treeItem$focus = treeItem.focus) === null || _treeItem$focus === void 0 || _treeItem$focus.call(treeItem);
 };
 /**
  * Focuses on the next item in a tree.
  */
-export var focusNextItem = function focusNextItem(props) {
-  var focusItemValue = props.focusItemValue,
-    focusableItems = props.focusableItems,
-    treeNodesRefs = props.treeNodesRefs,
-    valueKey = props.valueKey;
-  var activeIndex = getActiveIndex(focusItemValue, focusableItems, valueKey);
+export const focusNextItem = props => {
+  const {
+    focusItemValue,
+    focusableItems,
+    treeNodesRefs,
+    valueKey
+  } = props;
+  const activeIndex = getActiveIndex(focusItemValue, focusableItems, valueKey);
   if (focusableItems.length === 0) {
     return;
   }
-  var nextIndex = activeIndex === focusableItems.length - 1 ? 0 : activeIndex + 1;
-  var value = focusableItems[nextIndex][valueKey];
+  const nextIndex = activeIndex === focusableItems.length - 1 ? 0 : activeIndex + 1;
+  const value = focusableItems[nextIndex][valueKey];
   focusTreeNode(focusableItems[nextIndex].refKey, treeNodesRefs);
   return value;
 };
@@ -90,18 +90,20 @@ export var focusNextItem = function focusNextItem(props) {
 /**
  * Focuses on the previous item in a tree.
  */
-export var focusPreviousItem = function focusPreviousItem(props) {
-  var focusItemValue = props.focusItemValue,
-    focusableItems = props.focusableItems,
-    treeNodesRefs = props.treeNodesRefs,
-    valueKey = props.valueKey;
-  var activeIndex = getActiveIndex(focusItemValue, focusableItems, valueKey);
+export const focusPreviousItem = props => {
+  const {
+    focusItemValue,
+    focusableItems,
+    treeNodesRefs,
+    valueKey
+  } = props;
+  const activeIndex = getActiveIndex(focusItemValue, focusableItems, valueKey);
   if (focusableItems.length === 0) {
     return;
   }
-  var prevIndex = activeIndex === 0 ? focusableItems.length - 1 : activeIndex - 1;
+  let prevIndex = activeIndex === 0 ? focusableItems.length - 1 : activeIndex - 1;
   prevIndex = prevIndex >= 0 ? prevIndex : 0;
-  var value = focusableItems[prevIndex][valueKey];
+  const value = focusableItems[prevIndex][valueKey];
   focusTreeNode(focusableItems[prevIndex].refKey, treeNodesRefs);
   return value;
 };
@@ -109,12 +111,8 @@ export var focusPreviousItem = function focusPreviousItem(props) {
 /**
  * Returns the index of the first visible node in the tree that matches the given value.
  */
-var getScrollToIndex = function getScrollToIndex(nodes, value, valueKey) {
-  return nodes.filter(function (n) {
-    return n.visible;
-  }).findIndex(function (item) {
-    return item[valueKey] === value;
-  });
+const getScrollToIndex = (nodes, value, valueKey) => {
+  return nodes.filter(n => n.visible).findIndex(item => item[valueKey] === value);
 };
 /**
  * Scrolls the list to the active tree node.
@@ -122,22 +120,25 @@ var getScrollToIndex = function getScrollToIndex(nodes, value, valueKey) {
  * @param props - The props object containing the necessary parameters.
  */
 export function scrollToActiveTreeNode(props) {
-  var list = props.list,
-    value = props.value,
-    valueKey = props.valueKey,
-    virtualized = props.virtualized,
-    formattedNodes = props.formattedNodes;
+  const {
+    list,
+    value,
+    valueKey,
+    virtualized,
+    formattedNodes
+  } = props;
   if (virtualized && value) {
     var _list$scrollToItem;
-    var scrollIndex = getScrollToIndex(formattedNodes, value, valueKey);
+    const scrollIndex = getScrollToIndex(formattedNodes, value, valueKey);
     list === null || list === void 0 || (_list$scrollToItem = list.scrollToItem) === null || _list$scrollToItem === void 0 || _list$scrollToItem.call(list, scrollIndex);
   }
 }
-export var focusCurrentItem = function focusCurrentItem(props) {
-  var _props$selector = props.selector,
-    selector = _props$selector === void 0 ? SELECTED_TREEITEM_SELECTOR : _props$selector,
-    container = props.container;
-  var activeItem = container === null || container === void 0 ? void 0 : container.querySelector(selector);
+export const focusCurrentItem = props => {
+  const {
+    selector = SELECTED_TREEITEM_SELECTOR,
+    container
+  } = props;
+  const activeItem = container === null || container === void 0 ? void 0 : container.querySelector(selector);
   if (activeItem) {
     var _activeItem$focus, _activeItem$dataset;
     activeItem === null || activeItem === void 0 || (_activeItem$focus = activeItem.focus) === null || _activeItem$focus === void 0 || _activeItem$focus.call(activeItem);

package/esm/Tree/utils/formatNodeRefKey.js

@@ -3,5 +3,5 @@
  * Formats the reference key for a tree node.
  */
 export function formatNodeRefKey(value) {
-  return "" + (typeof value === 'number' ? 'Number_' : 'String_') + value;
+  return `${typeof value === 'number' ? 'Number_' : 'String_'}${value}`;
 }

package/esm/Tree/utils/getExpandItemValues.js

@@ -3,11 +3,13 @@
  * Returns an array of expanded item values.
  */
 export function getExpandItemValues(_ref) {
-  var node = _ref.node,
-    isExpand = _ref.isExpand,
-    expandItemValues = _ref.expandItemValues,
-    valueKey = _ref.valueKey;
-  var newExpandItemValues = new Set(expandItemValues);
+  let {
+    node,
+    isExpand,
+    expandItemValues,
+    valueKey
+  } = _ref;
+  const newExpandItemValues = new Set(expandItemValues);
   if (isExpand) {
     newExpandItemValues.add(node[valueKey]);
   } else {

package/esm/Tree/utils/getNodeParentKeys.js

@@ -3,15 +3,15 @@
  * Retrieves an array of parent keys for a given node in a tree.
  */
 export function getNodeParentKeys(nodes, node, valueKey) {
-  var parentKeys = [];
-  var _traverse = function traverse(node) {
+  const parentKeys = [];
+  const traverse = node => {
     var _node$parent;
     if (node !== null && node !== void 0 && (_node$parent = node.parent) !== null && _node$parent !== void 0 && _node$parent.refKey) {
       var _node$parent2;
-      _traverse(nodes[node.parent.refKey]);
+      traverse(nodes[node.parent.refKey]);
       parentKeys.push(node === null || node === void 0 || (_node$parent2 = node.parent) === null || _node$parent2 === void 0 ? void 0 : _node$parent2[valueKey]);
     }
   };
-  _traverse(node);
+  traverse(node);
   return parentKeys;
 }

package/esm/Tree/utils/getTreeActiveNode.js

@@ -7,8 +7,8 @@ export function getTreeActiveNode(nodes, value, valueKey) {
   if (typeof value === 'undefined') {
     return;
   }
-  for (var refKey in nodes) {
-    var node = nodes[refKey];
+  for (const refKey in nodes) {
+    const node = nodes[refKey];
     if (shallowEqual(node[valueKey], value)) {
       return node;
     }

package/esm/Tree/utils/hasVisibleChildren.js

@@ -6,7 +6,5 @@ export function hasVisibleChildren(node, childrenKey) {
   if (!Array.isArray(node[childrenKey])) {
     return false;
   }
-  return node[childrenKey].some(function (child) {
-    return child.visible;
-  });
+  return node[childrenKey].some(child => child.visible);
 }