rsuite 5.60.2 → 5.61.0

package/cjs/Tree/utils/flattenTree.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Strategy for walking the tree.
+ */
+export declare enum WalkTreeStrategy {
+    DFS = 0,
+    BFS = 1
+}
+/**
+ * Flattens a tree structure into an array.
+ */
+export declare function flattenTree<T>(rootNodes: readonly T[], getChildren: (node: T) => readonly T[] | undefined, walkStrategy?: WalkTreeStrategy): T[];
+/**
+ * Walks the tree in a breadth-first search (BFS) manner.
+ */
+export declare function walkTreeBfs<T>(rootNodes: readonly T[], getChildren: (node: T) => readonly T[] | undefined, callback: (node: T) => void): void;
+/**
+ * Walks the tree in a depth-first search (DFS) manner.
+ */
+export declare function walkTreeDfs<T>(rootNodes: readonly T[], getChildren: (node: T) => readonly T[] | undefined, callback: (node: T) => void): void;
+/**
+ * Flattens a tree structure to an array (deprecated).
+ * @deprecated This function is considered unsafe because it mutates the `tree` argument in-place.
+ *             Use the `flattenTree` function instead.
+ */
+export declare function UNSAFE_flattenTree<TItem>(tree: TItem[], childrenKey?: string, executor?: (node: any, index: number) => any): TItem[];

package/cjs/Tree/utils/flattenTree.js

@@ -0,0 +1,95 @@
+'use client';
+"use strict";
+
+exports.__esModule = true;
+exports.flattenTree = flattenTree;
+exports.walkTreeBfs = walkTreeBfs;
+exports.walkTreeDfs = walkTreeDfs;
+exports.UNSAFE_flattenTree = UNSAFE_flattenTree;
+exports.WalkTreeStrategy = void 0;
+var _attachParent = require("../../utils/attachParent");
+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; }
+/**
+ * Strategy for walking the tree.
+ */
+var WalkTreeStrategy;
+/**
+ * Flattens a tree structure into an array.
+ */
+exports.WalkTreeStrategy = WalkTreeStrategy;
+(function (WalkTreeStrategy) {
+  WalkTreeStrategy[WalkTreeStrategy["DFS"] = 0] = "DFS";
+  WalkTreeStrategy[WalkTreeStrategy["BFS"] = 1] = "BFS";
+})(WalkTreeStrategy || (exports.WalkTreeStrategy = WalkTreeStrategy = {}));
+function flattenTree(rootNodes, getChildren, walkStrategy) {
+  if (walkStrategy === void 0) {
+    walkStrategy = WalkTreeStrategy.BFS;
+  }
+  var result = [];
+  if (walkStrategy === WalkTreeStrategy.BFS) {
+    walkTreeBfs(rootNodes, getChildren, function (node) {
+      return result.push(node);
+    });
+  } else if (walkStrategy === WalkTreeStrategy.DFS) {
+    walkTreeDfs(rootNodes, getChildren, function (node) {
+      return result.push(node);
+    });
+  }
+  return result;
+}
+
+/**
+ * Walks the tree in a breadth-first search (BFS) manner.
+ */
+function walkTreeBfs(rootNodes, getChildren, callback) {
+  for (var queue = [].concat(rootNodes); queue.length > 0;) {
+    var _node = queue.shift();
+    callback(_node);
+    var children = getChildren(_node);
+    if (children) {
+      queue.push.apply(queue, children);
+    }
+  }
+}
+
+/**
+ * Walks the tree in a depth-first search (DFS) manner.
+ */
+function walkTreeDfs(rootNodes, getChildren, callback) {
+  for (var _iterator = _createForOfIteratorHelperLoose(rootNodes), _step; !(_step = _iterator()).done;) {
+    var _node2 = _step.value;
+    callback(_node2);
+    var children = getChildren(_node2);
+    if (children) {
+      walkTreeDfs(children, getChildren, callback);
+    }
+  }
+}
+
+/**
+ * Flattens a tree structure to an array (deprecated).
+ * @deprecated This function is considered unsafe because it mutates the `tree` argument in-place.
+ *             Use the `flattenTree` function instead.
+ */
+function UNSAFE_flattenTree(tree, childrenKey, executor) {
+  if (childrenKey === void 0) {
+    childrenKey = 'children';
+  }
+  var flattenData = [];
+  var traverse = function traverse(data, parent) {
+    if (!Array.isArray(data)) {
+      return;
+    }
+    data.forEach(function (item, index) {
+      var node = typeof executor === 'function' ? executor(item, index) : item;
+      flattenData.push((0, _attachParent.attachParent)(node, parent));
+      if (item[childrenKey]) {
+        traverse(item[childrenKey], item);
+      }
+    });
+  };
+  traverse(tree, null);
+  return flattenData;
+}

