moon_tui

Returns the escape sequence that enters the alternate screen.

Returns the escape sequence that leaves the alternate screen.

Returns the escape sequence that hides the cursor.

Returns the escape sequence that shows the cursor.

Returns the escape sequence that enables bracketed paste.

Returns the escape sequence that disables bracketed paste.

Returns the escape sequence that enables focus events.

Returns the escape sequence that disables focus events.

Returns the escape sequence that enables mouse events.

Returns the escape sequence that disables mouse events.

Returns the escape sequence that clears the screen.

Returns the escape sequence that saves the cursor.

Returns the escape sequence that restores the cursor.

Returns the escape sequence that moves the cursor.

• position: Cell to move the cursor to.

Encodes a complete style from reset. Runs share styles, so this is emitted once per changed run rather than once per cell.

• value: Style to encode from a reset.

Encoded terminal output and its final cursor position.

Encodes one desired frame in the portable xterm subset. Application text is already sanitized into cells; this module is the package's sole escape producer.

• previous: What the terminal is believed to be showing.
• next: What it should show.
• before_cursor: Cursor state of the presented frame.
• after_cursor: Cursor state the new frame asks for.
• origin: Absolute cell the grid is placed at.
• force: True to emit every cell rather than only the changes.

Inline viewports use relative row movement from the presenter's own last known position, avoiding cursor-position queries and absolute row guesses.

• previous: What the terminal is believed to be showing.
• next: What it should show.
• before_cursor: Cursor state of the presented frame.
• after_cursor: Cursor state the new frame asks for.
• origin: Absolute cell the grid is placed at.
• force: True to emit every cell rather than only the changes.
• relative: True to move by relative rows instead of absolute ones.
• last_y: Row the presenter last left the cursor on.

Dense row-major cell grid. The backing array is reused by reset/resize.

Scalar generations shared by every value-copy of a Buffer handle.

Creates a new value with the supplied configuration.

• size: Grid extent to allocate.

One dense grid cell. Wide heads have span=2; their following cell has continuation=true and span=0.

Creates a blank terminal cell.

Creates a blank cell with the supplied style.

• value: Style the blank cell carries.

Creates the head cell for a grapheme of the supplied display span.

• grapheme: Text the cell draws.
• value: Style the cell carries.
• span: Display columns it occupies; 2 makes the next cell a continuation.

Creates a wide-cell continuation marker.

• value: Style the continuation cell carries, matching its head.

Runtime clock seam. Production uses host monotonic time and real sleeping; tests inject a reference-backed fake with no wall-clock delay.

Deterministic clock handle for runtime tests.

Shared mutable time and sleep counters for a fake clock.

Returns the system implementation.

Creates a deterministic fake implementation.

• start_ms: Time the fake clock starts at.

Bounded incremental VT decoder. The constructor returns one managed stream; copied pointers share it while separate decoders remain independent.

Creates a new value with the supplied configuration.

• max_pending: Byte ceiling on held-back input.
• max_paste: Byte ceiling on one paste.
• escape_timeout_ms: How long a lone Escape waits for a continuation.

use moon_tui.decoder
use moon_tui.event.{Event, KeyCode}

fn main() {
  let escape = std.strings.from_code(27)
  let input = decoder.new(max_pending: 4096, max_paste: 1024, escape_timeout_ms: 25)
  for event in input.push(escape + "[A", 0) {
    match event {
      Event.Key(key) => match key.code {
        KeyCode.Up => println("up"),
        _ => {},
      },
      _ => {},
    }
  }
  println(input.flush_deadlines(25))
}

One adjacent row segment whose desired cells share a style.

Finds changed, style-coalesced row runs. Continuation cells remain in the run extent so a wide-to-narrow replacement clears both physical columns.

• previous: What the terminal is believed to be showing.
• next: What it should show.
• force: True to emit every cell rather than only the changes.

Terminal feature flags supported by a backend.

Returns the conservative terminal capabilities.

Enumerates the supported ReadResult cases.

Injected terminal backend. Closures capture reference-backed driver state; there is no package-global handle or saved-mode storage.

Shared mutable queues and counters for a fake terminal driver.

Deterministic in-memory terminal backend for tests.

Creates a deterministic fake implementation.

• size: Extent the fake terminal reports.

use moon_tui.driver
use moon_tui.geometry
use moon_tui.style
use moon_tui.terminal

fn main() {
  let backend = driver.fake(geometry.size(20, 4))
  let term = terminal.open_with(terminal.options(), backend.driver).unwrap()
  let frame = term.begin_frame()
  frame.root().write_text(0, 0, "moon", style.plain())
  term.present()
  println(backend.output())
  backend.push_read(driver.ReadResult.Data("q"))
  println(term.poll(0).unwrap())
  term.close()
  println(backend.close_count())
}

