@visulima/tui 1.0.0-alpha.4 → 1.0.0-alpha.5

package/dist/ink/components/textarea.d.ts

@@ -1,62 +0,0 @@
-/**
- * Multi-line text input component for Ink.
- *
- * Provides a full-featured textarea with cursor navigation, selection,
- * clipboard support, undo/redo, and viewport scrolling.
- */
-import type { ReactElement } from "react";
-export type Props = {
-    /** @default "" */
-    readonly defaultValue?: string;
-    /**
-     * When true, all input is ignored and text is dimmed.
-     * @default false
-     */
-    readonly isDisabled?: boolean;
-    /**
-     * When true, the component responds to keyboard input.
-     * @default true
-     */
-    readonly isFocused?: boolean;
-    /**
-     * Maximum visible rows before viewport scrolling kicks in.
-     * When set, the textarea will grow from `rows` to `maxRows` before scrolling.
-     */
-    readonly maxRows?: number;
-    /**
-     * Fires on every edit with the updated text.
-     */
-    readonly onChange?: (value: string) => void;
-    /**
-     * Fires when the user presses Meta+Enter or Ctrl+Enter.
-     */
-    readonly onSubmit?: (value: string) => void;
-    /**
-     * Greyed-out text shown when the textarea is empty.
-     */
-    readonly placeholder?: string;
-    /**
-     * Number of visible rows (viewport height).
-     * @default 5
-     */
-    readonly rows?: number;
-    /**
-     * Show line numbers in the left gutter.
-     * @default false
-     */
-    readonly showLineNumbers?: boolean;
-    /**
-     * Number of spaces inserted for a Tab key press.
-     * @default 2
-     */
-    readonly tabSize?: number;
-};
-/**
- * A multi-line text input with cursor navigation, selection, clipboard, undo/redo,
- * paste support, and viewport scrolling.
- *
- * ```tsx
- * <Textarea defaultValue="Hello\nWorld" rows={10} onChange={setValue} onSubmit={handleSubmit} />
- * ```
- */
-export default function Textarea({ defaultValue, isDisabled, isFocused, maxRows, onChange, onSubmit, placeholder, rows, showLineNumbers, tabSize, }: Props): ReactElement;

package/dist/ink/components/timer.d.ts

@@ -1,50 +0,0 @@
-import type { ReactElement, Ref } from "react";
-import type { UseTimerResult } from "../hooks/use-timer.d.ts";
-export type TimerRef = Omit<UseTimerResult, "isFinished" | "isRunning" | "remaining">;
-export type Props = {
-    /**
-     * Whether to start the timer immediately.
-     * @default false
-     */
-    readonly autoStart?: boolean;
-    /**
-     * Make the rendered text bold.
-     */
-    readonly bold?: boolean;
-    /**
-     * Text color for the rendered time.
-     */
-    readonly color?: string;
-    /**
-     * Total countdown duration in milliseconds.
-     */
-    readonly duration: number;
-    /**
-     * Custom formatter for the remaining time.
-     * Receives remaining milliseconds, returns a display string.
-     * @default formatDuration (MM:SS or HH:MM:SS)
-     */
-    readonly format?: (remaining: number) => string;
-    /**
-     * Tick interval in milliseconds.
-     * @default 1000
-     */
-    readonly interval?: number;
-    /**
-     * Called once when the timer reaches zero.
-     */
-    readonly onTimeout?: () => void;
-    readonly ref?: Ref<TimerRef>;
-};
-/**
- * A countdown timer component.
- *
- * Exposes `start`, `stop`, `toggle`, and `reset` methods via ref.
- *
- * ```tsx
- * const ref = useRef&lt;TimerRef>(null);
- * &lt;Timer ref={ref} duration={60_000} autoStart />
- * ```
- */
-declare const Timer: ({ autoStart, bold, color, duration, format, interval, onTimeout, ref }: Props) => ReactElement;
-export default Timer;

package/dist/ink/components/toast.d.ts

@@ -1,41 +0,0 @@
-import type { ReactElement, ReactNode } from "react";
-import type { Variant } from "./variant-config.d.ts";
-export type ToastVariant = Variant;
-export type Props = {
-    /**
-     * Toast body.
-     */
-    readonly children: ReactNode;
-    /**
-     * Milliseconds to display before auto-dismissing. Use `0` to disable.
-     * @default 4000
-     */
-    readonly duration?: number;
-    /**
-     * Called after the toast dismisses itself.
-     */
-    readonly onDismiss?: () => void;
-    /**
-     * Optional title rendered before the body.
-     */
-    readonly title?: string;
-    /**
-     * Visual variant determining the icon and border color.
-     * @default "info"
-     */
-    readonly variant?: ToastVariant;
-    /**
-     * Manually control visibility. When provided, `duration` is ignored.
-     */
-    readonly visible?: boolean;
-    /**
-     * Optional width override.
-     */
-    readonly width?: number;
-};
-/**
- * Ephemeral notification. Disappears automatically after `duration` ms.
- * @param props See {@link Props}.
- * @returns A bordered `ReactElement` while visible; `null` once dismissed.
- */
-export default function Toast({ children, duration, onDismiss, title, variant, visible, width }: Props): ReactElement | null;

