@choice-ui/react 1.3.13 → 1.4.0

package/dist/cjs/components/tree-list/src/tree-list.cjs

@@ -1,419 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require$$0 = require("react/jsx-runtime");
-const index = require("../../scroll-area/dist/index.cjs");
-const reactVirtual = require("@tanstack/react-virtual");
-const React = require("react");
-const tree = require("./utils/tree.cjs");
-const useSelection = require("./hooks/use-selection.cjs");
-const useRenaming = require("./hooks/use-renaming.cjs");
-const useDragDrop = require("./hooks/use-drag-drop.cjs");
-const useModifierKeys = require("./hooks/use-modifier-keys.cjs");
-const treeNodeWrapper = require("./components/tree-node-wrapper.cjs");
-const tcx = require("../../../shared/utils/tcx/tcx.cjs");
-const TreeContext = React.createContext(null);
-const useTreeContext = () => {
-  const context = React.useContext(TreeContext);
-  if (!context) {
-    throw new Error("useTreeContext must be used within a TreeList");
-  }
-  return context;
-};
-const DEFAULT_NODE_HEIGHT = 32;
-const TreeList = React.forwardRef((props, ref) => {
-  const {
-    data,
-    selectedNodeIds,
-    initialExpandedNodeIds,
-    className,
-    style,
-    containerWidth,
-    virtualScroll = true,
-    nodeHeight = DEFAULT_NODE_HEIGHT,
-    allowMultiSelect = true,
-    allowDrag = true,
-    allowDrop = true,
-    renderNode,
-    renderIcon,
-    renderActions,
-    renderLabel,
-    onNodeSelect,
-    onExpandedNodesChange,
-    onNodeRename,
-    onNodeContextMenu,
-    onNodeDrop,
-    onNodeIconDoubleClick,
-    onNodeHover,
-    onMouseDown,
-    showFullPathOnRename
-  } = props;
-  const [maxNodeWidth, setMaxNodeWidth] = React.useState(0);
-  const nodeMeasurerRef = React.useRef(/* @__PURE__ */ new Map());
-  const [internalExpandedNodeIds, setInternalExpandedNodeIds] = React.useState(
-    initialExpandedNodeIds ?? /* @__PURE__ */ new Set()
-  );
-  const expandNode = React.useCallback(
-    (node, forceExpanded) => {
-      const isCurrentlyExpanded = internalExpandedNodeIds.has(node.id);
-      const newExpanded = forceExpanded !== void 0 ? forceExpanded : !isCurrentlyExpanded;
-      setInternalExpandedNodeIds((prev) => {
-        const newSet = new Set(prev);
-        if (newExpanded) {
-          newSet.add(node.id);
-        } else {
-          newSet.delete(node.id);
-        }
-        return newSet;
-      });
-    },
-    [internalExpandedNodeIds]
-  );
-  const expandedNodeIds = internalExpandedNodeIds;
-  React.useEffect(() => {
-    onExpandedNodesChange == null ? void 0 : onExpandedNodesChange(expandedNodeIds);
-  }, [expandedNodeIds, onExpandedNodesChange]);
-  React.useImperativeHandle(
-    ref,
-    () => ({
-      collapseAll: () => {
-        setInternalExpandedNodeIds(/* @__PURE__ */ new Set());
-      },
-      expandNodes: (nodeIds) => {
-        setInternalExpandedNodeIds((prev) => {
-          const newSet = new Set(prev);
-          nodeIds.forEach((id) => {
-            newSet.add(id);
-          });
-          return newSet;
-        });
-      }
-    }),
-    []
-  );
-  const initialFlattenedNodes = React.useMemo(() => {
-    return tree.flattenTree(data, 0, null, [], expandedNodeIds, /* @__PURE__ */ new Set());
-  }, [data, expandedNodeIds]);
-  const selectedNodes = initialFlattenedNodes.filter((node) => selectedNodeIds.has(node.id));
-  const { selectNode } = useSelection.useSelection({
-    allowMultiSelect,
-    selectedNodeIds,
-    flattenedNodes: initialFlattenedNodes,
-    onNodeSelect
-  });
-  const flattenedNodes = React.useMemo(() => {
-    return tree.flattenTree(
-      data,
-      0,
-      null,
-      [],
-      expandedNodeIds,
-      selectedNodeIds
-    );
-  }, [data, expandedNodeIds, selectedNodeIds]);
-  const {
-    startRename,
-    endRename
-  } = useRenaming.useRenaming({
-    onNodeRename
-  });
-  const { dragState, listRef, startDrag, handleDragOver, handleDrop, handleDragEnd } = useDragDrop.useDragDrop({
-    allowDrag,
-    allowDrop,
-    nodeHeight,
-    onNodeDrop
-  });
-  React.useEffect(() => {
-    const handleFolderExpand = (event) => {
-      var _a;
-      const customEvent = event;
-      const nodeId = (_a = customEvent.detail) == null ? void 0 : _a.nodeId;
-      if (nodeId) {
-        const nodeToExpand = flattenedNodes.find((node) => node.id === nodeId);
-        if (nodeToExpand && !nodeToExpand.state.isExpanded) {
-          expandNode(nodeToExpand, true);
-        }
-      }
-    };
-    document.addEventListener("folder-expand", handleFolderExpand);
-    return () => {
-      document.removeEventListener("folder-expand", handleFolderExpand);
-    };
-  }, [expandNode, flattenedNodes]);
-  const { isCommandKeyPressed, isShiftKeyPressed } = useModifierKeys.useModifierKeys();
-  const handleContextMenu = React.useCallback(
-    (node, event) => {
-      onNodeContextMenu == null ? void 0 : onNodeContextMenu(node, event);
-    },
-    [onNodeContextMenu]
-  );
-  const nodesWithDragState = React.useMemo(() => {
-    return flattenedNodes.map((node) => {
-      var _a;
-      const isDragging = dragState.dragNodes.some((dragNode) => dragNode.id === node.id);
-      const isDropTarget = ((_a = dragState.dropTargetNode) == null ? void 0 : _a.id) === node.id;
-      const isSelected = selectedNodeIds.has(node.id);
-      const { isParentSelected } = node.state;
-      if (isDragging || isDropTarget || isSelected || isParentSelected) {
-        return {
-          ...node,
-          state: {
-            ...node.state,
-            isDragging,
-            isDropTarget,
-            isSelected,
-            // 保持原有的isParentSelected值
-            dropPosition: isDropTarget ? dragState.dropPosition : void 0
-          }
-        };
-      }
-      return {
-        ...node,
-        state: {
-          ...node.state,
-          isSelected
-          // 保持原有的isParentSelected值
-        }
-      };
-    });
-  }, [flattenedNodes, dragState, selectedNodeIds]);
-  const prevSelectedNodeIdsRef = React.useRef(/* @__PURE__ */ new Set());
-  React.useEffect(() => {
-    if (selectedNodeIds.size === 0) {
-      prevSelectedNodeIdsRef.current = new Set(selectedNodeIds);
-      return;
-    }
-    const selectionChanged = prevSelectedNodeIdsRef.current.size !== selectedNodeIds.size || Array.from(selectedNodeIds).some((id) => !prevSelectedNodeIdsRef.current.has(id)) || Array.from(prevSelectedNodeIdsRef.current).some((id) => !selectedNodeIds.has(id));
-    if (!selectionChanged) {
-      return;
-    }
-    prevSelectedNodeIdsRef.current = new Set(selectedNodeIds);
-    setInternalExpandedNodeIds((prev) => {
-      const next = new Set(prev);
-      let changed = false;
-      selectedNodeIds.forEach((nodeId) => {
-        const path = tree.findNodePathById(data, nodeId);
-        if (!path) return;
-        path.slice(0, -1).forEach((ancestorId) => {
-          if (!next.has(ancestorId)) {
-            next.add(ancestorId);
-            changed = true;
-          }
-        });
-      });
-      return changed ? next : prev;
-    });
-  }, [selectedNodeIds, data]);
-  const visibleNodes = React.useMemo(() => {
-    return nodesWithDragState.filter((node) => node.state.isVisible);
-  }, [nodesWithDragState]);
-  const virtualizer = reactVirtual.useVirtualizer({
-    count: visibleNodes.length,
-    getScrollElement: () => listRef.current,
-    estimateSize: () => nodeHeight,
-    overscan: 10
-  });
-  const prevSelectedForScrollRef = React.useRef(/* @__PURE__ */ new Set());
-  const scrollTimeoutRef = React.useRef(null);
-  React.useEffect(() => {
-    if (scrollTimeoutRef.current) {
-      clearTimeout(scrollTimeoutRef.current);
-      scrollTimeoutRef.current = null;
-    }
-    if (selectedNodeIds.size === 0 || !virtualScroll) {
-      prevSelectedForScrollRef.current = new Set(selectedNodeIds);
-      return;
-    }
-    const selectedNodeId = Array.from(selectedNodeIds)[0];
-    const selectionChanged = prevSelectedForScrollRef.current.size !== selectedNodeIds.size || Array.from(selectedNodeIds).some((id) => !prevSelectedForScrollRef.current.has(id));
-    const scrollToNode = () => {
-      const nodeIndex = visibleNodes.findIndex((node) => node.id === selectedNodeId);
-      if (nodeIndex === -1) {
-        return false;
-      }
-      const virtualItems = virtualizer.getVirtualItems();
-      const isAlreadyVisible = virtualItems.some((item) => item.index === nodeIndex);
-      if (isAlreadyVisible) {
-        return true;
-      }
-      virtualizer.scrollToIndex(nodeIndex, {
-        align: "center",
-        behavior: "auto"
-      });
-      return true;
-    };
-    if (selectionChanged) {
-      prevSelectedForScrollRef.current = new Set(selectedNodeIds);
-      if (scrollToNode()) {
-        return;
-      }
-      scrollTimeoutRef.current = setTimeout(() => {
-        scrollToNode();
-        scrollTimeoutRef.current = null;
-      }, 150);
-    } else {
-      scrollToNode();
-    }
-  }, [selectedNodeIds, visibleNodes, virtualizer, virtualScroll, expandedNodeIds]);
-  const measureNodeWidth = React.useCallback((nodeId, width) => {
-    nodeMeasurerRef.current.set(nodeId, width);
-    let currentMax = 0;
-    nodeMeasurerRef.current.forEach((nodeWidth) => {
-      if (nodeWidth > currentMax) {
-        currentMax = nodeWidth;
-      }
-    });
-    setMaxNodeWidth(currentMax);
-  }, []);
-  const hasHorizontalScroll = listRef.current && listRef.current.scrollWidth > listRef.current.clientWidth;
-  const renderTreeNode = React.useCallback(
-    (node) => {
-      return /* @__PURE__ */ require$$0.jsx(
-        treeNodeWrapper.TreeNodeWrapper,
-        {
-          node,
-          flattenedNodes,
-          visibleNodes,
-          selectedNodes,
-          containerWidth: containerWidth ?? 0,
-          isCommandKeyPressed,
-          isDragging: dragState.isDragging,
-          dragNodes: dragState.dragNodes,
-          hasHorizontalScroll: !!hasHorizontalScroll,
-          listRef,
-          renderNode,
-          renderIcon,
-          renderActions,
-          renderLabel,
-          onSelect: (node2, event) => selectNode(
-            node2,
-            allowMultiSelect && (isCommandKeyPressed || (event == null ? void 0 : event.metaKey) || (event == null ? void 0 : event.ctrlKey)),
-            isShiftKeyPressed || (event == null ? void 0 : event.shiftKey),
-            event
-          ),
-          onExpand: expandNode,
-          onDragStart: startDrag,
-          onDragOver: handleDragOver,
-          onDragEnd: handleDragEnd,
-          onDrop: handleDrop,
-          onRename: endRename,
-          onContextMenu: handleContextMenu,
-          onMeasure: (width) => measureNodeWidth(node.id, width),
-          onIconDoubleClick: onNodeIconDoubleClick,
-          onHover: onNodeHover,
-          showFullPathOnRename
-        },
-        node.id
-      );
-    },
-    [
-      flattenedNodes,
-      visibleNodes,
-      selectedNodes,
-      containerWidth,
-      isCommandKeyPressed,
-      dragState.isDragging,
-      dragState.dragNodes,
-      hasHorizontalScroll,
-      listRef,
-      renderNode,
-      renderIcon,
-      renderActions,
-      renderLabel,
-      selectNode,
-      expandNode,
-      startDrag,
-      handleDragOver,
-      handleDragEnd,
-      handleDrop,
-      endRename,
-      handleContextMenu,
-      onNodeHover,
-      measureNodeWidth,
-      allowMultiSelect,
-      isShiftKeyPressed,
-      onNodeIconDoubleClick,
-      showFullPathOnRename
-    ]
-  );
-  const contextValue = React.useMemo(
-    () => ({
-      flattenedNodes: nodesWithDragState,
-      selectedNodes,
-      expandedNodeIds,
-      dragState,
-      selectNode,
-      expandNode,
-      startDrag,
-      handleDrop,
-      handleContextMenu,
-      startRename,
-      endRename
-    }),
-    [
-      nodesWithDragState,
-      selectedNodes,
-      expandedNodeIds,
-      dragState,
-      selectNode,
-      expandNode,
-      startDrag,
-      handleDrop,
-      handleContextMenu,
-      startRename,
-      endRename
-    ]
-  );
-  return /* @__PURE__ */ require$$0.jsx(TreeContext.Provider, { value: contextValue, children: /* @__PURE__ */ require$$0.jsx(
-    "div",
-    {
-      onMouseDown: () => {
-        onMouseDown == null ? void 0 : onMouseDown();
-      },
-      className: tcx.tcx(
-        className,
-        "group/tree-list tree-list",
-        dragState.isDragging && "dragging-active"
-      ),
-      style: {
-        ...style,
-        "--tree-list-width": containerWidth + "px",
-        "--tree-list-height": `${virtualizer.getTotalSize()}px`,
-        "--tree-node-width": `${maxNodeWidth > 0 ? `${Math.max(maxNodeWidth + 16, containerWidth || 0)}px` : "100%"}`
-      },
-      onContextMenu: (e) => {
-        if (e.target === e.currentTarget) {
-          e.preventDefault();
-        }
-      },
-      children: /* @__PURE__ */ require$$0.jsx(index.ScrollArea, { className: "h-full overflow-hidden", children: /* @__PURE__ */ require$$0.jsx(
-        index.ScrollArea.Viewport,
-        {
-          ref: listRef,
-          className: "tree-list__viewport h-full",
-          children: /* @__PURE__ */ require$$0.jsx(index.ScrollArea.Content, { className: "tree-list__content", children: virtualScroll ? /* @__PURE__ */ require$$0.jsx(require$$0.Fragment, { children: virtualizer.getVirtualItems().map((virtualItem) => {
-            const node = visibleNodes[virtualItem.index];
-            return /* @__PURE__ */ require$$0.jsx(
-              "div",
-              {
-                className: "group/tree-node",
-                style: {
-                  position: "absolute",
-                  top: 0,
-                  left: 0,
-                  width: "100%",
-                  height: `${virtualItem.size}px`,
-                  transform: `translateY(${virtualItem.start}px)`
-                },
-                children: renderTreeNode(node)
-              },
-              node.id
-            );
-          }) }) : visibleNodes.map((node) => renderTreeNode(node)) })
-        }
-      ) })
-    }
-  ) });
-});
-TreeList.displayName = "TreeList";
-exports.TreeList = TreeList;
-exports.useTreeContext = useTreeContext;