Returns the platform terminal driver.

Returns the platform terminal driver.

Modifier mask bit for Shift.

Modifier mask bit for Alt.

Modifier mask bit for Control.

Modifier mask bit for Super/Command.

Enumerates the supported KeyCode cases.

Decoded key code and modifier mask.

Enumerates the supported MouseKind cases.

Decoded mouse action, button, modifiers, and cell position.

Enumerates the supported Event cases.

Creates a keyboard event.

• code: Which key was pressed.
• modifiers: Modifier bits held at the time.

Optional app-owned focus order. Rendering reads the current id but never mutates it; applications call next/previous/focus from their update step.

Creates a new value with the supplied configuration.

• ids: Widget identifiers in focus order.

use moon_tui.focus

fn main() {
  let ring = focus.new(["search", "results", "footer"])
  println(ring.current())
  println(ring.next())
  println(ring.previous())
  println(ring.focus("footer"))
  println(ring.contains("search"))
}

Enumerates the supported CursorShape cases.

Requested cursor visibility, position, and shape for a frame.

A frame is a complete desired grid plus declarative cursor state.

A translating, clipped view over the frame's shared dense buffer.

Creates a new value with the supplied configuration.

• buffer: The dense grid to draw into.
• policy: How grapheme display widths are measured.

Constructs a Frame over cursor storage owned by Screen.

• buffer: The dense grid to draw into.
• cursor: Cursor storage owned by the screen.
• policy: How grapheme display widths are measured.

A zero-based terminal cell position.

A terminal cell extent. Constructors clamp negative dimensions to zero.

A half-open terminal-cell rectangle.

Enumerates the supported Direction cases.

Creates a terminal-cell position.

• x: Column, counting from zero.
• y: Row, counting from zero.

Creates a terminal-cell extent with non-negative dimensions.

• width: Columns spanned; negative is clamped to zero.
• height: Rows spanned; negative is clamped to zero.

Creates a clamped terminal-cell rectangle.

• x: Column of the left edge.
• y: Row of the top edge.
• width: Columns spanned; negative is clamped to zero.
• height: Rows spanned; negative is clamped to zero.

use moon_tui.geometry
use moon_tui.layout
use moon_tui.layout.{Constraint}

fn main() {
  let screen = geometry.rect(0, 0, 80, 24)
  let rows = layout.split(
    screen,
    geometry.Direction.Vertical,
    [Constraint.Length(3), Constraint.Weight(1), Constraint.Length(1)],
  )
  println(rows.map(|row| row.height))
  println(screen.inset(1).contains(geometry.position(2, 2)))
  println(screen.intersect(geometry.rect(70, 20, 20, 10)))
  println(screen.translate(1, 1).right())
}

Enumerates the supported Constraint cases.

Deterministic one-axis integer layout. Fixed lengths are assigned first, percentages use the original usable span, and weights divide the remainder.

• area: Region to divide.
• direction: Axis to divide along.
• constraints: One constraint per resulting region, in order.
• spacing: Cells left between adjacent regions.
• margin: Cells trimmed from every side before dividing.

Enumerates the supported RuntimeEvent cases.

Enumerates the supported Command cases.

Model transition, redraw decision, and follow-up commands.

Application model, update callback, and view callback.

use moon_tui.frame.{Frame}
use moon_tui.runtime
use moon_tui.runtime.{Program, RuntimeEvent, Update}
use moon_tui.style
use moon_tui.terminal
use moon_tui.tui

enum Msg { Tick, Quit }
struct Model { count: int }

fn init() -> Update<Model, Msg> {
  runtime.with_commands(
    runtime.redraw(Model { count: 0 }),
    [runtime.after(1000, Msg.Tick)],
  )
}

fn update(model: Model, event: RuntimeEvent<Msg>) -> Update<Model, Msg> {
  match event {
    RuntimeEvent.Message(Msg.Tick) => runtime.with_commands(
      runtime.redraw(Model { count: model.count + 1 }),
      [runtime.after(1000, Msg.Tick)],
    ),
    RuntimeEvent.Message(Msg.Quit) => runtime.quit(model),
    _ => runtime.unchanged(model),
  }
}

fn view(model: Model, frame: Frame) {
  frame.root().write_text(0, 0, "ticks: ${model.count}", style.plain())
}

async fn main() {
  let program = Program { init: init, update: update, view: view }
  let _final = (await tui.run(program, runtime.options(), terminal.options())).unwrap()
}

Terminal-runtime timing and input configuration.

