@visulima/tui 0.0.1 → 1.0.0-alpha.2

package/dist/ink/components/file-picker/FilePicker.d.ts

@@ -0,0 +1,75 @@
+import type { ReactElement } from "react";
+import type { FileEntry, FilePickerFilter } from "./types.d.ts";
+export type Props = {
+    /**
+     * Color for the focused item highlight.
+     *
+     * @default "cyan"
+     */
+    readonly accentColor?: string;
+    /**
+     * Color for directory entries.
+     *
+     * @default "blue"
+     */
+    readonly directoryColor?: string;
+    /**
+     * Color for file entries.
+     *
+     * @default "white"
+     */
+    readonly fileColor?: string;
+    /**
+     * File filter options.
+     */
+    readonly filter?: FilePickerFilter;
+    /**
+     * Starting directory path.
+     *
+     * @default process.cwd()
+     */
+    readonly initialPath?: string;
+    /**
+     * Whether keyboard navigation is active.
+     *
+     * @default true
+     */
+    readonly isFocused?: boolean;
+    /**
+     * Maximum number of visible items (viewport height).
+     *
+     * @default 10
+     */
+    readonly limit?: number;
+    /**
+     * Called when escape is pressed.
+     */
+    readonly onCancel?: () => void;
+    /**
+     * Called when a file is selected (enter on a file entry).
+     */
+    readonly onSelect?: (entry: FileEntry) => void;
+    /**
+     * Show file permissions column.
+     *
+     * @default false
+     */
+    readonly showPermissions?: boolean;
+    /**
+     * Show file size column.
+     *
+     * @default false
+     */
+    readonly showSize?: boolean;
+};
+/**
+ * A file system browser component for picking files from the terminal.
+ *
+ * ```tsx
+ * <FilePicker
+ *   onSelect={(entry) => console.log("Selected:", entry.path)}
+ *   filter={{ extensions: [".ts", ".tsx"] }}
+ * />
+ * ```
+ */
+export default function FilePicker({ accentColor, directoryColor, fileColor, filter, initialPath, isFocused, limit, onCancel, onSelect, showPermissions, showSize, }: Props): ReactElement;

package/dist/ink/components/file-picker/index.d.ts

@@ -0,0 +1,3 @@
+export type { Props as FilePickerProps } from "./FilePicker.d.ts";
+export { default as FilePicker } from "./FilePicker.d.ts";
+export type { FileEntry, FilePickerFilter } from "./types.d.ts";

package/dist/ink/components/file-picker/types.d.ts

@@ -0,0 +1,38 @@
+/**
+ * A single entry (file or directory) returned by the file system hook.
+ */
+export type FileEntry = {
+    readonly isDirectory: boolean;
+    readonly isHidden: boolean;
+    readonly name: string;
+    readonly path: string;
+    readonly permissions: string;
+    readonly size: number;
+};
+/**
+ * Filter options for the file picker.
+ */
+export type FilePickerFilter = {
+    /**
+     * Allowed file extensions (e.g. `[".ts", ".tsx"]`). Empty or omitted means all.
+     */
+    readonly extensions?: readonly string[];
+    /**
+     * Whether to include directories in the list.
+     *
+     * @default true
+     */
+    readonly showDirectories?: boolean;
+    /**
+     * Whether to include regular files in the list.
+     *
+     * @default true
+     */
+    readonly showFiles?: boolean;
+    /**
+     * Whether to include hidden files (names starting with `.`).
+     *
+     * @default false
+     */
+    readonly showHidden?: boolean;
+};

package/dist/ink/components/file-picker/use-file-system.d.ts

@@ -0,0 +1,16 @@
+import type { FileEntry, FilePickerFilter } from "./types.d.ts";
+type UseFileSystemOptions = {
+    readonly filter: FilePickerFilter;
+    readonly initialPath: string;
+};
+type UseFileSystemResult = {
+    readonly currentPath: string;
+    readonly entries: readonly FileEntry[];
+    readonly error: string | undefined;
+    readonly goUp: () => void;
+    readonly isLoading: boolean;
+    readonly navigateTo: (path: string) => void;
+    readonly refresh: () => void;
+};
+export default function useFileSystem(options: UseFileSystemOptions): UseFileSystemResult;
+export {};

package/dist/ink/components/scroll/ControlledScrollView.d.ts

