[[package]]

name = "crossterm"

version = "0.29.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "d8b9f2e4c67f833b660cdb0a3523065869fb35570177239812ed4c905aeff87b"

 "document-features",

 "mio 1.0.4",

 "parking_lot",

 "signal-hook",

 "signal-hook-mio",

 "winapi",

 "newline-converter",

 "once_cell",

 "tempfile",

 "unicode-segmentation",

 "unicode-width 0.1.14",

]

[[package]]

name = "linux-raw-sys"

version = "0.9.4"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12"

checksum = "b8f8bdf33df195859076e54ab11ee78a1b208382d3a26ec40d142ffc1ecc49ef"

[[package]]

name = "object"

version = "0.36.7"

source = "registry+https://github.com/rust-lang/crates.io-index"

 "signal-hook",

 "simple-logging",

 "terminal-light",

 "textwrap",

 "thiserror 2.0.16",

 "timeago 0.5.0",

 "bitflags 2.9.3",

 "cassowary",

 "compact_str",

 "indoc",

 "instability",

 "itertools 0.13.0",

 "paste",

 "serde",

 "strum",

 "time",

 "unicode-segmentation",

 "unicode-truncate",

[[package]]

name = "rustix"

version = "1.0.8"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "11181fbabf243db407ef8df94a6ce0b2f9a733bd8be4ad02b4eda9602296cac8"

 "bitflags 2.9.3",

 "errno",

 "libc",

 "windows-sys 0.60.2",

]

 "fastrand",

 "getrandom 0.3.3",

 "once_cell",

 "windows-sys 0.60.2",

]

dependencies = [

 "libc",

 "libredox 0.0.2",

 "redox_termios",

]

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "0a5318dd619ed73c52a9417ad19046724effc1287fb75cdcc4eca1d6ac1acbae"

dependencies = [

 "ratatui",

 "unicode-width 0.2.0",

]

checksum = "af3a19837351dc82ba89f8a125e22a3c475f05aba604acc023d62b2739ae2909"

dependencies = [

 "libc",

]

[[package]]

radicle-signals = { version = "0.11.0" }

ratatui = { version = "0.29.0", default-features = false, features = [

    "all-widgets",

    "serde",

] }

md5 = { version = "0.8.0" }

serde_json = { version = "1.0" }

signal-hook = { version = "0.3.17" }

timeago = { version = "0.5.0" }

terminal-light = { version = "1.4.0" }

textwrap = { version = "0.16.0" }

thiserror = { version = "2.0.16" }

tokio-util = { version = "0.7.17" }

tokio-stream = { version = "0.1.14" }

tui-textarea = { version = "0.7.0", default-features = false, features = [

] }

tui-tree-widget = { version = "0.23.0" }

use anyhow::Result;

use ratatui::layout::Constraint;

use ratatui::layout::Layout;

use ratatui::prelude::*;

use radicle_tui as tui;

use tui::store;

use tui::task::{Process, Task};

use tui::ui::im;

use tui::ui::{BufferedValue, Column, Spacing};

use tui::{Channel, Exit};

use crate::ui::items::filter::Filter;

use crate::ui::items::notification::filter::{NotificationFilter, SortBy};

use crate::ui::items::notification::Notification;

type Selection = tui::Selection<NotificationId>;

const HELP: &str = r#"# Generic keybindings

                            }

                        },

                    );

                }

                Page::Help => {

            self.show_browser_context(frame, ui);

            self.show_browser_shortcuts(frame, ui);

        });

    }

    pub fn show_browser_search(&self, frame: &mut Frame, ui: &mut im::Ui<Message>) {

        if ui.has_input(|key| key == Key::Esc) {

            ui.send_message(Message::HideSearch { apply: false });

        }

            ui.send_message(Message::HideSearch { apply: true });

        }

    }

use anyhow::{bail, Result};

use ratatui::layout::Constraint;

use ratatui::style::Stylize;

use ratatui::text::Text;

use radicle_tui as tui;

use tui::store;

use tui::task::EmptyProcessors;

