tui library TUI

Interactive TUI framework (Bubble Tea for Dart).

This library provides a framework for building interactive terminal applications using the Elm Architecture (Model-Update-View).

Core Components

Model: Represents the state of your application.
Update: A function that handles messages and returns a new model and commands.
View: A function that renders the current model into a string.
Program: The runtime that manages the event loop and rendering.
Bubbles: Reusable interactive widgets like text inputs, spinners, and lists.

Quick Start

import 'package:artisanal/tui.dart';

class CounterModel implements Model {
  final int count;
  CounterModel([this.count = 0]);

  @override
  Cmd? init() => null;

  @override
  (Model, Cmd?) update(Msg msg) {
    return switch (msg) {
      KeyMsg(key: Key(type: KeyType.up)) =>
        (CounterModel(count + 1), null),
      KeyMsg(key: Key(type: KeyType.down)) =>
        (CounterModel(count - 1), null),
      KeyMsg(key: Key(type: KeyType.runes, runes: [0x71])) =>
        (this, Cmd.quit()),
      _ => (this, null),
    };
  }

  @override
  String view() => 'Count: \$count\n\nUse ↑/↓ to change, q to quit';
}

void main() async {
  await runProgram(CounterModel());
}

The Elm Architecture

The TUI runtime follows The Elm Architecture (TEA) pattern, which separates state, logic, and presentation:

Model: The state of your application. It should be immutable.
Update: A pure function that takes a Msg and the current Model, and returns a new Model and an optional Cmd.
View: A pure function that takes the Model and returns a String (or a View object for advanced metadata) representing the UI.

┌─────────────────────────────────────────────────────┐
│                     Program                          │
│                                                      │
│    ┌───────┐     ┌────────┐     ┌──────┐            │
│    │ Model │────▶│ update │────▶│ view │            │
│    └───────┘     └────────┘     └──────┘            │
│        ▲              │              │               │
│        │              │              ▼               │
│        │         ┌────────┐     ┌────────┐          │
│        └─────────│  Cmd   │     │ Screen │          │
│                  └────────┘     └────────┘          │
│                       │                              │
│                       ▼                              │
│                  ┌────────┐                          │
│                  │  Msg   │◀──── User Input          │
│                  └────────┘                          │
└─────────────────────────────────────────────────────┘

Commands and Messages

Msg: Represents an event (key press, timer tick, network response).
Cmd: Represents an effect to be performed by the runtime (quitting, sending a message, running an external process).

Use BatchMsg to group multiple messages, and Cmd.batch to group multiple commands.

Program Lifecycle

Initialization: The Program starts, calls Model.init(), and executes the returned Cmd.
Event Loop: The program waits for input (stdin, signals, or commands).
Update: When a Msg arrives, Model.update(msg) is called.
Render: If the model changed, Model.view() is called and the result is rendered to the terminal.
Termination: The program exits when a QuitMsg is received or Cmd.quit() is executed.

Rendering and Performance

Artisanal supports multiple rendering strategies:

Standard: Simple ANSI output for basic terminals.
Ultraviolet: High-performance diff-based rendering with cell buffers.
ANSI Compression: Minimizes output by removing redundant SGR sequences.

Configure these via ProgramOptions.

The TUI runtime follows The Elm Architecture (TEA) pattern, which separates state, logic, and presentation:

Model: The state of your application. It should be immutable.
Update: A pure function that takes a Msg and the current Model, and returns a new Model and an optional Cmd.
View: A pure function that takes the Model and returns a String (or a View object for advanced metadata) representing the UI.

┌─────────────────────────────────────────────────────┐
│                     Program                          │
│                                                      │
│    ┌───────┐     ┌────────┐     ┌──────┐            │
│    │ Model │────▶│ update │────▶│ view │            │
│    └───────┘     └────────┘     └──────┘            │
│        ▲              │              │               │
│        │              │              ▼               │
│        │         ┌────────┐     ┌────────┐          │
│        └─────────│  Cmd   │     │ Screen │          │
│                  └────────┘     └────────┘          │
│                       │                              │
│                       ▼                              │
│                  ┌────────┐                          │
│                  │  Msg   │◀──── User Input          │
│                  └────────┘                          │
└─────────────────────────────────────────────────────┘

Msg: Represents an event (key press, timer tick, network response).
Cmd: Represents an effect to be performed by the runtime (quitting, sending a message, running an external process).

Use BatchMsg to group multiple messages, and Cmd.batch to group multiple commands.

Initialization: The Program starts, calls Model.init(), and executes the returned Cmd.
Event Loop: The program waits for input (stdin, signals, or commands).
Update: When a Msg arrives, Model.update(msg) is called.
Render: If the model changed, Model.view() is called and the result is rendered to the terminal.
Termination: The program exits when a QuitMsg is received or Cmd.quit() is executed.

Artisanal supports multiple rendering strategies:

Standard: Simple ANSI output for basic terminals.
Ultraviolet: High-performance diff-based rendering with cell buffers.
ANSI Compression: Minimizes output by removing redundant SGR sequences.

Configure these via ProgramOptions.

Classes

