@expcat/tigercat-react 1.0.7 → 1.2.0

package/dist/chunk-A54CDNCF.js

@@ -0,0 +1,608 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkP36GX65Njs = require('./chunk-P36GX65N.js');
+
+// src/components/Tree.tsx
+var _react = require('react');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var _jsxruntime = require('react/jsx-runtime');
+var spinnerSvg = _tigercatcore.getSpinnerSVG.call(void 0, "spinner");
+var ExpandIcon = ({
+  expanded,
+  hasChildren
+}) => {
+  if (!hasChildren) {
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: _tigercatcore.treeNodeIndentClasses });
+  }
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    "svg",
+    {
+      className: _tigercatcore.getTreeNodeExpandIconClasses.call(void 0, expanded),
+      width: "16",
+      height: "16",
+      viewBox: "0 0 16 16",
+      fill: "currentColor",
+      children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "path", { d: "M6 4l4 4-4 4V4z" })
+    }
+  );
+};
+var LoadingSpinner = () => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+  "svg",
+  {
+    className: _tigercatcore.treeLoadingClasses,
+    xmlns: "http://www.w3.org/2000/svg",
+    fill: "none",
+    viewBox: spinnerSvg.viewBox,
+    children: spinnerSvg.elements.map((el, index) => {
+      if (el.type === "circle") return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "circle", { ...el.attrs }, index);
+      if (el.type === "path") return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "path", { ...el.attrs }, index);
+      return null;
+    })
+  }
+);
+var Tree = ({
+  treeData = [],
+  selectionMode,
+  checkable = false,
+  showIcon = true,
+  showLine = false,
+  defaultExpandedKeys = [],
+  defaultSelectedKeys = [],
+  defaultCheckedKeys = [],
+  expandedKeys: controlledExpandedKeys,
+  selectedKeys: controlledSelectedKeys,
+  checkedKeys: controlledCheckedKeys,
+  defaultExpandAll = false,
+  checkStrictly = false,
+  checkStrategy = "all",
+  selectable = true,
+  multiple = false,
+  loadData,
+  filterValue = "",
+  searchable = false,
+  filterFn,
+  autoExpandParent = true,
+  blockNode = false,
+  emptyText = "No data",
+  ariaLabel = "Tree",
+  onExpand,
+  onSelect,
+  onCheck,
+  onNodeClick,
+  onNodeExpand,
+  onNodeCollapse,
+  className,
+  draggable: isDraggable = false,
+  onDrop,
+  virtual = false,
+  height = 400,
+  itemHeight = 32
+}) => {
+  const itemRefs = _react.useRef.call(void 0, /* @__PURE__ */ new Map());
+  const dragNodeKeyRef = _react.useRef.call(void 0, null);
+  const effectiveSelectable = _react.useMemo.call(void 0, () => {
+    if (selectionMode !== void 0) {
+      return selectionMode !== "none";
+    }
+    return selectable;
+  }, [selectionMode, selectable]);
+  const effectiveMultiple = _react.useMemo.call(void 0, () => {
+    if (selectionMode !== void 0) {
+      return selectionMode === "multiple";
+    }
+    return multiple;
+  }, [selectionMode, multiple]);
+  const [internalExpandedKeys, setInternalExpandedKeys] = _react.useState.call(void 0, () => {
+    if (controlledExpandedKeys !== void 0) {
+      return new Set(controlledExpandedKeys);
+    }
+    if (defaultExpandAll) {
+      return new Set(_tigercatcore.getAllKeys.call(void 0, treeData));
+    }
+    if (defaultExpandedKeys && defaultExpandedKeys.length > 0) {
+      return new Set(defaultExpandedKeys);
+    }
+    return /* @__PURE__ */ new Set();
+  });
+  const [internalSelectedKeys, setInternalSelectedKeys] = _react.useState.call(void 0, 
+    () => new Set(controlledSelectedKeys !== void 0 ? controlledSelectedKeys : defaultSelectedKeys)
+  );
+  const [internalCheckedState, setInternalCheckedState] = _react.useState.call(void 0, () => {
+    if (controlledCheckedKeys !== void 0) {
+      if (Array.isArray(controlledCheckedKeys)) {
+        return _tigercatcore.calculateCheckedState.call(void 0, treeData, controlledCheckedKeys, checkStrictly);
+      }
+      return controlledCheckedKeys;
+    }
+    return _tigercatcore.calculateCheckedState.call(void 0, treeData, defaultCheckedKeys, checkStrictly);
+  });
+  const [loadingNodes, setLoadingNodes] = _react.useState.call(void 0, /* @__PURE__ */ new Set());
+  const [filteredNodeKeys, setFilteredNodeKeys] = _react.useState.call(void 0, /* @__PURE__ */ new Set());
+  const [activeKey, setActiveKey] = _react.useState.call(void 0, );
+  const computedExpandedKeys = _react.useMemo.call(void 0, () => {
+    if (controlledExpandedKeys !== void 0) {
+      return new Set(controlledExpandedKeys);
+    }
+    return internalExpandedKeys;
+  }, [controlledExpandedKeys, internalExpandedKeys]);
+  const visibleItems = _react.useMemo.call(void 0, 
+    () => _tigercatcore.getVisibleTreeItems.call(void 0, treeData, computedExpandedKeys, filteredNodeKeys),
+    [treeData, computedExpandedKeys, filteredNodeKeys]
+  );
+  const focusableKeys = _react.useMemo.call(void 0, 
+    () => visibleItems.filter((i) => !i.node.disabled).map((i) => i.key),
+    [visibleItems]
+  );
+  const defaultActiveKey = focusableKeys[0];
+  _react.useEffect.call(void 0, () => {
+    if (activeKey === void 0) return;
+    _optionalChain([itemRefs, 'access', _ => _.current, 'access', _2 => _2.get, 'call', _3 => _3(activeKey), 'optionalAccess', _4 => _4.focus, 'call', _5 => _5()]);
+  }, [activeKey]);
+  const computedSelectedKeys = _react.useMemo.call(void 0, () => {
+    if (controlledSelectedKeys !== void 0) {
+      return new Set(controlledSelectedKeys);
+    }
+    return internalSelectedKeys;
+  }, [controlledSelectedKeys, internalSelectedKeys]);
+  const computedCheckedState = _react.useMemo.call(void 0, () => {
+    if (controlledCheckedKeys !== void 0) {
+      if (Array.isArray(controlledCheckedKeys)) {
+        return _tigercatcore.calculateCheckedState.call(void 0, treeData, controlledCheckedKeys, checkStrictly);
+      }
+      return controlledCheckedKeys;
+    }
+    return internalCheckedState;
+  }, [controlledCheckedKeys, internalCheckedState, treeData, checkStrictly]);
+  const checkedSets = _react.useMemo.call(void 0, 
+    () => _tigercatcore.checkedSetsFromState.call(void 0, computedCheckedState),
+    [computedCheckedState]
+  );
+  const [internalSearchValue, setInternalSearchValue] = _react.useState.call(void 0, "");
+  const effectiveFilterValue = searchable ? internalSearchValue : filterValue;
+  _react.useEffect.call(void 0, () => {
+    if (effectiveFilterValue) {
+      const matched = _tigercatcore.filterTreeNodes.call(void 0, treeData, effectiveFilterValue, filterFn);
+      setFilteredNodeKeys(matched);
+      if (autoExpandParent) {
+        const autoExpand = _tigercatcore.getAutoExpandKeys.call(void 0, treeData, matched);
+        if (controlledExpandedKeys === void 0) {
+          setInternalExpandedKeys((prev) => /* @__PURE__ */ new Set([...prev, ...autoExpand]));
+        }
+      }
+    } else {
+      setFilteredNodeKeys(/* @__PURE__ */ new Set());
+    }
+  }, [effectiveFilterValue, treeData, filterFn, autoExpandParent, controlledExpandedKeys]);
+  const handleExpand = _react.useCallback.call(void 0, 
+    (nodeKey) => {
+      const node = _tigercatcore.findNode.call(void 0, treeData, nodeKey);
+      if (!node) return;
+      const newExpandedKeys = new Set(computedExpandedKeys);
+      const isExpanded = newExpandedKeys.has(nodeKey);
+      if (isExpanded) {
+        newExpandedKeys.delete(nodeKey);
+        _optionalChain([onNodeCollapse, 'optionalCall', _6 => _6(node, nodeKey)]);
+      } else {
+        newExpandedKeys.add(nodeKey);
+        _optionalChain([onNodeExpand, 'optionalCall', _7 => _7(node, nodeKey)]);
+        if (loadData && !node.children && !node.isLeaf && !loadingNodes.has(nodeKey)) {
+          setLoadingNodes((prev) => /* @__PURE__ */ new Set([...prev, nodeKey]));
+          loadData(node).then((children) => {
+            node.children = children;
+            setLoadingNodes((prev) => {
+              const next = new Set(prev);
+              next.delete(nodeKey);
+              return next;
+            });
+          }).catch(() => {
+            setLoadingNodes((prev) => {
+              const next = new Set(prev);
+              next.delete(nodeKey);
+              return next;
+            });
+            newExpandedKeys.delete(nodeKey);
+          });
+        }
+      }
+      if (controlledExpandedKeys === void 0) {
+        setInternalExpandedKeys(newExpandedKeys);
+      }
+      _optionalChain([onExpand, 'optionalCall', _8 => _8(Array.from(newExpandedKeys), {
+        expanded: !isExpanded,
+        node
+      })]);
+    },
+    [
+      treeData,
+      computedExpandedKeys,
+      loadData,
+      loadingNodes,
+      controlledExpandedKeys,
+      onExpand,
+      onNodeExpand,
+      onNodeCollapse
+    ]
+  );
+  const handleSelect = _react.useCallback.call(void 0, 
+    (nodeKey, event) => {
+      const node = _tigercatcore.findNode.call(void 0, treeData, nodeKey);
+      if (!node || node.disabled || !effectiveSelectable) return;
+      const newSelectedKeys = new Set(computedSelectedKeys);
+      if (effectiveMultiple) {
+        if (newSelectedKeys.has(nodeKey)) {
+          newSelectedKeys.delete(nodeKey);
+        } else {
+          newSelectedKeys.add(nodeKey);
+        }
+      } else {
+        newSelectedKeys.clear();
+        newSelectedKeys.add(nodeKey);
+      }
+      if (controlledSelectedKeys === void 0) {
+        setInternalSelectedKeys(newSelectedKeys);
+      }
+      const selectedKeysArray = Array.from(newSelectedKeys);
+      _optionalChain([onSelect, 'optionalCall', _9 => _9(selectedKeysArray, {
+        selected: newSelectedKeys.has(nodeKey),
+        selectedNodes: selectedKeysArray.map((k) => _tigercatcore.findNode.call(void 0, treeData, k)).filter(Boolean),
+        node,
+        event
+      })]);
+    },
+    [
+      treeData,
+      computedSelectedKeys,
+      effectiveSelectable,
+      effectiveMultiple,
+      controlledSelectedKeys,
+      onSelect
+    ]
+  );
+  const handleCheck = _react.useCallback.call(void 0, 
+    (nodeKey, checked) => {
+      const node = _tigercatcore.findNode.call(void 0, treeData, nodeKey);
+      if (!node || node.disabled) return;
+      const currentCheckedKeys = computedCheckedState.checked;
+      const newCheckedState = _tigercatcore.handleNodeCheck.call(void 0, 
+        treeData,
+        nodeKey,
+        checked,
+        currentCheckedKeys,
+        checkStrictly
+      );
+      if (controlledCheckedKeys === void 0) {
+        setInternalCheckedState(newCheckedState);
+      }
+      const returnKeys = _tigercatcore.getCheckedKeysByStrategy.call(void 0, newCheckedState, treeData, checkStrategy);
+      _optionalChain([onCheck, 'optionalCall', _10 => _10(returnKeys, {
+        checked,
+        checkedNodes: newCheckedState.checked.map((k) => _tigercatcore.findNode.call(void 0, treeData, k)).filter(Boolean),
+        node,
+        checkedNodesPositions: newCheckedState
+      })]);
+    },
+    [treeData, computedCheckedState, checkStrictly, checkStrategy, controlledCheckedKeys, onCheck]
+  );
+  const getFirstChildKey = _react.useCallback.call(void 0, 
+    (nodeKey) => {
+      const index = visibleItems.findIndex((i) => i.key === nodeKey);
+      if (index < 0) return void 0;
+      const base = visibleItems[index];
+      for (let i = index + 1; i < visibleItems.length; i++) {
+        const item = visibleItems[i];
+        if (item.level <= base.level) break;
+        if (item.parentKey === nodeKey && !item.node.disabled) return item.key;
+      }
+      return void 0;
+    },
+    [visibleItems]
+  );
+  const handleKeyDown = _react.useCallback.call(void 0, 
+    (e, node, isExpanded, isChecked) => {
+      if (node.disabled) return;
+      const currentKey = _nullishCoalesce(_nullishCoalesce(activeKey, () => ( defaultActiveKey)), () => ( node.key));
+      const currentIndex = focusableKeys.findIndex((k) => k === currentKey);
+      const isExpandable = !!(node.children && node.children.length > 0) || !!(loadData && !node.isLeaf);
+      const parents = _tigercatcore.getParentKeys.call(void 0, treeData, node.key);
+      const parentKey = parents[parents.length - 1];
+      if (e.key === "ArrowDown") {
+        e.preventDefault();
+        setActiveKey(_nullishCoalesce(focusableKeys[currentIndex + 1], () => ( currentKey)));
+        return;
+      }
+      if (e.key === "ArrowUp") {
+        e.preventDefault();
+        setActiveKey(_nullishCoalesce(focusableKeys[currentIndex - 1], () => ( currentKey)));
+        return;
+      }
+      if (e.key === "Home") {
+        e.preventDefault();
+        setActiveKey(_nullishCoalesce(focusableKeys[0], () => ( currentKey)));
+        return;
+      }
+      if (e.key === "End") {
+        e.preventDefault();
+        setActiveKey(_nullishCoalesce(focusableKeys[focusableKeys.length - 1], () => ( currentKey)));
+        return;
+      }
+      if (e.key === "ArrowRight") {
+        e.preventDefault();
+        if (isExpandable && !isExpanded) {
+          handleExpand(node.key);
+          return;
+        }
+        if (isExpandable && isExpanded) {
+          setActiveKey(_nullishCoalesce(getFirstChildKey(node.key), () => ( currentKey)));
+        }
+        return;
+      }
+      if (e.key === "ArrowLeft") {
+        e.preventDefault();
+        if (isExpandable && isExpanded) {
+          handleExpand(node.key);
+          return;
+        }
+        if (parentKey !== void 0) {
+          setActiveKey(parentKey);
+        }
+        return;
+      }
+      if (e.key === "Escape") {
+        e.preventDefault();
+        if (isExpandable && isExpanded) {
+          handleExpand(node.key);
+          return;
+        }
+        if (parentKey !== void 0) {
+          if (computedExpandedKeys.has(parentKey)) {
+            handleExpand(parentKey);
+          }
+          setActiveKey(parentKey);
+        }
+        return;
+      }
+      if (e.key === "Enter") {
+        e.preventDefault();
+        if (effectiveSelectable) {
+          handleSelect(node.key, e);
+          return;
+        }
+        if (isExpandable) {
+          handleExpand(node.key);
+        }
+        return;
+      }
+      if (e.key === " ") {
+        e.preventDefault();
+        if (checkable) {
+          handleCheck(node.key, !isChecked);
+          return;
+        }
+        if (isExpandable) {
+          handleExpand(node.key);
+        }
+      }
+    },
+    [
+      activeKey,
+      defaultActiveKey,
+      focusableKeys,
+      treeData,
+      loadData,
+      checkable,
+      computedExpandedKeys,
+      effectiveSelectable,
+      getFirstChildKey,
+      handleExpand,
+      handleSelect,
+      handleCheck
+    ]
+  );
+  const renderTreeRow = (node, level) => {
+    const hasChildren = !!(node.children && node.children.length > 0);
+    const isExpanded = computedExpandedKeys.has(node.key);
+    const isSelected = computedSelectedKeys.has(node.key);
+    const isChecked = checkedSets.checkedSet.has(node.key);
+    const isHalfChecked = checkedSets.halfCheckedSet.has(node.key);
+    const isLoading = loadingNodes.has(node.key);
+    const isFiltered = filteredNodeKeys.size > 0;
+    const isMatched = filteredNodeKeys.has(node.key);
+    const isVisible = !isFiltered || isMatched;
+    const isExpandable = hasChildren || !!(loadData && !node.isLeaf);
+    const isFocusable = !node.disabled && node.key === (_nullishCoalesce(activeKey, () => ( defaultActiveKey)));
+    if (!isVisible) {
+      return null;
+    }
+    const indent = [];
+    for (let i = 0; i < level; i++) {
+      indent.push(/* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: _tigercatcore.treeNodeIndentClasses }, i));
+    }
+    return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+      "div",
+      {
+        className: _tigercatcore.getTreeNodeClasses.call(void 0, isSelected, !!node.disabled, blockNode),
+        ref: (el) => {
+          itemRefs.current.set(node.key, el);
+        },
+        role: "treeitem",
+        "aria-level": level + 1,
+        "aria-disabled": node.disabled || void 0,
+        "aria-selected": effectiveSelectable ? isSelected : void 0,
+        "aria-expanded": isExpandable ? isExpanded : void 0,
+        "aria-checked": checkable ? isHalfChecked ? "mixed" : isChecked : void 0,
+        tabIndex: isFocusable ? 0 : -1,
+        draggable: isDraggable && !node.disabled ? true : void 0,
+        onDragStart: isDraggable && !node.disabled ? (e) => {
+          e.stopPropagation();
+          dragNodeKeyRef.current = node.key;
+        } : void 0,
+        onDragOver: isDraggable ? (e) => {
+          e.preventDefault();
+          e.stopPropagation();
+        } : void 0,
+        onDrop: isDraggable ? (e) => {
+          e.preventDefault();
+          e.stopPropagation();
+          if (dragNodeKeyRef.current !== null && dragNodeKeyRef.current !== node.key) {
+            _optionalChain([onDrop, 'optionalCall', _11 => _11({ dragKey: dragNodeKeyRef.current, dropKey: node.key })]);
+          }
+          dragNodeKeyRef.current = null;
+        } : void 0,
+        onDragEnd: isDraggable ? () => {
+          dragNodeKeyRef.current = null;
+        } : void 0,
+        onFocus: () => {
+          if (!node.disabled) setActiveKey(node.key);
+        },
+        onKeyDown: (e) => handleKeyDown(e, node, isExpanded, isChecked),
+        onClick: (e) => {
+          setActiveKey(node.key);
+          if (!node.disabled) _optionalChain([onNodeClick, 'optionalCall', _12 => _12(node, e)]);
+          if (effectiveSelectable && !node.disabled) {
+            handleSelect(node.key, e);
+          }
+        },
+        children: [
+          indent,
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            "span",
+            {
+              className: isExpandable ? "cursor-pointer" : "",
+              onClick: (e) => {
+                e.stopPropagation();
+                if (isExpandable) {
+                  setActiveKey(node.key);
+                  handleExpand(node.key);
+                }
+              },
+              children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ExpandIcon, { expanded: isExpanded, hasChildren: isExpandable })
+            }
+          ),
+          checkable && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            "input",
+            {
+              type: "checkbox",
+              "aria-label": `Select ${node.label}`,
+              className: _tigercatcore.treeNodeCheckboxClasses,
+              checked: isChecked,
+              ref: (input) => {
+                if (input) {
+                  input.indeterminate = isHalfChecked;
+                }
+              },
+              disabled: node.disabled,
+              onClick: (e) => {
+                e.stopPropagation();
+              },
+              onChange: (e) => {
+                handleCheck(node.key, e.target.checked);
+              }
+            }
+          ),
+          showIcon && node.icon ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: _tigercatcore.treeNodeIconClasses, children: node.icon }) : null,
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            "span",
+            {
+              className: _tigercatcore.classNames.call(void 0, 
+                _tigercatcore.treeNodeLabelClasses,
+                isFiltered && isMatched ? "font-semibold text-[var(--tiger-primary,#2563eb)]" : ""
+              ),
+              children: node.label
+            }
+          ),
+          isLoading && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, LoadingSpinner, {})
+        ]
+      }
+    );
+  };
+  const renderTreeNode = (node, level) => {
+    const hasChildren = !!(node.children && node.children.length > 0);
+    const isExpanded = computedExpandedKeys.has(node.key);
+    const isFiltered = filteredNodeKeys.size > 0;
+    const isMatched = filteredNodeKeys.has(node.key);
+    const isVisible = !isFiltered || isMatched;
+    if (!isVisible) {
+      return null;
+    }
+    return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: _tigercatcore.treeNodeWrapperClasses, children: [
+      renderTreeRow(node, level),
+      hasChildren && isExpanded && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.classNames.call(void 0, _tigercatcore.treeNodeChildrenClasses, showLine && _tigercatcore.treeLineClasses), children: node.children.map((child) => renderTreeNode(child, level + 1)) })
+    ] }, node.key);
+  };
+  if (!treeData || treeData.length === 0) {
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      "div",
+      {
+        className: _tigercatcore.classNames.call(void 0, _tigercatcore.treeBaseClasses, "p-4", className),
+        role: "tree",
+        "aria-label": ariaLabel,
+        children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.treeEmptyStateClasses, children: emptyText })
+      }
+    );
+  }
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+    "div",
+    {
+      className: _tigercatcore.classNames.call(void 0, _tigercatcore.treeBaseClasses, className),
+      role: "tree",
+      "aria-label": ariaLabel,
+      "aria-multiselectable": effectiveMultiple || void 0,
+      children: [
+        searchable && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          "input",
+          {
+            type: "text",
+            className: "w-full mb-2 px-2 py-1 text-sm border border-[var(--tiger-border,#e5e7eb)] rounded bg-[var(--tiger-surface,#ffffff)] focus:outline-none focus:ring-1 focus:ring-[var(--tiger-primary,#2563eb)]",
+            placeholder: "Search...",
+            value: internalSearchValue,
+            onChange: (e) => setInternalSearchValue(e.target.value)
+          }
+        ),
+        virtual ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _chunkP36GX65Njs.VirtualList,
+          {
+            itemCount: visibleItems.length,
+            itemHeight,
+            height,
+            renderItem: ({ index }) => {
+              const item = visibleItems[index];
+              if (!item) return null;
+              return renderTreeRow(item.node, item.level - 1);
+            }
+          }
+        ) : treeData.map((node) => renderTreeNode(node, 0))
+      ]
+    }
+  );
+};
+var Tree_default = Tree;
+
+
+
+
+exports.Tree = Tree; exports.Tree_default = Tree_default;