Returns the default options.

Returns an update that requests a redraw.

• model: The model the next cycle sees.

Returns an update that leaves the model without a redraw.

• model: The model the next cycle sees.

Returns an update that requests runtime shutdown.

• model: The model returned to the caller of the loop.

Returns a model update with follow-up commands.

• update: The transition to attach work to.
• commands: Follow-up work the runtime should start.

Creates a command backed by an asynchronous effect.

• run: Called once; the message it resolves to is delivered to update.

Creates a command that emits a message after a delay.

• delay_ms: How long to wait before delivering.
• message: What to deliver.

Enumerates the supported EffectOutcome cases.

Runtime bookkeeping for one asynchronous effect.

Delayed message scheduled for a monotonic deadline.

Runs the serial model/update/view loop over an already-open Terminal. The same low-level begin_frame/present path is used by custom-loop callers.

• program: The init, update, and view callbacks to drive.
• terminal: An already-open session to draw on.
• clock: Time source, so tests can drive the loop without waiting.
• config: Frame rate, event batching, and idle behaviour.

Byte and cell counts from one terminal presentation.

Reusable previous/next grids. One managed state object lets a Terminal and its copied Frames observe the same buffers without singleton arrays.

Shared mutable backing state for a terminal screen.

Creates a screen with blank current and previous buffers.

• size: Grid extent for both buffers.
• policy: How grapheme display widths are measured.

Portable terminal colors. Indexed uses the xterm 0..255 palette.

Style attribute mask bit for bold text.

Style attribute mask bit for dim text.

Style attribute mask bit for italic text.

Style attribute mask bit for underlined text.

Style attribute mask bit for reversed colors.

Style attribute mask bit for hidden text.

Style attribute mask bit for struck-through text.

A complete cell style.

A composable style delta. Missing colors leave the destination unchanged.

Returns the default unstyled value.

Creates a style from foreground, background, and attributes.

• fg: Foreground color.
• bg: Background color.
• attrs: Attribute bits, OR-ed together.

use moon_tui.style
use moon_tui.style.Color

fn main() {
  let base = style.styled(Color.Indexed(14), Color.Default, style.BOLD)
  let changed = base.apply(
    style.patch(none, some(Color.Rgb(20, 30, 40)), style.UNDERLINE, style.BOLD),
  )
  println(changed)
  println(style.plain())
}

Creates a partial style update.

• fg: Foreground to set; absence leaves it alone.
• bg: Background to set; absence leaves it alone.
• add_attrs: Attribute bits to turn on.
• remove_attrs: Attribute bits to turn off.

Terminal backend, viewport, width, and polling configuration.

Returns the default options.

Shared mutable state for an open terminal session.

Open terminal session with drawing and input operations.

Opens a terminal using the default platform backend.

• config: Viewport, input modes, and width policy for the session.

use moon_tui.event.{Event, KeyCode}
use moon_tui.style
use moon_tui.terminal

fn main() {
  let term = terminal.open(terminal.options()).unwrap()
  defer term.close()
  let frame = term.begin_frame()
  frame.root().write_text(0, 0, "press Escape", style.plain())
  println(term.present().success)
  for event in term.poll(std.time.monotonic_ms()).unwrap() {
    match event {
      Event.Key(key) => match key.code { KeyCode.Escape => return, _ => {} },
      _ => {},
    }
  }
  term.refresh()
}

Opens a terminal with an explicit backend.

• options: Viewport, input modes, and width policy for the session.
• backend: Driver to read and write through, in place of the platform one.

Runs the configured application loop.

• program: The init, update, and view callbacks to drive.
• runtime_options: Frame rate, event batching, and idle behaviour.
• terminal_options: Viewport, input modes, and width policy.

Runs the application loop with explicit dependencies.

• program: The init, update, and view callbacks to drive.
• terminal: An already-open session to draw on.
• injected_clock: Time source, so tests can drive the loop without waiting.
• runtime_options: Frame rate, event batching, and idle behaviour.

Unicode data version used by the generated width tables.

SHA-256 of the source Unicode data used to generate these tables.

Sorted Unicode code-point ranges for extend.

Sorted Unicode code-point ranges for spacing mark.

Sorted Unicode code-point ranges for prepend.

Sorted Unicode code-point ranges for wide.

Sorted Unicode code-point ranges for ambiguous.

Sorted Unicode code-point ranges for emoji presentation.

Sorted Unicode code-point ranges for extended pictographic.

Enumerates the supported Viewport cases.

Screen origin and drawable size selected for a viewport.

Computes viewport geometry for the terminal size.

• mode: Which viewport to compute for.
• terminal_size: Extent the terminal reported.

