@visulima/tui 1.0.0-alpha.9 → 1.0.0

package/dist/components/timer.d.ts

@@ -0,0 +1,59 @@
+import { Ref, ReactElement } from 'react';
+import { UseTimerResult } from "../ink/hooks/use-timer.js";
+type TimerRef = Omit<UseTimerResult, "isFinished" | "isRunning" | "remaining">;
+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 { Props, Timer, type Props as TimerProps, TimerRef, Timer as default };

package/dist/components/timer.js

@@ -0,0 +1 @@
+import{jsx as l}from"react/jsx-runtime";import{useImperativeHandle as f}from"react";import p from"../ink/hooks/use-timer.js";import{f as u}from"../packem_shared/format-time-fjoQHMxD.js";import{Text as d}from"./text.js";const b=({autoStart:o,bold:r,color:e,duration:a,format:i=u,interval:m,onTimeout:s,ref:n})=>{const t=p({autoStart:o,duration:a,interval:m,onTimeout:s});return f(n,()=>({reset:t.reset,start:t.start,stop:t.stop,toggle:t.toggle}),[t.reset,t.start,t.stop,t.toggle]),l(d,{bold:r,color:e,children:i(t.remaining)})};export{b as Timer,b as default};

package/dist/components/toast.d.ts

@@ -0,0 +1,49 @@
+import { ReactNode, ReactElement } from 'react';
+import { V as Variant } from "../packem_shared/variant-config.d-D5NnrrQK.js";
+type ToastVariant = Variant;
+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.
+* @returns A bordered `ReactElement` while visible; `null` once dismissed.
+*/
+declare function Toast({
+  children,
+  duration,
+  onDismiss,
+  title,
+  variant,
+  visible,
+  width
+}: Props): ReactElement | null;
+export { Props, Toast, type Props as ToastProps, ToastVariant, Toast as default };

package/dist/components/toast.js

@@ -0,0 +1 @@
+import{jsxs as c,jsx as t}from"react/jsx-runtime";import{useState as v,useRef as T,useEffect as w}from"react";import{Box as u}from"./box.js";import{Text as i}from"./text.js";import{o as g}from"../packem_shared/variant-config-BJqpNo7H.js";function B({children:f,duration:r=4e3,onDismiss:n,title:l,variant:m="info",visible:o,width:a}){const[p,h]=v(!0),e=o??p,d=T(n);if(d.current=n,w(()=>{if(o!==void 0||r<=0||!e)return;const b=setTimeout(()=>{h(!1),d.current?.()},r);return()=>{clearTimeout(b)}},[r,o,e]),!e)return null;const{color:s,icon:x}=g[m];return c(u,{borderColor:s,borderStyle:"round",gap:1,paddingX:1,width:a,children:[t(i,{color:s,children:x}),c(u,{flexDirection:"column",flexGrow:1,children:[l===void 0?void 0:t(i,{bold:!0,children:l}),t(i,{children:f})]})]})}export{B as Toast,B as default};

package/dist/components/tooltip.d.ts

