use console_static_text::ConsoleStaticText;
use deno_core::parking_lot::Mutex;
use deno_runtime::ops::tty::ConsoleSize;
use once_cell::sync::Lazy;
use std::sync::Arc;
use std::time::Duration;
use crate::util::console::console_size;
pub trait DrawThreadRenderer: Send + Sync + std::fmt::Debug {
fn render(&self, data: &ConsoleSize) -> String;
}
#[derive(Debug)]
pub struct DrawThreadGuard(u16);
impl Drop for DrawThreadGuard {
fn drop(&mut self) {
DrawThread::finish_entry(self.0)
}
}
#[derive(Debug, Clone)]
struct InternalEntry {
id: u16,
renderer: Arc<dyn DrawThreadRenderer>,
}
#[derive(Debug)]
struct InternalState {
drawer_id: usize,
hide: bool,
has_draw_thread: bool,
next_entry_id: u16,
entries: Vec<InternalEntry>,
static_text: ConsoleStaticText,
}
impl InternalState {
pub fn should_exit_draw_thread(&self, drawer_id: usize) -> bool {
self.drawer_id != drawer_id || self.entries.is_empty()
}
}
static INTERNAL_STATE: Lazy<Arc<Mutex<InternalState>>> = Lazy::new(|| {
Arc::new(Mutex::new(InternalState {
drawer_id: 0,
hide: false,
has_draw_thread: false,
entries: Vec::new(),
next_entry_id: 0,
static_text: ConsoleStaticText::new(|| {
let size = console_size().unwrap();
console_static_text::ConsoleSize {
cols: Some(size.cols as u16),
rows: Some(size.rows as u16),
}
}),
}))
});
static IS_TTY_WITH_CONSOLE_SIZE: Lazy<bool> = Lazy::new(|| {
atty::is(atty::Stream::Stderr)
&& console_size()
.map(|s| s.cols > 0 && s.rows > 0)
.unwrap_or(false)
});
#[derive(Clone, Debug)]
pub struct DrawThread;
impl DrawThread {
pub fn is_supported() -> bool {
log::log_enabled!(log::Level::Info) && *IS_TTY_WITH_CONSOLE_SIZE
}
pub fn add_entry(renderer: Arc<dyn DrawThreadRenderer>) -> DrawThreadGuard {
let internal_state = &*INTERNAL_STATE;
let mut internal_state = internal_state.lock();
let id = internal_state.next_entry_id;
internal_state.entries.push(InternalEntry { id, renderer });
if internal_state.next_entry_id == u16::MAX {
internal_state.next_entry_id = 0;
} else {
internal_state.next_entry_id += 1;
}
Self::maybe_start_draw_thread(&mut internal_state);
DrawThreadGuard(id)
}
pub fn hide() {
let internal_state = &*INTERNAL_STATE;
let mut internal_state = internal_state.lock();
internal_state.hide = true;
Self::clear_and_stop_draw_thread(&mut internal_state);
}
pub fn show() {
let internal_state = &*INTERNAL_STATE;
let mut internal_state = internal_state.lock();
internal_state.hide = false;
Self::maybe_start_draw_thread(&mut internal_state);
}
fn finish_entry(entry_id: u16) {
let internal_state = &*INTERNAL_STATE;
let mut internal_state = internal_state.lock();
if let Some(index) =
internal_state.entries.iter().position(|e| e.id == entry_id)
{
internal_state.entries.remove(index);
if internal_state.entries.is_empty() {
Self::clear_and_stop_draw_thread(&mut internal_state);
}
}
}
fn clear_and_stop_draw_thread(internal_state: &mut InternalState) {
if internal_state.has_draw_thread {
internal_state.static_text.eprint_clear();
internal_state.drawer_id += 1;
internal_state.has_draw_thread = false;
}
}
fn maybe_start_draw_thread(internal_state: &mut InternalState) {
if internal_state.has_draw_thread
|| internal_state.hide
|| internal_state.entries.is_empty()
|| !DrawThread::is_supported()
{
return;
}
internal_state.drawer_id += 1;
internal_state.has_draw_thread = true;
let drawer_id = internal_state.drawer_id;
tokio::task::spawn_blocking(move || {
let mut previous_size = console_size();
loop {
let mut delay_ms = 120;
{
let entries = {
let internal_state = &*INTERNAL_STATE;
let internal_state = internal_state.lock();
if internal_state.should_exit_draw_thread(drawer_id) {
break;
}
internal_state.entries.clone()
};
let size = console_size();
let mut text = String::new();
if size != previous_size {
previous_size = size;
delay_ms = 200;
} else if let Some(size) = size {
let mut should_new_line_next = false;
for entry in entries {
let new_text = entry.renderer.render(&size);
if should_new_line_next && !new_text.is_empty() {
text.push('\n');
}
should_new_line_next = !new_text.is_empty();
text.push_str(&new_text);
}
{
let internal_state = &*INTERNAL_STATE;
let mut internal_state = internal_state.lock();
if internal_state.should_exit_draw_thread(drawer_id) {
break;
}
internal_state.static_text.eprint_with_size(
&text,
console_static_text::ConsoleSize {
cols: Some(size.cols as u16),
rows: Some(size.rows as u16),
},
);
}
}
}
std::thread::sleep(Duration::from_millis(delay_ms));
}
});
}
}