@@ -0,0 +1,43 @@
+import type React from "react";
+import type { ReactNode, Ref } from "react";
+import type { Props as BoxProps } from "../Box.d.ts";
+export interface ControlledScrollViewProps extends BoxProps {
+    children?: ReactNode;
+    debug?: boolean;
+    onContentHeightChange?: (height: number, previousHeight: number) => void;
+    onItemHeightChange?: (index: number, height: number, previousHeight: number) => void;
+    onViewportSizeChange?: (size: {
+        height: number;
+        width: number;
+    }, previousSize: {
+        height: number;
+        width: number;
+    }) => void;
+    /**
+     * Number of extra items to render above/below the viewport when virtualized.
+     * @default 3
+     */
+    overscan?: number;
+    scrollOffset: number;
+    /**
+     * Only render items visible in the viewport plus overscan.
+     * Items must be measured first (first render always renders all items).
+     * @default false
+     */
+    virtualize?: boolean;
+}
+export interface ControlledScrollViewRef {
+    getBottomOffset: () => number;
+    getContentHeight: () => number;
+    getItemHeight: (index: number) => number;
+    getItemPosition: (index: number) => {
+        height: number;
+        top: number;
+    } | null;
+    getViewportHeight: () => number;
+    remeasure: () => void;
+    remeasureItem: (index: number) => void;
+}
+export declare const ControlledScrollView: ({ children, debug, onContentHeightChange, onItemHeightChange, onViewportSizeChange, overscan, ref, scrollOffset, virtualize, ...boxProps }: ControlledScrollViewProps & {
+    ref?: Ref<ControlledScrollViewRef>;
+}) => React.JSX.Element;

package/dist/ink/components/scroll/ScrollBar.d.ts

@@ -0,0 +1,20 @@
+import React from "react";
+import type { Props as BoxProps } from "../Box.d.ts";
+type ScrollBarPlacement = "inset" | "left" | "right";
+type ScrollBarStyle = BoxProps["borderStyle"] | "block" | "line" | "thick" | "dots";
+interface ScrollBarProps {
+    autoHide?: boolean;
+    color?: string;
+    contentHeight: number;
+    dimColor?: boolean;
+    placement?: ScrollBarPlacement;
+    scrollOffset: number;
+    style?: ScrollBarStyle;
+    thumbChar?: string;
+    trackChar?: string;
+    viewportHeight: number;
+}
+declare const ScrollBar: React.FC<ScrollBarProps>;
+export type { ScrollBarPlacement, ScrollBarProps, ScrollBarStyle };
+export { ScrollBar };
+export default ScrollBar;

package/dist/ink/components/scroll/ScrollBarBox.d.ts

@@ -0,0 +1,15 @@
+import type React from "react";
+import type { Props as BoxProps } from "../Box.d.ts";
+interface ScrollBarBoxProps extends BoxProps {
+    children?: React.ReactNode;
+    contentHeight: number;
+    scrollBarAutoHide?: boolean;
+    scrollBarPosition?: "left" | "right";
+    scrollOffset: number;
+    thumbChar?: string;
+    viewportHeight: number;
+}
+declare const ScrollBarBox: ({ borderColor, borderDimColor, borderLeftColor, borderLeftDimColor, borderRightColor, borderRightDimColor, borderStyle, children, contentHeight, height, scrollBarAutoHide, scrollBarPosition, scrollOffset, thumbChar, viewportHeight, ...boxProps }: ScrollBarBoxProps) => React.JSX.Element;
+export type { ScrollBarBoxProps };
+export { ScrollBarBox };
+export default ScrollBarBox;

package/dist/ink/components/scroll/ScrollList.d.ts

@@ -0,0 +1,12 @@
+import type React from "react";
+import type { Ref } from "react";
+import type { ScrollViewProps, ScrollViewRef } from "./ScrollView.d.ts";
+export type ScrollAlignment = "auto" | "bottom" | "center" | "top";
+export interface ScrollListProps extends ScrollViewProps {
+    readonly scrollAlignment?: ScrollAlignment;
+    readonly selectedIndex?: number;
+}
+export type ScrollListRef = ScrollViewRef;
+export declare const ScrollList: (props: ScrollListProps & {
+    ref?: Ref<ScrollListRef>;
+}) => React.JSX.Element;

package/dist/ink/components/scroll/ScrollView.d.ts