use tui::ui::rm::widget::container::{

        )

        .shortcuts(shortcuts)

        .to_widget(tx.clone())

            let default = PageProps::default();

            let props = props

                .and_then(|props| props.inner_ref::<PageProps>())

                .unwrap_or(&default);

            if props.handle_keys {

                }

            } else {

                None

        .content(content)

        .shortcuts(shortcuts)

        .to_widget(tx.clone())

            _ => None,

        })

        .on_update(|_| PageProps::default().handle_keys(true).to_boxed_any().into())

use std::vec;

use radicle::issue::{self, CloseReason};

use ratatui::Frame;

use tokio::sync::broadcast;

use ratatui::layout::{Constraint, Layout};

use ratatui::style::Stylize;

use ratatui::text::{Line, Text};

use radicle_tui as tui;

use tui::ui::rm::widget;

use tui::ui::rm::widget::container::{

    Container, ContainerProps, Footer, FooterProps, Header, HeaderProps,

    type Message = Message;

    type State = State;

        let default = BrowserProps::default();

        let props = props

            .and_then(|props| props.inner_ref::<BrowserProps>())

            .unwrap_or(&default);

        if props.show_search {

                    self.search.reset();

                    Some(Message::CloseSearch)

                }

                _ => {

                    None

                }

            }

        } else {

                _ => {

                    None

                }

            }

use anyhow::Result;

use radicle::patch::PatchId;

use radicle::storage::git::Repository;

use radicle::Profile;

use radicle_tui as tui;

use tui::store;

use tui::task::EmptyProcessors;

use tui::ui::im;

                            }

                        },

                    );

                }

                Page::Help => {

            self.show_browser_context(frame, ui);

            self.show_browser_shortcuts(frame, ui);

        });

    }

    pub fn show_browser_search(&self, frame: &mut Frame, ui: &mut im::Ui<Message>) {

        if ui.has_input(|key| key == Key::Esc) {

            ui.send_message(Message::HideSearch { apply: false });

        }

            ui.send_message(Message::HideSearch { apply: true });

        }

    }

use serde::{Deserialize, Serialize};

use ratatui::layout::{Constraint, Layout, Position};

use ratatui::style::{Style, Stylize};

use ratatui::text::Text;

use radicle_tui as tui;

use tui::store;

use tui::task::EmptyProcessors;

use tui::ui::im::widget::{ContainerState, TableState, TextViewState, Window};

use radicle_tui::ui::Spacing;

use ratatui::layout::{Constraint, Layout};

use ratatui::Frame;

use radicle_tui as tui;

use tui::ui::im::widget::{TableState, TextEditState, Widget};

use tui::ui::im::{Borders, Response, Ui};

use tui::ui::{BufferedValue, Column, ToRow};

                *self.show_search = false;

                self.search.reset();

            }

                *self.show_search = false;

                self.search.apply();

            }

use anyhow::Result;

use ratatui::layout::Constraint;

use ratatui::Viewport;

use radicle_tui as tui;

use tui::store;

use tui::task::EmptyProcessors;

use tui::ui::rm::widget::container::{Container, Header, HeaderProps};

    let window = Window::default()

        .page(0, page)

        .to_widget(sender.clone())

            _ => None,

        })

        .on_update(|_| WindowProps::default().current_page(0).to_boxed_any().into());

use anyhow::Result;

use ratatui::layout::Position;

use ratatui::{Frame, Viewport};

use radicle_tui as tui;

use tui::store;

use tui::task::EmptyProcessors;

use tui::ui::im::widget::Window;

use anyhow::Result;

use ratatui::Viewport;

use ratatui::style::Color;

use ratatui::text::Text;

use radicle_tui as tui;

use tui::store;

