dwind_build/
colors.rs

1use serde::{Deserialize, Serialize};
2use std::collections::HashMap;
3use std::fs;
4use std::io::Write;
5use std::path::Path;
6
7#[derive(Serialize, Deserialize)]
8pub struct Color {
9    pub name: String,
10    pub shades: HashMap<u32, String>,
11}
12
13#[derive(Serialize, Deserialize)]
14pub struct ColorFile {
15    pub colors: Vec<Color>,
16}
17
18pub fn render_color_json_file_to_rust_file(
19    color_file_path: impl AsRef<Path>,
20    colors_out_file: impl AsRef<Path>,
21) {
22    // Generate the colors file
23    let color_file = fs::read_to_string(color_file_path).unwrap();
24    let colors: ColorFile = serde_json::from_str(&color_file).unwrap();
25
26    let mut colors_out_file = fs::File::create(colors_out_file).unwrap();
27
28    for color in colors.colors.iter() {
29        let _ = colors_out_file
30            .write(render_color(color, "bg", "bg-color-").as_bytes())
31            .unwrap();
32        let _ = colors_out_file
33            .write(render_color(color, "text", "text-color-").as_bytes())
34            .unwrap();
35        let _ = colors_out_file
36            .write(render_color(color, "border", "border-color-").as_bytes())
37            .unwrap();
38
39        let _ = colors_out_file
40            .write(render_color(color, "gradient-from", "gradient-from-").as_bytes())
41            .unwrap();
42        let _ = colors_out_file
43            .write(render_color(color, "gradient-to", "gradient-to-").as_bytes())
44            .unwrap();
45
46        let _ = colors_out_file
47            .write(render_color(color, "fill", "fill-").as_bytes())
48            .unwrap();
49
50        let _ = colors_out_file
51            .write(render_color(color, "stroke", "stroke-").as_bytes())
52            .unwrap();
53    }
54
55    let _ = colors_out_file
56        .write(render_dwind_colors(&colors).as_bytes())
57        .unwrap();
58}
59
60// render a once cell with a hash map of all the colors
61fn render_dwind_colors(colors: &ColorFile) -> String {
62    let colors = colors
63        .colors
64        .iter()
65        .map(|color| {
66            let shades = color
67                .shades
68                .iter()
69                .map(|(shade, value)| format!("({shade}, \"{value}\".to_string())"))
70                .collect::<Vec<_>>()
71                .join(", ");
72
73            format!(
74                "(\"{}\".to_string(), std::collections::BTreeMap::from([{shades}]))",
75                color.name
76            )
77        })
78        .collect::<Vec<_>>()
79        .join(",\n");
80
81    format!(
82        r#"pub static DWIND_COLORS: once_cell::sync::Lazy<std::collections::BTreeMap<String, std::collections::BTreeMap<u32, String>>> = once_cell::sync::Lazy::new(|| {{
83    std::collections::BTreeMap::from([
84    {colors}
85])
86}});"#
87    )
88}
89
90fn render_color(color: &Color, prefix: &str, generator: &str) -> String {
91    let shades = color
92        .shades
93        .iter()
94        .map(|(intensity, value)| format!("    (\"{}-{intensity}\", \"{value}\")", color.name))
95        .collect::<Vec<String>>()
96        .join(",\n");
97
98    format!(
99        r#"dwgenerate_map!("{prefix}", "{generator}", [
100{shades}
101]);"#,
102    )
103}