osteak 0.1.2

Elm for ratatui — you bring the loop
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

# osteak

[![Crates.io](https://img.shields.io/crates/v/osteak.svg)](https://crates.io/crates/osteak)
[![docs.rs](https://img.shields.io/docsrs/osteak)](https://docs.rs/osteak)
[![CI](https://github.com/os-tack/osteak/actions/workflows/ci.yml/badge.svg)](https://github.com/os-tack/osteak/actions/workflows/ci.yml)
[![License](https://img.shields.io/crates/l/osteak.svg)](LICENSE-MIT)

**Elm for [ratatui](https://ratatui.rs) — you bring the loop.**

## Why osteak?

Every ratatui app that grows past demo complexity hits the "bag of booleans"
wall — state scattered across fields, implicit transitions, race conditions
when async work outlives UI signals.

| | osteak | ratatui-elm | teatui | tui-realm |
|---|---|---|---|---|
| ratatui 0.30 | **yes** | no (0.29) | no (0.29) | no (0.29) |
| You keep event loop | **yes** | no | no | no |
| `&mut` update (no clone) | **yes** | yes | no | n/a |
| Full `Frame` access | **yes** | yes | no | yes |
| Async task integration | **yes** | no | own runtime | n/a |
| Dirty tracking | **yes** | no | no | no |

## Quick Start

```sh
cargo add osteak
```

```rust
use osteak::{Tea, Cmd};
use ratatui::Frame;
use ratatui::widgets::Paragraph;

struct Counter { count: i32 }

enum Msg { Increment, Decrement, Quit }

impl Tea for Counter {
    type Msg = Msg;

    fn update(&mut self, msg: Msg) -> Cmd<Msg> {
        match msg {
            Msg::Increment => { self.count += 1; Cmd::dirty() }
            Msg::Decrement => { self.count -= 1; Cmd::dirty() }
            Msg::Quit => Cmd::quit(),
        }
    }

    fn view(&mut self, frame: &mut Frame) {
        let text = format!("Count: {}", self.count);
        frame.render_widget(Paragraph::new(text), frame.area());
    }
}
```

### With the built-in runner

```rust,no_run
use crossterm::event::{Event, KeyCode, KeyEventKind};

#[tokio::main]
async fn main() -> std::io::Result<()> {
    osteak::runner::run(Counter { count: 0 }, |ev| {
        let Event::Key(k) = ev else { return None };
        if k.kind != KeyEventKind::Press { return None; }
        match k.code {
            KeyCode::Up => Some(Msg::Increment),
            KeyCode::Down => Some(Msg::Decrement),
            KeyCode::Char('q') => Some(Msg::Quit),
            _ => None,
        }
    }).await
}
```

### Without the runner

You always have the option to write your own event loop — osteak never takes
control away. See [`examples/counter_manual.rs`](examples/counter_manual.rs).

## Architecture

```text
                    ┌──────────────────────┐
                    │    Your Event Loop    │
                    │  (or osteak::runner)  │
                    └──────┬───────────────┘
                           │ Msg
                    ┌──────▼───────────────┐
                    │   Tea::update(&mut)   │
                    │   → Cmd { action,     │
                    │         dirty }       │
                    └──────┬───────────────┘
                           │
              ┌────────────┼────────────┐
              │            │            │
        Action::Task  Action::None  Action::Quit
        (you spawn)   (no-op)       (exit loop)
              │
              │ Msg (on completion)
              └──────────► back to update
```

## Features

| Feature | Default | Description |
|---------|---------|-------------|
| `crossterm-backend` | yes | Crossterm terminal backend + `EventStream` |
| `tokio-runtime` | yes | Tokio integration for the runner module |

To use osteak without the runner (just the traits):

```sh
cargo add osteak --no-default-features
```

## Examples

- [`counter`](examples/counter.rs) — minimal app with the built-in runner
- [`counter_manual`](examples/counter_manual.rs) — same app, hand-written event loop
- [`async_tasks`](examples/async_tasks.rs) — `Cmd::task` with `tokio::spawn` in a manual loop
- [`multi_pane`](examples/multi_pane.rs) — model composition with `Cmd::map`

```sh
cargo run --example counter
cargo run --example counter_manual
cargo run --example multi_pane
```

## MSRV

The minimum supported Rust version is **1.86.0** (same as ratatui 0.30).

## License

[MIT](LICENSE-MIT)

## Contributing

See [CONTRIBUTING.md](CONTRIBUTING.md).