use tui::task::EmptyProcessors;

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

    let scene = TextArea::default()

        .to_widget(sender.clone())

            _ => None,

        })

        .on_update(|app: &App| {

use anyhow::Result;

use ratatui::layout::{Constraint, Layout};

use ratatui::style::Stylize;

use ratatui::text::Span;

use radicle_tui as tui;

use tui::task::EmptyProcessors;

use tui::ui::im::widget::Window;

use tui::ui::im::{Borders, Context};

use tui::ui::{Column, ToRow};

use tui::Channel;

use tui::{

                    ui.shortcuts(frame, &[("q", "quit")], '|');

                        ui.send_message(Message::Return);

                    }

                },

#[derive(Clone, Copy, Debug)]

pub enum Event {

}

use std::io;

use std::time::Duration;

use tokio::sync::broadcast;

use tokio::sync::mpsc::UnboundedSender;

use tokio_util::sync::CancellationToken;

use ratatui::prelude::*;

use ratatui::{CompletedFrame, TerminalOptions, Viewport};

use super::event::Event;

const STDIN_TICK_RATE: Duration = Duration::from_millis(20);

    pub fn restore(&mut self) -> io::Result<()> {

        match self {

            Terminal::Fullscreen(inner) => {

                inner.clear()?;

            }

            Terminal::Inline(inner) => {

                inner.clear()?;

            }

        }

        Ok(())

    }

    fn try_from(viewport: Viewport) -> Result<Self, Self::Error> {

        match viewport {

            Viewport::Fullscreen => {

                let options = TerminalOptions { viewport };

                let mut terminal =

                terminal.clear()?;

                Ok(Terminal::Fullscreen(terminal))

            }

            _ => {

                let options = TerminalOptions { viewport };

                let terminal =

                Ok(Terminal::Inline(terminal))

            }

    }

}

#[derive(Default)]

pub struct StdinReader {}

        event_tx: UnboundedSender<Event>,

        mut interrupt_rx: broadcast::Receiver<Interrupted<P>>,

    ) -> anyhow::Result<Interrupted<P>> {

        let token = CancellationToken::new();

        let token_clone = token.clone();

        let key_event_tx = event_tx.clone();

        let key_listener = tokio::spawn(async move {

            loop {

                    }

                }

            }

        });

                Ok(interrupted)

            }

        };

        key_listener.await?;

        result

    }

use tokio::sync::broadcast;

use tokio::sync::mpsc::UnboundedReceiver;

use ratatui::layout::{Constraint, Flex, Position, Rect};

use ratatui::{Frame, Viewport};

use crate::store::Update;

use crate::terminal::Terminal;

use crate::ui::theme::Theme;

                // Handle input events

                Some(event) = event_rx.recv() => {

                    match event {

                    }

                },

                // Handle state updates

                },

                // Catch and handle interrupt signal to gracefully shutdown

                Ok(interrupted) = interrupt_rx.recv() => {

                    break Ok(interrupted);

                }

            }

pub struct Context<M> {

    /// Currently captured user inputs. Inputs that where stored via `store_input`

    /// need to be cleared manually via `clear_inputs` (usually for each frame drawn).

    /// Current frame of the application.

    pub(crate) frame_size: Rect,

    /// The message sender used by the `Ui` to send application messages.

        }

    }

        self.inputs = inputs;

        self

    }

        self.frame_size

    }

    }

    pub fn clear_inputs(&mut self) {

impl<M> Ui<M> {

    pub fn has_input(&mut self, f: impl Fn(Key) -> bool) -> bool {

    }

    pub fn get_input(&mut self, f: impl Fn(Key) -> bool) -> Option<Key> {

        if self.has_focus && self.is_area_focused() {

        } else {

            None

        }

use std::cmp;

use ratatui::layout::{Direction, Layout, Position, Rect};

use ratatui::style::{Style, Stylize};

use ratatui::text::{Line, Span, Text};

use ratatui::widgets::{Block, BorderType, Row, Scrollbar, ScrollbarState};

use ratatui::Frame;

use ratatui::{layout::Constraint, widgets::Paragraph};

use crate::ui::ext::{FooterBlock, FooterBlockType, HeaderBlock};

use crate::ui::theme::style;

use crate::ui::{layout, span, Spacing};

            len: self.len,

        };

            state.focus_next();

            response.changed = true;

        }

    /// on either the terminal event, the state or the interrupt message channel.

    /// After all, it will draw the (potentially) updated root widget.

    ///

    /// State messages are being sent by the applications' `Store`. Received state updates

    /// will be passed to the root widget as well.

    ///

                _ = ticker.tick() => (),

                // Handle input events

                Some(event) = events_rx.recv() => match event {

                    },

                },

                // Handle state updates

                Some(state) = state_rx.recv() => {

                },

                // Catch and handle interrupt signal to gracefully shutdown

                Ok(interrupted) = interrupt_rx.recv() => {

                }

            }

            terminal.draw(|frame| root.render(RenderProps::from(frame.area()), frame))?;