package/cjs/Tree/utils/focusableTree.d.ts

@@ -0,0 +1,55 @@
+import { TreeNode, TreeNodeMap } from '../types';
+import { ListHandle } from '../../internals/Windowing';
+interface FocusableItemsProps {
+    disabledItemValues: any;
+    valueKey: string;
+    childrenKey: string;
+    expandItemValues: any;
+}
+/**
+ * Retrieves the focusable items from the filtered data based on the provided props.
+ * Excludes nodes that are not visible or are disabled.
+ */
+export declare const getFocusableItems: <TItem extends TreeNode>(filteredData: TItem[], props: FocusableItemsProps, isSearching?: boolean) => TItem[];
+/**
+ * Retrieves the active item from the flattened nodes based on the provided focus item value.
+ */
+export declare const getActiveItem: (focusItemValue: string | number, flattenedNodes: TreeNodeMap, valueKey: string) => any;
+/**
+ * Focuses on a specific tree node element.
+ *
+ */
+export declare const focusTreeNode: (refKey: string, treeNodeRefs: any) => void;
+interface FocusItemProps {
+    focusItemValue?: string | number | null;
+    focusableItems: any[];
+    treeNodesRefs: any;
+    selector?: string;
+    valueKey: string;
+}
+/**
+ * Focuses on the next item in a tree.
+ */
+export declare const focusNextItem: (props: FocusItemProps) => any;
+/**
+ * Focuses on the previous item in a tree.
+ */
+export declare const focusPreviousItem: (props: FocusItemProps) => any;
+interface ScrollToActiveTreeNodeProps {
+    value: any;
+    valueKey: string;
+    virtualized: boolean;
+    list?: ListHandle;
+    formattedNodes: TreeNode[];
+}
+/**
+ * Scrolls the list to the active tree node.
+ *
+ * @param props - The props object containing the necessary parameters.
+ */
+export declare function scrollToActiveTreeNode(props: ScrollToActiveTreeNodeProps): void;
+export declare const focusCurrentItem: (props: {
+    selector?: string;
+    container?: HTMLElement | null;
+}) => string | undefined;
+export {};

package/cjs/Tree/utils/focusableTree.js