@@ -0,0 +1,43 @@
+import { AnsiColors } from '@visulima/colorize';
+import { ReactNode, ReactElement } from 'react';
+import { LiteralUnion } from 'type-fest';
+type TooltipPlacement = "bottom" | "left" | "right" | "top";
+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`.
+*/
+declare function Tooltip({
+  children,
+  color,
+  content,
+  isVisible,
+  placement
+}: Props): ReactElement;
+export { Props, Tooltip, TooltipPlacement, type Props as TooltipProps, Tooltip as default };

package/dist/components/tooltip.js

@@ -0,0 +1 @@
+import{jsx as o,jsxs as f}from"react/jsx-runtime";import{Box as t}from"./box.js";import{Text as a}from"./text.js";const m={bottom:{flexDirection:"column",orderFirst:!1},left:{flexDirection:"row",orderFirst:!0},right:{flexDirection:"row",orderFirst:!1},top:{flexDirection:"column",orderFirst:!0}};function p({children:c,color:i="gray",content:r,isVisible:s=!0,placement:e="right"}){const{flexDirection:d,orderFirst:n}=m[e],l=s?o(t,{borderColor:i,borderStyle:"round",flexShrink:0,marginLeft:e==="right"?1:0,marginRight:e==="left"?1:0,paddingX:1,children:typeof r=="string"?o(a,{color:i,children:r}):r}):void 0;return f(t,{alignItems:"center",flexDirection:d,children:[n?l:void 0,o(t,{children:c}),n?void 0:l]})}export{p as Tooltip,p as default};

package/dist/components/transform.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode, ReactElement } from 'react';
+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.
+*/
+declare function Transform({
+  accessibilityLabel,
+  children,
+  transform
+}: Props): ReactElement | null;
+export { Props, Transform, type Props as TransformProps, Transform as default };

package/dist/components/transform.js

@@ -0,0 +1 @@
+import{jsx as o}from"react/jsx-runtime";import{useContext as i}from"react";import{a as l}from"../packem_shared/accessibility-context-DDyHTwmA.js";const s={flexDirection:"row",flexGrow:0,flexShrink:1};function m({accessibilityLabel:r,children:t,transform:e}){const{isScreenReaderEnabled:n}=i(l);return t==null?null:o("ink-text",{internal_transform:e,style:s,children:n&&r?r:t})}export{m as Transform,m as default};

package/dist/components/transition.d.ts

@@ -0,0 +1,74 @@
+import { ReactNode, ReactElement } from 'react';
+type TransitionPreset = "fade" | "reveal" | "slide-down" | "slide-left" | "slide-right" | "slide-up";
+type TransitionPhase = "entered" | "entering" | "exited" | "exiting";
+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;
+};
+/**
+* Animate a child's entry and exit using a TUI-friendly preset. Drive via
+* `show`; the component toggles between enter and exit, fires `onExit` once
+* the exit animation completes.
+*
+* **Fade preset note:** `dimColor` is only applied when the child is a plain
+* string. Non-string children (Box trees, other components) pass through
+* untouched during the transition — wrap them in `<Text>` if you need the
+* fade effect.
+* @returns A `ReactElement` rendering the transitioning child, or `null`
+* once a hidden transition has fully completed.
+*/
+declare function Transition({
+  children,
+  distance,
+  duration,
+  onExit,
+  preset,
+  show,
+  tickInterval
+}: Props): ReactElement | null;
+/**
+* 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 { Props, Transition, TransitionPhase, TransitionPreset, type Props as TransitionProps, TransitionWithMarker as default };

package/dist/components/transition.js

@@ -0,0 +1 @@
+import{jsx as e}from"react/jsx-runtime";import{useState as w,useRef as d,useEffect as D}from"react";import{Box as c}from"./box.js";import{Text as b}from"./text.js";const j=(t,r)=>t>=1?e(c,{children:r}):t<=0?e(c,{}):e(c,{children:typeof r=="string"?e(b,{dimColor:t<.7,children:r}):r}),y=(t,r)=>Math.max(0,Math.min(r,Math.round((1-t)*r))),f=(t,r)=>(i,u,h)=>{const n=y(i,h);return i>=1?e(c,{children:u}):i<=0?e(c,{}):t==="x"?e(c,{paddingLeft:r===1?n:0,paddingRight:r===-1?n:0,children:u}):e(c,{flexDirection:"column",paddingBottom:r===-1?n:0,paddingTop:r===1?n:0,children:u})},A=(t,r,i)=>{if(t>=1)return e(c,{children:r});if(t<=0)return e(c,{});const u=Math.max(0,Math.min(i,Math.round(t*i)));return e(c,{flexDirection:"column",height:u,overflowY:"hidden",children:r})},C={fade:j,reveal:A,"slide-down":f("y",-1),"slide-left":f("x",-1),"slide-right":f("x",1),"slide-up":f("y",1)},O=(t,r)=>t?r>=1?"entered":"entering":r<=0?"exited":"exiting";function K({children:t,distance:r=4,duration:i=240,onExit:u,preset:h="fade",show:n=!0,tickInterval:g=30}){const[m,I]=w(n?1:0),x=d(n?1:0),M=d(Date.now()),s=d(n?1:0),a=d(!n),p=d(u);p.current=u;const[k,B]=w(0);if(D(()=>{const o=n?1:0;x.current!==o&&(x.current=o,M.current=Date.now(),s.current=m,a.current=!1,B(l=>l+1))},[n]),D(()=>{const o=x.current;if(s.current===o){o===0&&!a.current&&(a.current=!0,p.current?.());return}const l=setInterval(()=>{const R=Date.now()-M.current,v=i<=0?1:Math.min(1,R/i),T=s.current+(o-s.current)*v;I(T),v>=1&&(clearInterval(l),o===0&&!a.current&&(a.current=!0,p.current?.()))},g);return()=>{clearInterval(l)}},[k,i,g]),O(n,m)==="exited"&&!n)return null;const E=C[h];return E(m,t,r)}const Y=Object.assign(K,{isAnimatable:!0});export{K as Transition,Y as default};

package/dist/components/tree-view-entry.d.ts

@@ -0,0 +1,357 @@
+import { BoxProps as Props$1 } from "./box.js";
+import { Props as Props$2 } from "./text.js";
+import { ReactNode, ReactElement } from 'react';
+import 'type-fest';
+import "../packem_shared/dom.d-B4kXbaVY.js";
+import 'yoga-layout';
+import "../packem_shared/cursor-helpers.d-BONB9tky.js";
+import '@visulima/colorize';
+import 'cli-boxes';
+import "../packem_shared/styles.d-cMo36xQz.js";
+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: () => Props$1;
+    expandIndicator: (_props: StyleFunctionProps) => Props$2;
+    focusIndicator: () => Props$2;
+    indent: ({
+      depth
+    }: StyleFunctionProps) => Props$1;
+    label: ({
+      isFocused,
+      isSelected
+    }: StyleFunctionProps) => Props$2;
+    loadingIndicator: () => Props$2;
+    node: ({
+      isFocused
+    }: StyleFunctionProps) => Props$1;
+    selectedIndicator: () => Props$2;
+  };
+};
+type Theme = typeof theme;
+/**
+* A single node in the tree. Generic over the user's data shape.
+* The `id` field MUST be unique across the entire tree.
+*/
+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.
+*/
+type AsyncChildrenFunction<T = Record<string, unknown>> = (node: TreeNode<T>) => Promise<TreeNode<T>[]>;
+/**
+* State passed to custom renderers and theme functions.
+*/
+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.
+*/
+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.
+*/
+type SelectionMode = "multiple" | "none" | "single";
+/**
+* A flattened representation of a tree node with navigation links.
+*/
+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.
+*/
+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;
+}
+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"
+* />
+* ```
+*/
+declare function TreeView<T = Record<string, unknown>>({
+  ariaLabel,
+  data,
+  defaultExpanded,
+  defaultSelected,
+  isDisabled,
+  loadChildren,
+  onExpandChange,
+  onFocusChange,
+  onLoadError,
+  onSelectChange,
+  renderNode,
+  selectionMode,
+  visibleNodeCount
+}: Props<T>): ReactElement;
+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;
+};
+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;
+};
+declare function useTreeViewState<T = Record<string, unknown>>({
+  data,
+  defaultExpanded,
+  defaultSelected,
+  onExpandChange,
+  onFocusChange,
+  onSelectChange,
+  selectionMode,
+  visibleNodeCount
+}: UseTreeViewStateProps<T>): TreeViewState<T>;
+type UseTreeViewProps<T = Record<string, unknown>> = {
+  /**
+  * When disabled, user input is ignored.
+  * @default false
+  */
+  readonly isDisabled?: boolean;
+  /**
+  * Async function to load children on demand.
+  */
+  readonly loadChildren?: AsyncChildrenFunction<T>;
+  /**
+  * Called when `loadChildren` rejects.
+  */
+  readonly onLoadError?: (nodeId: string, error: Error) => void;
+  /**
+  * Selection mode.
+  */
+  readonly selectionMode: SelectionMode;
+  /**
+  * The tree view state from `useTreeViewState`.
+  */
+  readonly state: TreeViewState<T>;
+};
+declare function useTreeView<T>({
+  isDisabled,
+  loadChildren,
+  onLoadError,
+  selectionMode,
+  state
+}: UseTreeViewProps<T>): void;
+export { type AsyncChildrenFunction, type FlatNode, type SelectionMode, type TreeNode, TreeNodeMap, type TreeNodeRendererProps, type TreeNodeState, TreeView, type Props as TreeViewProps, type TreeViewState, type Theme as TreeViewTheme, type UseTreeViewProps, type UseTreeViewStateProps, theme as treeViewTheme, useTreeView, useTreeViewState };

