- Support for Radicle CI

**Applications**

- `issue/list`: Support for edit, comment and state actions

- `inbox/list`: Notifications are now loaded asynchronously

**Library**

- Support asynchronous tasks via additional message processors

- Support popup widgets

- Support tree widgets

- Support contextual and global shortcuts with separate alignment

- Panic hook via `ratatui::init()`

### Fixed

**Library**

- Table border when focussed

- Properly terminate event listener thread

### Changed

- Releases can be build locally

- CLI tests do not require a binary anymore

**Applications**

- Filter expression grammar to better reflect item fields

- Fuzzy search on additional item fields

- Applications are relaunched after operation execution by default

- `issue/list`: Port to imUI

- `inbox/list`: Port to imUI

- `inbox/list`: Improved notification loading times

- `patch/list`: Improved patch loading times

**Library**

- Switched terminal backend from `termion` to `crossterm`

- Unified panes and container widget

- Text widget interface improvements

### Removed

**Applications**

- Legacy selection mode (id-only / operation)

**Library**

- rmUI: Support for retained-mode UIs

## The application framework

The library portion of this crate is a framework that is the foundation for all `radicle-tui` binaries. It supports building concurrent applications with an immediate mode UI. It 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 framework is under heavy development and still missing some required concepts / components as well as some common low-level widgets. These will be added where needed by the `radicle-tui` binaries.

### Design

The framework was built first and foremost with developer experience in mind:

- **easy-to-use**: building new or changing existing applications should be as easy as possible; ready-made widgets should come with defaults for user interactions and rendering

- **extensibility**: extending existing and building new widgets should be straight-forward; custom application logic components should be easy to implement

- **flexibility**: widgets and application logic should be easy to change and compose; it should be all about changing and composing functions and not about writing boilerplate code

#### Components

The central pieces of the framework are the `Store`, the `Frontend` and a message passing system that let both communicate with each other. The `Store` handles the centralized application state and sends updates to the `Frontend`, whereas the `Frontend` handles user-interactions and sends messages to the `Store`, which updates the state accordingly.

The `Frontend` drives an _immediate mode_ `Ui`. In _immediate mode_, widgets are rendered the moment they're created and events are handled right before the actual drawing happens (in _retained mode_, you'd create stateful widgets once and later modify their properties or handle their events).

> **Note:** The first versions of the framework provided a retained mode UI (rmUI) which was then replaced in favor of an immediate mode UI (imUI). The Retained mode UI is still supported, but it's recommended to use the new immediate mode UI.

1. [Getting Started](#Getting-started)

   - [Installation](#Installation)

   - [Usage](#Usage)

2. [Build with `radicle-tui`](#Build-with-radicle-tui)

   - [Example](#Example)

3. [Contributing](#Contributing)

4. [Contact](#Contact)

5. [License](#License)

This crate provides a binary called `rad-tui` which can be used as a drop-in replacement for `rad`. It maps known commands and operations to internal ones, running the corresponding interface, e.g.

```

rad-tui patch

```

runs the patch list interface and calls `rad` with the operation and id selected. Commands or operations not known to `rad-tui` will be forwarded to `rad`, e.g. the following just calls `rad node`:

rad-tui node

```

The default forwarding behaviour can be overridden with a flag, e.g.

```

rad-tui help --no-forward

```

runs the internal help command instead of forwarding to `rad help`.

### Using a shell alias

In order to make the CLI integration opaque, a shell alias can be used:

```

alias rad="rad-tui"

## Build with `radicle-tui`

The library portion of this crate is a framework that is the foundation for all `radicle-tui` binaries. Although it evolved from the work on Radicle-specific applications and is far from being complete, it can serve as a general purpose framework to build applications on top already.

Find out more about the [framework](./FRAMEWORK.md).

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

use ratatui::layout::Position;

use tui::event::Key;

use tui::task::EmptyProcessors;

use tui::ui::widget::{Borders, Window};

use tui::ui::{Context, Show};

            ui.text_view(

                frame,

                self.hello.clone(),

                &mut Position::default(),

                Some(Borders::None),

            );

            if ui.has_input(|key| key == Key::Char('q')) {

    tui::im(

        app,

        Viewport::default(),

        Channel::default(),

        EmptyProcessors::new(),

    )

    .await?;

See [LICENSE-APACHE](./LICENSE-APACHE) and [LICENSE-MIT](./LICENSE-MIT) for details.

Please get in touch on [Zulip](https://radicle.zulipchat.com/#narrow/channel/522964-TUI).

use anyhow::Result;

use ratatui::layout::Position;

use ratatui::{Frame, Viewport};

use radicle_tui as tui;

use tui::event::Key;

use tui::store;

use tui::task::EmptyProcessors;

use tui::ui::widget::{Borders, Window};

use tui::ui::{Context, Show};

use tui::{Channel, Exit};

#[derive(Clone, Debug)]

struct App {

    hello: String,

}

#[derive(Clone, Debug)]

enum Message {

    Quit,

}

impl store::Update<Message> for App {

    type Return = ();

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

        match message {

            Message::Quit => Some(Exit { value: None }),

        }

    }

}

impl Show<Message> for App {

    fn show(&self, ctx: &Context<Message>, frame: &mut Frame) -> Result<()> {

        Window::default().show(ctx, |ui| {

            ui.text_view(

                frame,

                self.hello.clone(),

                &mut Position::default(),

                Some(Borders::None),

            );

            if ui.has_input(|key| key == Key::Char('q')) {

                ui.send_message(Message::Quit);

            }

        });

        Ok(())

    }

}

#[tokio::main]

pub async fn main() -> Result<()> {

    let app = App {

        hello: "Hello World!".to_string(),

    };

    tui::im(

        app,

        Viewport::default(),

        Channel::default(),

        EmptyProcessors::new(),

    )

    .await?;

    Ok(())

}