@@ -0,0 +1,157 @@
+'use client';
+"use strict";
+
+exports.__esModule = true;
+exports.scrollToActiveTreeNode = scrollToActiveTreeNode;
+exports.focusCurrentItem = exports.focusPreviousItem = exports.focusNextItem = exports.focusTreeNode = exports.getActiveItem = exports.getFocusableItems = void 0;
+var _utils = require("../../utils");
+// Active tree node selector
+var 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.
+ */
+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 (0, _utils.shallowEqual)(disabledItem, node[valueKey]);
+      });
+      if (!disabled && node.visible) {
+        items.push(node);
+      }
+      // always expand when searching
+      var expand = isSearching ? true : expandItemValues.includes(node[valueKey]);
+      if (node[childrenKey] && expand) {
+        loop(node[childrenKey]);
+      }
+    });
+  };
+  loop(filteredData);
+  return items;
+};
+
+/**
+ * Returns the index of the active item in the focusItems array.
+ *
+ */
+exports.getFocusableItems = getFocusableItems;
+var getActiveIndex = function getActiveIndex(focusItemValue, focusItems, valueKey) {
+  var activeIndex = -1;
+  focusItems.forEach(function (item, index) {
+    if ((0, _utils.shallowEqual)(item[valueKey], focusItemValue)) {
+      activeIndex = index;
+    }
+  });
+  return activeIndex;
+};
+
+/**
+ * Retrieves the active item from the flattened nodes based on the provided focus item value.
+ */
+var getActiveItem = function getActiveItem(focusItemValue, flattenedNodes, valueKey) {
+  var nodeData = null;
+  var activeNode = Object.values(flattenedNodes).find(function (node) {
+    return (0, _utils.shallowEqual)(node[valueKey], focusItemValue);
+  });
+  if (activeNode) {
+    nodeData = activeNode;
+  }
+  return nodeData;
+};
+
+/**
+ * Focuses on a specific tree node element.
+ *
+ */
+exports.getActiveItem = getActiveItem;
+var focusTreeNode = function focusTreeNode(refKey, treeNodeRefs) {
+  var _treeItem$focus;
+  var treeItem = treeNodeRefs[refKey];
+  treeItem === null || treeItem === void 0 ? void 0 : (_treeItem$focus = treeItem.focus) === null || _treeItem$focus === void 0 ? void 0 : _treeItem$focus.call(treeItem);
+};
+exports.focusTreeNode = focusTreeNode;
+/**
+ * Focuses on the next item in a tree.
+ */
+var focusNextItem = function focusNextItem(props) {
+  var focusItemValue = props.focusItemValue,
+    focusableItems = props.focusableItems,
+    treeNodesRefs = props.treeNodesRefs,
+    valueKey = props.valueKey;
+  var activeIndex = getActiveIndex(focusItemValue, focusableItems, valueKey);
+  if (focusableItems.length === 0) {
+    return;
+  }
+  var nextIndex = activeIndex === focusableItems.length - 1 ? 0 : activeIndex + 1;
+  var value = focusableItems[nextIndex][valueKey];
+  focusTreeNode(focusableItems[nextIndex].refKey, treeNodesRefs);
+  return value;
+};
+
+/**
+ * Focuses on the previous item in a tree.
+ */
+exports.focusNextItem = focusNextItem;
+var focusPreviousItem = function focusPreviousItem(props) {
+  var focusItemValue = props.focusItemValue,
+    focusableItems = props.focusableItems,
+    treeNodesRefs = props.treeNodesRefs,
+    valueKey = props.valueKey;
+  var activeIndex = getActiveIndex(focusItemValue, focusableItems, valueKey);
+  if (focusableItems.length === 0) {
+    return;
+  }
+  var prevIndex = activeIndex === 0 ? focusableItems.length - 1 : activeIndex - 1;
+  prevIndex = prevIndex >= 0 ? prevIndex : 0;
+  var value = focusableItems[prevIndex][valueKey];
+  focusTreeNode(focusableItems[prevIndex].refKey, treeNodesRefs);
+  return value;
+};
+
+/**
+ * Returns the index of the first visible node in the tree that matches the given value.
+ */
+exports.focusPreviousItem = focusPreviousItem;
+var getScrollToIndex = function getScrollToIndex(nodes, value, valueKey) {
+  return nodes.filter(function (n) {
+    return n.visible;
+  }).findIndex(function (item) {
+    return item[valueKey] === value;
+  });
+};
+/**
+ * Scrolls the list to the active tree node.
+ *
+ * @param props - The props object containing the necessary parameters.
+ */
+function scrollToActiveTreeNode(props) {
+  var list = props.list,
+    value = props.value,
+    valueKey = props.valueKey,
+    virtualized = props.virtualized,
+    formattedNodes = props.formattedNodes;
+  if (virtualized && value) {
+    var _list$scrollToItem;
+    var scrollIndex = getScrollToIndex(formattedNodes, value, valueKey);
+    list === null || list === void 0 ? void 0 : (_list$scrollToItem = list.scrollToItem) === null || _list$scrollToItem === void 0 ? void 0 : _list$scrollToItem.call(list, scrollIndex);
+  }
+}
+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);
+  if (activeItem) {
+    var _activeItem$focus, _activeItem$dataset;
+    activeItem === null || activeItem === void 0 ? void 0 : (_activeItem$focus = activeItem.focus) === null || _activeItem$focus === void 0 ? void 0 : _activeItem$focus.call(activeItem);
+    return (_activeItem$dataset = activeItem.dataset) === null || _activeItem$dataset === void 0 ? void 0 : _activeItem$dataset.key;
+  }
+};
+exports.focusCurrentItem = focusCurrentItem;

package/cjs/Tree/utils/formatNodeRefKey.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Formats the reference key for a tree node.
+ */
+export declare function formatNodeRefKey(value: string | number): string;

package/cjs/Tree/utils/formatNodeRefKey.js

@@ -0,0 +1,11 @@
+'use client';
+"use strict";
+
+exports.__esModule = true;
+exports.formatNodeRefKey = formatNodeRefKey;
+/**
+ * Formats the reference key for a tree node.
+ */
+function formatNodeRefKey(value) {
+  return "" + (typeof value === 'number' ? 'Number_' : 'String_') + value;
+}