package/dist/components/tree-view-entry.js

@@ -0,0 +1 @@
+import{theme as o}from"../packem_shared/treeViewTheme-Dq3ekRAC.js";import{TreeNodeMap as m}from"../packem_shared/TreeNodeMap-cJlYqckB.js";import{TreeView as f}from"../packem_shared/TreeView-BsvLCsf0.js";import{useTreeView as T}from"../packem_shared/useTreeView-D5ifGwG3.js";import{useTreeViewState as w}from"../packem_shared/useTreeViewState-BiTJakkh.js";export{m as TreeNodeMap,f as TreeView,o as treeViewTheme,T as useTreeView,w as useTreeViewState};

package/dist/components/unordered-list.d.ts

@@ -0,0 +1,30 @@
+import { ReactNode, ReactElement } from 'react';
+type UnorderedListEntry = {
+  /**
+  * Content of the list entry. Can be a string or nested list.
+  */
+  readonly children?: ReadonlyArray<UnorderedListEntry>;
+  /**
+  * Display text for this item.
+  */
+  readonly label: ReactNode;
+};
+type Props = {
+  /**
+  * Entries to render as a bullet list.
+  */
+  readonly items: ReadonlyArray<UnorderedListEntry>;
+  /**
+  * Custom bullet symbol(s). A string uses the same symbol at all depths.
+  * An array cycles through symbols by nesting depth.
+  */
+  readonly marker?: ReadonlyArray<string> | string;
+};
+/**
+* Renders a bullet list with nesting support.
+*/
+declare function UnorderedList({
+  items,
+  marker
+}: Props): ReactElement;
+export { Props, UnorderedList, UnorderedListEntry, type Props as UnorderedListProps, UnorderedList as default };

