Struct StreamWidget 

pub struct StreamWidget { /* private fields */ }

A streaming text widget optimized for LLM token output.

This widget maintains its own content buffer and provides two rendering paths:

• Fast path: Direct cursor-based append for simple cases
• Slow path: Full dirty-rect re-render for complex cases

Implementations

impl StreamWidget

pub fn new(bounds: Rect) -> Self

Create a new stream widget with the given bounds.

pub fn with_config(bounds: Rect, config: StreamConfig) -> Self

Create a new stream widget with custom configuration.

pub const fn bounds(&self) -> Rect

Get the widget bounds.

pub fn set_bounds(&mut self, bounds: Rect)

Set new bounds for the widget.

If the width changes, content will be rewrapped to fit the new width.

pub const fn set_fg(&mut self, fg: Rgb)

Set the foreground color for subsequent text.

pub const fn set_bg(&mut self, bg: Rgb)

Set the background color for subsequent text.

pub const fn reset_colors(&mut self)

Reset colors to defaults.

pub fn append(&mut self, text: &str) -> AppendResult

Append text to the widget.

This automatically chooses between fast and slow path based on the text content and current state.

pub fn render(&mut self, buffer: &mut Buffer)

Render the widget to a buffer.

This renders the visible content to the given buffer.

pub fn write_fast_path( &self, result: AppendResult, text: &str, output: &mut Vec<u8>, )

Write fast-path output directly to an output buffer.

This generates ANSI sequences for direct terminal output, bypassing the buffer diffing.

pub fn append_fast_into(&mut self, text: &str, output: &mut Vec<u8>) -> bool

Append text and perform fast-path generation if possible.

If the text was successfully appended via fast path (no wrap, no scroll), the ANSI sequence is written to output and true is returned. Otherwise returns false (caller should rely on standard cycle).

pub fn push(&mut self, engine: &Engine, text: &str)

Push text to the stream with automatic optimization.

This is the recommended API for appending content. It handles all rendering decisions internally:

• Fast Path: If the text fits on the current line without wrapping or scrolling, ANSI codes are emitted directly to the terminal for zero-latency display.
• Slow Path: If wrapping or scrolling is required, the internal buffer is updated and the widget is marked dirty for the next frame.

Example

// Just push. The engine handles the rest.
stream.push(&engine, "Hello ");
stream.push(&engine, "world!");

pub const fn needs_redraw(&self) -> bool

Check if a full redraw is needed.

pub fn dirty_rects(&self) -> &[Rect]

Get the dirty rectangles.

pub const fn invalidate(&mut self)

Mark the widget for full redraw.

pub fn clear(&mut self)

Clear all content.

pub fn scroll_up(&mut self, lines: usize)

Scroll up by the given number of lines.

pub const fn scroll_down(&mut self, lines: usize)

Scroll down by the given number of lines.

pub const fn cursor_position(&self) -> (u16, u16)

Get the current cursor position within the widget.

pub fn line_count(&self) -> usize

Get the number of lines in the buffer.