package/dist/cjs/components/tree-list/src/utils/node.cjs

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-function isLastInParent(node, flattenedNodes) {
-  if (!node.parentId) return false;
-  const siblings = flattenedNodes.filter(
-    (n) => n.parentId === node.parentId && n.state.level === node.state.level
-  );
-  return siblings.length > 0 && siblings[siblings.length - 1].id === node.id;
-}
-function getSelectionPosition(node, visibleNodes, selectedNodesCount) {
-  if (selectedNodesCount <= 1 || !node.state.isSelected) {
-    return {
-      isFirstSelected: false,
-      isMiddleSelected: false,
-      isLastSelected: false
-    };
-  }
-  const selectedIndices = visibleNodes.map((n, index) => n.state.isSelected ? index : -1).filter((index) => index !== -1).sort((a, b) => a - b);
-  const currentNodeIndex = visibleNodes.findIndex((n) => n.id === node.id);
-  const positionInSelection = selectedIndices.indexOf(currentNodeIndex);
-  let startOfGroup = positionInSelection;
-  let endOfGroup = positionInSelection;
-  while (startOfGroup > 0 && selectedIndices[startOfGroup - 1] === selectedIndices[startOfGroup] - 1) {
-    startOfGroup--;
-  }
-  while (endOfGroup < selectedIndices.length - 1 && selectedIndices[endOfGroup + 1] === selectedIndices[endOfGroup] + 1) {
-    endOfGroup++;
-  }
-  const inConsecutiveGroup = endOfGroup - startOfGroup >= 1;
-  const isFirstInGroup = inConsecutiveGroup && positionInSelection === startOfGroup;
-  const isLastInGroup = inConsecutiveGroup && positionInSelection === endOfGroup;
-  return {
-    isFirstSelected: isFirstInGroup,
-    isMiddleSelected: inConsecutiveGroup && !isFirstInGroup && !isLastInGroup,
-    isLastSelected: isLastInGroup
-  };
-}
-function isInvalidDropTarget(targetNode, dragNodes, flattenedNodes) {
-  return dragNodes.some((dragNode) => {
-    const dragNodeIsFolder = Boolean(dragNode.children && dragNode.children.length > 0) || Boolean(dragNode.isFolder);
-    if (dragNodeIsFolder) {
-      let current = targetNode;
-      if (current.id === dragNode.id) return false;
-      while (current && current.parentId) {
-        if (current.parentId === dragNode.id) {
-          return true;
-        }
-        current = flattenedNodes.find((n) => n.id === (current == null ? void 0 : current.parentId));
-        if (!current) break;
-      }
-    }
-    return false;
-  });
-}
-exports.getSelectionPosition = getSelectionPosition;
-exports.isInvalidDropTarget = isInvalidDropTarget;
-exports.isLastInParent = isLastInParent;

