- [Installation](#installation)

    - [Usage](#usage)

    - [Design](#design)

    - [Example](#example)

All interfaces return a common JSON object on `stderr` that reflects the choices made by the user, e.g.: 

The library portion of this crate is a framework that is the foundation for all `radicle-tui` binaries. The framework is built on top of [ratatui](https://ratatui.rs) and mostly follows the Flux application pattern. It took some ideas from [tui-realm](https://github.com/veeso/tui-realm) and [cursive](https://github.com/gyscos/cursive). The concurrency model was mostly inspired by [rust-chat-server](https://github.com/Yengas/rust-chat-server).

> **Note**: Existing core functionalities are considered to be stable, but the API may still change at any point. New features like configurations, used-defined keybindings, themes etc. will be added soon though.

The framework comes with a widget library that provides low-level widgets such as lists, text fields etc. as well as higher-level application widgets such as windows, pages and various other containers.

> **Note:** The widget library is under heavy development and still missing most low-level widgets. These will be added where needed by the `radicle-tui` binaries.

The framework was built with a few design goals in mind:

- **async**: state updates and IO should be asynchronous and not block the UI

- **declarative**: developers should rather think about the *What* then the *How*

- **widget library**: custom widgets should be easy to build; ready-made widgets should come with defaults for user interactions and rendering

On top of this, an extensible widget library was built. A widget is defined by an implementation of the `View` trait and a `Widget` it is wrapped in. A `View` handles user-interactions, updates itself whenever the application state changed and renders itself frequently. A `Widget` adds additional support for properties and event, update and render callbacks. Properties define the data, configuration etc. of a widget. They are updated by the framework taking the properties built by the `on_update` callback. The `on_event` callback is used to emit application messages whenever a widget receives an event.

The main idea is to build widgets that handle their specific events already, and that are updated with the properties built by the `on_update` callback. Custom logic is added by setting the `on_event` callback. E.g. the `Table` widget handles item selection already; items are set via the `on_update` callback and application messages are emitted via the `on_event` callback.

use ratatui::text::Text;

use tui::ui::widget::text::{TextArea, TextAreaProps};

use tui::ui::widget::ToWidget;

use tui::{BoxedAny, Channel, Exit};

/// Centralized application state.

struct State {

/// All messages known by the application.

/// Implementation of the app-state trait. It's updated whenever a message was received.

/// Applications quit whenever an `Exit` is returned by the `update` function. The `Exit`

/// type also provides and optional return value. 

impl store::State<()> for State {

    type Message = Message;

    fn update(&mut self, message: Self::Message) -> Option<tui::Exit<()>> {

/// 1. Initializes the communication channel between frontend and state store

/// 2. Initializes the application state

/// 3. Builds a textarea widget which renders a welcome message and quits the 

///    application when (q) is pressed

/// 4. Runs the TUI application

    let channel = Channel::default();

    let sender = channel.tx.clone();

    let state = State {

        hello: "Hey there, press (q) to quit...".to_string(),

    let textarea = TextArea::default()

        .to_widget(sender.clone())

        .on_event(|key, _, _| match key {

            Key::Char('q') => Some(Message::Quit),

            _ => None,

        })

        .on_update(|state: &State| {

            TextAreaProps::default()

                .text(&Text::raw(state.hello.clone()))

                .to_boxed_any()

                .into()

        });

    tui::run(channel, state, textarea).await?;

### Later   

## License

`radicle-tui` is distributed under the terms of both the MIT license and the Apache License (Version 2.0).

See [LICENSE-APACHE](https://app.radicle.xyz/nodes/seed.radicle.xyz/rad:z39mP9rQAaGmERfUMPULfPUi473tY/tree/LICENSE-APACHE) and [LICENSE-MIT](https://app.radicle.xyz/nodes/seed.radicle.xyz/rad:z39mP9rQAaGmERfUMPULfPUi473tY/tree/LICENSE-MIT) for details.