package/dist/components/unordered-list.js

@@ -0,0 +1 @@
+import{jsx as o,jsxs as l}from"react/jsx-runtime";import{Box as t}from"./box.js";import{Text as c}from"./text.js";const a=["─","◦","▪"],f=r=>typeof r=="string"?[r]:Array.isArray(r)?r:a,s=(r,e,i)=>{const d=e[i%e.length]??"─";return o(t,{flexDirection:"column",children:r.map((n,m)=>l(t,{gap:1,children:[o(c,{dimColor:!0,children:d}),l(t,{flexDirection:"column",children:[o(c,{children:n.label}),n.children?s(n.children,e,i+1):void 0]})]},m))})};function x({items:r,marker:e}){const i=f(e);return s(r,i,0)}export{x as UnorderedList,x as default};

package/dist/core/index.d.ts

@@ -1,5 +1,5 @@
-export { I as InlineLoop, a as InlineOptions, b as InlinePaintFn, c as InputParser, M as MouseEvent, T as TuiApp, d as createInlineLoop } from "../packem_shared/input.d-Bfq7oc06.js";
-import 'eventemitter3';
+export { I as InlineLoop, a as InlineOptions, b as InlinePaintFn, c as InputParser, M as MouseEvent, T as TuiApp, d as createInlineLoop } from "../packem_shared/input.d-CgxV2e8U.js";
+import 'tseep';
 /**
 * 2×u32 per-cell back-buffer layout:
 *   buffer[idx * 2]     = charCode  (Unicode codepoint, u32)

package/dist/core/index.js

@@ -1 +1 @@
-import{TuiApp as o}from"../packem_shared/TuiApp-DrjI_i-R.js";import{Cell as t,StyleMasks as m}from"../packem_shared/Cell-BrXn3jxY.js";import{createInlineLoop as l}from"../packem_shared/createInlineLoop-DRNZ7jqH.js";import{InputParser as f}from"../packem_shared/InputParser-rZKjY_7Y.js";import{Renderer as x,TerminalGuard as s,terminalSize as u}from"../packem_shared/Renderer-DJXooAsp.js";export{t as Cell,f as InputParser,x as Renderer,m as StyleMasks,s as TerminalGuard,o as TuiApp,l as createInlineLoop,u as terminalSize};
+import{TuiApp as o}from"../packem_shared/TuiApp-BPL8v1i1.js";import{Cell as t,StyleMasks as m}from"../packem_shared/Cell-BrXn3jxY.js";import{createInlineLoop as l}from"../packem_shared/createInlineLoop-BT40Wpmx.js";import{InputParser as f}from"../packem_shared/InputParser-CtwkCbrQ.js";import{Renderer as x,TerminalGuard as s,terminalSize as u}from"../packem_shared/Renderer-DsskdkUd.js";export{t as Cell,f as InputParser,x as Renderer,m as StyleMasks,s as TerminalGuard,o as TuiApp,l as createInlineLoop,u as terminalSize};