package/dist/ink/components/tooltip.d.ts

@@ -1,36 +0,0 @@
-import type { AnsiColors } from "@visulima/colorize";
-import type { ReactElement, ReactNode } from "react";
-import type { LiteralUnion } from "type-fest";
-export type TooltipPlacement = "bottom" | "left" | "right" | "top";
-export type Props = {
-    /**
-     * The element the tooltip is attached to.
-     */
-    readonly children: ReactNode;
-    /**
-     * Border color.
-     * @default "gray"
-     */
-    readonly color?: LiteralUnion<AnsiColors, string>;
-    /**
-     * Tooltip body content.
-     */
-    readonly content: ReactNode;
-    /**
-     * Controls whether the tooltip is rendered.
-     * @default true
-     */
-    readonly isVisible?: boolean;
-    /**
-     * Relative position. Terminal rendering does not support floating layers,
-     * so the tooltip is placed inline next to (or above / below) the anchor.
-     * @default "right"
-     */
-    readonly placement?: TooltipPlacement;
-};
-/**
- * Renders supplementary text next to an anchor. Because terminals don't have
- * a floating-layer concept, the tooltip lives inline in the layout. Hide it
- * by toggling `isVisible`.
- */
-export default function Tooltip({ children, color, content, isVisible, placement }: Props): ReactElement;

package/dist/ink/components/transform.d.ts

@@ -1,16 +0,0 @@
-import type { ReactElement, ReactNode } from "react";
-export type Props = {
-    /**
-     * Screen-reader-specific text to output. If this is set, all children will be ignored.
-     */
-    readonly accessibilityLabel?: string;
-    readonly children?: ReactNode;
-    /**
-     * Function that transforms children output. It accepts children and must return transformed children as well. Note that when children use `<Text>` styling props (e.g. `color`, `bold`), the string will contain ANSI escape codes.
-     */
-    readonly transform: (children: string, index: number) => string;
-};
-/**
- * Transform a string representation of React components before they're written to output. For example, you might want to apply a gradient to text, add a clickable link, or create some text effects. These use cases can't accept React nodes as input; they expect a string. That's what the <Transform> component does: it gives you an output string of its child components and lets you transform it in any way.
- */
-export default function Transform({ accessibilityLabel, children, transform }: Props): ReactElement | null;

package/dist/ink/components/transition.d.ts

@@ -1,53 +0,0 @@
-import type { ReactElement, ReactNode } from "react";
-export type TransitionPreset = "fade" | "reveal" | "slide-down" | "slide-left" | "slide-right" | "slide-up";
-export type TransitionPhase = "entered" | "entering" | "exited" | "exiting";
-export type Props = {
-    /**
-     * Content to animate.
-     */
-    readonly children: ReactNode;
-    /**
-     * For slide presets, how many characters of offset to animate across.
-     * For the `reveal` preset, the maximum row count to scale through.
-     * @default 4
-     */
-    readonly distance?: number;
-    /**
-     * Duration of both enter and exit transitions, in milliseconds.
-     * @default 240
-     */
-    readonly duration?: number;
-    /**
-     * Called once the exit animation finishes (i.e. the component has fully
-     * transitioned out). AnimatePresence uses this to unmount the wrapper.
-     */
-    readonly onExit?: () => void;
-    /**
-     * Animation preset controlling how the content appears/disappears.
-     * @default "fade"
-     */
-    readonly preset?: TransitionPreset;
-    /**
-     * Controls the target phase. `true` drives towards `entered`, `false`
-     * drives towards `exited`. Flip the value to trigger animation.
-     * @default true
-     */
-    readonly show?: boolean;
-    /**
-     * Tick interval in milliseconds. Lower values yield smoother animation
-     * at the cost of CPU.
-     * @default 30
-     */
-    readonly tickInterval?: number;
-};
-type TransitionComponent = ((props: Props) => ReactElement | null) & {
-    isAnimatable: true;
-};
-/**
- * Static marker used by `AnimatePresence` to recognize Transition children
- * even when the consumer hasn't explicitly passed a `show` prop. Consumers
- * can apply the same marker to their own wrappers (`MyWrapper.isAnimatable
- * = true`) to opt them into animation orchestration.
- */
-declare const TransitionWithMarker: TransitionComponent;
-export default TransitionWithMarker;

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

@@ -1,24 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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/tree-view-node.d.ts