Reserves fixed-height primary-screen rows without a cursor-position query.

• height: Rows to reserve on the primary screen.

Returns escape sequences that clear an inline viewport.

• height: Rows the inline viewport occupies.

Returns the escape sequence that moves to the inline anchor.

• current_y: Row the cursor currently sits on.

Finishes inline rendering and optionally clears its rows.

• height: Rows the inline viewport occupies.
• clear: Whether to clear those rows on the way out.
• current_y: Row the cursor currently sits on.

Shared alignment and text helpers used by the pure widget modules.

Clamps a value to the inclusive bounds.

• value: Value to constrain.
• low: Lowest value allowed.
• high: Highest value allowed.

Repeats the value the requested number of times.

• text: Text to repeat.
• count: How many copies to emit.

Clips on grapheme boundaries and never emits a partial wide cluster.

• text: Text to clip.
• max_width: Columns the result must fit in.
• policy: How grapheme display widths are measured.

Deterministic grapheme wrapping. Newlines are honored; long logical lines wrap at cell boundaries without splitting a cluster.

• text: Text to wrap; newlines are honoured.
• max_width: Columns each line must fit in.
• policy: How grapheme display widths are measured.

Writes a styled, width-aware line into a window.

• window: Window to draw into.
• y: Local row to write.
• text: Text to draw, clipped to the window width.
• value: Style the written cells carry.
• alignment: How the text sits within the row.

Border mask bit for the top edge.

Border mask bit for the right edge.

Border mask bit for the bottom edge.

Border mask bit for the left edge.

Border mask containing every edge.

Border, title, and style configuration for a block widget.

Creates a bordered block widget.

• title: Text drawn on the top border.

use moon_tui.buffer
use moon_tui.frame
use moon_tui.geometry
use moon_tui.geometry.{Direction}
use moon_tui.layout
use moon_tui.layout.{Constraint}
use moon_tui.widget.{Alignment}
use moon_tui.widget_block
use moon_tui.widget_gauge
use moon_tui.widget_list
use moon_tui.widget_paragraph
use moon_tui.widget_separator
use moon_tui.widget_table
use moon_tui.widget_tabs

fn main() {
  let grid = buffer.new(geometry.size(60, 16))
  let root = frame.new(grid).root()
  let inner = widget_block.render(
    widget_block.block("Build"),
    root.window(geometry.rect(0, 0, 60, 16)),
  )
  let rows = layout.split(
    inner,
    Direction.Vertical,
    [Constraint.Length(2), Constraint.Weight(1), Constraint.Length(1)],
  )
  widget_paragraph.render(
    widget_paragraph.paragraph("moon build dashboard"),
    root.window(rows[0]),
  )
  let columns = [
    widget_table.column("Stage", Constraint.Weight(2)),
    widget_table.column("State", Constraint.Weight(1), Alignment.Right),
  ]
  widget_table.render(
    widget_table.table(columns, [["compile", "done"], ["test", "green"]]),
    widget_table.state(),
    root.window(rows[1]),
  )
  widget_gauge.render(widget_gauge.gauge(0.75, "75%"), root.window(rows[2]))
  let list_state = widget_list.state()
  list_state.select(1, 2)
  list_state.scroll_into_view(2, 2)
  println(widget_list.list([widget_list.item("one"), widget_list.item("two")]))
  println(widget_tabs.tabs(["Build", "Logs"], 0))
  println(widget_separator.separator(Direction.Horizontal))
}

Paints the block and returns its local content rectangle.

• value: The block to paint.
• window: Window to draw into.

Ratio, label, and style configuration for a gauge widget.

Creates a gauge widget.

• ratio: How full the bar is, from 0.0 to 1.0.
• label: Text drawn over the bar.

Renders the value into its target.

• value: The gauge to paint.
• window: Window to draw into.

Text and style for one list row.

Mutable selection and scroll state for a list.

Items and presentation configuration for a list widget.

Creates a list item.

• text: The row text.
• value: Style the row carries.

Creates mutable widget state.

• selected: Index of the selected item.
• offset: Index of the first visible item.

Creates a list widget.

• items: Rows to draw, in order.

Rendering only observes ListState; selection/scroll changes belong in update.

• value: The list to paint.
• state: Selection and scroll position, read but not changed.
• window: Window to draw into.

Text, wrapping, alignment, and style for a paragraph widget.

Creates a paragraph widget.

• text: The text to draw.

Renders the value into its target.

• value: The paragraph to paint.
• window: Window to draw into.

Direction and style for a separator widget.

Creates a separator widget.

• direction: Whether the rule runs across or down.