AccentPanel: A panel with a colored vertical accent stripe on one side.
AccentPanelThemeData: Theme data for AccentPanel widgets.
Accordion
ActionButton: A compact, styled button designed for use in dialog footers and inline prompt panels.
ActionChip: Flutter-style action chip.
AdaptiveChromaTheme: An adaptive syntax highlighting theme that selects between light and dark variants based on terminal background.
Alert: A fluent builder for creating styled alerts.
AlertBox
AlertComponent: An alert/notice block component.
Align
Alignment
AlwaysStoppedAnimation<T>: An Animation that is always stopped at a given value.
Animatable<T>: Transforms a double (typically from an Animation<double>) into a value of type T.
AnimatedBuilder: A general-purpose widget that rebuilds whenever a Listenable notifies.
AnimatedTint: A widget that applies an animated color tint over its child.
AnimatedWidgetBaseState<T extends ImplicitlyAnimatedWidget>: Base state class for ImplicitlyAnimatedWidget.
Animation<T>: An animation with a value of type T.
AnimationController: A TEA-native animation controller.
AnimationTickMsg: Message delivered on each animation frame tick.
AnsiRenderer: Renders markdown AST nodes to ANSI-styled terminal output.
AnsiRendererOptions: Configuration options for ANSI markdown rendering.
AnticipateConfig: Configuration for anticipate/autocomplete component.
AnticipateKeyMap: Key map for anticipate navigation and selection.
AnticipateModel: Anticipate model for autocomplete input.
ArtisanalApp: A high-level root shell for artisanal widget applications.
AsciiFont: Abstract base class for ASCII art fonts.
AsciiGlyph: Represents a single ASCII art character glyph.
AsciiText: A widget that renders text using large ASCII art font glyphs.
AsyncSnapshot<T>
BackendTerminal: Terminal implementation that layers ANSI/OSC semantics over a TerminalBackend.
BackgroundColorMsg: Message containing the terminal's background color.
Badge: A compact label with colored background, used for status, priority, or tags.
BatchMsg: Message containing multiple messages to be processed sequentially.
BlockFocus: A widget that blocks keyboard events from reaching its children.
BorderRadius
Box: A boxed message component.
BoxBuilder: A fluent builder for creating styled boxes.
BoxConstraints: Box constraints for layout.
BoxDecoration
BreadcrumbItem
Breadcrumbs
BrowserTerminalHostServer: Reusable browser host server for remote TUI sessions.
Budgeted<W extends Widget>: Wraps child with an explicit budget-aware signal.
BufferedTuiRenderer: A renderer that buffers output for efficient writes.
BuildContext: An opaque handle to location in the widget tree.
Builder: A widget that delegates its build to a callback.
BulletList: A bullet list component.
Button
CapabilityMsg: Message sent when a terminal capability is reported.
Card
CellSizeMsg: Message sent when the terminal reports its cell size in pixels.
Center
ChangeNotifier: A Listenable implementation that stores listeners and can notify them.
Checkbox
CheckboxListTile: Flutter-style checkbox list tile.
CheckedPopupMenuItem<T>: A selectable menu entry with a check indicator.
Chip: Flutter-style non-interactive chip.
ChoiceChip: Flutter-style single-select chip.
ChromaTheme: Configuration for syntax highlighting colors.
CircularProgressIndicator: Flutter-style circular progress indicator.
ClearScreenMsg: Internal message to clear the screen.
ClipboardMsg: Clipboard content message.
ClipboardSetMsg: Message emitted after a best-effort clipboard write is attempted.
ClipRect: A widget that clips its child to its allocated size.
Cmd TUI: A command that produces a message asynchronously.
CodeBlockCommentDelimiters
CodeEditor: A higher-level code editor built on top of TextEditor.
CodeLanguageProfile
ColoredBox: A widget that fills its area with a single solid color.
ColorPaletteMsg: Message containing a terminal palette entry color.
ColorProfileMsg: Message sent when the terminal color profile is detected or changed.
ColorSchemeMsg: Message sent when the terminal reports its preferred light/dark scheme.
Column
ColumnComponent: A component that renders with a newline after each child.
ColumnsComponent: A multi-column layout component.
CommandPalette: A searchable, grouped list displayed in a modal overlay.
CommandPaletteItem: A single item in a CommandPalette.
CommandPaletteMatch: A scored command palette match with explainable evidence.
CommandPaletteThemeData: Theme data for CommandPalette widgets.
Comment: A fluent builder for creating styled comments.
CommentComponent: A comment component (dimmed text with // prefix).
CommonKeyBindings: Commonly used key bindings for navigation.
ComponentBoxChars: Box drawing characters for component system.
CompositeComponent: A component that composes multiple child components.
CompositeModel: A model that wraps another model, useful for composition.
ConditionalStep: Conditional wizard step.
ConfirmCancelledMsg: Message sent when confirmation is cancelled.
ConfirmKeyMap: Key bindings for the confirm component.
ConfirmModel: A confirmation (yes/no) component following the Model architecture.
ConfirmResultMsg: Message sent when confirmation is made.
ConfirmStep: Confirmation wizard step.
ConfirmStyles: Styles for the confirm component.
ConstantTween<T>: A tween that always returns the same constant value.
ConstrainedBox
Container
CountdownModel: A countdown model built on top of TimerModel.
Cubic: A cubic Bezier curve defined by two control points.
CursorBlinkMsg: Message indicating the cursor should toggle its blink state.
CursorColorMsg: Message containing the terminal's cursor color.
CursorModel: A blinking cursor widget for text input components.
CursorPositionMsg: Message sent when the terminal reports the cursor position.
Curve: A mapping of the unit interval to the unit interval.
Curves: A collection of common animation curves.
CurveTween: An Animatable that applies a Curve to the input value.
CustomMsg<T>: Message wrapper for custom user-defined messages.
DataTable: A simple data table widget that renders tabular data with column headers, row separators, and optional theming.
DataTableModel<T>: A hybrid interactive data table model.
DataTableSelectionMadeMsg<T>: Message sent when a data table row is selected.
DataTableStyles: Styles for the interactive data table.
DebugConsole: A scrollable developer console pane.
DebugConsoleController: Mutable controller for a debug console pane.
DebugConsoleEntry: One line in a DebugConsoleController.
DebugConsoleHost: Wraps a subtree with a toggleable debug console overlay.
DebugConsoleScope: Exposes a DebugConsoleController to descendant widgets.
DebugOverlay: A debug overlay that displays rendering metrics.
DebugOverlayModel: Draggable render-metrics overlay for debugging TUI performance.
DecisionCard: A bordered card showing progressive-disclosure decision transparency.
DecisionData: Data for a DecisionCard.
DecisionDetails: Quantitative details for level-3 disclosure.
DecoratedBox: A widget that paints a Decoration either behind or in front of its child.
Decoration
DefaultItemDelegate: Default item delegate with simple rendering.
DefinitionList: A fluent builder for creating styled definition lists.
DefinitionListComponent: A definition list component (term: description pairs).
DestructiveConfirmModel: A destructive confirmation component that requires typing to confirm.
DialogAlert: A simple alert dialog with a title, message, and OK button.
DialogConfirm: A simple yes/no confirmation dialog.
DialogPrompt: A dialog with a text input field.
DialogSelect<T>: A generic searchable, grouped selection list dialog.
DialogSelectItem<T>: A single item in a DialogSelect list.
DialogStack: Manages a stack of modal dialogs.
DialogStackState: State for DialogStack, providing the push/pop/replace/clear API.
DialogThemeData: Theme data for dialog widgets (DialogConfirm, DialogAlert, DialogPrompt, DialogSelect).
DiffFile: A file entry in a parsed diff.
DiffLine: A single parsed line from a unified diff.
DiffStyles: Configuration for diff styling.
DisableBracketedPasteMsg: Internal message to disable bracketed paste.
DisableMouseMsg: Internal message to disable mouse tracking.
DisableReportFocusMsg: Internal message to disable focus reporting.
DisplayComponent: Base type for display-only UI building blocks.
Divider
DoubleTapGestureRecognizer: Recognizes double-tap gestures.
DoubleTween: An explicit double tween (mostly for documentation clarity).
DragEndDetails: Details for the end of a drag gesture.
DragGestureRecognizer: Recognizes drag gestures.
DragStartDetails: Details for the start of a drag gesture.
DragUpdateDetails: Details for a drag update event.
Drawer
DropdownButton<T>: Flutter-style dropdown button wrapper.
DropdownMenuItem<T>: Flutter-style dropdown menu item.
EdgeInsets
EditHistoryController<Action, State, Marker>
EditorState
EditorThemeData: Theme data for editable text surfaces such as TextArea, TextEditor, CodeEditor, and MarkdownEditor.
ElasticInCurve: An elastic curve that overshoots and then oscillates at the start.
ElasticInOutCurve: An elastic curve that overshoots and oscillates at both ends.
ElasticOutCurve: An elastic curve that overshoots and then oscillates at the end.
ElevatedButton: Flutter-style elevated button wrapper.
EmbeddedTerminalBackend: Generic embedded backend backed by callbacks and externally supplied streams.
EnableBracketedPasteMsg: Internal message to enable bracketed paste.
EnableMouseAllMotionMsg: Internal message to enable mouse all motion tracking.
EnableMouseCellMotionMsg: Internal message to enable mouse cell motion tracking.
EnableReportFocusMsg: Internal message to enable focus reporting.
EnterAltScreenMsg: Internal message to enter alt screen.
ErrorThrowingWidget: A widget that deliberately throws during build.
EveryCmd: A repeating command that fires at regular intervals.
EvidenceTerm: A single evidence term in a DecisionCard.
ExceptionComponent: An exception renderer component.
ExecProcessMsg: Message signaling that an external process should be executed.
ExecResult: Result of executing an external process.
ExitAltScreenMsg: Internal message to exit alt screen.
Expanded
ExpansionTile: Flutter-style expansion tile built on top of ListTile.
FadeModalBarrier: A modal barrier that fades in/out with an animated opacity.
FadeTint: A widget that fades a tint in or out over its child.
FileEntry: A file entry with cached stat information.
FileImage: An ImageProvider that loads an image from a file path.
FilePicker
FilePickerErrorMsg: Error message when reading a directory fails.
FilePickerKeyMap: Key mappings for the file picker component.
FilePickerModel: A file picker model for navigating and selecting files.
FilePickerReadDirMsg: Message sent when directory contents are read.
FilePickerStyles: Styles for the file picker component.
FilledButton: Flutter-style filled button wrapper.
FilterChip: Flutter-style multi-select chip.
FilteredItem: Filtered item with match information.
FilteredSearchItem<T>: A filtered item with its original index and match positions.
FilterMatchesMsg: Filter matches message.
Flex
Flexible
FlippedCurve: A curve that is the reverse of another curve.
Focusable: A widget that responds to keyboard input when focused.
FocusController: Controls which focusable widget is currently focused.
FocusMsg: Message sent when focus is gained or lost.
FocusScope: Provides a FocusController to descendants.
ForegroundColorMsg: Message containing the terminal's foreground color.
Frame
FrameTickModel: Optional interface for models that want to control frame ticks.
FrameTickMsg: Message sent automatically by the TUI runtime every frame.
FullScreenTuiRenderer: Full-screen renderer using the alternate screen buffer.
FutureBuilder<T>
GestureArenaManager: Manages gesture arenas for conflict resolution.
GestureDetector
GestureRecognizer: Abstract base class for all gesture recognizers.
GitDiffController: Controller for GitDiffViewer.
GitDiffKeyMap: Key bindings for the git diff viewer.
GitDiffModel: A git diff viewer bubble.
GitDiffThemeData: Theme data for GitDiffViewer widgets.
GitDiffViewer: A widget for viewing git diffs with syntax highlighting and scrolling.
Gradient
GroupedDefinitionList: A fluent builder for creating grouped definition lists.
GroupStep: Group of wizard steps.
GutterContext: GutterContext provides context to a GutterFunc.
HBox
Help: Help information for a key binding.
HelpModel: A help view widget for displaying key bindings.
HelpStyles: Styles for the help view.
HelpView: A widget-side help view for rendering KeyMap bindings.
HideCursorMsg: Internal message to hide cursor.
HighlightInfo: Describes a text highlight region within the viewport.
HistoryEntry: A single entry in the undo/redo history.
HistoryPanel: A panel that displays undo/redo command history with a position marker.
HitTestEntry: A single entry in a HitTestResult, linking a render object to the local coordinates at which it was hit.
HitTestMouseMsg: Message dispatched to an element when render-tree hit-testing determines that a MouseMsg landed within its render object's bounds.
HitTestResult: Accumulated result of a hit test, ordered deepest-first.
HorizontalTableComponent: A horizontal table component (row-as-headers style).
HyperlinkText: A text widget that renders as a clickable hyperlink using OSC 8 escape sequences in terminals that support them.
Icon
IconButton: Flutter-style icon button wrapper.
IconData
Icons
IgnorePointer: A widget that is invisible to hit-testing.
Image: A widget that displays an image in the terminal.
ImageData: Data class holding a decoded image.
ImageProvider: Abstract base class for providing images to the Image widget.
ImplicitlyAnimatedWidget: Abstract base class for widgets that implicitly animate when their properties change.
InheritedWidget: A widget that exposes data to descendants.
InlineTuiRenderer: Inline renderer that renders below the current cursor position.
InputChip: Flutter-style input chip.
InterruptMsg: Message sent when the runtime receives a terminal interrupt.
Interval: An interval that starts and/or ends at a fractional point along the curve.
IntTween: A tween that interpolates between two integers.
ItemDelegate: Item delegate for rendering list items.
JsonTerminalBackend: Message-oriented backend that speaks the terminal bridge JSON protocol.
Key: Represents a parsed keyboard input event.
KeyBinding: A key binding that maps keys to actions with optional help text.
KeyboardEnhancements: KeyboardEnhancements describes the requested keyboard enhancement features.
KeyboardEnhancementsMsg: Message sent when keyboard enhancements are reported.
KeyboardListener: A widget that calls a callback when a key is pressed.
KeyHint: A small widget that displays a keyboard shortcut key and its label.
KeyMap: A collection of key bindings forming a key map.
KeyMsg: Message sent when a key is pressed.
KeyParser: Parses raw terminal input bytes into Key objects and Msg objects.
Keys: Key constants and utilities for keyboard input handling.
KeyValue: A key-value pair component with dot fill.
Label
LayoutBuilder: A widget that provides its parent's constraints to a builder callback.
LimitedBox: A box that limits its size only when it's unconstrained.
LinearProgressIndicator: Flutter-style linear progress indicator.
LineInfo
LinkComponent: A clickable hyperlink component (OSC 8).
LinkGroupComponent: A group of related links component.
Listenable: An object that maintains a list of listeners.
ListenableBuilder: A widget that rebuilds when a Listenable changes.
ListEnumerator: Defines how list items are explicitly enumerated.
ListItem: Item interface for list items.
ListKeyMap: Key map for list navigation.
ListModel: List model for interactive lists.
ListStyles: Styles for list rendering.
ListTile
ListView
ListViewController: Controller for scroll position in VirtualListView.
LoggingNavigatorObserver: A NavigatorObserver that logs navigation events to the console.
LongPressEndDetails: Details for the end of a long-press gesture.
LongPressGestureRecognizer: Recognizes long-press gestures.
LongPressStartDetails: Details for the start of a long-press gesture.
Markdown: A component that renders markdown to ANSI-styled terminal output.
MarkdownEditor: A higher-level Markdown editor with a live rendered preview.
MarkdownOptions: Configuration options for the Markdown component.
MarkdownText: A widget that renders Markdown content as styled ANSI text.
MediaQuery
MediaQueryData
MemoryImage: An ImageProvider that loads an image from raw bytes.
MetricDisplay: A single-value metric display widget.
Modal
ModalRoute<T>: A modal overlay route with an optional barrier.
Model TUI: Abstract interface for TUI application models.
ModeReportMsg: Message sent when the terminal replies to a mode status query.
ModifyOtherKeysMsg: Message sent when the terminal reports a ModifyOtherKeys mode.
MouseMsg: Message sent for mouse events.
MouseRegion
Msg TUI: Base class for all messages in the TUI runtime.
MultiProgressModel: A model for managing multiple progress bars simultaneously.
MultiSearchKeyMap: Key bindings for the multi-search component.
MultiSearchModel<T>: A multi-select search/filter component.
MultiSearchSelectionMadeMsg<T>: Message sent when multiple search results are selected.
MultiSelectionMadeMsg<T>: Message sent when multiple items are selected.
MultiSelectKeyMap: Key bindings for the multi-select component.
MultiSelectModel<T>: A multi-select component following the Model architecture.
MultiSelectStep: Multi-select wizard step.
MultiSelectStyles: Styles for the multi-select component.
Navigator: A widget that manages a stack of Route objects.
NavigatorObserver: An interface for observing the behavior of a Navigator.
NavigatorState: State for Navigator, providing route stack management.
NetworkImage: An ImageProvider that loads an image from an HTTP(S) URL.
NullTuiRenderer: A renderer that does nothing (for testing).
NumberCancelledMsg: Emitted when the user cancels the prompt.
NumberedList: A numbered list component.
NumberInputKeyMap: Key bindings for NumberInputModel.
NumberInputModel: Interactive numeric input component.
NumberInputStyles: Visual styles for NumberInputModel.
NumberSubmittedMsg: Emitted when the user submits a valid number.
Offset: An offset in terminal cell units (column, row).
Opacity
OpenCodeThemes: All 33 OpenCode themes, ported from the official JSON definitions.
OutlinedButton: Flutter-style outlined button wrapper.
OverflowBox: A widget that imposes different constraints on its child than it gets from its parent, possibly allowing the child to overflow the parent.
Overlay: A widget that manages a stack of OverlayEntry objects.
OverlayEntry: An entry in an Overlay.
OverlayState: State for Overlay, providing methods to insert and remove entries.
Padding
PageRoute<T>: A full-screen page route.
Pagination
PaginatorKeyMap: Key bindings for paginator navigation.
PaginatorModel: A paginator widget for handling pagination state and rendering.
Panel: A fluent builder for creating styled panels.
PaneLayout: A complete computed layout for all leaf panes and split handles.
PanelBox
PanelBoxChars: Box drawing characters for panels and borders.
PanelBoxCharSet: A set of box drawing characters.
PanelComponent: A boxed panel component with optional title.
PaneLeaf
PaneRect: Rectangle coordinates for leaf pane geometry.
PaneSnapTarget: A target split handle used for snap behavior.
PaneSplit
PaneTreeNode
ParallelCmd: A command that executes multiple commands in parallel through the Program's command execution system.
PasswordCancelledMsg: Message sent when password input is cancelled.
PasswordConfirmModel: A password confirmation component that asks for password twice.
PasswordKeyMap: Key bindings for the password component.
PasswordModel: A password input component following the Model architecture.
PasswordStep: Password input wizard step.
PasswordStyles: Styles for the password component.
PasswordSubmittedMsg: Message sent when password input is submitted.
PasteErrorMsg: Message for paste errors.
PasteMsg: Message sent when bracketed paste content is received.
PauseModel: A simple "press any key" pause model.
PerformanceOverlay: A simpler variant of DebugOverlay that only shows render timing.
Point: 3D point helper.
PopBehavior: Configuration for how a Navigator handles pop requests via keyboard.
PopupMenuButton<T>: Flutter-style popup menu button.
PopupMenuDivider<T>: A non-selectable divider entry for PopupMenuButton.
PopupMenuEntry<T>: Base class for entries used in PopupMenuButton.
PopupMenuItem<T>: A selectable menu entry for PopupMenuButton.
Positioned
PrimaryDeviceAttributesMsg: Message sent when the terminal replies with primary device attributes.
PrintLineMsg: Message for printing a line above the program output.
Program<M extends Model> TUI: The TUI program runtime.
ProgramHost: Reusable launch target for a Program.
ProgramHostBinding: Resolved runtime configuration produced by a ProgramHost.
ProgramInterceptor: Intercepts program messages and lifecycle events.
ProgramMacro: Recorded user-input macro that can be replayed later.
ProgramOptions: Options for configuring the TUI program.
ProgramReplay: Message replay source for ProgramOptions.replay.
ProgramReplayStep: One replay step for ProgramReplay.script.
ProgressBar: A progress indicator component.
ProgressBarAdvanceMsg
ProgressBarComponent TUI: A progress bar component.
ProgressBarIterateDoneMsg
ProgressBarIterateErrorMsg
ProgressBarModel: A UV-safe progress bar model that can be hosted inside a parent Model.
ProgressBarMsg
ProgressBarSetMsg
ProgressFrameMsg: Message indicating a progress bar animation frame should advance.
ProgressIndicator
ProgressModel: A progress bar widget with optional animation support.
Projectile: A simple projectile integrator mirroring harmonica/projectile.go.
PromptFooterBar: A footer bar for inline prompt panels and dialog bottoms.
ProxyAnimation: An Animation that proxies another animation.
QuitMsg: Internal message signaling that the program should quit.
Radio<T>
RadioListTile<T>: Flutter-style radio list tile.
RangeSlider: Flutter-style range slider for selecting a start/end interval.
RangeValues: Immutable pair of values used by RangeSlider.
Rank: Rank from filtering.
RawModeGuard: Guard object returned by Terminal.enableRawMode.
Rect: A rectangle defined by offset + size, in terminal cell units.
ReloadController: Controller for development-time subtree reloads.
ReloadHost: Rebuildable host for development-time reloads.
ReloadScope: Exposes a ReloadController to descendant widgets.
ReloadSignal: One reload signal emitted by ReloadController.
RenderAlign
RenderBudgetController: Tracks render budget pressure and adjusts degradation levels.
RenderBudgetMsg: Message sent when the runtime changes render-budget degradation state.
RenderBudgetOptions: Configuration for budget-aware render degradation.
RenderBudgetState: The current state of a RenderBudgetController.
RenderConfig TUI: Rendering configuration for display-only UI building blocks.
RenderConstrainedBox
RenderContainer
RenderIgnorePointer: A render object that never reports a hit, causing hit-testing to skip its subtree and continue to siblings in the parent's child list.
RenderListViewport: Render object backing VirtualListView.
RenderListViewScrollViewport: Render object for _ListViewViewport.
RenderMetrics: Tracks render performance metrics including FPS, frame times, and render durations.
RenderMetricsModel: Optional interface for models that want render metrics updates.
RenderMetricsMsg: Message sent periodically with renderer performance metrics.
RenderPadding
RenderScrollbar: Render object that draws a vertical scrollbar next to or over child content.
RenderSingleChildViewport: Render object for _SingleChildViewport.
RenderSizedBox
RenderStack
RenderViewport: Render object backing Viewport.
RenderWrap
RepaintMsg: Message sent to force a repaint of the view.
RepaintRequestMsg: Internal message to request a repaint.
ReplayAction: Replay action schema used by TUI scenario JSON files.
ReplayCoordinateInterceptor: Coordinate interceptor that scales replay mouse coordinates to current runtime window dimensions.
ReplayCustomEvent: Structured custom event embedded in replay actions.
ReplayEventDirective: Hook decision produced for ReplayCustomEvent actions.
ReplayEventMsg: Replay message emitted for custom event actions.
ReplayMouseMsg: Replay-only mouse message marker.
ReplayScenario: Replay scenario document.
ReplayScreen: Screen metadata captured for replay coordinate scaling.
ReplayTraceConversionOptions: Trace conversion options for ReplayTraceConverter.
ReplayTraceConversionResult: Conversion output returned by ReplayTraceConverter.convertFile.
ReplayTraceConverter: Converts TuiTrace logs into replay scenarios.
RequestWindowSizeMsg: Internal message to request window size.
ResumeMsg: Message sent when the program resumes from suspension.
ReverseTween<T>: A tween that evaluates another tween in reverse.
RichText: A widget that displays styled text using a TextSpan tree.
Route<T>: Abstract base class for routes managed by a Navigator.
RouteSettings: Immutable route metadata.
Row
RowComponent: A component that renders children horizontally with a separator.
Rule: A horizontal rule/separator component.
SanitizerOptions: Options for configuring the sanitizer behavior.
SawTooth: A sawtooth curve that repeats count times over the unit interval.
ScrollArea: A convenience widget that wraps SingleChildScrollView with optional sizing and an optional Scrollbar.
Scrollbar: A scrollbar that decorates a scrollable child.
ScrollbarChars
ScrollbarGradient: A vertical gradient for scrollbar tracks or thumbs.
ScrollController: Scroll controller interface for scrollable widgets.
ScrollView: A scrollable container for a single child widget.
SearchCancelledMsg: Message sent when search is cancelled.
SearchKeyMap: Key bindings for the search component.
SearchModel<T>: A search/filter component following the Model architecture.
SearchSelectionMadeMsg<T>: Message sent when a search result is selected.
SearchStyles: Styles for the search component.
SecondaryDeviceAttributesMsg: Message sent when the terminal replies with secondary device attributes.
Select<T>
SelectableTextAreaView: A read-only selectable view of a TextAreaController.
SelectableTextFieldView: A read-only selectable view of a TextEditingController.
SelectionCancelledMsg: Message sent when selection is cancelled.
SelectionMadeMsg<T>: Message sent when an item is selected.
SelectKeyMap: Key bindings for the select component.
SelectModel<T>: A single-select component following the Model architecture.
SelectOption<T>
SelectStep: Single-select wizard step.
SelectStyles: Styles for the select component.
SetWindowTitleMsg: Internal message to set window title.
ShowCursorMsg: Internal message to show cursor.
ShrinkWrap
Sidebar
SimpleExceptionComponent: A simple one-line exception component.
SimpleTuiRenderer: TuiRenderer that writes output without diffing or clearing (nil renderer mode).
SingleChildScrollView: A scrollable container for a single child widget.
Size: Size in terminal cell units.
SizedBox
SizedOverflowBox: A widget that is a specific size but passes its original constraints through to its child, which may then overflow.
Slider: Flutter-style slider for selecting a single value.
SocketTerminalBackend: Socket-backed backend for remote/shell-mode terminal hosts.
SocketTerminalHostServer: Reusable raw socket host server for remote TUI sessions.
Spacer
Spinner: A spinner animation definition.
SpinnerFrame: A spinner frame component (for use in animations).
SpinnerIndicator
SpinnerModel: A spinner widget for showing loading/activity states.
Spinners: Pre-defined spinner animations.
SpinnerTickMsg: Message indicating a spinner should advance to the next frame.
SplitHandle: Geometry for a split handle used by resize/snap calculations.
SplitTerminal: A terminal that splits "control/input" from "display/output".
SplitView
Spring: A stable damped spring integrator (Ryan Juckett formulation) matching charmbracelet/harmonica.
Stack
StackParentData
State<T extends StatefulWidget>: Mutable state for a StatefulWidget.
StatefulWidget: A widget with mutable state managed by a State object.
StatelessWidget: A widget with a build method and no mutable state.
StaticComponent: A ViewComponent that only has a view and no state/updates.
StaticWidget: A simple widget that wraps a static string or View.
StatusBar: A horizontal bar that displays a row of KeyHint items.
StatusBarThemeData: Theme data for StatusBar widgets.
StatusItem: A typed item that can be displayed in a StatusLine.
StatusLine: A horizontal status bar with left, center, and right regions.
StatusMessageTimeoutMsg: Status message timeout message.
StdioTerminal: Standard terminal implementation using dart:io.
StdioTerminalBackend: Native stdio backend for BackendTerminal.
StepIndicator: A step-by-step progress indicator widget.
StepItem: A single step in a StepIndicator.
StepTween: A tween that floors the interpolated value to an integer.
StopwatchModel: A stopwatch model that counts up from zero.
StopwatchResetMsg: Message sent to reset the stopwatch.
StopwatchStartStopMsg: Message sent to start or stop the stopwatch.
StopwatchTickMsg: Message sent when the stopwatch ticks.
StreamBuilder<T>
StreamCmd<T>: A command that manages a stream subscription.
StringItem: Simple string item implementation.
StringSinkTuiRenderer: A renderer that writes to a StringSink (for testing).
StringTerminal: A terminal that captures output to a string buffer (for testing).
StyledAsciiText: A convenience wrapper that applies a Style to AsciiText.
StyledBlock: A fluent builder for creating styled blocks (Symfony-style).
StyledBlockComponent: A styled block component (Symfony-style).
StyledText: A styled text component using the context's style.
SuggestCancelledMsg: Emitted when the user cancels the suggest prompt.
SuggestKeyMap: Key bindings for SuggestModel.
SuggestModel: Interactive text-input with a scrollable prefix-matched suggestion dropdown.
SuggestStyles: Visual styles for SuggestModel.
SuggestSubmittedMsg: Emitted when the user accepts a value (typed or from the dropdown).
SuspendMsg: Message signaling the program should suspend (like Ctrl+Z).
Switch
SwitchListTile: Flutter-style switch list tile.
SyntaxHighlighter
TabItem
Table: A fluent builder for creating styled tables.
TableComponent: A table component with headers and rows.
TableKeyMap: Key map for table navigation.
TableModel: Table model for interactive tables.
TableStyles: Styles for table rendering.
TableTheme: A composable table theme with blend-aware effects and presets.
TableThemeEffect: A composable style rule for table cells.
Tabs
TapDownDetails: Details for a tap-down event.
TapGestureRecognizer: Recognizes single-tap gestures.
TapUpDetails: Details for a tap-up event.
TaskComponent: A task status component (Laravel-style).
TerminalBackend: Low-level I/O backend for a terminal host.
TerminalBridge: Bridge controller for embedded terminal hosts such as xterm.js, sockets, or custom UI surfaces.
TerminalBridgeJsonChannel: JSON message channel layered over a TerminalBridge.
TerminalBridgeMessage: JSON-serializable bridge message for remote/browser terminal hosts.
TerminalProgressBar: TerminalProgressBar represents the terminal taskbar progress (OSC 9;4).
TerminalState: Terminal state snapshot for saving/restoring.
TerminalThemeState: Tracks terminal theme information (background + dark/light heuristic).
TerminalVersionMsg: Message sent when the terminal version is reported.
TertiaryDeviceAttributesMsg: Message sent when the terminal replies with tertiary device attributes.
Text
TextArea: A multi-line text editor widget powered by the bubbles textarea model.
TextAreaController: Controls the state of a TextArea.
TextAreaCursorStyle
TextAreaKeyMap
TextAreaModel
TextAreaPasteErrorMsg
TextAreaPasteMsg
TextAreaStyles
TextAreaStyleState
TextButton: Flutter-style text button wrapper.
TextCommandResult
TextCursorCommandResult
TextDecorationLayerBinding: Keeps one named range-decoration layer in sync with a text controller.
TextDecorationRange
TextDiagnosticRange
TextDiagnosticsBinding: Keeps a TextAreaController's diagnostics in sync with its current text.
TextDocument
TextDocumentChange
TextDocumentEditResult
TextEditingController: Controls the state of a TextField.
TextEditingValue: The current state of a text field.
TextEditor: A higher-level editor surface built on top of TextArea.
TextEditResult
TextExtmark
TextExtmarkOptions
TextExtmarkPositionRange
TextExtmarksController
TextField: A text input widget supporting single-line and multi-line editing.
TextHighlightRange
TextHitResult
TextInputCursorStyle: Style for the cursor.
TextInputKeyMap: Key map for text input navigation and editing.
TextInputModel: Text input model for single-line or multi-line text entry.
TextInputStep: Text input wizard step.
TextInputStyles: Styles for the text input.
TextInputStyleState: Style state for focused and blurred states.
TextLineCommandResult
TextLineDecoration
TextLineDecorationLayerBinding: Keeps one named whole-line decoration layer in sync with a text controller.
TextLineStateSnapshot
TextModel: A high-level text component that supports selection, scrolling, and wrapping. It is built on top of ViewportModel but defaults to auto-height and soft-wrap.
TextOffsetStateSnapshot
TextPasteChunk
TextPasteChunkStep
TextPasteController
TextPastePlan
TextPasteReference
TextPasteReferenceStore
TextPasteSession
TextPatternDiagnosticRule
TextPosition
TextPositionDiagnosticRange
TextPositionDiagnosticsSource: Produces positional diagnostics from a listenable text source.
TextSelection: Range of text that is selected.
TextSpan
TextSyntaxBuildResult<State>
TextSyntaxChangeWindow
TextSyntaxDecorationPatch
TextSyntaxLineWindow
TextSyntaxProvider<State>
TextSyntaxSession<State>
TextSyntaxSnapshot<State>
TextView
TextViewLine
TextViewport
TextVisualCursorPosition
Theme: Theme containing semantic colors, text styles, and component themes.
ThemeScope: Provides a theme to descendant widgets via the build context.
Threshold: A curve that jumps from 0.0 to 1.0 when t passes threshold.
TickMsg: Message sent when a timer tick occurs.
TilingPaneManager: Immutable tiling pane manager with split tree and focused pane id.
TimerModel: A countdown timer model.
TimerStartStopMsg: Message sent to start or stop the timer.
TimerTickMsg: Message sent when the timer ticks.
TimerTimeoutMsg: Internal message sent when timer times out.
Tint: A widget that applies a color tint over its child.
TitledBlockComponent: A simple titled block used by the artisanal-style I/O facade.
Toast
Tooltip: A hover-triggered message bubble for a child widget.
TraceEventRecord: A structured event decoded from one trace log line.
TraceEventType: Structured trace event names emitted by TuiTrace.event.
TraceSpan: A timing span for hierarchical tracing.
Transform: A widget that applies spatial transformations to its child.
Tree: A fluent builder for creating styled trees (lipgloss v2 parity).
TreeChildren
TreeComponent: A tree structure component.
TreeEnumerator: Defines the characters used to draw tree branches.
TreeFilter
TreeNode
TreeNodeChildren
TreeStringData
TreeView: A hierarchical tree view widget.
TreeViewNode: A node in a TreeView widget.
TtyTerminal: POSIX /dev/tty terminal implementation.
TUIErrorWidget: A widget that displays an error message with red styling.
TuiEvidence: Optional evidence logger for structured runtime diagnostics.
TuiEvidenceRecord: A decoded evidence event line.
TuiRenderer TUI: Abstract renderer interface for TUI output.
TuiRendererOptions: Options for configuring a TuiRenderer.
TuiTrace: Lightweight debug tracer for TUI frame rendering and message dispatch.
Tween<T extends dynamic>: A linear interpolation between a begin and end value.
TweenSequence<T>: An Animatable that chains multiple tweens end-to-end with proportional durations.
TweenSequenceItem<T>: A single entry in a TweenSequence.
TwoColumnDetail: A fluent builder for creating two-column detail rows.
TwoColumnDetailComponent: A two-column detail component with dot fill.
TwoColumnDetailList: A fluent builder for creating multiple two-column detail rows.
UltravioletTuiRenderer: Ultraviolet-inspired renderer backed by a cell buffer + diffing updates.
UndoableCommand<State>: A command that knows how to apply and undo its own effect on a mutable state.
UndoCommandJournalEntry: Journal envelope for one command or transaction.
UndoManager<State>: Undo/redo command journal with optional transactional grouping.
UvEventMsg: Raw Ultraviolet event message (only emitted when UV input decoding is enabled).
ValueListenable<T>: A Listenable that exposes a current value.
ValueListenableBuilder<T>: A widget that rebuilds when a ValueListenable changes its value.
ValueNotifier<T>: A ChangeNotifier that holds a single value and notifies when it changes.
VBox
Vector: 3D vector helper.
VerticalDivider: A vertical line divider.
View TUI: View represents a terminal view that can contain metadata for terminal control.
ViewComponent: A lightweight, composable TUI component.
ViewDegradation: Opt-in degraded content stages for a View.
Viewport: A string-backed scrollable viewport powered by ViewportModel.
ViewportController: Controller for Viewport.
ViewportKeyMap: Key bindings for viewport navigation.
ViewportModel: A viewport widget for scrollable content.
ViewportScrollPane
ViewState: Stores the view state when navigating into directories.
VirtualListView: A render-object driven list view that only paints visible items.
Visibility
WatchedBrowserArtisanalAppHost: Browser host wrapper that owns the reload controller and optional watcher.
WatchedSocketArtisanalAppHost: Socket host wrapper that owns the reload controller and optional watcher.
WebSocketTerminalBackend: WebSocket-backed backend that speaks the terminal bridge JSON protocol.
Widget: Base class for composable TUI widgets.
WidgetApp: Runs a widget tree using an element hierarchy.
WidgetDegradationSignal: Signal controlling widget visibility under degradation.
WidgetScrollController: A simple ScrollController for use with SingleChildScrollView, ScrollView, and ListView.
WindowPixelSizeMsg: Message sent when the terminal window reports its pixel dimensions.
WindowSizeMsg: Message sent when the terminal window is resized.
Wizard
WizardCancelledMsg: Message sent when the wizard is cancelled.
WizardCompletedMsg: Message sent when the entire wizard is completed.
WizardFormStep
WizardModel: Wizard model for multi-step forms.
WizardStep: Base class for wizard steps.
WizardStepCompletedMsg: Message sent when a wizard step is completed.
Wrap
Zone
ZoneInBoundsMsg: Message sent when a zone is within bounds of a mouse event.
ZoneInfo: Holds information about the start and end positions of a zone.
ZoneManager: Zone manager for tracking clickable regions in TUI output.

Enums

AccentSide: The side on which the accent stripe is drawn.
AlertDisplayStyle: Alert display style.
AlertType: Alert types.
AlertVariant
AnimationStatus: The status of an animation.
AsyncConnectionState
Axis
BlockStyleType: Block style types.
BorderStyle: Border styles for boxes.
BoxAlign: Alignment for box content.
BoxFit: How an image should be inscribed into a box.
ButtonSize
ButtonVariant
ClipboardSelection: Clipboard selection targets for OSC 52 operations.
ClipboardSetMethod: Clipboard write transport used by ClipboardSetMsg.
ConfirmDisplayMode: Display mode for the confirm component.
CrossAxisAlignment
CursorMode: Cursor display mode.
DataTableBorderStyle: Border style for DataTable.
DebugOverlayPosition: Position options for the debug overlay.
DecisionSignal: Signal level for a DecisionCard.
DecorationPosition: Where to paint a decoration relative to the child.
DegradationLevel: Ordered render degradation levels used by the runtime.
DiffLineType: The type of a parsed diff line.
DiffViewMode: The display mode for the diff viewer.
DisclosureLevel: Progressive-disclosure level for a DecisionCard.
EchoMode: Echo mode for text input display.
EvidenceDirection: Direction of an evidence term.
FilterState: Filter state for the list.
FlexFit
GestureDisposition: The final disposition of a recognizer in the arena.
GestureRecognizerState: The lifecycle state of a gesture recognizer.
HistoryPanelMode: Display mode for HistoryPanel.
HitTestBehavior: Controls how a widget behaves during hit testing.
ImageAutoMode: Controls how ImageRenderMode.auto chooses a rendering backend.
ImageRenderMode: Preferred rendering backend for the Image widget.
KeyType: Types of keyboard input events.
ListTileControlAffinity: Position of the control in list-tile-style rows.
MainAxisAlignment
MainAxisSize
MetricTrend: Trend direction for a MetricDisplay.
ModeReportValue: The reported state of a terminal mode query.
MouseAction: Mouse event action types.
MouseButton: Mouse button identifiers.
MouseMode: Mouse tracking modes for the terminal.
Overflow
PaginationType: Pagination rendering type.
PanelAlignment: Alignment for panel content.
PaneNavigationDirection: Navigation direction used for focus traversal.
PaneSnapAlignment: Snap alignment for drag gestures near a split handle.
PaneSplitDirection: Direction for pane geometry splits.
PasswordEchoMode: Echo mode for password display.
ProgressLabelPosition: Where to display the percentage label relative to the bar.
ProgressStyle: Predefined fill/track character sets for ProgressIndicator.
ReloadMode: The kind of reload requested through ReloadController.
ReplayEventControl: Replay control decision for a custom replay event.
ScreenMode: Controls how the TUI renders relative to the terminal's primary screen.
SidebarSide
StackFit
StepStatus: Status of a single step in a StepIndicator.
StyledBlockDisplayStyle: Display style for styled blocks.
TableAlign: Column alignment options for tables.
TableBlendMode: Blend mode used by themed table effects.
TableThemeGradientAxis: The axis for sampling gradient colors in a table theme.
TableThemeSection: The table section an effect should apply to.
TaskStatus: Task status values.
TerminalBridgeMessageType: Message kinds used by TerminalBridgeMessage.
TerminalProgressBarState: TerminalProgressBarState represents the state of the terminal taskbar progress.
TextAlign
TextDiagnosticSeverity
TextOverflow
TextPasteMode
ThemeMode: Controls how ArtisanalApp resolves its shell theme.
TooltipPosition
TraceTag: Trace categories for filtering and grouping trace output.
UiAnchor: Which edge of the terminal the inline UI region is anchored to.
WidgetDegradationPriority: Priority values used by the render-budget engine when deciding which widgets to retain during a degraded frame.
WrapAlignment
WrapCrossAlignment

Mixins

AnimationMixin<T extends StatefulWidget>: Mixin for State classes that host one or more AnimationControllers.
ComponentHost: A mixin for Models that host one or more ViewComponents.
CopyWithModel: Mixin that documents the copyWith pattern for models.
FocusableWidget: Mixin for widgets that need to track focus state.
TerminalThemeHost: Mixin for models/components that want terminal theme state with minimal boilerplate.

Extensions

AlertFactory on Alert: Factory methods for common alert styles.
BoxPresets on BoxBuilder: Factory methods for common box styles.
CmdExtension on Cmd?: Extension methods for nullable Cmd.
DefinitionListFactory on DefinitionList: Factory methods for common definition list styles.
KeyMatchExtension on Key: Extension to check key matches more fluently.
KeyMsgMatchExtension on KeyMsg: Extension to check KeyMsg matches.
PanelPresets on Panel: Factory methods for common panel styles.
StyledBlockFactory on StyledBlock: Factory methods for common styled block styles.
TableFactory on Table: Factory methods for common table styles.
TextLineStateCommandExtensions on TextLineStateSnapshot
TextOffsetStateCommandExtensions on TextOffsetStateSnapshot
TextOffsetStateDocumentEditingExtensions on TextOffsetStateSnapshot
ThemeContext on BuildContext: Convenience accessors for theme lookup on BuildContext.
TreeFactory on Tree: Factory methods for common tree styles.
TuiTerminalRendererExtension on TuiTerminal: Extension to create renderers from terminals.
TwoColumnDetailFactory on TwoColumnDetail: Factory methods for common two-column detail styles.

Constants

dataTablePromptOptions → const ProgramOptions: Dedicated defaults for interactive data-table prompts.
defaultCodeAutoPairs → const Map<String, String>
defaultCodeClosingToOpening → const Map<String, String>
defaultEmptyCharBlock → const String: Default character used to fill the empty portion of the progress bar.
defaultFullCharFullBlock → const String: Default character used to fill the progress bar (full block).
defaultFullCharHalfBlock → const String: Default character used to fill the progress bar. It is a half block, which allows more granular color blending control.
defaultWidgetProgramOptions → const ProgramOptions: Widget-friendly runtime defaults for runWidgetApp and runArtisanalApp.
gravity → const Vector: Gravity helpers (match harmonica names).
promptProgramOptions → const ProgramOptions: Shared defaults for "artisanal-style" prompts that run a single bubble and return a value.
terminalGravity → const Vector
textActiveLineDecorationKey → const String
textActiveLineDecorationLayerKey → const String
textActiveLineDecorationLayerPriority → const int
textActiveLineNumberDecorationKey → const String
textareaPromptOptions → const ProgramOptions
textDefaultDecorationLayerKey → const String
textDefaultDecorationLayerPriority → const int
textDefaultExtmarkType → const String
textDefaultLineDecorationLayerKey → const String
textDefaultLineDecorationLayerPriority → const int
textDiagnosticErrorDecorationKey → const String
textDiagnosticErrorLineDecorationKey → const String
textDiagnosticErrorLineNumberDecorationKey → const String
textDiagnosticHintDecorationKey → const String
textDiagnosticHintLineDecorationKey → const String
textDiagnosticHintLineNumberDecorationKey → const String
textDiagnosticInfoDecorationKey → const String
textDiagnosticInfoLineDecorationKey → const String
textDiagnosticInfoLineNumberDecorationKey → const String
textDiagnosticsDecorationLayerKey → const String
textDiagnosticsDecorationLayerPriority → const int
textDiagnosticsLineDecorationLayerKey → const String
textDiagnosticsLineDecorationLayerPriority → const int
textDiagnosticWarningDecorationKey → const String
textDiagnosticWarningLineDecorationKey → const String
textDiagnosticWarningLineNumberDecorationKey → const String
textSearchActiveMatchDecorationKey → const String
textSearchDecorationLayerKey → const String
textSearchDecorationLayerPriority → const int
textSearchMatchDecorationKey → const String
textSyntaxDecorationLayerKey → const String
textSyntaxDecorationLayerPriority → const int
undefined → const Object: Sentinel value to distinguish "not provided" from "explicitly set to null" in ViewportModel.copyWith. This allows callers to set nullable fields to null (e.g., copyWith(selectionStart: null)) rather than keeping the existing value (the default when the parameter is omitted).

Properties

currentTheme → Theme: Returns the current global theme.
no setter
globalZone → ZoneManager?: Returns the global zone manager if initialized.
no setter
hasDarkBackground → bool: Whether the terminal has a dark background.
no setter
hasGlobalZone → bool: Whether the global zone manager has been initialized.
no setter
isSharedStdinStreamStarted → bool: Returns true if the shared stdin stream has started listening to stdin.
no setter
sharedStdinStream → Stream<List<int>>: Shared broadcast stream for stdin to allow multiple listeners and restarts.
no setter
zone → ZoneManager: Gets the global zone manager.
no setter

Functions

closeGlobalZone() → void: Closes the global zone manager.
codeBlockNewlineSuffix({required String beforeCursor, required String afterCursor, required String baseIndent}) → ({int consumedColumns, String text})?
codeHandleAutoPair({required TextDocument document, required TextOffsetStateSnapshot state, required CodeLanguageProfile profile, required String typed}) → TextCommandResult
codeHandleClosingDelimiterAlignment({required TextDocument document, required TextOffsetStateSnapshot state, required CodeLanguageProfile profile, required String typed, required int indentWidth}) → TextCommandResult
codeHandlePairBackspace({required TextDocument document, required TextOffsetStateSnapshot state, required CodeLanguageProfile profile}) → TextCommandResult
codeInsertIndentedNewline({required TextDocument document, required TextOffsetStateSnapshot state, required int indentWidth, String? language}) → TextCommandResult
codeLeadingIndent(String line) → String
codeOutdentedIndent(String indent, int width) → String
codeShouldAutoPairSymmetricDelimiter(String text, int offset, {bool hasSelection = false}) → bool
codeShouldAutoPairSymmetricDelimiterInDocument(TextDocument document, int offset, {bool hasSelection = false}) → bool
codeShouldIncreaseIndentAfter(String prefix, {String? language}) → bool
codeToggleBlockComments({required TextDocument document, required TextOffsetStateSnapshot state, required CodeLanguageProfile profile}) → TextCommandResult
compressAnsi(String input) → String: Removes redundant SGR sequences to reduce output size.
computeTextDocumentChange(String previousText, String nextText) → TextDocumentChange
computeTextDocumentChangeForDocuments({required TextDocument previousDocument, required TextDocument nextDocument}) → TextDocumentChange
createSanitizer([SanitizerOptions? options]) → RuneSanitizer: Creates a rune sanitizer with the given options.
defaultFilter(String term, List<String> targets) → List<Rank>: Default fuzzy filter implementation.
defaultSearchFilter<T>(String query, List<T> items, String toString(T)) → List<FilteredSearchItem<T>>: Default fuzzy filter implementation.
defaultTextAreaStyles() → TextAreaStyles
defaultTextInputStyles({bool isDark = true}) → TextInputStyles: Returns the default styles for the text input.
deleteAfterCursor(List<String> graphemes, int cursorOffset) → TextEditResult
deleteBeforeCursor(List<String> graphemes, int cursorOffset) → TextEditResult
deleteNext(List<String> graphemes, {required int cursorOffset, int? selectionBaseOffset, int? selectionExtentOffset}) → TextCommandResult
deleteNextDocumentGrapheme(TextDocument document, int cursorOffset) → TextDocumentEditResult
deleteNextGrapheme(List<String> graphemes, int cursorOffset) → TextEditResult
deleteNextOrSelection(List<String> graphemes, {required int cursorOffset, int? selectionBaseOffset, int? selectionExtentOffset}) → TextCommandResult
deletePrevious(List<String> graphemes, {required int cursorOffset, int? selectionBaseOffset, int? selectionExtentOffset}) → TextCommandResult
deletePreviousDocumentGrapheme(TextDocument document, int cursorOffset) → TextDocumentEditResult
deletePreviousGrapheme(List<String> graphemes, int cursorOffset) → TextEditResult
deletePreviousOrSelection(List<String> graphemes, {required int cursorOffset, int? selectionBaseOffset, int? selectionExtentOffset}) → TextCommandResult
deleteSelection(List<String> graphemes, {int? selectionBaseOffset, int? selectionExtentOffset, required int cursorOffset}) → TextCommandResult
deleteSurroundingPair(List<String> graphemes, {required int cursorOffset, int? selectionBaseOffset, int? selectionExtentOffset, required Map<String, String> surroundPairs}) → TextCommandResult
deleteToLineEnd(List<String> graphemes, {required int cursorOffset, int? selectionBaseOffset, int? selectionExtentOffset, required int lineEndOffset}) → TextCommandResult
deleteToLineStart(List<String> graphemes, {required int cursorOffset, int? selectionBaseOffset, int? selectionExtentOffset, required int lineStartOffset}) → TextCommandResult
deleteWordBackward(List<String> graphemes, {required int cursorOffset, int? selectionBaseOffset, int? selectionExtentOffset, required GraphemePredicate isWord}) → TextCommandResult
deleteWordBackwardRange(List<String> graphemes, int offset, {required GraphemePredicate isWord}) → ({int end, int start})
deleteWordBackwardRangeFromReader(int length, int offset, {required GraphemePredicate isWord, required GraphemeReader graphemeAt}) → ({int end, int start})
deleteWordForward(List<String> graphemes, {required int cursorOffset, int? selectionBaseOffset, int? selectionExtentOffset, required GraphemePredicate isWord}) → TextCommandResult
deleteWordForwardRange(List<String> graphemes, int offset, {required GraphemePredicate isWord}) → ({int end, int start})
deleteWordForwardRangeFromReader(int length, int offset, {required GraphemePredicate isWord, required GraphemeReader graphemeAt}) → ({int end, int start})
duplicateSelectedLinesAbove(List<String> lines, {required TextPosition cursor, TextPosition? selectionBase, TextPosition? selectionExtent}) → TextLineCommandResult
duplicateSelectedLinesBelow(List<String> lines, {required TextPosition cursor, TextPosition? selectionBase, TextPosition? selectionExtent}) → TextLineCommandResult
every(Duration interval, Msg? callback(DateTime time), {Object? id}) → Cmd: Helper to create a repeating timer command.
findTextQueryHighlights({required TextDocument document, required String query, bool caseSensitive = false}) → List<TextHighlightRange>
firstGraphemeCluster(String s) → ({String first, String rest}): Gets the first grapheme cluster from a string.
fpsDelta(int n) → double: Returns the time delta for a given frames-per-second value.
highlightCodeString(String code, {String? language, ChromaTheme? theme}) → String: Highlights code and returns ANSI-styled output.
initGlobalZone() → ZoneManager: Initializes the global zone manager.
insertAtCursor(List<String> graphemes, int cursorOffset, List<String> inserted) → TextEditResult
insertAutoPair(List<String> graphemes, {required int cursorOffset, int? selectionBaseOffset, int? selectionExtentOffset, required List<String> opening, required List<String> closing}) → TextCommandResult
insertIndentedNewline(List<String> graphemes, {required int cursorOffset, int? selectionBaseOffset, int? selectionExtentOffset, required List<String> baseIndent, List<String> additionalIndent = const <String>[], List<String> trailingSuffix = const <String>[], int trailingSuffixReplaceCount = 0}) → TextCommandResult
insertIntoDocument(TextDocument document, int cursorOffset, List<String> inserted) → TextDocumentEditResult
insertTextIntoDocument(TextDocument document, int cursorOffset, String inserted) → TextDocumentEditResult
keyMatches(Key key, List<KeyBinding> bindings) → bool: Checks if a key message matches any of the given bindings.
keyMatchesSingle(Key key, KeyBinding binding) → bool: Checks if a key matches a single binding.
keyToIdOrFallback(Key? key, Object fallback) → String: Returns a stable string ID for a possibly-null key.
lineSnapshotFromEditorState(EditorState editorState, {required int lineCount, required int lineLength(int line), bool preserveCollapsedSelection = false}) → TextLineStateSnapshot
lineSnapshotFromOffsets(TextDocument document, {required int cursorOffset, int? selectionBaseOffset, int? selectionExtentOffset}) → TextLineStateSnapshot
markdownToAnsi(String markdown, {AnsiRendererOptions? options}) → String: Converts a markdown string to ANSI-styled terminal text.
mathMax(int a, int b) → int
mergeTextSyntaxDecorationPatch(List<TextDecorationRange> previousDecorations, TextSyntaxDecorationPatch patch) → List<TextDecorationRange>
moveCursorByCharacter(List<String> graphemes, {required int cursorOffset, int? selectionBaseOffset, int? selectionExtentOffset, required bool forward, bool extendSelection = false, bool clearSelection = true, bool preserveCollapsedSelection = false}) → TextCursorCommandResult
moveCursorByVisualLine(TextDocument document, EditorState state, TextView view, {required int cursorOffset, int? selectionBaseOffset, int? selectionExtentOffset, required int lineDelta, int desiredDisplayColumn = -1, bool extendSelection = false, bool clearSelection = true, bool preserveCollapsedSelection = false}) → TextCursorCommandResult
moveCursorByWord(List<String> graphemes, {required int cursorOffset, int? selectionBaseOffset, int? selectionExtentOffset, required bool forward, required GraphemePredicate isWord, bool extendSelection = false, bool clearSelection = true, bool preserveCollapsedSelection = false}) → TextCursorCommandResult
moveCursorToDocumentBoundary(List<String> graphemes, {required int cursorOffset, int? selectionBaseOffset, int? selectionExtentOffset, required bool forward, bool extendSelection = false, bool clearSelection = true, bool preserveCollapsedSelection = false}) → TextCursorCommandResult
moveCursorToOffset({required int textLength, required int cursorOffset, int? selectionBaseOffset, int? selectionExtentOffset, required int targetOffset, bool extendSelection = false, bool clearSelection = true, bool preserveCollapsedSelection = false}) → TextCursorCommandResult
moveCursorToVisualLineBoundary(TextDocument document, EditorState state, TextView view, {required int cursorOffset, int? selectionBaseOffset, int? selectionExtentOffset, required bool end, bool extendSelection = false, bool clearSelection = true, bool preserveCollapsedSelection = false}) → TextCursorCommandResult
moveSelectedLines(List<String> lines, {required TextPosition cursor, TextPosition? selectionBase, TextPosition? selectionExtent, required int direction}) → TextLineCommandResult
moveWordBackward(List<String> graphemes, int offset, {required GraphemePredicate isWord}) → int
moveWordBackwardFromReader(int length, int offset, {required GraphemePredicate isWord, required GraphemeReader graphemeAt}) → int
moveWordForward(List<String> graphemes, int offset, {required GraphemePredicate isWord}) → int
moveWordForwardFromReader(int length, int offset, {required GraphemePredicate isWord, required GraphemeReader graphemeAt}) → int
newSpringFromFps(int fps, double frequency, double damping) → Spring: Convenience to create a spring using FPS like the Go API.
nextTextPasteChunk({required int totalRunes, required int offset, required int chunkSize}) → TextPasteChunk?
nextWordRange(List<String> graphemes, int offset, {required GraphemePredicate isWord}) → ({int end, int start})?
nextWordRangeFromReader(int length, int offset, {required GraphemePredicate isWord, required GraphemeReader graphemeAt}) → ({int end, int start})?
noCmd(Model model) → UpdateResult: Helper function to create an update result with no command.
normalizedSelectionRange(int? baseOffset, int? extentOffset) → ({int end, int start})?
normalizeTextDiagnostics(Iterable<TextDiagnosticRange> diagnostics, {int? maxLength}) → List<TextDiagnosticRange>
offsetSnapshotFromEditorState(TextDocument document, EditorState editorState, {required int textLength, bool preserveCollapsedSelection = false}) → TextOffsetStateSnapshot
planTextPaste(String content, {required bool collapseLargePaste, required int collapsedPasteMinChars, required int collapsedPasteMinLines, required int chunkThresholdRunes}) → TextPastePlan
previousWordRange(List<String> graphemes, int offset, {required GraphemePredicate isWord}) → ({int end, int start})?
previousWordRangeFromReader(int length, int offset, {required GraphemePredicate isWord, required GraphemeReader graphemeAt}) → ({int end, int start})?
progressIterateCmd<T>({required int id, required Iterable<T> items, required Future<void> onItem(T item)}) → StreamCmd<Msg>: Produces a UV-safe StreamCmd that runs onItem for each element and emits progress updates for a hosted ProgressBarModel.
quit(Model model) → UpdateResult: Helper function to create an update result that quits.
removeDocumentRange(TextDocument document, {required int start, required int end, int? cursorOffset}) → TextDocumentEditResult
removeRange(List<String> graphemes, {required int start, required int end, int? cursorOffset}) → TextEditResult
renumberNumberedList(List<String> lines, {required TextPosition cursor, TextPosition? selectionBase, TextPosition? selectionExtent, int startAt = 1}) → TextLineCommandResult
replaceDocumentRange(TextDocument document, {required int start, required int end, List<String> replacement = const <String>[], int? cursorOffset}) → TextDocumentEditResult
replaceDocumentTextRange(TextDocument document, {required int start, required int end, String replacement = '', int? cursorOffset}) → TextDocumentEditResult
replaceRange(List<String> graphemes, {required int start, required int end, List<String> replacement = const <String>[], int? cursorOffset}) → TextEditResult
replaceSelectionOrInsert(List<String> graphemes, {required int cursorOffset, int? selectionBaseOffset, int? selectionExtentOffset, List<String> replacement = const <String>[], bool replaceSelection = true}) → TextCommandResult
replayScenarioStream(List<ReplayAction> actions, {required bool loop, required bool keepOpen, required double speed, ReplayEventHook? eventHook}) → Stream<Msg>: Builds a replay message stream from a list of replay actions.
resolveCodeLanguageProfile(String? language) → CodeLanguageProfile
runAnticipatePrompt(AnticipateModel model, Terminal terminal, {ProgramOptions? options}) → Future<String?>: Runs an AnticipateModel and resolves to the accepted value, or null if cancelled.
runArtisanalApp(ArtisanalApp app, {ProgramOptions? options, ProgramHost? host, ImageAutoMode? imageAutoMode}) → Future<void>: Runs an ArtisanalApp with widget-oriented runtime defaults.
runConfirmPrompt(ConfirmModel model, Terminal terminal, {ProgramOptions? options}) → Future<bool?>: Runs a ConfirmModel and resolves to the selected value, or null if cancelled.
runDataTablePrompt<T>(DataTableModel<T> model, Terminal terminal, {ProgramOptions? options}) → Future<T?>: Runs a DataTableModel and resolves to the selected item, or null if cancelled.
runeWidth(int rune) → int: Calculates the display width of a single rune.
runMultiSearchPrompt<T>(MultiSearchModel<T> model, Terminal terminal, {ProgramOptions? options}) → Future<List<T>?>: Runs a MultiSearchModel and resolves to the selected items, or null if cancelled.
runMultiSelectPrompt<T>(MultiSelectModel<T> model, Terminal terminal, {ProgramOptions? options}) → Future<List<T>?>: Runs a MultiSelectModel and resolves to the selected items, or null if cancelled.
runNumberInputPrompt(NumberInputModel model, Terminal terminal, {ProgramOptions? options}) → Future<num?>: Runs a NumberInputModel and resolves to the submitted number, or null if the user cancels.
runPasswordConfirmPrompt(PasswordConfirmModel model, Terminal terminal, {ProgramOptions? options}) → Future<String?>: Runs a PasswordConfirmModel and resolves to the submitted password, or null if cancelled.
runPasswordPrompt(PasswordModel model, Terminal terminal, {ProgramOptions? options}) → Future<String?>: Runs a PasswordModel and resolves to the submitted password, or null if cancelled.
runProgram<M extends Model>(M model, {ProgramOptions options = const ProgramOptions(), ProgramHost? host, TuiTerminal? terminal}) → Future<void>: Runs a TUI program with the given model.
runProgramDebug<M extends Model>(M model, {ProgramOptions? options, ProgramHost? host, TuiTerminal? terminal}) → Future<void>: Runs a TUI program without panic catching (for debugging).
runProgramWithResult<M extends Model>(M model, {ProgramOptions options = const ProgramOptions(), ProgramHost? host, TuiTerminal? terminal}) → Future<M>: Runs a TUI program and returns the final model after exit.
runReloadableArtisanalApp({required ReloadWidgetBuilder homeBuilder, required ReloadController controller, String? title, Theme? theme, Theme? darkTheme, ThemeMode themeMode = ThemeMode.system, Theme themeBuilder()?, ProgramOptions? options, ProgramHost? host, ImageAutoMode? imageAutoMode}) → Future<void>: Runs an ArtisanalApp with a reloadable home widget.
runReloadableWidgetApp(ReloadWidgetBuilder builder, {required ReloadController controller, ProgramOptions? options, ProgramHost? host, ImageAutoMode? imageAutoMode}) → Future<void>: Runs a reloadable WidgetApp backed by ReloadHost.
runSearchPrompt<T>(SearchModel<T> model, Terminal terminal, {ProgramOptions? options}) → Future<T?>: Runs a SearchModel and resolves to the selected item, or null if cancelled.
runSelectPrompt<T>(SelectModel<T> model, Terminal terminal, {ProgramOptions? options}) → Future<T?>: Runs a SelectModel and resolves to the selected item, or null if cancelled.
runSpinnerTask<T>({required String message, required Future<T> task(), Spinner spinner = Spinners.miniDot, required Terminal terminal, ProgramOptions? options}) → Future<T>: Runs an animated spinner while executing task, returning its result.
runSuggestPrompt(SuggestModel model, Terminal terminal, {ProgramOptions? options}) → Future<String?>: Runs a SuggestModel and resolves to the accepted value, or null if the user cancels.
runTextAreaPrompt(TextAreaModel model, Terminal terminal, {ProgramOptions? options}) → Future<String?>: Runs a TextAreaModel and resolves to the submitted value, or null if cancelled.
runTextInputPrompt(TextInputModel model, Terminal terminal, {ProgramOptions? options}) → Future<String?>: Runs a TextInputModel and resolves to the submitted value, or null if cancelled.
runWatchedArtisanalApp({required ReloadWidgetBuilder homeBuilder, required Iterable<String> watchRoots, String? title, Theme? theme, Theme? darkTheme, ThemeMode themeMode = ThemeMode.system, Theme themeBuilder()?, ReloadController? controller, ReloadMode watchMode = ReloadMode.reload, Duration watchDebounce = const Duration(milliseconds: 150), bool watchRecursive = true, bool watchIgnoreHidden = true, Iterable<String> watchExtensions = const <String>['.dart'], ProgramOptions? options, ProgramHost? host, ImageAutoMode? imageAutoMode}) → Future<void>: Runs an ArtisanalApp with a watched, reloadable home widget.
runWatchedWidgetApp(ReloadWidgetBuilder builder, {required Iterable<String> watchRoots, ReloadController? controller, ReloadMode watchMode = ReloadMode.reload, Duration watchDebounce = const Duration(milliseconds: 150), bool watchRecursive = true, bool watchIgnoreHidden = true, Iterable<String> watchExtensions = const <String>['.dart'], ProgramOptions? options, ProgramHost? host, ImageAutoMode? imageAutoMode}) → Future<void>: Runs a reloadable WidgetApp and watches filesystem roots for changes.
runWidgetApp(WidgetApp app, {ProgramOptions? options, ProgramHost? host, ImageAutoMode? imageAutoMode}) → Future<void>: Runs a WidgetApp with widget-oriented runtime defaults.
runWizardPrompt(WizardModel model, Terminal terminal, {ProgramOptions? options}) → Future<Map<String, dynamic>?>: Runs a WizardModel and resolves to the final answers, or null if cancelled.
serveArtisanalAppInBrowser({required ArtisanalApp appBuilder(), InternetAddress? address, int port = 8080, String pagePath = '/', String webSocketPath = '/ws', String browserTitle = 'Artisanal Widget Host', String? pageHtml, ImageAutoMode imageAutoMode = ImageAutoMode.sessionCapabilities, ProgramOptions? options}) → Future<BrowserTerminalHostServer>: Serves an ArtisanalApp in the browser through the shared websocket host.
serveArtisanalAppOnSocket({required ArtisanalApp appBuilder(), InternetAddress? address, int port = 2323, bool v6Only = false, bool shared = false, TerminalDimensions initialSize = (width: 80, height: 24), bool supportsAnsi = true, ColorProfile colorProfile = ColorProfile.trueColor, ImageAutoMode imageAutoMode = ImageAutoMode.sessionCapabilities, ProgramOptions? options}) → Future<SocketTerminalHostServer>: Serves an ArtisanalApp on the reusable raw TCP socket host.
serveReloadableArtisanalAppInBrowser({required ReloadWidgetBuilder homeBuilder, required ReloadController controller, InternetAddress? address, int port = 8080, String pagePath = '/', String webSocketPath = '/ws', String browserTitle = 'Artisanal Widget Host', String? pageHtml, String? title, Theme? theme, Theme? darkTheme, ThemeMode themeMode = ThemeMode.system, Theme themeBuilder()?, ImageAutoMode imageAutoMode = ImageAutoMode.sessionCapabilities, ProgramOptions? options}) → Future<BrowserTerminalHostServer>: Serves a reloadable ArtisanalApp in the browser.
serveReloadableArtisanalAppOnSocket({required ReloadWidgetBuilder homeBuilder, required ReloadController controller, InternetAddress? address, int port = 2323, bool v6Only = false, bool shared = false, TerminalDimensions initialSize = (width: 80, height: 24), bool supportsAnsi = true, ColorProfile colorProfile = ColorProfile.trueColor, String? title, Theme? theme, Theme? darkTheme, ThemeMode themeMode = ThemeMode.system, Theme themeBuilder()?, ImageAutoMode imageAutoMode = ImageAutoMode.sessionCapabilities, ProgramOptions? options}) → Future<SocketTerminalHostServer>: Serves a reloadable ArtisanalApp on the raw socket host.
serveWatchedArtisanalAppInBrowser({required ReloadWidgetBuilder homeBuilder, required Iterable<String> watchRoots, ReloadController? controller, ReloadMode watchMode = ReloadMode.reload, Duration watchDebounce = const Duration(milliseconds: 150), bool watchRecursive = true, bool watchIgnoreHidden = true, Iterable<String> watchExtensions = const <String>['.dart'], InternetAddress? address, int port = 8080, String pagePath = '/', String webSocketPath = '/ws', String browserTitle = 'Artisanal Widget Host', String? pageHtml, String? title, Theme? theme, Theme? darkTheme, ThemeMode themeMode = ThemeMode.system, Theme themeBuilder()?, ImageAutoMode imageAutoMode = ImageAutoMode.sessionCapabilities, ProgramOptions? options}) → Future<WatchedBrowserArtisanalAppHost>: Serves a watched, reloadable ArtisanalApp in the browser.
serveWatchedArtisanalAppOnSocket({required ReloadWidgetBuilder homeBuilder, required Iterable<String> watchRoots, ReloadController? controller, ReloadMode watchMode = ReloadMode.reload, Duration watchDebounce = const Duration(milliseconds: 150), bool watchRecursive = true, bool watchIgnoreHidden = true, Iterable<String> watchExtensions = const <String>['.dart'], InternetAddress? address, int port = 2323, bool v6Only = false, bool shared = false, TerminalDimensions initialSize = (width: 80, height: 24), bool supportsAnsi = true, ColorProfile colorProfile = ColorProfile.trueColor, String? title, Theme? theme, Theme? darkTheme, ThemeMode themeMode = ThemeMode.system, Theme themeBuilder()?, ImageAutoMode imageAutoMode = ImageAutoMode.sessionCapabilities, ProgramOptions? options}) → Future<WatchedSocketArtisanalAppHost>: Serves a watched, reloadable ArtisanalApp on the raw socket host.
serveWidgetAppInBrowser({required WidgetApp appBuilder(), InternetAddress? address, int port = 8080, String pagePath = '/', String webSocketPath = '/ws', String browserTitle = 'Artisanal Widget Host', String? pageHtml, ImageAutoMode imageAutoMode = ImageAutoMode.sessionCapabilities, ProgramOptions? options}) → Future<BrowserTerminalHostServer>: Serves a WidgetApp in the browser through the shared websocket host.
serveWidgetAppOnSocket({required WidgetApp appBuilder(), InternetAddress? address, int port = 2323, bool v6Only = false, bool shared = false, TerminalDimensions initialSize = (width: 80, height: 24), bool supportsAnsi = true, ColorProfile colorProfile = ColorProfile.trueColor, ImageAutoMode imageAutoMode = ImageAutoMode.sessionCapabilities, ProgramOptions? options}) → Future<SocketTerminalHostServer>: Serves a WidgetApp on the reusable raw TCP socket host.
setHasDarkBackground(bool value) → void: Updates the dark background state.
setTheme(Theme theme) → void: Sets the global theme.
shortHash(Object? object) → String: Short 5-hex hash for diagnostics.
shutdownSharedStdinStream() → Future<void>: Shuts down the shared stdin stream so the process can exit cleanly.
skipClosingDelimiter(List<String> graphemes, {required int cursorOffset, int? selectionBaseOffset, int? selectionExtentOffset, required List<String> closing, bool clearSelection = false}) → TextCursorCommandResult
stringWidth(String s) → int: Calculates the display width of a string, accounting for wide characters.
syncEditorStateFromLineSnapshot(EditorState editorState, TextLineStateSnapshot snapshot, {required int lineCount, required int lineLength(int line)}) → void
syncEditorStateFromOffsets(TextDocument document, EditorState editorState, {required int cursorOffset, int? selectionBaseOffset, int? selectionExtentOffset}) → void
textAreaStylesFromTheme(Theme theme) → TextAreaStyles
textCapitalizeWords(String text) → String
textCleanupWhitespace({required List<String> lines, required TextLineStateSnapshot state, bool trimTrailingBlankLines = true}) → TextLineCommandResult
textCleanupWhitespaceDocument({required TextDocument document, required TextLineStateSnapshot state, bool trimTrailingBlankLines = true}) → TextCommandResult
textCollapsedPasteToken({required int lineCount}) → String
textCountLines(String text) → int
textDeleteLines({required List<String> lines, required TextLineStateSnapshot state}) → TextLineCommandResult
textDeleteLinesDocument({required TextDocument document, required TextLineStateSnapshot state}) → TextCommandResult
textDeleteNext({required TextDocument document, required TextOffsetStateSnapshot state}) → TextCommandResult
textDeletePrevious({required TextDocument document, required TextOffsetStateSnapshot state}) → TextCommandResult
textDeleteSelection({required TextDocument document, required TextOffsetStateSnapshot state}) → TextCommandResult
textDeleteToLineEnd({required TextDocument document, required TextOffsetStateSnapshot state}) → TextCommandResult
textDeleteToLineStart({required TextDocument document, required TextOffsetStateSnapshot state}) → TextCommandResult
textDeleteWordBackward({required TextDocument document, required TextOffsetStateSnapshot state, GraphemePredicate isWord = _isWordGrapheme}) → TextCommandResult
textDeleteWordForward({required TextDocument document, required TextOffsetStateSnapshot state, GraphemePredicate isWord = _isWordGrapheme}) → TextCommandResult
textDiagnosticAtOffset({required List<TextDiagnosticRange> diagnostics, required int offset}) → TextDiagnosticRange?
textDiagnosticContainingIndex({required List<TextDiagnosticRange> diagnostics, required int offset}) → int?
textDiagnosticDecorations(Iterable<TextDiagnosticRange> diagnostics) → List<TextDecorationRange>
textDiagnosticLineDecorations({required String text, required Iterable<TextDiagnosticRange> diagnostics}) → List<TextLineDecoration>
textDiagnosticLineDecorationsForDocument({required TextDocument document, required Iterable<TextDiagnosticRange> diagnostics}) → List<TextLineDecoration>
textDiagnosticLineMarker(TextDiagnosticSeverity severity) → String
textDiagnosticLineNumberStyleKey(TextDiagnosticSeverity severity) → String
textDiagnosticLineStyleKey(TextDiagnosticSeverity severity) → String
textDiagnosticLocationLabel({required String text, required TextDiagnosticRange diagnostic}) → String
textDiagnosticLocationLabelForDocument({required TextDocument document, required TextDiagnosticRange diagnostic}) → String
textDiagnosticNavigationIndex({required List<TextDiagnosticRange> diagnostics, required int cursorOffset, int? activeIndex, bool forward = true, bool wrap = true}) → int?
textDiagnosticSeverityLabel(TextDiagnosticSeverity severity) → String
textDiagnosticsFromPositions({required TextDocument document, required Iterable<TextPositionDiagnosticRange> diagnostics}) → List<TextDiagnosticRange>
textDiagnosticStartPosition({required String text, required TextDiagnosticRange diagnostic}) → TextPosition
textDiagnosticStartPositionForDocument({required TextDocument document, required TextDiagnosticRange diagnostic}) → TextPosition
textDiagnosticStyleKey(TextDiagnosticSeverity severity) → String
textDiagnosticSummaryLabel({required String text, required TextDiagnosticRange diagnostic}) → String
textDiagnosticSummaryLabelForDocument({required TextDocument document, required TextDiagnosticRange diagnostic}) → String
textDuplicateSelectedLinesAbove({required List<String> lines, required TextLineStateSnapshot state}) → TextLineCommandResult
textDuplicateSelectedLinesAboveDocument({required TextDocument document, required TextLineStateSnapshot state}) → TextCommandResult
textDuplicateSelectedLinesBelow({required List<String> lines, required TextLineStateSnapshot state}) → TextLineCommandResult
textDuplicateSelectedLinesBelowDocument({required TextDocument document, required TextLineStateSnapshot state}) → TextCommandResult
textExtmarkPositionRange(TextDocument document, TextExtmark extmark) → TextExtmarkPositionRange
textIndentLines({required List<String> lines, required TextLineStateSnapshot state, int width = 2}) → TextLineCommandResult
textIndentLinesDocument({required TextDocument document, required TextLineStateSnapshot state, int width = 2}) → TextCommandResult
textInsertGraphemes({required TextDocument document, required TextOffsetStateSnapshot state, required List<String> graphemes, bool replaceSelection = true}) → TextCommandResult
textInsertText({required TextDocument document, required TextOffsetStateSnapshot state, required String text, bool replaceSelection = true}) → TextCommandResult
textJoinLines({required List<String> lines, required TextLineStateSnapshot state}) → TextLineCommandResult
textJoinLinesDocument({required TextDocument document, required TextLineStateSnapshot state}) → TextCommandResult
textMoveByCharacter({required TextDocument document, required TextOffsetStateSnapshot state, required bool forward, bool extendSelection = false, bool clearSelection = false}) → TextCursorCommandResult
textMoveByWord({required TextDocument document, required TextOffsetStateSnapshot state, required bool forward, GraphemePredicate isWord = _isWordGrapheme, bool extendSelection = false, bool clearSelection = false}) → TextCursorCommandResult
textMoveSelectedLines({required List<String> lines, required TextLineStateSnapshot state, required int direction}) → TextLineCommandResult
textMoveSelectedLinesDocument({required TextDocument document, required TextLineStateSnapshot state, required int direction}) → TextCommandResult
textMoveToDocumentBoundary({required TextDocument document, required TextOffsetStateSnapshot state, required bool forward, bool extendSelection = false, bool clearSelection = false}) → TextCursorCommandResult
textOutdentLines({required List<String> lines, required TextLineStateSnapshot state, int width = 2}) → TextLineCommandResult
textOutdentLinesDocument({required TextDocument document, required TextLineStateSnapshot state, int width = 2}) → TextCommandResult
textPatternDiagnostics({required String text, required Iterable<TextPatternDiagnosticRule> rules}) → List<TextPositionDiagnosticRange>
textPatternDiagnosticsForDocument({required TextDocument document, required Iterable<TextPatternDiagnosticRule> rules}) → List<TextPositionDiagnosticRange>
textPrepareInsertedGraphemes(List<int> runes, {required bool multiline, int? maxGraphemes}) → List<String>
textRenumberNumberedList({required List<String> lines, required TextLineStateSnapshot state, int startAt = 1}) → TextLineCommandResult
textRenumberNumberedListDocument({required TextDocument document, required TextLineStateSnapshot state, int startAt = 1}) → TextCommandResult
textSanitizeRunes(List<int> runes, {required bool multiline}) → List<int>
textSanitizeRunesLimited(List<int> runes, {required bool multiline, required int maxOutputCodepoints}) → List<int>
textSearchDecorations(Iterable<TextHighlightRange> matches, {int activeIndex = -1}) → List<TextDecorationRange>
textSortSelectedLines({required List<String> lines, required TextLineStateSnapshot state, bool descending = false, bool caseSensitive = false}) → TextLineCommandResult
textSortSelectedLinesDocument({required TextDocument document, required TextLineStateSnapshot state, bool descending = false, bool caseSensitive = false}) → TextCommandResult
textSplitLine({required TextDocument document, required TextOffsetStateSnapshot state}) → TextCommandResult
textSyntaxChangeWindow({required TextDocument previousDocument, required TextDocument nextDocument, required TextDocumentChange change, int lookBehindLines = 0, int lookAheadLines = 0}) → TextSyntaxChangeWindow
textToggleChecklistState({required List<String> lines, required TextLineStateSnapshot state, String checkedMarker = 'x'}) → TextLineCommandResult
textToggleChecklistStateDocument({required TextDocument document, required TextLineStateSnapshot state, String checkedMarker = 'x'}) → TextCommandResult
textToggleHeadingPrefix({required List<String> lines, required TextLineStateSnapshot state, int level = 1}) → TextLineCommandResult
textToggleHeadingPrefixDocument({required TextDocument document, required TextLineStateSnapshot state, int level = 1}) → TextCommandResult
textToggleLinePrefix({required List<String> lines, required TextLineStateSnapshot state, required String prefix, bool addSpaceWhenNonEmpty = true, bool skipBlankLinesWhenChecking = true}) → TextLineCommandResult
textToggleLinePrefixDocument({required TextDocument document, required TextLineStateSnapshot state, required String prefix, bool addSpaceWhenNonEmpty = true, bool skipBlankLinesWhenChecking = true}) → TextCommandResult
textToggleNumberedList({required List<String> lines, required TextLineStateSnapshot state, int startAt = 1}) → TextLineCommandResult
textToggleNumberedListDocument({required TextDocument document, required TextLineStateSnapshot state, int startAt = 1}) → TextCommandResult
textTransformSelectionOrLine({required TextDocument document, required TextOffsetStateSnapshot state, required String transform(String text)}) → TextCommandResult
textTransformWordOrAdjacent({required TextDocument document, required TextOffsetStateSnapshot state, required String transform(String text)}) → TextCommandResult
textTransposeBackward({required TextDocument document, required TextOffsetStateSnapshot state}) → TextCommandResult
textUnwrapSelection({required TextDocument document, required TextOffsetStateSnapshot state, required Map<String, String> surroundPairs}) → TextCommandResult
textWrapSelection({required TextDocument document, required TextOffsetStateSnapshot state, required String before, String? after}) → TextCommandResult
toggleChecklistState(List<String> lines, {required TextPosition cursor, TextPosition? selectionBase, TextPosition? selectionExtent, String checkedMarker = 'x'}) → TextLineCommandResult
toggleDelimitedSegment(List<String> graphemes, {required int cursorOffset, int? selectionBaseOffset, int? selectionExtentOffset, required int rangeStartOffset, required int rangeEndOffset, required String startDelimiter, required String endDelimiter}) → TextCommandResult
toggleHeadingPrefix(List<String> lines, {required TextPosition cursor, TextPosition? selectionBase, TextPosition? selectionExtent, int level = 1}) → TextLineCommandResult
toggleLinePrefix(List<String> lines, {required TextPosition cursor, TextPosition? selectionBase, TextPosition? selectionExtent, required String prefix, bool addSpaceWhenNonEmpty = true, bool skipBlankLinesWhenChecking = true}) → TextLineCommandResult
toggleNumberedList(List<String> lines, {required TextPosition cursor, TextPosition? selectionBase, TextPosition? selectionExtent, int startAt = 1}) → TextLineCommandResult
transformSelectionOrLine(List<String> graphemes, {required int cursorOffset, required int lineStartOffset, required int lineEndOffset, int? selectionBaseOffset, int? selectionExtentOffset, required String transform(String text)}) → TextCommandResult
transformWordOrAdjacent(List<String> graphemes, {required int cursorOffset, required GraphemePredicate isWord, required String transform(String text)}) → TextCommandResult
truncate(String s, int width, [String tail = '']) → String: Truncates a string to fit within the given width.
unwrapSelection(List<String> graphemes, {required int cursorOffset, int? selectionBaseOffset, int? selectionExtentOffset, required Map<String, String> surroundPairs}) → TextCommandResult
updateThemeFromBackground(String? hex) → void: Updates theme based on background hex color (e.g., '#1a1a1a').
withImageAutoCapabilities<T>(TerminalCapabilities capabilities, T callback()) → T
withImageAutoConfiguration<T>({required ImageAutoMode mode, TerminalCapabilities? capabilities, required T callback()}) → T
withImageAutoMode<T>(ImageAutoMode mode, T callback()) → T
wordRangeForTransform(List<String> graphemes, int offset, {required GraphemePredicate isWord}) → ({int end, int start})?
wordRangeForTransformFromReader(int length, int offset, {required GraphemePredicate isWord, required GraphemeReader graphemeAt}) → ({int end, int start})?
wrapSelection(List<String> graphemes, {required int cursorOffset, int? selectionBaseOffset, int? selectionExtentOffset, required List<String> before, List<String>? after}) → TextCommandResult

Typedefs

AlertStyleFunc = Style? Function(String line, int lineIndex): Callback for alert message styling.
AnimationStatusListener = void Function(AnimationStatus status): Signature for callbacks that receive AnimationStatus changes.
AsyncWidgetBuilder<T> = Widget Function(BuildContext context, AsyncSnapshot<T> snapshot)
BoxContentStyleFunc = Style? Function(String line, int lineIndex): Callback for box content styling.
BrowserTerminalSessionHandler = Future<void> Function(WebSocket socket): Session handler invoked for each accepted browser websocket connection.
CmdCallback = Cmd? Function()
CmdFunc = Cmd Function(): Type alias for a function that creates commands.
CmdFunc1<T> = Cmd Function(T value): Type alias for a function that creates commands from a value.
ColorFunc = Color Function(double total, double current): Function that can be used to dynamically fill the progress bar. total is the total filled percentage, and current is the current percentage that is actively being filled with a color.
DefinitionStyleFunc = Style? Function(String term, String description, int index, bool isTerm): Callback for styling definition list items.
EditHistoryCoalescePredicate<Action, State, Marker> = bool Function(Action action, {required State currentState, required Action? lastAction, required Marker? lastMarker})
EditHistoryMarkerBuilder<Action, State, Marker> = Marker Function(Action action, State state)
EditHistoryStateEquals<State> = bool Function(State a, State b)
FilterFunc = List<Rank> Function(String term, List<String> targets): Filter function type.
FocusChangedCallback = void Function(bool focused)
FocusKeyCallback = Cmd? Function(KeyMsg msg)
FocusListener = void Function()
GestureDoubleTapCallback = Cmd? Function(): Callback for double-tap events.
GestureDragEndCallback = Cmd? Function(DragEndDetails details): Callback for the end of a drag gesture.
GestureDragStartCallback = Cmd? Function(DragStartDetails details): Callback for the start of a drag gesture.
GestureDragUpdateCallback = Cmd? Function(DragUpdateDetails details): Callback for drag update events.
GestureLongPressCallback = Cmd? Function(): Callback for long-press events.
GestureLongPressEndCallback = Cmd? Function(LongPressEndDetails details): Callback for the end of a long-press gesture.
GestureLongPressStartCallback = Cmd? Function(LongPressStartDetails details): Callback for the start of a long-press gesture.
GestureTapCallback = Cmd? Function(): Callback for simple tap events (press + release within slop).
GestureTapCancelCallback = Cmd? Function(): Callback for tap cancellation (pointer moved beyond slop).
GestureTapDownCallback = Cmd? Function(TapDownDetails details): Callback for tap-down events with position and modifier details.
GestureTapUpCallback = Cmd? Function(TapUpDetails details): Callback for tap-up events with position details.
GestureWheelCallback = Cmd? Function(MouseMsg msg): Callback for mouse wheel events (passes through raw MouseMsg).
GraphemePredicate = bool Function(String grapheme)
GraphemeReader = String? Function(int offset)
GutterFunc = String Function(GutterContext context): GutterFunc can be implemented and set into ViewportModel.leftGutterFunc.
IndexedSeparatorBuilder = Widget Function(BuildContext context, int index)
IndexedWidgetBuilder = Widget Function(BuildContext context, int index): A scrollable list of child widgets.
ListStyleFunc = Style? Function(int index, String item): Callback for per-item styling in lists.
MessageFilter = Msg? Function(Model model, Msg msg): A function that filters messages before they reach the model.
MouseEnterCallback = Cmd? Function(MouseMsg msg): Callback for mouse enter events.
MouseExitCallback = Cmd? Function(MouseMsg msg): Callback for mouse exit events.
PanelContentStyleFunc = Style? Function(String line, int lineIndex): Callback for panel content styling.
ProgramHostResolver = ProgramHostBinding Function(ProgramOptions options): Resolves a reusable launch target for a Program.
PromptFunc = String Function(PromptInfo info)
PromptInfo = ({int col, bool isFocused, int lineIndex, int row})
ReloadWidgetBuilder = Widget Function(BuildContext context, int revision): Builder used by ReloadHost.
ReplayEventHook = FutureOr<ReplayEventDirective?> Function(ReplayCustomEvent event): Hook invoked when replay reaches an event action.
RouteFactory = Route? Function(RouteSettings settings): A factory function that creates a route from settings.
RouteWidgetBuilder = Widget Function(BuildContext context): A builder that creates a widget for a route.
RuneSanitizer = List<int> Function(List<int> runes): Function type for sanitizing rune lists.
SearchFilterFunc<T> = List<FilteredSearchItem<T>> Function(String query, List<T> items, String toString(T)): Filter function type for search.
SocketTerminalSessionHandler = Future<void> Function(Socket socket): Session handler invoked for each accepted raw socket terminal connection.
StyledBlockStyleFunc = Style? Function(String line, int lineIndex): Callback for block content styling.
TableStyleFunc = Style? Function(int row, int col, String data): Callback for per-cell styling in tables.
TerminalDimensions = ({int height, int width}): Terminal dimensions expressed in cells.
TextChangedCallback = void Function(String value): Signature for text change notifications from TextField.
TextDecorationLayerBuilder = Iterable<TextDecorationRange> Function(String text): Builds range decorations from plain text.
TextDiagnosticsBuilder = Iterable<TextPositionDiagnosticRange> Function(String text): Builds positional diagnostics from plain text.
TextFieldController = TextEditingController: Alias for TextEditingController for backward compatibility.
TextLineDecorationLayerBuilder = Iterable<TextLineDecoration> Function(String text): Builds whole-line decorations from plain text.
TextPositionDiagnosticsBuilder = Iterable<TextPositionDiagnosticRange> Function(String text): Builds positional diagnostics from plain text.
TreeEnumeratorFunc = String Function(List<TreeNode> children, int index)
TreeEnumeratorStyleFunc = Style? Function(List children, int index): Callback for per-item enumerator (branch character) styling in trees.
TreeIndenterFunc = String Function(List<TreeNode> children, int index)
TreeNodeStyleFunc = Style Function(List<TreeNode> children, int index)
TreeStyleFunc = Style? Function(String item, int depth, bool isDirectory): Callback for per-item styling in trees.
TuiTerminal = Terminal: Alias for backward compatibility.
TweenConstructor = Tween Function(dynamic value): Callback type for constructing a new Tween from a target value.
TweenVisitor = Tween? Function(Tween? tween, dynamic targetValue, TweenConstructor constructor): Callback type for visiting tweens in AnimatedWidgetBaseState.forEachTween.
TwoColumnStyleFunc = Style? Function(String text, bool isLeft): Callback for styling the left or right column.
UndoCommandDecoder<State> = UndoableCommand<State> Function(String type, Map<String, Object?> payload)
UpdateResult = (Model, Cmd?): Type alias for the update function return type.
ValueCmdCallback<T> = Cmd? Function(T value)
VoidCallback = void Function()
WizardValidateFunc = String? Function(String value)

Exceptions / Errors

FlutterError: Simple error class for widget framework errors.
ProgramCancelledError: Error thrown when a program is cancelled via an external signal.