@@ -1,29 +0,0 @@
-/**
- * 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/tree-view.d.ts

@@ -1,89 +0,0 @@
-/**
- * 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/types.d.ts

@@ -1,55 +0,0 @@
-/**
- * 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";

package/dist/ink/components/tree-view/use-tree-view-state.d.ts

@@ -1,135 +0,0 @@
-import { TreeNodeMap } from "./tree-node-map.d.ts";
-import type { SelectionMode, TreeNode, TreeNodeState } from "./types.d.ts";
-export type State<T> = {
-    expandedIds: Set<string>;
-    focusedId: string | undefined;
-    loadingIds: Set<string>;
-    nodeMap: TreeNodeMap<T>;
-    previousExpandedIds: Set<string>;
-    previousSelectedIds: Set<string>;
-    selectedIds: Set<string>;
-    selectionMode: SelectionMode;
-    viewportFromIndex: number;
-    viewportToIndex: number;
-    /** O(1) lookup from node ID to index in visibleIds. */
-    visibleIdIndex: Map<string, number>;
-    visibleIds: string[];
-    visibleNodeCount: number;
-};
-export type Action<T> = {
-    nodeId: string;
-    type: "collapse-node";
-} | {
-    nodeId: string;
-    type: "expand-node";
-} | {
-    nodeId: string;
-    type: "set-children-error";
-} | {
-    children: TreeNode<T>[];
-    parentId: string;
-    type: "insert-children";
-} | {
-    isLoading: boolean;
-    nodeId: string;
-    type: "set-loading";
-} | {
-    state: State<T>;
-    type: "reset";
-} | {
-    type: "collapse";
-} | {
-    type: "collapse-all";
-} | {
-    type: "expand";
-} | {
-    type: "expand-all";
-} | {
-    type: "focus-first";
-} | {
-    type: "focus-first-child";
-} | {
-    type: "focus-last";
-} | {
-    type: "focus-next";
-} | {
-    type: "focus-parent";
-} | {
-    type: "focus-previous";
-} | {
-    type: "select";
-} | {
-    type: "toggle-expanded";
-};
-export declare function reducer<T>(state: State<T>, action: Action<T>): State<T>;
-export type CreateDefaultStateProps<T> = {
-    data: TreeNode<T>[];
-    defaultExpanded?: ReadonlySet<string> | "all";
-    defaultSelected?: ReadonlySet<string>;
-    selectionMode: SelectionMode;
-    visibleNodeCount: number;
-};
-export declare function createDefaultState<T>({ data, defaultExpanded, defaultSelected, selectionMode, visibleNodeCount }: CreateDefaultStateProps<T>): State<T>;
-export type UseTreeViewStateProps<T = Record<string, unknown>> = {
-    /** The tree data. Array of root-level nodes. */
-    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>;
-    /** Called when expanded set changes. */
-    readonly onExpandChange?: (expandedIds: ReadonlySet<string>) => void;
-    /** Called when the focused node changes. */
-    readonly onFocusChange?: (nodeId: string) => void;
-    /** Called when selection changes. */
-    readonly onSelectChange?: (selectedIds: ReadonlySet<string>) => void;
-    /**
-     * Selection mode.
-     * @default "none"
-     */
-    readonly selectionMode?: SelectionMode;
-    /**
-     * Number of visible nodes in the viewport (for virtualization).
-     * @default Infinity
-     */
-    readonly visibleNodeCount?: number;
-};
-export type TreeViewState<T = Record<string, unknown>> = {
-    readonly collapse: () => void;
-    readonly collapseAll: () => void;
-    readonly collapseNode: (nodeId: string) => void;
-    readonly expand: () => void;
-    readonly expandAll: () => void;
-    readonly expandedIds: ReadonlySet<string>;
-    readonly expandNode: (nodeId: string) => void;
-    readonly focusedId: string | undefined;
-    readonly focusFirst: () => void;
-    readonly focusFirstChild: () => void;
-    readonly focusLast: () => void;
-    readonly focusNext: () => void;
-    readonly focusParent: () => void;
-    readonly focusPrevious: () => void;
-    readonly hasScrollDown: boolean;
-    readonly hasScrollUp: boolean;
-    readonly insertChildren: (parentId: string, children: TreeNode<T>[]) => void;
-    readonly loadingIds: ReadonlySet<string>;
-    readonly nodeMap: TreeNodeMap<T>;
-    readonly select: () => void;
-    readonly selectedIds: ReadonlySet<string>;
-    readonly setChildrenError: (nodeId: string) => void;
-    readonly setLoading: (nodeId: string, isLoading: boolean) => void;
-    readonly toggleExpanded: () => void;
-    readonly viewportFromIndex: number;
-    readonly viewportNodes: {
-        node: TreeNode<T>;
-        state: TreeNodeState;
-    }[];
-    readonly viewportToIndex: number;
-    readonly visibleCount: number;
-};
-export declare function useTreeViewState<T = Record<string, unknown>>({ data, defaultExpanded, defaultSelected, onExpandChange, onFocusChange, onSelectChange, selectionMode, visibleNodeCount, }: UseTreeViewStateProps<T>): TreeViewState<T>;