package/cjs/Tree/utils/getExpandItemValues.d.ts

@@ -0,0 +1,11 @@
+interface ExpandOptions<T> {
+    node: Record<string, unknown>;
+    isExpand: boolean;
+    expandItemValues: T[];
+    valueKey: string;
+}
+/**
+ * Returns an array of expanded item values.
+ */
+export declare function getExpandItemValues<T>({ node, isExpand, expandItemValues, valueKey }: ExpandOptions<T>): T[];
+export {};

package/cjs/Tree/utils/getExpandItemValues.js

@@ -0,0 +1,21 @@
+'use client';
+"use strict";
+
+exports.__esModule = true;
+exports.getExpandItemValues = getExpandItemValues;
+/**
+ * Returns an array of expanded item values.
+ */
+function getExpandItemValues(_ref) {
+  var node = _ref.node,
+    isExpand = _ref.isExpand,
+    expandItemValues = _ref.expandItemValues,
+    valueKey = _ref.valueKey;
+  var newExpandItemValues = new Set(expandItemValues);
+  if (isExpand) {
+    newExpandItemValues.add(node[valueKey]);
+  } else {
+    newExpandItemValues.delete(node[valueKey]);
+  }
+  return Array.from(newExpandItemValues);
+}

package/cjs/Tree/utils/getNodeParentKeys.d.ts

@@ -0,0 +1,5 @@
+import { TreeNode, TreeNodeMap } from '../types';
+/**
+ * Retrieves an array of parent keys for a given node in a tree.
+ */
+export declare function getNodeParentKeys<T>(nodes: TreeNodeMap, node: TreeNode, valueKey: string): T[];

package/cjs/Tree/utils/getNodeParentKeys.js

@@ -0,0 +1,21 @@
+'use client';
+"use strict";
+
+exports.__esModule = true;
+exports.getNodeParentKeys = getNodeParentKeys;
+/**
+ * Retrieves an array of parent keys for a given node in a tree.
+ */
+function getNodeParentKeys(nodes, node, valueKey) {
+  var parentKeys = [];
+  var traverse = function 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]);
+      parentKeys.push(node === null || node === void 0 ? void 0 : (_node$parent2 = node.parent) === null || _node$parent2 === void 0 ? void 0 : _node$parent2[valueKey]);
+    }
+  };
+  traverse(node);
+  return parentKeys;
+}

package/cjs/Tree/utils/getTreeActiveNode.d.ts

@@ -0,0 +1,5 @@
+import { TreeNodeMap } from '../types';
+/**
+ * Retrieves the active node from a tree based on the provided value and value key.
+ */
+export declare function getTreeActiveNode<T extends number | string | undefined | null>(nodes: TreeNodeMap, value: T, valueKey: string): import("../types").TreeNode | undefined;

package/cjs/Tree/utils/getTreeActiveNode.js

@@ -0,0 +1,21 @@
+'use client';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.getTreeActiveNode = getTreeActiveNode;
+var _shallowEqual = _interopRequireDefault(require("../../utils/shallowEqual"));
+/**
+ * Retrieves the active node from a tree based on the provided value and value key.
+ */
+function getTreeActiveNode(nodes, value, valueKey) {
+  if (typeof value === 'undefined') {
+    return;
+  }
+  for (var refKey in nodes) {
+    var node = nodes[refKey];
+    if ((0, _shallowEqual.default)(node[valueKey], value)) {
+      return node;
+    }
+  }
+}

package/cjs/Tree/utils/hasVisibleChildren.d.ts

@@ -0,0 +1,5 @@
+import { TreeNode } from '../types';
+/**
+ * Checks if a node has visible children.
+ */
+export declare function hasVisibleChildren(node: TreeNode, childrenKey: string): any;

package/cjs/Tree/utils/hasVisibleChildren.js

@@ -0,0 +1,16 @@
+'use client';
+"use strict";
+
+exports.__esModule = true;
+exports.hasVisibleChildren = hasVisibleChildren;
+/**
+ * Checks if a node has visible children.
+ */
+function hasVisibleChildren(node, childrenKey) {
+  if (!Array.isArray(node[childrenKey])) {
+    return false;
+  }
+  return node[childrenKey].some(function (child) {
+    return child.visible;
+  });
+}

package/cjs/Tree/utils/indentTreeNode.d.ts