@@ -0,0 +1,98 @@
+import type React from "react";
+import type { ReactNode, Ref } from "react";
+import type { Props as BoxProps } from "../Box.d.ts";
+export interface ScrollViewProps extends BoxProps {
+    children?: ReactNode;
+    debug?: boolean;
+    /**
+     * Auto-scroll to bottom when content grows and user is at/near the bottom.
+     * Pauses when user scrolls away from bottom; resumes when they return.
+     * @default false
+     */
+    followOutput?: boolean;
+    /**
+     * Number of lines from bottom that still counts as "at bottom" for followOutput.
+     * @default 3
+     */
+    followThreshold?: number;
+    /**
+     * Enable built-in keyboard navigation (arrows, page up/down, home/end, ctrl+u/d).
+     * When enabled, the component becomes focusable.
+     * @default false
+     */
+    keyboard?: boolean;
+    onContentHeightChange?: (height: number, previousHeight: number) => void;
+    onItemHeightChange?: (index: number, height: number, previousHeight: number) => void;
+    /**
+     * Fires when scrolled within `reachThreshold` lines of the end.
+     * Only fires once per entry into the threshold zone.
+     */
+    onReachEnd?: () => void;
+    /**
+     * Fires when scrolled within `reachThreshold` lines of the start.
+     * Only fires once per entry into the threshold zone.
+     */
+    onReachStart?: () => void;
+    onScroll?: (scrollOffset: number) => void;
+    onViewportSizeChange?: (size: {
+        height: number;
+        width: number;
+    }, previousSize: {
+        height: number;
+        width: number;
+    }) => void;
+    /**
+     * Number of extra items to render above/below the viewport when virtualized.
+     * @default 3
+     */
+    overscan?: number;
+    /**
+     * Distance in lines from the edge to trigger onReachEnd/onReachStart.
+     * @default 5
+     */
+    reachThreshold?: number;
+    /**
+     * Show a scrollbar track when content overflows the viewport.
+     * @default false
+     */
+    scrollbar?: boolean;
+    /**
+     * Color of the scrollbar thumb and track.
+     */
+    scrollbarColor?: string;
+    /**
+     * Scrollbar visual style.
+     * @default "line"
+     */
+    scrollbarStyle?: "arrow" | "block" | "bold" | "classic" | "dots" | "double" | "doubleSingle" | "line" | "round" | "single" | "singleDouble" | "thick";
+    /**
+     * Enable vim-style keybindings (j/k/g/G/u/d). Requires `keyboard` to be true.
+     * @default false
+     */
+    vimBindings?: boolean;
+    /**
+     * Only render items visible in the viewport plus overscan. Requires items to be measured first.
+     * @default false
+     */
+    virtualize?: boolean;
+}
+export interface ScrollViewRef {
+    getBottomOffset: () => number;
+    getContentHeight: () => number;
+    getItemHeight: (index: number) => number;
+    getItemPosition: (index: number) => {
+        height: number;
+        top: number;
+    } | null;
+    getScrollOffset: () => number;
+    getViewportHeight: () => number;
+    remeasure: () => void;
+    remeasureItem: (index: number) => void;
+    scrollBy: (delta: number) => void;
+    scrollTo: (offset: number) => void;
+    scrollToBottom: () => void;
+    scrollToTop: () => void;
+}
+export declare const ScrollView: ({ children, debug, followOutput, followThreshold, keyboard, onContentHeightChange, onItemHeightChange, onReachEnd, onReachStart, onScroll, onViewportSizeChange, overscan, reachThreshold, ref, scrollbar, scrollbarColor, scrollbarStyle: scrollbarStyleProp, vimBindings, virtualize, ...boxProps }: ScrollViewProps & {
+    ref?: Ref<ScrollViewRef>;
+}) => React.JSX.Element;

package/dist/ink/components/scroll/index.d.ts

@@ -0,0 +1,10 @@
+export type { ControlledScrollViewProps, ControlledScrollViewRef } from "./ControlledScrollView.d.ts";
+export { ControlledScrollView } from "./ControlledScrollView.d.ts";
+export type { ScrollBarPlacement, ScrollBarProps, ScrollBarStyle } from "./ScrollBar.d.ts";
+export { ScrollBar } from "./ScrollBar.d.ts";
+export type { ScrollBarBoxProps } from "./ScrollBarBox.d.ts";
+export { ScrollBarBox } from "./ScrollBarBox.d.ts";
+export type { ScrollAlignment, ScrollListProps, ScrollListRef } from "./ScrollList.d.ts";
+export { ScrollList } from "./ScrollList.d.ts";
+export type { ScrollViewProps, ScrollViewRef } from "./ScrollView.d.ts";
+export { ScrollView } from "./ScrollView.d.ts";