use tokio::sync::broadcast;

use ratatui::prelude::*;

use self::{

    container::SectionGroupState,

    text::{TextAreaState, TextViewState},

};

pub type BoxedView<S, M> = Box<dyn View<State = S, Message = M>>;

pub type UpdateCallback<S> = fn(&S) -> ViewProps;

pub type RenderCallback<M> = fn(Option<&ViewProps>, &RenderProps) -> Option<M>;

pub type InitCallback<M> = fn() -> Option<M>;

    fn reset(&mut self) {}

    /// Should handle key events and call `handle_event` on all children.

        None

    }

    /// Calls `handle_event` on the wrapped view as well as the `on_event` callback.

    /// Sends any message returned by either the view or the callback.

            let _ = self.sender.send(message);

        }

        if let Some(on_event) = self.on_event {

            if let Some(message) =

            {

                let _ = self.sender.send(message);

            }

use std::fmt::Debug;

use std::marker::PhantomData;

use ratatui::prelude::*;

use ratatui::widgets::{Block, BorderType, Borders, Row};

use crate::ui::ext::{FooterBlock, FooterBlockType, HeaderBlock};

use crate::ui::theme::{style, Theme};

use crate::ui::Column;

    type Message = M;

    type State = S;

        if let Some(content) = &mut self.content {

        }

        None

    type Message = M;

    type State = S;

        let default = SplitContainerProps::default();

        let props = props

            .and_then(|props| props.inner_ref::<SplitContainerProps>())

        match props.split_focus {

            SplitContainerFocus::Top => {

                if let Some(top) = self.top.as_mut() {

                }

            }

            SplitContainerFocus::Bottom => {

                if let Some(bottom) = self.bottom.as_mut() {

                }

            }

        }

    type State = S;

    type Message = M;

        let default = SectionGroupProps::default();

        let props = props

            .and_then(|props| props.inner_ref::<SectionGroupProps>())

            .focus

            .and_then(|focus| self.sections.get_mut(focus))

        {

        }

        if props.handle_keys {

                }

            }

        }

use std::marker::PhantomData;

use std::{cmp, vec};

use ratatui::layout::{Constraint, Layout};

use ratatui::style::{Style, Stylize};

use ratatui::symbols::border;

use tui_tree_widget::TreeState;

use crate::ui::theme::style;

use crate::ui::{layout, span};

use crate::ui::{Column, ToRow, ToTree};

    type Message = M;

    type State = S;

        let default = TableProps::default();

        let props = props

            .and_then(|props| props.inner_ref::<TableProps<R, W>>())

        let page_size = self.height;

            }

        }

        None

        }

    }

            }

        }

        None

use std::marker::PhantomData;

use ratatui::layout::{Alignment, Constraint, Layout, Position, Rect};

use ratatui::style::{Style, Stylize};

use ratatui::text::{Line, Span, Text};

use ratatui::widgets::Paragraph;

use ratatui::Frame;

use crate::ui::theme::{self, Theme};

use super::{utils, RenderProps, View, ViewProps, ViewState};

        };

    }

            }

        }

        None

    type State = S;

    type Message = M;

        use tui_textarea::Input;

        let default = TextAreaProps::default();

        if props.handle_keys {

            if !props.insert_mode {

                    }

                }

            } else {

                // TODO: Implement insert mode.

    type Message = M;

    type State = S;

        let default = TextViewProps::default();

        let props = props

            .and_then(|props| props.inner_ref::<TextViewProps>())

        let page_size = self.area.0 as usize;

        if props.handle_keys {

                }

            }

        }

use std::hash::Hash;

use std::{collections::HashMap, marker::PhantomData};

use ratatui::layout::{Constraint, Layout};

use ratatui::style::{Style, Stylize};

use ratatui::text::Text;

use ratatui::widgets::Row;

use crate::ui::theme::{style, Theme};

use super::{RenderProps, View, ViewProps, Widget};

    type Message = M;

    type State = S;

        let default = WindowProps::default();

        let props = props

            .and_then(|props| props.inner_ref::<WindowProps<Id>>())

            .and_then(|id| self.pages.get_mut(id));