@@ -0,0 +1,3 @@
+export declare function indentTreeNode(rtl: any, layer: any, absolute?: boolean): {
+    [x: string]: number;
+};

package/cjs/Tree/utils/indentTreeNode.js

@@ -0,0 +1,18 @@
+'use client';
+"use strict";
+
+exports.__esModule = true;
+exports.indentTreeNode = indentTreeNode;
+function indentTreeNode(rtl, layer, absolute) {
+  var _ref2;
+  if (absolute === void 0) {
+    absolute = false;
+  }
+  // layer start from 1
+  var offset = layer * 26;
+  if (absolute) {
+    var _ref;
+    return _ref = {}, _ref[rtl ? 'right' : 'left'] = offset, _ref;
+  }
+  return _ref2 = {}, _ref2[rtl ? 'paddingRight' : 'paddingLeft'] = offset, _ref2;
+}

package/cjs/Tree/utils/index.d.ts

@@ -0,0 +1,11 @@
+export { getNodeParentKeys } from './getNodeParentKeys';
+export { UNSAFE_flattenTree, flattenTree, WalkTreeStrategy } from './flattenTree';
+export { hasVisibleChildren } from './hasVisibleChildren';
+export { getExpandItemValues } from './getExpandItemValues';
+export { getTreeActiveNode } from './getTreeActiveNode';
+export { formatNodeRefKey } from './formatNodeRefKey';
+export { indentTreeNode } from './indentTreeNode';
+export { isSearching } from './isSearching';
+export { isExpand } from './isExpand';
+export { getFocusableItems, getActiveItem, focusNextItem, focusPreviousItem, focusTreeNode, focusCurrentItem } from './focusableTree';
+export { handleLeftArrow, handleRightArrow } from './treeKeyboardInteractions';

package/cjs/Tree/utils/index.js

@@ -0,0 +1,35 @@
+'use client';
+"use strict";
+
+exports.__esModule = true;
+exports.handleRightArrow = exports.handleLeftArrow = exports.focusCurrentItem = exports.focusTreeNode = exports.focusPreviousItem = exports.focusNextItem = exports.getActiveItem = exports.getFocusableItems = exports.isExpand = exports.isSearching = exports.indentTreeNode = exports.formatNodeRefKey = exports.getTreeActiveNode = exports.getExpandItemValues = exports.hasVisibleChildren = exports.WalkTreeStrategy = exports.flattenTree = exports.UNSAFE_flattenTree = exports.getNodeParentKeys = void 0;
+var _getNodeParentKeys = require("./getNodeParentKeys");
+exports.getNodeParentKeys = _getNodeParentKeys.getNodeParentKeys;
+var _flattenTree = require("./flattenTree");
+exports.UNSAFE_flattenTree = _flattenTree.UNSAFE_flattenTree;
+exports.flattenTree = _flattenTree.flattenTree;
+exports.WalkTreeStrategy = _flattenTree.WalkTreeStrategy;
+var _hasVisibleChildren = require("./hasVisibleChildren");
+exports.hasVisibleChildren = _hasVisibleChildren.hasVisibleChildren;
+var _getExpandItemValues = require("./getExpandItemValues");
+exports.getExpandItemValues = _getExpandItemValues.getExpandItemValues;
+var _getTreeActiveNode = require("./getTreeActiveNode");
+exports.getTreeActiveNode = _getTreeActiveNode.getTreeActiveNode;
+var _formatNodeRefKey = require("./formatNodeRefKey");
+exports.formatNodeRefKey = _formatNodeRefKey.formatNodeRefKey;
+var _indentTreeNode = require("./indentTreeNode");
+exports.indentTreeNode = _indentTreeNode.indentTreeNode;
+var _isSearching = require("./isSearching");
+exports.isSearching = _isSearching.isSearching;
+var _isExpand = require("./isExpand");
+exports.isExpand = _isExpand.isExpand;
+var _focusableTree = require("./focusableTree");
+exports.getFocusableItems = _focusableTree.getFocusableItems;
+exports.getActiveItem = _focusableTree.getActiveItem;
+exports.focusNextItem = _focusableTree.focusNextItem;
+exports.focusPreviousItem = _focusableTree.focusPreviousItem;
+exports.focusTreeNode = _focusableTree.focusTreeNode;
+exports.focusCurrentItem = _focusableTree.focusCurrentItem;
+var _treeKeyboardInteractions = require("./treeKeyboardInteractions");
+exports.handleLeftArrow = _treeKeyboardInteractions.handleLeftArrow;
+exports.handleRightArrow = _treeKeyboardInteractions.handleRightArrow;