package/dist/ink/components/scroll/use-state-ref.d.ts

@@ -0,0 +1,8 @@
+import type React from "react";
+/**
+ * Hook to manage state with immediate ref synchronization.
+ * Useful for values that need to be read synchronously in imperative methods
+ * but also trigger re-renders when changed.
+ */
+declare const useStateRef: <T>(initialValue: T) => readonly [T, (update: React.SetStateAction<T>) => void, () => T];
+export default useStateRef;

package/dist/ink/components/tree-view/TreeView.d.ts

@@ -0,0 +1,89 @@
+/**
+ * TreeView component for terminal UIs with keyboard navigation,
+ * expand/collapse, single/multi selection, async children loading,
+ * and viewport virtualization.
+ *
+ * Ported from ink-tree-view by John Costa.
+ * @see https://github.com/costajohnt/ink-tree-view
+ *
+ * MIT License
+ * Copyright (c) John Costa
+ */
+import type { ReactElement, ReactNode } from "react";
+import type { AsyncChildrenFunction, SelectionMode, TreeNode, TreeNodeRendererProps } from "./types.d.ts";
+export type Props<T = Record<string, unknown>> = {
+    /**
+     * Accessible label for the tree container.
+     * Useful when multiple tree views are on screen.
+     * @default "Tree view"
+     */
+    readonly ariaLabel?: string;
+    /**
+     * The tree data. Array of root-level nodes.
+     *
+     * **Important:** Must be referentially stable across renders (e.g. stored
+     * in state or wrapped in `useMemo`). Passing a new array reference on
+     * every render will reset focus, expansion, and selection state.
+     */
+    readonly data: TreeNode<T>[];
+    /**
+     * Set of node IDs that are expanded by default.
+     * If not provided, all nodes start collapsed.
+     */
+    readonly defaultExpanded?: ReadonlySet<string> | "all";
+    /**
+     * Set of node IDs that are selected by default.
+     */
+    readonly defaultSelected?: ReadonlySet<string>;
+    /**
+     * When disabled, user input is ignored.
+     * @default false
+     */
+    readonly isDisabled?: boolean;
+    /**
+     * Async function to load children on demand.
+     */
+    readonly loadChildren?: AsyncChildrenFunction<T>;
+    /** Called when expanded set changes. */
+    readonly onExpandChange?: (expandedIds: ReadonlySet<string>) => void;
+    /** Called when the focused node changes. */
+    readonly onFocusChange?: (nodeId: string) => void;
+    /**
+     * Called when `loadChildren` rejects. Receives the node ID and error.
+     */
+    readonly onLoadError?: (nodeId: string, error: Error) => void;
+    /** Called when selection changes. */
+    readonly onSelectChange?: (selectedIds: ReadonlySet<string>) => void;
+    /**
+     * Custom node renderer. Receives node + state, returns Ink JSX.
+     */
+    readonly renderNode?: (props: TreeNodeRendererProps<T>) => ReactNode;
+    /**
+     * Selection mode.
+     * - "none": No selection behavior (default).
+     * - "single": One node can be selected at a time.
+     * - "multiple": Multiple nodes can be selected (checkboxes shown).
+     * @default "none"
+     */
+    readonly selectionMode?: SelectionMode;
+    /**
+     * Number of visible nodes in the viewport (for virtualization).
+     * @default Infinity (no virtualization)
+     */
+    readonly visibleNodeCount?: number;
+};
+/**
+ * Renders an interactive tree view with keyboard navigation.
+ *
+ * ```tsx
+ * &lt;TreeView
+ *   data={[
+ *     { id: "1", label: "Root", children: [
+ *       { id: "1.1", label: "Child" },
+ *     ]},
+ *   ]}
+ *   defaultExpanded="all"
+ * />
+ * ```
+ */
+export declare function TreeView<T = Record<string, unknown>>({ ariaLabel, data, defaultExpanded, defaultSelected, isDisabled, loadChildren, onExpandChange, onFocusChange, onLoadError, onSelectChange, renderNode, selectionMode, visibleNodeCount, }: Props<T>): ReactElement;

