intuitils 0.0.7

utilities for intuis projects
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

use std::{
    io,
    ops::{Deref, DerefMut},
};

use color_eyre::Result;
use crossterm::{
    cursor,
    event::{DisableMouseCapture, EnableMouseCapture, Event as CrosstermEvent, KeyEventKind},
    terminal::{disable_raw_mode, is_raw_mode_enabled, EnterAlternateScreen, LeaveAlternateScreen},
};
use futures::{FutureExt, StreamExt};
use ratatui::prelude::*;
use tokio::{
    sync::mpsc::{self, UnboundedReceiver, UnboundedSender},
    task::JoinHandle,
};

pub struct Terminal {
    terminal: ratatui::Terminal<CrosstermBackend<std::io::Stdout>>,
    task: JoinHandle<Result<()>>,
    event_rx: UnboundedReceiver<CrosstermEvent>,
    event_tx: UnboundedSender<CrosstermEvent>,
}

impl Deref for Terminal {
    type Target = ratatui::Terminal<CrosstermBackend<std::io::Stdout>>;

    fn deref(&self) -> &Self::Target {
        &self.terminal
    }
}

impl DerefMut for Terminal {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.terminal
    }
}

impl Terminal {
    pub fn new() -> Result<Self> {
        let ratatui_terminal = ratatui::Terminal::new(CrosstermBackend::new(std::io::stdout()))?;
        let (event_tx, event_rx) = mpsc::unbounded_channel();
        let task = tokio::task::spawn(async { Ok(()) });
        Ok(Self {
            terminal: ratatui_terminal,
            task,
            event_rx,
            event_tx,
        })
    }

    pub fn init(&mut self) -> Result<()> {
        crossterm::terminal::enable_raw_mode()?;
        crossterm::execute!(
            std::io::stdout(),
            EnterAlternateScreen,
            cursor::Hide,
            EnableMouseCapture
        )?;
        let event_tx = self.event_tx.clone();

        self.task = tokio::task::spawn(async move {
            let mut reader = crossterm::event::EventStream::new();
            loop {
                let crossterm_event = reader.next().fuse();
                tokio::select! {
                    event = crossterm_event => Self::handle_crossterm_event(event, &event_tx)?,
                }
            }
        });

        Ok(())
    }

    pub fn exit(&mut self) -> Result<()> {
        self.task.abort();

        if is_raw_mode_enabled()? {
            self.terminal.flush()?;
            crossterm::execute!(
                std::io::stdout(),
                LeaveAlternateScreen,
                cursor::Show,
                DisableMouseCapture
            )?;
            disable_raw_mode()?;
        }

        Ok(())
    }

    fn handle_crossterm_event(
        event: Option<Result<CrosstermEvent, io::Error>>,
        event_tx: &UnboundedSender<CrosstermEvent>,
    ) -> Result<()> {
        match event {
            Some(Ok(CrosstermEvent::Key(key))) => {
                if key.kind == KeyEventKind::Press {
                    event_tx.send(CrosstermEvent::Key(key))?;
                }
            }
            Some(Ok(event)) => event_tx.send(event)?,
            Some(Err(e)) => Err(e)?,
            _ => (),
        }
        Ok(())
    }

    pub async fn next(&mut self) -> Option<CrosstermEvent> {
        self.event_rx.recv().await
    }
}