package/dist/cjs/components/tree-list/src/utils/tree.cjs

@@ -1,238 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-function buildTree(data, parentId = null) {
-  return data.filter((item) => parentId === null && !item.parentId || item.parentId === parentId).map((item) => ({
-    ...item,
-    children: buildTree(data, item.id)
-  }));
-}
-function flattenTree(nodes, level = 0, parent = null, result = [], expandedIds = /* @__PURE__ */ new Set(), selectedIds = /* @__PURE__ */ new Set(), hasSelectedAncestor = false) {
-  nodes.forEach((node, _index) => {
-    const isExpanded = expandedIds.has(node.id);
-    const isSelected = selectedIds.has(node.id);
-    const isParentSelected = hasSelectedAncestor || (parent ? selectedIds.has(parent.id) : false);
-    if (parent) {
-      node.parentId = parent.id;
-    }
-    const treeNode = {
-      ...node,
-      parentId: parent == null ? void 0 : parent.id,
-      // 显式设置parentId
-      state: {
-        isExpanded,
-        isSelected,
-        isVisible: !parent || parent && expandedIds.has(parent.id),
-        isDragging: false,
-        isDropTarget: false,
-        isParentSelected,
-        level,
-        indexKey: node.indexKey
-      }
-    };
-    result.push(treeNode);
-    if (isExpanded && node.children && node.children.length > 0) {
-      const nextHasSelectedAncestor = isSelected || hasSelectedAncestor;
-      flattenTree(
-        node.children,
-        level + 1,
-        node,
-        result,
-        expandedIds,
-        selectedIds,
-        nextHasSelectedAncestor
-      );
-    }
-  });
-  return result;
-}
-function getVisibleChildren(node, flattenedNodes) {
-  if (!node.state.isExpanded || !node.children || node.children.length === 0) {
-    return [];
-  }
-  const startIndex = flattenedNodes.findIndex((n) => n.id === node.id) + 1;
-  const result = [];
-  for (let i = startIndex; i < flattenedNodes.length; i++) {
-    const currentNode = flattenedNodes[i];
-    if (currentNode.state.level <= node.state.level) {
-      break;
-    }
-    if (currentNode.state.level === node.state.level + 1) {
-      result.push(currentNode);
-    }
-  }
-  return result;
-}
-function getVisibleNodes(flattenedNodes) {
-  return flattenedNodes.filter((node) => node.state.isVisible);
-}
-function findNodeById(nodes, id) {
-  for (const node of nodes) {
-    if (node.id === id) {
-      return node;
-    }
-    if (node.children && node.children.length > 0) {
-      const found = findNodeById(node.children, id);
-      if (found) {
-        return found;
-      }
-    }
-  }
-  return void 0;
-}
-function getAncestorIds(flattenedNodes, nodeId) {
-  const node = flattenedNodes.find((n) => n.id === nodeId);
-  if (!node) return [];
-  const ancestors = [];
-  const level = node.state.level;
-  if (level === 0) return [];
-  let index = flattenedNodes.findIndex((n) => n.id === nodeId) - 1;
-  while (index >= 0) {
-    const current = flattenedNodes[index];
-    if (current.state.level < level) {
-      ancestors.push(current.id);
-      if (current.state.level === 0) break;
-    }
-    index--;
-  }
-  return ancestors.reverse();
-}
-function getNodePathNames(flattenedNodes, nodeId) {
-  const nodeIndex = flattenedNodes.findIndex((n) => n.id === nodeId);
-  if (nodeIndex === -1) return [];
-  const node = flattenedNodes[nodeIndex];
-  const pathNames = [node.name];
-  let currentLevel = node.state.level;
-  for (let i = nodeIndex - 1; i >= 0; i--) {
-    const ancestor = flattenedNodes[i];
-    if (ancestor.state.level < currentLevel) {
-      pathNames.unshift(ancestor.name);
-      currentLevel = ancestor.state.level;
-      if (currentLevel === 0) break;
-    }
-  }
-  return pathNames;
-}
-function getDescendantIds(flattenedNodes, nodeId) {
-  const startIndex = flattenedNodes.findIndex((node2) => node2.id === nodeId);
-  if (startIndex === -1) return [];
-  const node = flattenedNodes[startIndex];
-  const result = [];
-  for (let i = startIndex + 1; i < flattenedNodes.length; i++) {
-    const current = flattenedNodes[i];
-    if (current.state.level <= node.state.level) break;
-    result.push(current.id);
-  }
-  return result;
-}
-function findNodePathById(nodes, targetId, path = []) {
-  for (const node of nodes) {
-    const currentPath = [...path, node.id];
-    if (node.id === targetId) {
-      return currentPath;
-    }
-    if (node.children && node.children.length > 0) {
-      const result = findNodePathById(node.children, targetId, currentPath);
-      if (result) {
-        return result;
-      }
-    }
-  }
-  return null;
-}
-function renameNode(nodes, nodeId, newName) {
-  return nodes.map((node) => {
-    if (node.id === nodeId) {
-      return {
-        ...node,
-        name: newName
-      };
-    }
-    if (node.children && node.children.length > 0) {
-      return {
-        ...node,
-        children: renameNode(node.children, nodeId, newName)
-      };
-    }
-    return node;
-  });
-}
-function getNodesInRange(flattenedNodes, startId, endId) {
-  const visibleNodes = flattenedNodes.filter((node) => node.state.isVisible);
-  const startIndex = visibleNodes.findIndex((node) => node.id === startId);
-  const endIndex = visibleNodes.findIndex((node) => node.id === endId);
-  if (startIndex === -1 || endIndex === -1) return [];
-  const start = Math.min(startIndex, endIndex);
-  const end = Math.max(startIndex, endIndex);
-  return visibleNodes.slice(start, end + 1).map((node) => node.id);
-}
-function calculateDropPosition(event, element) {
-  const rect = element.getBoundingClientRect();
-  const y = event.clientY - rect.top;
-  const height = rect.height;
-  if (y < height * 0.25) {
-    return "before";
-  }
-  if (y > height * 0.75) {
-    return "after";
-  }
-  return "inside";
-}
-function getNextNodeId(currentNodeId, flattenedNodes, key) {
-  var _a;
-  const currentIndex = flattenedNodes.findIndex((node) => node.id === currentNodeId);
-  if (currentIndex === -1) return null;
-  const currentNode = flattenedNodes[currentIndex];
-  switch (key) {
-    case "ArrowUp": {
-      for (let i = currentIndex - 1; i >= 0; i--) {
-        if (flattenedNodes[i].state.isVisible) {
-          return flattenedNodes[i].id;
-        }
-      }
-      return null;
-    }
-    case "ArrowDown": {
-      for (let i = currentIndex + 1; i < flattenedNodes.length; i++) {
-        if (flattenedNodes[i].state.isVisible) {
-          return flattenedNodes[i].id;
-        }
-      }
-      return null;
-    }
-    case "ArrowLeft": {
-      if (currentNode.state.isExpanded && currentNode.children && currentNode.children.length > 0) {
-        return currentNodeId;
-      }
-      for (let i = currentIndex - 1; i >= 0; i--) {
-        if (flattenedNodes[i].state.level < currentNode.state.level) {
-          return flattenedNodes[i].id;
-        }
-      }
-      return null;
-    }
-    case "ArrowRight": {
-      if (!currentNode.state.isExpanded && currentNode.children && currentNode.children.length > 0) {
-        return currentNodeId;
-      }
-      if (currentNode.state.isExpanded && currentNode.children && currentNode.children.length > 0) {
-        return ((_a = flattenedNodes[currentIndex + 1]) == null ? void 0 : _a.id) || null;
-      }
-      return null;
-    }
-    default:
-      return null;
-  }
-}
-exports.buildTree = buildTree;
-exports.calculateDropPosition = calculateDropPosition;
-exports.findNodeById = findNodeById;
-exports.findNodePathById = findNodePathById;
-exports.flattenTree = flattenTree;
-exports.getAncestorIds = getAncestorIds;
-exports.getDescendantIds = getDescendantIds;
-exports.getNextNodeId = getNextNodeId;
-exports.getNodePathNames = getNodePathNames;
-exports.getNodesInRange = getNodesInRange;
-exports.getVisibleChildren = getVisibleChildren;
-exports.getVisibleNodes = getVisibleNodes;
-exports.renameNode = renameNode;