package/dist/ink/components/tree-view/TreeViewNode.d.ts

@@ -0,0 +1,29 @@
+/**
+ * TreeViewNode renders a single node in the tree with focus indicator,
+ * indentation, expand/collapse indicator, label, and selection state.
+ *
+ * Ported from ink-tree-view by John Costa.
+ * @see https://github.com/costajohnt/ink-tree-view
+ *
+ * MIT License
+ * Copyright (c) John Costa
+ */
+import type { ReactElement } from "react";
+import type { Theme } from "./theme.d.ts";
+import type { SelectionMode, TreeNode, TreeNodeState } from "./types.d.ts";
+type Props<T = Record<string, unknown>> = {
+    readonly isScreenReaderEnabled: boolean;
+    readonly node: TreeNode<T>;
+    readonly nodeState: TreeNodeState;
+    readonly selectionMode: SelectionMode;
+    readonly siblingCount: number;
+    readonly siblingPosition: number;
+    readonly styles: Theme["styles"];
+};
+export declare function buildNodeAriaLabel(label: string, nodeState: TreeNodeState, siblingPosition: number, siblingCount: number): string;
+export declare function buildNodeAriaState(nodeState: TreeNodeState, selectionMode: SelectionMode): {
+    expanded?: boolean;
+    selected?: boolean;
+} | undefined;
+export declare function TreeViewNode<T>({ isScreenReaderEnabled, node, nodeState, selectionMode, siblingCount, siblingPosition, styles }: Props<T>): ReactElement;
+export {};

package/dist/ink/components/tree-view/index.d.ts

@@ -0,0 +1,11 @@
+export type { Theme as TreeViewTheme } from "./theme.d.ts";
+export { theme as treeViewTheme } from "./theme.d.ts";
+export type { FlatNode } from "./tree-node-map.d.ts";
+export { TreeNodeMap } from "./tree-node-map.d.ts";
+export type { Props as TreeViewProps } from "./TreeView.d.ts";
+export { TreeView } from "./TreeView.d.ts";
+export type { AsyncChildrenFunction, SelectionMode, TreeNode, TreeNodeRendererProps, TreeNodeState } from "./types.d.ts";
+export type { UseTreeViewProps } from "./use-tree-view.d.ts";
+export { useTreeView } from "./use-tree-view.d.ts";
+export type { TreeViewState, UseTreeViewStateProps } from "./use-tree-view-state.d.ts";
+export { useTreeViewState } from "./use-tree-view-state.d.ts";

package/dist/ink/components/tree-view/theme.d.ts

@@ -0,0 +1,24 @@
+import type { Props as BoxProps } from "../Box.d.ts";
+import type { Props as TextProps } from "../Text.d.ts";
+type StyleFunctionProps = {
+    readonly depth?: number;
+    readonly hasChildren?: boolean;
+    readonly isExpanded?: boolean;
+    readonly isFocused?: boolean;
+    readonly isLoading?: boolean;
+    readonly isSelected?: boolean;
+};
+declare const theme: {
+    styles: {
+        container: () => BoxProps;
+        expandIndicator: (_props: StyleFunctionProps) => TextProps;
+        focusIndicator: () => TextProps;
+        indent: ({ depth }: StyleFunctionProps) => BoxProps;
+        label: ({ isFocused, isSelected }: StyleFunctionProps) => TextProps;
+        loadingIndicator: () => TextProps;
+        node: ({ isFocused }: StyleFunctionProps) => BoxProps;
+        selectedIndicator: () => TextProps;
+    };
+};
+export { theme };
+export type Theme = typeof theme;

package/dist/ink/components/tree-view/tree-node-map.d.ts

