ratada 0.2.0

A ratatui widget toolkit: driver, modals, forms, pickers, theming
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

//! ratatui adapter for framework-agnostic [`crate::theme::Color`] values.
//!
//! This is the single place that maps theme colors to ratatui styles, so the
//! rest of the kit never converts colors inline.

use ratatui::style::{Color as RatColor, Modifier, Style};

use crate::theme::{Color, Palette};

/// Converts a theme color to a ratatui color (`Default` -> `Reset`).
pub fn to_ratatui(color: Color) -> RatColor {
    match color {
        Color::Default => RatColor::Reset,
        Color::Rgb(red, green, blue) => RatColor::Rgb(red, green, blue),
    }
}

/// A foreground style in `color`.
pub fn fg(color: Color) -> Style {
    Style::default().fg(to_ratatui(color))
}

/// A background style in `color`.
pub fn bg(color: Color) -> Style {
    Style::default().bg(to_ratatui(color))
}

/// A base style pairing a `foreground` and `background`; set once on the
/// full-screen block so plain text inherits the theme's text color.
pub fn base(foreground: Color, background: Color) -> Style {
    Style::default()
        .fg(to_ratatui(foreground))
        .bg(to_ratatui(background))
}

/// The `DIM` modifier. Prefer the palette-driven [`secondary`] for secondary
/// text; this remains for helpers that have no [`Palette`] in scope.
pub fn dim() -> Style {
    Style::default().add_modifier(Modifier::DIM)
}

// --- Semantic style roles ---------------------------------------------------
//
// The single source for how each part of the UI is colored. Widgets use these
// instead of assembling `fg(...).add_modifier(...)` by hand, so the look lives
// in one place.

/// Primary text.
pub fn primary(palette: &Palette) -> Style {
    fg(palette.foreground)
}

/// Secondary/dimmed text (replaces the bare `DIM` modifier).
pub fn secondary(palette: &Palette) -> Style {
    fg(palette.foreground_dim)
}

/// A heading/title: primary text, bold.
pub fn title(palette: &Palette) -> Style {
    fg(palette.foreground).add_modifier(Modifier::BOLD)
}

/// Accent text.
pub fn accent(palette: &Palette) -> Style {
    fg(palette.accent)
}

/// Muted accent text.
pub fn accent_dim(palette: &Palette) -> Style {
    fg(palette.accent_dim)
}

/// Vivid accent text.
pub fn accent_vivid(palette: &Palette) -> Style {
    fg(palette.accent_vivid)
}

/// A shortcut key: accent, bold.
pub fn key(palette: &Palette) -> Style {
    fg(palette.accent).add_modifier(Modifier::BOLD)
}

/// The selected-row / active background.
pub fn selected(palette: &Palette) -> Style {
    bg(palette.selection)
}

/// The block-cursor background.
pub fn cursor(palette: &Palette) -> Style {
    bg(palette.cursor)
}

/// A border/line.
pub fn border(palette: &Palette) -> Style {
    fg(palette.border)
}

/// A disabled/unavailable item.
pub fn disabled(palette: &Palette) -> Style {
    fg(palette.foreground_dim)
}

/// Success text.
pub fn success(palette: &Palette) -> Style {
    fg(palette.success)
}

/// Warning text.
pub fn warning(palette: &Palette) -> Style {
    fg(palette.warning)
}

/// Error text.
pub fn error(palette: &Palette) -> Style {
    fg(palette.error)
}

/// Info text.
pub fn info(palette: &Palette) -> Style {
    fg(palette.info)
}

/// Darkens a ratatui color toward black by `factor` (`0.0` = black, `1.0` =
/// unchanged). Only `Rgb` colors are scaled; every other variant (e.g.
/// `Reset` or a named ANSI color) has no known RGB base and is returned as-is.
pub fn darken(color: RatColor, factor: f32) -> RatColor {
    let scale = |channel: u8| (f32::from(channel) * factor).round() as u8;
    match color {
        RatColor::Rgb(red, green, blue) => {
            RatColor::Rgb(scale(red), scale(green), scale(blue))
        }
        other => other,
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn darken_scales_rgb_channels() {
        assert_eq!(
            darken(RatColor::Rgb(100, 200, 50), 0.5),
            RatColor::Rgb(50, 100, 25),
        );
    }

    #[test]
    fn darken_leaves_non_rgb_unchanged() {
        assert_eq!(darken(RatColor::Reset, 0.5), RatColor::Reset);
        assert_eq!(darken(RatColor::Red, 0.5), RatColor::Red);
    }
}