git_iris/
ui.rs

1use colored::Colorize;
2use console::Term;
3use indicatif::{ProgressBar, ProgressStyle};
4use once_cell::sync::Lazy;
5use parking_lot::Mutex;
6use ratatui::style::Color;
7use std::fmt::Write;
8use std::time::Duration;
9
10pub const STARLIGHT: Color = Color::Rgb(255, 255, 240);
11pub const NEBULA_PURPLE: Color = Color::Rgb(167, 132, 239);
12pub const CELESTIAL_BLUE: Color = Color::Rgb(75, 115, 235);
13pub const SOLAR_YELLOW: Color = Color::Rgb(255, 225, 100);
14pub const AURORA_GREEN: Color = Color::Rgb(140, 255, 170);
15pub const PLASMA_CYAN: Color = Color::Rgb(20, 255, 255);
16pub const METEOR_RED: Color = Color::Rgb(255, 89, 70);
17pub const GALAXY_PINK: Color = Color::Rgb(255, 162, 213);
18pub const COMET_ORANGE: Color = Color::Rgb(255, 165, 0);
19pub const BLACK_HOLE: Color = Color::Rgb(0, 0, 0);
20
21/// Track quiet mode state
22static QUIET_MODE: Lazy<Mutex<bool>> = Lazy::new(|| Mutex::new(false));
23
24/// Enable or disable quiet mode
25pub fn set_quiet_mode(enabled: bool) {
26    let mut quiet_mode = QUIET_MODE.lock();
27    *quiet_mode = enabled;
28}
29
30/// Check if quiet mode is enabled
31pub fn is_quiet_mode() -> bool {
32    *QUIET_MODE.lock()
33}
34
35pub fn create_spinner(message: &str) -> ProgressBar {
36    // Don't create a spinner in quiet mode
37    if is_quiet_mode() {
38        return ProgressBar::hidden();
39    }
40
41    let pb = ProgressBar::new_spinner();
42    pb.set_style(
43        ProgressStyle::default_spinner()
44            .tick_chars("✦✧✶✷✸✹✺✻✼✽")
45            .template("{spinner} {msg}")
46            .expect("Could not set spinner style"),
47    );
48    pb.set_message(message.to_string());
49    pb.enable_steady_tick(Duration::from_millis(100));
50    pb
51}
52
53pub fn print_info(message: &str) {
54    if !is_quiet_mode() {
55        println!("{}", message.cyan().bold());
56    }
57}
58
59pub fn print_warning(message: &str) {
60    if !is_quiet_mode() {
61        println!("{}", message.yellow().bold());
62    }
63}
64
65pub fn print_error(message: &str) {
66    // Always print errors, even in quiet mode
67    eprintln!("{}", message.red().bold());
68}
69
70pub fn print_success(message: &str) {
71    if !is_quiet_mode() {
72        println!("{}", message.green().bold());
73    }
74}
75
76pub fn print_version(version: &str) {
77    if !is_quiet_mode() {
78        println!(
79            "{} {} {}",
80            "🔮 Git-Iris".magenta().bold(),
81            "version".cyan(),
82            version.green()
83        );
84    }
85}
86
87pub fn create_gradient_text(text: &str) -> String {
88    let gradient = vec![
89        (129, 0, 255), // Deep purple
90        (134, 51, 255),
91        (139, 102, 255),
92        (144, 153, 255),
93        (149, 204, 255), // Light cyan
94    ];
95
96    apply_gradient(text, &gradient)
97}
98
99pub fn create_secondary_gradient_text(text: &str) -> String {
100    let gradient = vec![
101        (75, 0, 130),   // Indigo
102        (106, 90, 205), // Slate blue
103        (138, 43, 226), // Blue violet
104        (148, 0, 211),  // Dark violet
105        (153, 50, 204), // Dark orchid
106    ];
107
108    apply_gradient(text, &gradient)
109}
110
111fn apply_gradient(text: &str, gradient: &[(u8, u8, u8)]) -> String {
112    let chars: Vec<char> = text.chars().collect();
113    let chars_len = chars.len();
114    let gradient_len = gradient.len();
115
116    let mut result = String::new();
117
118    if chars_len == 0 || gradient_len == 0 {
119        return result;
120    }
121
122    chars.iter().enumerate().fold(&mut result, |acc, (i, &c)| {
123        let index = if chars_len == 1 {
124            0
125        } else {
126            i * (gradient_len - 1) / (chars_len - 1)
127        };
128        let (r, g, b) = gradient[index];
129        write!(acc, "{}", c.to_string().truecolor(r, g, b)).unwrap();
130        acc
131    });
132
133    result
134}
135
136pub fn write_gradient_text(
137    term: &Term,
138    text: &str,
139    gradient: &[(u8, u8, u8)],
140) -> std::io::Result<()> {
141    let gradient_text = apply_gradient(text, gradient);
142    term.write_line(&gradient_text)
143}
144
145pub fn write_colored_text(term: &Term, text: &str, color: (u8, u8, u8)) -> std::io::Result<()> {
146    let colored_text = text.truecolor(color.0, color.1, color.2);
147    term.write_line(&colored_text)
148}
149
150pub fn write_bold_text(term: &Term, text: &str) -> std::io::Result<()> {
151    term.write_line(&text.bold())
152}