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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211

//! Color types for used for being generic over the color
use crate::{BgColorDisplay, BgDynColorDisplay, FgColorDisplay, FgDynColorDisplay};
use core::fmt;

macro_rules! colors {
    ($(
        $color:ident $fg:literal $bg:literal
    ),* $(,)?) => {

        pub(crate) mod ansi_colors {
            use core::fmt;

            #[allow(unused_imports)]
            use crate::OwoColorize;

            /// Available standard ANSI colors for use with [`OwoColorize::color`](OwoColorize::color)
            /// or [`OwoColorize::on_color`](OwoColorize::on_color)
            #[allow(missing_docs)]
            #[derive(Copy, Clone, Debug, PartialEq, Eq)]
            pub enum AnsiColors {
                $(
                    $color,
                )*
            }

            impl crate::DynColor for AnsiColors {
                fn fmt_ansi_fg(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                    let color = match self {
                        $(
                            AnsiColors::$color => concat!("\x1b[", stringify!($fg), "m"),
                        )*
                    };

                    write!(f, "{}", color)
                }

                fn fmt_ansi_bg(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                    let color = match self {
                        $(
                            AnsiColors::$color => concat!("\x1b[", stringify!($bg), "m"),
                        )*
                    };

                    write!(f, "{}", color)
                }

                fn fmt_raw_ansi_fg(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                    let color = match self {
                        $(
                            AnsiColors::$color => stringify!($fg),
                        )*
                    };

                    f.write_str(color)
                }

                fn fmt_raw_ansi_bg(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                    let color = match self {
                        $(
                            AnsiColors::$color => stringify!($bg),
                        )*
                    };

                    f.write_str(color)
                }

                #[doc(hidden)]
                fn get_dyncolors_fg(&self) -> crate::DynColors {
                    crate::DynColors::Ansi(*self)
                }

                #[doc(hidden)]
                fn get_dyncolors_bg(&self) -> crate::DynColors {
                    crate::DynColors::Ansi(*self)
                }
            }
        }

        $(
            /// A color for use with [`OwoColorize`](crate::OwoColorize)'s `fg` and `bg` methods.
            pub struct $color;

            impl crate::Color for $color {
                const ANSI_FG: &'static str = concat!("\x1b[", stringify!($fg), "m");
                const ANSI_BG: &'static str = concat!("\x1b[", stringify!($bg), "m");

                const RAW_ANSI_FG: &'static str = stringify!($fg);
                const RAW_ANSI_BG: &'static str = stringify!($bg);

                #[doc(hidden)]
                type DynEquivelant = ansi_colors::AnsiColors;

                #[doc(hidden)]
                const DYN_EQUIVELANT: Self::DynEquivelant = ansi_colors::AnsiColors::$color;

                #[doc(hidden)]
                fn into_dyncolors() -> crate::DynColors {
                    crate::DynColors::Ansi(ansi_colors::AnsiColors::$color)
                }
            }
        )*

    };
}

colors! {
    Black   30 40,
    Red     31 41,
    Green   32 42,
    Yellow  33 43,
    Blue    34 44,
    Magenta 35 45,
    Cyan    36 46,
    White   37 47,
    Default   39 49,

    BrightBlack   90 100,
    BrightRed     91 101,
    BrightGreen   92 102,
    BrightYellow  93 103,
    BrightBlue    94 104,
    BrightMagenta 95 105,
    BrightCyan    96 106,
    BrightWhite   97 107,
}

macro_rules! impl_fmt_for {
    ($($trait:path),* $(,)?) => {
        $(
            impl<'a, Color: crate::Color, T: $trait> $trait for FgColorDisplay<'a, Color, T> {
                #[inline(always)]
                fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                    f.write_str(Color::ANSI_FG)?;
                    <T as $trait>::fmt(&self.0, f)?;
                    f.write_str("\x1b[39m")
                }
            }

            impl<'a, Color: crate::Color, T: $trait> $trait for BgColorDisplay<'a, Color, T> {
                #[inline(always)]
                fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                    f.write_str(Color::ANSI_BG)?;
                    <T as $trait>::fmt(&self.0, f)?;
                    f.write_str("\x1b[49m")
                }
            }
        )*
    };
}

impl_fmt_for! {
    fmt::Display,
    fmt::Debug,
    fmt::UpperHex,
    fmt::LowerHex,
    fmt::Binary,
    fmt::UpperExp,
    fmt::LowerExp,
    fmt::Octal,
    fmt::Pointer,
}

macro_rules! impl_fmt_for_dyn {
    ($($trait:path),* $(,)?) => {
        $(
            impl<'a, Color: crate::DynColor, T: $trait> $trait for FgDynColorDisplay<'a, Color, T> {
                #[inline(always)]
                fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                    (self.1).fmt_ansi_fg(f)?;
                    <T as $trait>::fmt(&self.0, f)?;
                    f.write_str("\x1b[39m")
                }
            }

            impl<'a, Color: crate::DynColor, T: $trait> $trait for BgDynColorDisplay<'a, Color, T> {
                #[inline(always)]
                fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                    (self.1).fmt_ansi_bg(f)?;
                    <T as $trait>::fmt(&self.0, f)?;
                    f.write_str("\x1b[49m")
                }
            }
        )*
    };
}

impl_fmt_for_dyn! {
    fmt::Display,
    fmt::Debug,
    fmt::UpperHex,
    fmt::LowerHex,
    fmt::Binary,
    fmt::UpperExp,
    fmt::LowerExp,
    fmt::Octal,
    fmt::Pointer,
}

/// CSS named colors. Not as widely supported as standard ANSI as it relies on 48bit color support.
///
/// Reference: <https://www.w3schools.com/cssref/css_colors.asp>
/// Reference: <https://developer.mozilla.org/en-US/docs/Web/CSS/color_value>
pub mod css;
/// XTerm 256-bit colors. Not as widely supported as standard ANSI but contains 240 more colors.
pub mod xterm;

mod custom;

pub use custom::CustomColor;

pub(crate) mod dynamic;