@@ -0,0 +1,72 @@
+import type { TreeNode } from "./types.d.ts";
+/**
+ * A flattened representation of a tree node with navigation links.
+ */
+export type FlatNode<T = Record<string, unknown>> = {
+    /** Ordered list of direct children IDs. */
+    readonly childrenIds: ReadonlyArray<string>;
+    /** Depth in the tree (0 for roots). */
+    readonly depth: number;
+    /** Index in the flattened DFS order (across ALL nodes, not just visible). */
+    readonly flatIndex: number;
+    /** Whether this node has children. */
+    readonly hasChildren: boolean;
+    /** Next sibling's ID, or undefined. */
+    readonly nextSiblingId: string | undefined;
+    /** The original tree node. */
+    readonly node: TreeNode<T>;
+    /** Parent's id, or undefined if root. */
+    readonly parentId: string | undefined;
+    /** Previous sibling's ID, or undefined. */
+    readonly previousSiblingId: string | undefined;
+    /** Total number of siblings (including this node). */
+    readonly siblingCount: number;
+    /** Zero-based index among siblings. */
+    readonly siblingIndex: number;
+};
+/**
+ * A flattened map of all tree nodes built via DFS traversal.
+ * Stores parent/child/sibling links for O(1) navigation.
+ */
+export declare class TreeNodeMap<T = Record<string, unknown>> {
+    /** All node IDs in DFS order. */
+    readonly orderedIds: string[];
+    /** Root-level node IDs. */
+    readonly rootIds: string[];
+    /** Map from node ID to FlatNode. */
+    private readonly map;
+    constructor(data: TreeNode<T>[]);
+    /**
+     * Iterate over all entries.
+     */
+    entries(): IterableIterator<[string, FlatNode<T>]>;
+    /**
+     * Get a flat node by ID.
+     */
+    get(id: string): FlatNode<T> | undefined;
+    /**
+     * Total number of nodes in the tree.
+     */
+    get size(): number;
+    /**
+     * 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: ReadonlySet<string>): string[];
+    /**
+     * Check if a node is a descendant of another node.
+     */
+    isDescendantOf(nodeId: string, ancestorId: string): boolean;
+    /**
+     * Insert dynamically-loaded children under a parent node.
+     * Returns a new TreeNodeMap (immutable operation).
+     *
+     * Rebuilds the full tree from the current map state (not the original
+     * input data), so successive calls for different parents are safe.
+     */
+    withChildren(parentId: string, children: TreeNode<T>[]): TreeNodeMap<T>;
+    private buildFromData;
+}

package/dist/ink/components/tree-view/types.d.ts

@@ -0,0 +1,55 @@
+/**
+ * A single node in the tree. Generic over the user's data shape.
+ * The `id` field MUST be unique across the entire tree.
+ */
+export type TreeNode<T = Record<string, unknown>> = {
+    /** Child nodes. Undefined or empty array means leaf node. */
+    readonly children?: TreeNode<T>[];
+    /** Arbitrary user data attached to this node. */
+    readonly data?: T;
+    /** Unique identifier for this node. Used as the key for all lookups. */
+    readonly id: string;
+    /**
+     * Explicitly marks this node as a parent that can have children loaded
+     * asynchronously via `loadChildren`. When true, the node shows an expand
+     * indicator even if `children` is empty or undefined, and expanding it
+     * triggers the `loadChildren` callback.
+     */
+    readonly isParent?: boolean;
+    /** Display label. Used by the default renderer. */
+    readonly label: string;
+};
+/**
+ * For async/lazy loading: a function that resolves children on demand.
+ */
+export type AsyncChildrenFunction<T = Record<string, unknown>> = (node: TreeNode<T>) => Promise<TreeNode<T>[]>;
+/**
+ * State passed to custom renderers and theme functions.
+ */
+export type TreeNodeState = {
+    /** Depth of this node in the tree (root = 0). */
+    readonly depth: number;
+    /** Whether this node has children (or a lazy loader). */
+    readonly hasChildren: boolean;
+    /** Whether this node is expanded (children visible). */
+    readonly isExpanded: boolean;
+    /** Whether this node is currently focused (cursor is on it). */
+    readonly isFocused: boolean;
+    /** Whether children are currently loading (async mode). */
+    readonly isLoading: boolean;
+    /** Whether this node is selected (in select/multi-select mode). */
+    readonly isSelected: boolean;
+};
+/**
+ * Props received by a custom node renderer.
+ */
+export type TreeNodeRendererProps<T = Record<string, unknown>> = {
+    /** The tree node data. */
+    readonly node: TreeNode<T>;
+    /** Current state of this node. */
+    readonly state: TreeNodeState;
+};
+/**
+ * Selection mode for the tree view.
+ */
+export type SelectionMode = "multiple" | "none" | "single";