package/cjs/Tree/utils/isExpand.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Determines whether the tree node should be expanded based on the search keyword and expand flag.
+ * If a search keyword is provided, the node is always expanded.
+ * Otherwise, the node is expanded if the expand flag is true.
+ */
+export declare function isExpand(searchKeyword: string, expand: boolean): boolean;

package/cjs/Tree/utils/isExpand.js

@@ -0,0 +1,14 @@
+'use client';
+"use strict";
+
+exports.__esModule = true;
+exports.isExpand = isExpand;
+var _isSearching = require("./isSearching");
+/**
+ * Determines whether the tree node should be expanded based on the search keyword and expand flag.
+ * If a search keyword is provided, the node is always expanded.
+ * Otherwise, the node is expanded if the expand flag is true.
+ */
+function isExpand(searchKeyword, expand) {
+  return (0, _isSearching.isSearching)(searchKeyword) ? true : expand;
+}

package/cjs/Tree/utils/isSearching.d.ts

@@ -0,0 +1 @@
+export declare function isSearching(searchKeyword?: string): boolean;

package/cjs/Tree/utils/isSearching.js

@@ -0,0 +1,10 @@
+'use client';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.isSearching = isSearching;
+var _isEmpty = _interopRequireDefault(require("lodash/isEmpty"));
+function isSearching(searchKeyword) {
+  return !(0, _isEmpty.default)(searchKeyword);
+}

package/cjs/Tree/utils/treeKeyboardInteractions.d.ts

@@ -0,0 +1,21 @@
+import { TreeNode } from '../types';
+export interface ArrowHandlerProps {
+    focusItem: TreeNode;
+    expand: boolean;
+    childrenKey: string;
+    onExpand?: (focusItem: TreeNode, expanded: boolean) => void;
+    onFocusItem: () => void;
+}
+/**
+ * Handles the left arrow key press event for tree navigation.
+ * If the focus item is expanded, it collapses it. If the focus item is not expanded and has a parent,
+ * it moves the focus to the parent item.
+ */
+export declare function handleLeftArrow(props: ArrowHandlerProps): void;
+/**
+ * Handles the right arrow key press event for tree navigation.
+ * If the focused item has children and is collapsed, it expands the item.
+ * If the focused item has children and is expanded, it moves the focus to the next sibling.
+ * If the focused item does not have children, it does nothing.
+ */
+export declare function handleRightArrow(props: ArrowHandlerProps): void;

package/cjs/Tree/utils/treeKeyboardInteractions.js

@@ -0,0 +1,49 @@
+'use client';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.handleLeftArrow = handleLeftArrow;
+exports.handleRightArrow = handleRightArrow;
+var _isEmpty = _interopRequireDefault(require("lodash/isEmpty"));
+/**
+ * Handles the left arrow key press event for tree navigation.
+ * If the focus item is expanded, it collapses it. If the focus item is not expanded and has a parent,
+ * it moves the focus to the parent item.
+ */
+function handleLeftArrow(props) {
+  var focusItem = props.focusItem,
+    expand = props.expand,
+    onExpand = props.onExpand,
+    onFocusItem = props.onFocusItem;
+  if ((0, _isEmpty.default)(focusItem)) {
+    return;
+  }
+  if (expand) {
+    onExpand === null || onExpand === void 0 ? void 0 : onExpand(focusItem, expand);
+  } else if (focusItem !== null && focusItem !== void 0 && focusItem.parent) {
+    onFocusItem();
+  }
+}
+
+/**
+ * Handles the right arrow key press event for tree navigation.
+ * If the focused item has children and is collapsed, it expands the item.
+ * If the focused item has children and is expanded, it moves the focus to the next sibling.
+ * If the focused item does not have children, it does nothing.
+ */
+function handleRightArrow(props) {
+  var focusItem = props.focusItem,
+    expand = props.expand,
+    childrenKey = props.childrenKey,
+    onExpand = props.onExpand,
+    onFocusItem = props.onFocusItem;
+  if ((0, _isEmpty.default)(focusItem) || !Array.isArray(focusItem[childrenKey])) {
+    return;
+  }
+  if (!expand) {
+    onExpand === null || onExpand === void 0 ? void 0 : onExpand(focusItem, expand);
+  } else {
+    onFocusItem();
+  }
+}