ink-tree-view 0.1.0

package/dist/index.js

@@ -0,0 +1,878 @@
+// src/components/tree-view/tree-view.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+
+// src/components/tree-view/use-tree-view-state.ts
+import { useCallback, useEffect, useMemo, useReducer, useRef, useState } from "react";
+
+// src/tree-node-map.ts
+var TreeNodeMap = class _TreeNodeMap {
+  /** Map from node ID to FlatNode. */
+  map;
+  /** All node IDs in DFS order. */
+  orderedIds;
+  /** Root-level node IDs. */
+  rootIds;
+  constructor(data) {
+    this.map = /* @__PURE__ */ new Map();
+    this.orderedIds = [];
+    this.rootIds = [];
+    this.buildFromData(data);
+  }
+  buildFromData(data) {
+    const stack = [];
+    for (let i = data.length - 1; i >= 0; i--) {
+      stack.push({
+        node: data[i],
+        depth: 0,
+        parentId: void 0,
+        siblings: data,
+        siblingIndex: i
+      });
+    }
+    for (const node of data) {
+      this.rootIds.push(node.id);
+    }
+    let flatIndex = 0;
+    while (stack.length > 0) {
+      const entry = stack.pop();
+      const { node, depth, parentId, siblings, siblingIndex } = entry;
+      if (this.map.has(node.id)) {
+        throw new Error(
+          `TreeView: Duplicate node id '${node.id}' found. All node ids must be unique.`
+        );
+      }
+      const children = node.children ?? [];
+      const hasChildren = children.length > 0 || node.isParent === true;
+      const childrenIds = children.map((c) => c.id);
+      const previousSiblingId = siblingIndex > 0 ? siblings[siblingIndex - 1].id : void 0;
+      const nextSiblingId = siblingIndex < siblings.length - 1 ? siblings[siblingIndex + 1].id : void 0;
+      const flatNode = {
+        node,
+        depth,
+        flatIndex,
+        parentId,
+        hasChildren,
+        childrenIds,
+        previousSiblingId,
+        nextSiblingId
+      };
+      this.map.set(node.id, flatNode);
+      this.orderedIds.push(node.id);
+      flatIndex++;
+      if (hasChildren) {
+        for (let i = children.length - 1; i >= 0; i--) {
+          stack.push({
+            node: children[i],
+            depth: depth + 1,
+            parentId: node.id,
+            siblings: children,
+            siblingIndex: i
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Get a flat node by ID.
+   */
+  get(id) {
+    return this.map.get(id);
+  }
+  /**
+   * Total number of nodes in the tree.
+   */
+  get size() {
+    return this.map.size;
+  }
+  /**
+   * Iterate over all entries.
+   */
+  entries() {
+    return this.map.entries();
+  }
+  /**
+   * Check if a node is a descendant of another node.
+   */
+  isDescendantOf(nodeId, ancestorId) {
+    let currentId = nodeId;
+    while (currentId !== void 0) {
+      const flat = this.map.get(currentId);
+      if (!flat) return false;
+      if (flat.parentId === ancestorId) return true;
+      currentId = flat.parentId;
+    }
+    return false;
+  }
+  /**
+   * Given a set of expanded node IDs, return the ordered list of
+   * VISIBLE node IDs (i.e., a node is visible if all its ancestors
+   * are expanded).
+   *
+   * Uses iterative DFS, skipping collapsed subtrees.
+   */
+  getVisibleIds(expandedIds) {
+    const result = [];
+    const stack = [];
+    for (let i = this.rootIds.length - 1; i >= 0; i--) {
+      stack.push(this.rootIds[i]);
+    }
+    while (stack.length > 0) {
+      const id = stack.pop();
+      result.push(id);
+      const flatNode = this.map.get(id);
+      if (flatNode && expandedIds.has(id) && flatNode.childrenIds.length > 0) {
+        for (let i = flatNode.childrenIds.length - 1; i >= 0; i--) {
+          stack.push(flatNode.childrenIds[i]);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Insert dynamically-loaded children under a parent node.
+   * Returns a new TreeNodeMap (immutable operation).
+   */
+  withChildren(parentId, children) {
+    const parentFlat = this.map.get(parentId);
+    if (!parentFlat) return this;
+    const rebuildNode = (node) => {
+      if (node.id === parentId) {
+        return { ...node, children };
+      }
+      if (node.children) {
+        return { ...node, children: node.children.map(rebuildNode) };
+      }
+      return node;
+    };
+    const rootData = [];
+    for (const rootId of this.rootIds) {
+      const rootFlat = this.map.get(rootId);
+      if (rootFlat) {
+        rootData.push(rebuildNode(rootFlat.node));
+      }
+    }
+    return new _TreeNodeMap(rootData);
+  }
+};
+
+// src/components/tree-view/use-tree-view-state.ts
+function buildVisibleIdIndex(visibleIds) {
+  const map = /* @__PURE__ */ new Map();
+  for (let i = 0; i < visibleIds.length; i++) {
+    map.set(visibleIds[i], i);
+  }
+  return map;
+}
+function adjustViewport(state, targetIndex) {
+  if (state.visibleNodeCount >= state.visibleIds.length) {
+    return { viewportFromIndex: 0, viewportToIndex: state.visibleIds.length };
+  }
+  let from = state.viewportFromIndex;
+  let to = state.viewportToIndex;
+  if (targetIndex >= to) {
+    to = targetIndex + 1;
+    from = to - state.visibleNodeCount;
+  }
+  if (targetIndex < from) {
+    from = targetIndex;
+    to = from + state.visibleNodeCount;
+  }
+  return {
+    viewportFromIndex: Math.max(0, from),
+    viewportToIndex: Math.min(state.visibleIds.length, to)
+  };
+}
+function adjustViewportForNewVisible(state, newVisible) {
+  if (state.visibleNodeCount >= newVisible.length) {
+    return { viewportFromIndex: 0, viewportToIndex: newVisible.length };
+  }
+  const focusedIdx = state.focusedId ? newVisible.indexOf(state.focusedId) : -1;
+  if (focusedIdx < 0) {
+    return {
+      viewportFromIndex: 0,
+      viewportToIndex: Math.min(state.visibleNodeCount, newVisible.length)
+    };
+  }
+  let from = state.viewportFromIndex;
+  let to = state.viewportToIndex;
+  to = Math.min(to, newVisible.length);
+  from = Math.max(0, to - state.visibleNodeCount);
+  if (focusedIdx >= to) {
+    to = focusedIdx + 1;
+    from = to - state.visibleNodeCount;
+  }
+  if (focusedIdx < from) {
+    from = focusedIdx;
+    to = from + state.visibleNodeCount;
+  }
+  return {
+    viewportFromIndex: Math.max(0, from),
+    viewportToIndex: Math.min(newVisible.length, to)
+  };
+}
+function reducer(state, action) {
+  switch (action.type) {
+    case "focus-next": {
+      if (!state.focusedId) return state;
+      const idx = state.visibleIdIndex.get(state.focusedId) ?? -1;
+      if (idx < 0 || idx >= state.visibleIds.length - 1) return state;
+      const nextId = state.visibleIds[idx + 1];
+      return {
+        ...state,
+        focusedId: nextId,
+        ...adjustViewport(state, idx + 1)
+      };
+    }
+    case "focus-previous": {
+      if (!state.focusedId) return state;
+      const idx = state.visibleIdIndex.get(state.focusedId) ?? -1;
+      if (idx <= 0) return state;
+      const prevId = state.visibleIds[idx - 1];
+      return {
+        ...state,
+        focusedId: prevId,
+        ...adjustViewport(state, idx - 1)
+      };
+    }
+    case "focus-first": {
+      if (state.visibleIds.length === 0) return state;
+      return {
+        ...state,
+        focusedId: state.visibleIds[0],
+        viewportFromIndex: 0,
+        viewportToIndex: Math.min(
+          state.visibleNodeCount,
+          state.visibleIds.length
+        )
+      };
+    }
+    case "focus-last": {
+      if (state.visibleIds.length === 0) return state;
+      const lastIdx = state.visibleIds.length - 1;
+      return {
+        ...state,
+        focusedId: state.visibleIds[lastIdx],
+        ...adjustViewport(state, lastIdx)
+      };
+    }
+    case "expand": {
+      if (!state.focusedId) return state;
+      return reducer(state, { type: "expand-node", nodeId: state.focusedId });
+    }
+    case "expand-node": {
+      const { nodeId } = action;
+      const flat = state.nodeMap.get(nodeId);
+      if (!flat || !flat.hasChildren) return state;
+      if (state.expandedIds.has(nodeId)) return state;
+      const newExpanded = new Set(state.expandedIds);
+      newExpanded.add(nodeId);
+      const newVisible = state.nodeMap.getVisibleIds(newExpanded);
+      return {
+        ...state,
+        previousExpandedIds: state.expandedIds,
+        expandedIds: newExpanded,
+        visibleIds: newVisible,
+        visibleIdIndex: buildVisibleIdIndex(newVisible),
+        ...adjustViewportForNewVisible(
+          { ...state, visibleIds: newVisible },
+          newVisible
+        )
+      };
+    }
+    case "collapse": {
+      if (!state.focusedId) return state;
+      return reducer(state, { type: "collapse-node", nodeId: state.focusedId });
+    }
+    case "collapse-node": {
+      const { nodeId } = action;
+      if (!state.expandedIds.has(nodeId)) return state;
+      const newExpanded = new Set(state.expandedIds);
+      newExpanded.delete(nodeId);
+      const newVisible = state.nodeMap.getVisibleIds(newExpanded);
+      let newFocusedId = state.focusedId;
+      if (newFocusedId !== void 0 && newFocusedId !== nodeId && state.nodeMap.isDescendantOf(newFocusedId, nodeId)) {
+        newFocusedId = nodeId;
+      }
+      return {
+        ...state,
+        focusedId: newFocusedId,
+        previousExpandedIds: state.expandedIds,
+        expandedIds: newExpanded,
+        visibleIds: newVisible,
+        visibleIdIndex: buildVisibleIdIndex(newVisible),
+        ...adjustViewportForNewVisible(
+          { ...state, focusedId: newFocusedId, visibleIds: newVisible },
+          newVisible
+        )
+      };
+    }
+    case "toggle-expanded": {
+      if (!state.focusedId) return state;
+      if (state.expandedIds.has(state.focusedId)) {
+        return reducer(state, { type: "collapse" });
+      }
+      return reducer(state, { type: "expand" });
+    }
+    case "expand-all": {
+      const allParentIds = /* @__PURE__ */ new Set();
+      for (const [id, flat] of state.nodeMap.entries()) {
+        if (flat.hasChildren) allParentIds.add(id);
+      }
+      const newVisible = state.nodeMap.getVisibleIds(allParentIds);
+      return {
+        ...state,
+        previousExpandedIds: state.expandedIds,
+        expandedIds: allParentIds,
+        visibleIds: newVisible,
+        visibleIdIndex: buildVisibleIdIndex(newVisible),
+        ...adjustViewportForNewVisible(
+          { ...state, visibleIds: newVisible },
+          newVisible
+        )
+      };
+    }
+    case "collapse-all": {
+      const newExpanded = /* @__PURE__ */ new Set();
+      const newVisible = state.nodeMap.getVisibleIds(newExpanded);
+      return {
+        ...state,
+        previousExpandedIds: state.expandedIds,
+        expandedIds: newExpanded,
+        visibleIds: newVisible,
+        visibleIdIndex: buildVisibleIdIndex(newVisible),
+        focusedId: newVisible[0],
+        viewportFromIndex: 0,
+        viewportToIndex: Math.min(
+          state.visibleNodeCount,
+          newVisible.length
+        )
+      };
+    }
+    case "select": {
+      if (!state.focusedId) return state;
+      if (state.selectionMode === "none") return state;
+      if (state.selectionMode === "single") {
+        const newSelected2 = /* @__PURE__ */ new Set([state.focusedId]);
+        return {
+          ...state,
+          previousSelectedIds: state.selectedIds,
+          selectedIds: newSelected2
+        };
+      }
+      const newSelected = new Set(state.selectedIds);
+      if (newSelected.has(state.focusedId)) {
+        newSelected.delete(state.focusedId);
+      } else {
+        newSelected.add(state.focusedId);
+      }
+      return {
+        ...state,
+        previousSelectedIds: state.selectedIds,
+        selectedIds: newSelected
+      };
+    }
+    case "focus-parent": {
+      if (!state.focusedId) return state;
+      const flat = state.nodeMap.get(state.focusedId);
+      if (!flat?.parentId) return state;
+      const parentIdx = state.visibleIdIndex.get(flat.parentId) ?? -1;
+      if (parentIdx < 0) return state;
+      return {
+        ...state,
+        focusedId: flat.parentId,
+        ...adjustViewport(state, parentIdx)
+      };
+    }
+    case "focus-first-child": {
+      if (!state.focusedId) return state;
+      const flat = state.nodeMap.get(state.focusedId);
+      if (!flat || flat.childrenIds.length === 0) return state;
+      if (!state.expandedIds.has(state.focusedId)) return state;
+      const firstChildId = flat.childrenIds[0];
+      const childIdx = state.visibleIdIndex.get(firstChildId) ?? -1;
+      if (childIdx < 0) return state;
+      return {
+        ...state,
+        focusedId: firstChildId,
+        ...adjustViewport(state, childIdx)
+      };
+    }
+    case "set-loading": {
+      const newLoading = new Set(state.loadingIds);
+      if (action.isLoading) {
+        newLoading.add(action.nodeId);
+      } else {
+        newLoading.delete(action.nodeId);
+      }
+      return { ...state, loadingIds: newLoading };
+    }
+    case "set-children-error": {
+      const newLoading = new Set(state.loadingIds);
+      newLoading.delete(action.nodeId);
+      return { ...state, loadingIds: newLoading };
+    }
+    case "insert-children": {
+      const parentFlat = state.nodeMap.get(action.parentId);
+      if (!parentFlat) return state;
+      const newNodeMap = state.nodeMap.withChildren(
+        action.parentId,
+        action.children
+      );
+      const newVisible = newNodeMap.getVisibleIds(state.expandedIds);
+      return {
+        ...state,
+        nodeMap: newNodeMap,
+        visibleIds: newVisible,
+        visibleIdIndex: buildVisibleIdIndex(newVisible)
+      };
+    }
+    case "reset": {
+      return action.state;
+    }
+    default: {
+      return state;
+    }
+  }
+}
+function createDefaultState({
+  data,
+  selectionMode,
+  defaultExpanded,
+  defaultSelected,
+  visibleNodeCount
+}) {
+  const nodeMap = new TreeNodeMap(data);
+  let expandedIds;
+  if (defaultExpanded === "all") {
+    expandedIds = /* @__PURE__ */ new Set();
+    for (const [id, flat] of nodeMap.entries()) {
+      if (flat.hasChildren) expandedIds.add(id);
+    }
+  } else if (defaultExpanded) {
+    expandedIds = new Set(defaultExpanded);
+  } else {
+    expandedIds = /* @__PURE__ */ new Set();
+  }
+  const visibleIds = nodeMap.getVisibleIds(expandedIds);
+  const selectedIds = selectionMode !== "none" && defaultSelected ? new Set(defaultSelected) : /* @__PURE__ */ new Set();
+  const nodeCount = Math.min(visibleNodeCount, visibleIds.length);
+  return {
+    nodeMap,
+    expandedIds,
+    visibleIds,
+    visibleIdIndex: buildVisibleIdIndex(visibleIds),
+    focusedId: visibleIds[0],
+    visibleNodeCount,
+    viewportFromIndex: 0,
+    viewportToIndex: nodeCount,
+    selectionMode,
+    selectedIds,
+    previousSelectedIds: selectedIds,
+    previousExpandedIds: expandedIds,
+    loadingIds: /* @__PURE__ */ new Set()
+  };
+}
+function useTreeViewState({
+  data,
+  selectionMode = "none",
+  defaultExpanded,
+  defaultSelected,
+  visibleNodeCount = Infinity,
+  onFocusChange,
+  onExpandChange,
+  onSelectChange
+}) {
+  const [state, dispatch] = useReducer(
+    reducer,
+    { data, selectionMode, defaultExpanded, defaultSelected, visibleNodeCount },
+    createDefaultState
+  );
+  const [lastData, setLastData] = useState(data);
+  if (data !== lastData) {
+    dispatch({
+      type: "reset",
+      state: createDefaultState({
+        data,
+        selectionMode,
+        defaultExpanded,
+        defaultSelected,
+        visibleNodeCount
+      })
+    });
+    setLastData(data);
+  }
+  const isInitialMount = useRef(true);
+  useEffect(() => {
+    if (isInitialMount.current) {
+      isInitialMount.current = false;
+      return;
+    }
+    if (state.focusedId) onFocusChange?.(state.focusedId);
+  }, [state.focusedId, onFocusChange]);
+  useEffect(() => {
+    if (state.expandedIds !== state.previousExpandedIds) {
+      onExpandChange?.(state.expandedIds);
+    }
+  }, [state.expandedIds, state.previousExpandedIds, onExpandChange]);
+  useEffect(() => {
+    if (state.selectedIds !== state.previousSelectedIds) {
+      onSelectChange?.(state.selectedIds);
+    }
+  }, [state.selectedIds, state.previousSelectedIds, onSelectChange]);
+  const viewportNodes = useMemo(() => {
+    return state.visibleIds.slice(state.viewportFromIndex, state.viewportToIndex).map((id) => {
+      const flat = state.nodeMap.get(id);
+      return {
+        node: flat.node,
+        state: {
+          isFocused: id === state.focusedId,
+          isExpanded: state.expandedIds.has(id),
+          isSelected: state.selectedIds.has(id),
+          depth: flat.depth,
+          hasChildren: flat.hasChildren,
+          isLoading: state.loadingIds.has(id)
+        }
+      };
+    });
+  }, [
+    state.visibleIds,
+    state.viewportFromIndex,
+    state.viewportToIndex,
+    state.focusedId,
+    state.expandedIds,
+    state.selectedIds,
+    state.nodeMap,
+    state.loadingIds
+  ]);
+  const focusNext = useCallback(
+    () => dispatch({ type: "focus-next" }),
+    []
+  );
+  const focusPrevious = useCallback(
+    () => dispatch({ type: "focus-previous" }),
+    []
+  );
+  const focusFirst = useCallback(
+    () => dispatch({ type: "focus-first" }),
+    []
+  );
+  const focusLast = useCallback(
+    () => dispatch({ type: "focus-last" }),
+    []
+  );
+  const expand = useCallback(() => dispatch({ type: "expand" }), []);
+  const expandNode = useCallback(
+    (nodeId) => dispatch({ type: "expand-node", nodeId }),
+    []
+  );
+  const collapse = useCallback(
+    () => dispatch({ type: "collapse" }),
+    []
+  );
+  const collapseNode = useCallback(
+    (nodeId) => dispatch({ type: "collapse-node", nodeId }),
+    []
+  );
+  const toggleExpanded = useCallback(
+    () => dispatch({ type: "toggle-expanded" }),
+    []
+  );
+  const expandAll = useCallback(
+    () => dispatch({ type: "expand-all" }),
+    []
+  );
+  const collapseAll = useCallback(
+    () => dispatch({ type: "collapse-all" }),
+    []
+  );
+  const select = useCallback(() => dispatch({ type: "select" }), []);
+  const focusParent = useCallback(
+    () => dispatch({ type: "focus-parent" }),
+    []
+  );
+  const focusFirstChild = useCallback(
+    () => dispatch({ type: "focus-first-child" }),
+    []
+  );
+  const setLoading = useCallback(
+    (nodeId, isLoading) => dispatch({ type: "set-loading", nodeId, isLoading }),
+    []
+  );
+  const setChildrenError = useCallback(
+    (nodeId) => dispatch({ type: "set-children-error", nodeId }),
+    []
+  );
+  const insertChildren = useCallback(
+    (parentId, children) => dispatch({ type: "insert-children", parentId, children }),
+    []
+  );
+  return {
+    focusedId: state.focusedId,
+    expandedIds: state.expandedIds,
+    selectedIds: state.selectedIds,
+    viewportNodes,
+    visibleCount: state.visibleIds.length,
+    hasScrollUp: state.viewportFromIndex > 0,
+    hasScrollDown: state.viewportToIndex < state.visibleIds.length,
+    viewportFromIndex: state.viewportFromIndex,
+    viewportToIndex: state.viewportToIndex,
+    loadingIds: state.loadingIds,
+    nodeMap: state.nodeMap,
+    focusNext,
+    focusPrevious,
+    focusFirst,
+    focusLast,
+    expand,
+    expandNode,
+    collapse,
+    collapseNode,
+    toggleExpanded,
+    expandAll,
+    collapseAll,
+    select,
+    focusParent,
+    focusFirstChild,
+    setLoading,
+    setChildrenError,
+    insertChildren
+  };
+}
+
+// src/components/tree-view/use-tree-view.ts
+import { useInput } from "ink";
+import { useRef as useRef2 } from "react";
+function useTreeView({
+  isDisabled = false,
+  selectionMode,
+  state,
+  loadChildren,
+  onLoadError
+}) {
+  const loadingRef = useRef2(/* @__PURE__ */ new Set());
+  const stateRef = useRef2(state);
+  stateRef.current = state;
+  const loadChildrenRef = useRef2(loadChildren);
+  loadChildrenRef.current = loadChildren;
+  const onLoadErrorRef = useRef2(onLoadError);
+  onLoadErrorRef.current = onLoadError;
+  const triggerLoadRef = useRef2(async (nodeId) => {
+    if (loadingRef.current.has(nodeId)) return;
+    const currentLoadChildren = loadChildrenRef.current;
+    if (!currentLoadChildren) return;
+    const flat = stateRef.current.nodeMap.get(nodeId);
+    if (!flat || flat.childrenIds.length > 0) return;
+    loadingRef.current.add(nodeId);
+    stateRef.current.setLoading(nodeId, true);
+    try {
+      const children = await currentLoadChildren(flat.node);
+      stateRef.current.insertChildren(nodeId, children);
+      stateRef.current.expandNode(nodeId);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      stateRef.current.setChildrenError(nodeId);
+      onLoadErrorRef.current?.(nodeId, err);
+    } finally {
+      stateRef.current.setLoading(nodeId, false);
+      loadingRef.current.delete(nodeId);
+    }
+  });
+  const triggerLoad = triggerLoadRef.current;
+  useInput(
+    (input, key) => {
+      if (key.downArrow) {
+        state.focusNext();
+        return;
+      }
+      if (key.upArrow) {
+        state.focusPrevious();
+        return;
+      }
+      if (key.rightArrow) {
+        if (state.focusedId && state.expandedIds.has(state.focusedId)) {
+          state.focusFirstChild();
+        } else if (state.focusedId) {
+          if (loadChildren) {
+            const flat = state.nodeMap.get(state.focusedId);
+            if (flat && flat.hasChildren && flat.childrenIds.length === 0) {
+              void triggerLoad(state.focusedId);
+              return;
+            }
+          }
+          state.expand();
+        }
+        return;
+      }
+      if (key.leftArrow) {
+        if (state.focusedId && state.expandedIds.has(state.focusedId)) {
+          state.collapse();
+        } else {
+          state.focusParent();
+        }
+        return;
+      }
+      if (key.return) {
+        if (selectionMode !== "none") {
+          state.select();
+        } else {
+          state.toggleExpanded();
+        }
+        return;
+      }
+      if (input === " ") {
+        if (selectionMode === "multiple") {
+          state.select();
+        } else {
+          state.toggleExpanded();
+        }
+        return;
+      }
+      if (input === "\x1B[H" || input === "\x1B[1~" || input === "\x1BOH") {
+        state.focusFirst();
+        return;
+      }
+      if (input === "\x1B[F" || input === "\x1B[4~" || input === "\x1BOF") {
+        state.focusLast();
+        return;
+      }
+    },
+    { isActive: !isDisabled }
+  );
+}
+
+// src/components/tree-view/tree-view-node.tsx
+import { Box, Text } from "ink";
+import figures from "figures";
+import { jsx, jsxs } from "react/jsx-runtime";
+function TreeViewNode({
+  node,
+  nodeState,
+  selectionMode,
+  styles
+}) {
+  const { isFocused, isExpanded, isSelected, depth, hasChildren, isLoading } = nodeState;
+  let expandChar = " ";
+  if (isLoading) {
+    expandChar = "\u27F3";
+  } else if (hasChildren) {
+    expandChar = isExpanded ? figures.triangleDown : figures.triangleRight;
+  }
+  return /* @__PURE__ */ jsxs(Box, { ...styles.node({ isFocused }), children: [
+    isFocused && /* @__PURE__ */ jsx(Text, { ...styles.focusIndicator(), children: figures.pointer }),
+    depth > 0 && /* @__PURE__ */ jsx(Box, { ...styles.indent({ depth }) }),
+    selectionMode === "multiple" && /* @__PURE__ */ jsx(Text, { ...styles.selectedIndicator(), children: isSelected ? figures.checkboxOn : figures.checkboxOff }),
+    /* @__PURE__ */ jsx(Text, { ...isLoading ? styles.loadingIndicator() : styles.expandIndicator({ isExpanded }), children: expandChar }),
+    /* @__PURE__ */ jsx(Text, { ...styles.label({ isFocused, isSelected }), children: node.label }),
+    selectionMode === "single" && isSelected && /* @__PURE__ */ jsxs(Text, { ...styles.selectedIndicator(), children: [
+      " ",
+      figures.tick
+    ] })
+  ] });
+}
+
+// src/components/tree-view/theme.ts
+var theme = {
+  styles: {
+    container: () => ({
+      flexDirection: "column"
+    }),
+    node: ({ isFocused }) => ({
+      gap: 1,
+      paddingLeft: isFocused ? 0 : 2
+    }),
+    indent: ({ depth }) => ({
+      width: (depth ?? 0) * 2
+    }),
+    focusIndicator: () => ({
+      color: "blue"
+    }),
+    expandIndicator: (_props) => ({
+      color: "gray"
+    }),
+    label: ({ isFocused, isSelected }) => {
+      let color;
+      if (isSelected) color = "green";
+      if (isFocused) color = "blue";
+      return { color };
+    },
+    selectedIndicator: () => ({
+      color: "green"
+    }),
+    loadingIndicator: () => ({
+      color: "yellow"
+    })
+  }
+};
+var theme_default = theme;
+
+// src/components/tree-view/tree-view.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function TreeView({
+  data,
+  selectionMode = "none",
+  defaultExpanded,
+  defaultSelected,
+  visibleNodeCount,
+  renderNode,
+  loadChildren,
+  onLoadError,
+  onFocusChange,
+  onExpandChange,
+  onSelectChange,
+  isDisabled = false
+}) {
+  const state = useTreeViewState({
+    data,
+    selectionMode,
+    defaultExpanded,
+    defaultSelected,
+    visibleNodeCount,
+    onFocusChange,
+    onExpandChange,
+    onSelectChange
+  });
+  useTreeView({
+    isDisabled,
+    selectionMode,
+    state,
+    loadChildren,
+    onLoadError
+  });
+  const styles = theme_default.styles;
+  return /* @__PURE__ */ jsxs2(Box2, { ...styles.container(), children: [
+    state.hasScrollUp && /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      "  ",
+      "\\u2191 ",
+      state.viewportFromIndex,
+      " more above"
+    ] }),
+    state.viewportNodes.map(({ node, state: nodeState }) => {
+      if (renderNode) {
+        return /* @__PURE__ */ jsx2(Box2, { children: renderNode({ node, state: nodeState }) }, node.id);
+      }
+      return /* @__PURE__ */ jsx2(
+        TreeViewNode,
+        {
+          node,
+          nodeState,
+          selectionMode,
+          styles
+        },
+        node.id
+      );
+    }),
+    state.hasScrollDown && /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      "  ",
+      "\\u2193 ",
+      state.visibleCount - state.viewportToIndex,
+      " ",
+      "more below"
+    ] })
+  ] });
+}
+export {
+  TreeNodeMap,
+  TreeView,
+  theme_default as treeViewTheme,
+  useTreeView,
+  useTreeViewState
+};