hypen_tailwind_parse/
parser.rs

1//! Main parser for Tailwind classes
2
3use serde::{Deserialize, Serialize};
4use std::collections::HashMap;
5
6use crate::backgrounds;
7use crate::borders;
8use crate::colors;
9use crate::effects;
10use crate::interactivity;
11use crate::layout;
12use crate::misc;
13use crate::sizing;
14use crate::spacing;
15use crate::tables;
16use crate::transforms;
17use crate::typography;
18
19/// Represents a parsed CSS property
20#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
21pub struct CssProperty {
22    pub property: String,
23    pub value: String,
24}
25
26impl CssProperty {
27    pub fn new(property: &str, value: &str) -> Self {
28        Self {
29            property: property.to_string(),
30            value: value.to_string(),
31        }
32    }
33}
34
35/// Variant type for responsive/state/dark mode
36#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
37pub enum Variant {
38    /// No variant (default)
39    None,
40    /// Responsive breakpoint: sm, md, lg, xl, 2xl
41    Responsive(String),
42    /// State: hover, focus, active, disabled
43    State(String),
44    /// Dark mode
45    Dark,
46    /// Combined variants like "md:hover:"
47    Combined(Vec<Variant>),
48}
49
50impl Variant {
51    pub fn is_none(&self) -> bool {
52        matches!(self, Variant::None)
53    }
54}
55
56/// Output from parsing Tailwind classes
57#[derive(Debug, Clone, Default, Serialize, Deserialize)]
58pub struct TailwindOutput {
59    /// Properties with no variant (default styles)
60    pub base: Vec<CssProperty>,
61    /// Properties grouped by variant
62    pub variants: HashMap<String, Vec<CssProperty>>,
63}
64
65impl TailwindOutput {
66    pub fn new() -> Self {
67        Self::default()
68    }
69
70    pub fn add(&mut self, variant: Variant, property: CssProperty) {
71        match variant {
72            Variant::None => self.base.push(property),
73            Variant::Responsive(bp) => {
74                self.variants
75                    .entry(format!("@{}", bp))
76                    .or_default()
77                    .push(property);
78            }
79            Variant::State(state) => {
80                self.variants
81                    .entry(format!(":{}", state))
82                    .or_default()
83                    .push(property);
84            }
85            Variant::Dark => {
86                self.variants
87                    .entry("dark".to_string())
88                    .or_default()
89                    .push(property);
90            }
91            Variant::Combined(variants) => {
92                // For combined variants, create a compound key
93                let key = variants
94                    .iter()
95                    .map(|v| match v {
96                        Variant::Responsive(bp) => format!("@{}", bp),
97                        Variant::State(state) => format!(":{}", state),
98                        Variant::Dark => "dark".to_string(),
99                        _ => String::new(),
100                    })
101                    .collect::<Vec<_>>()
102                    .join("");
103                self.variants.entry(key).or_default().push(property);
104            }
105        }
106    }
107
108    /// Convert to a flat map for engine props
109    /// Format: { "padding": "1rem", "padding@md": "2rem", "backgroundColor:hover": "#fff" }
110    pub fn to_props(&self) -> HashMap<String, String> {
111        let mut props = HashMap::new();
112
113        for prop in &self.base {
114            props.insert(prop.property.clone(), prop.value.clone());
115        }
116
117        for (variant, properties) in &self.variants {
118            for prop in properties {
119                let key = format!("{}{}", prop.property, variant);
120                props.insert(key, prop.value.clone());
121            }
122        }
123
124        props
125    }
126}
127
128/// Parse a string of space-separated Tailwind classes
129pub fn parse_classes(input: &str) -> TailwindOutput {
130    let mut output = TailwindOutput::new();
131
132    for class in input.split_whitespace() {
133        if let Some((variant, properties)) = parse_class(class) {
134            for prop in properties {
135                output.add(variant.clone(), prop);
136            }
137        }
138    }
139
140    output
141}
142
143/// Parse a single Tailwind class
144/// Returns the variant and list of CSS properties
145pub fn parse_class(class: &str) -> Option<(Variant, Vec<CssProperty>)> {
146    // Extract variant prefix(es): "md:hover:bg-blue-500" -> (Combined[Responsive(md), State(hover)], "bg-blue-500")
147    let (variant, utility) = extract_variant(class);
148
149    // Parse the utility class
150    let properties = parse_utility(utility)?;
151
152    Some((variant, properties))
153}
154
155/// Extract variant prefix from class
156fn extract_variant(class: &str) -> (Variant, &str) {
157    let parts: Vec<&str> = class.split(':').collect();
158
159    if parts.len() == 1 {
160        return (Variant::None, class);
161    }
162
163    let utility = parts.last().unwrap();
164    let variant_parts = &parts[..parts.len() - 1];
165
166    if variant_parts.len() == 1 {
167        let v = parse_variant_name(variant_parts[0]);
168        (v, utility)
169    } else {
170        let variants: Vec<Variant> = variant_parts
171            .iter()
172            .map(|p| parse_variant_name(p))
173            .filter(|v| !v.is_none())
174            .collect();
175
176        if variants.is_empty() {
177            (Variant::None, utility)
178        } else if variants.len() == 1 {
179            (variants.into_iter().next().unwrap(), utility)
180        } else {
181            (Variant::Combined(variants), utility)
182        }
183    }
184}
185
186fn parse_variant_name(name: &str) -> Variant {
187    match name {
188        // Responsive
189        "sm" => Variant::Responsive("sm".to_string()),
190        "md" => Variant::Responsive("md".to_string()),
191        "lg" => Variant::Responsive("lg".to_string()),
192        "xl" => Variant::Responsive("xl".to_string()),
193        "2xl" => Variant::Responsive("2xl".to_string()),
194        // State
195        "hover" => Variant::State("hover".to_string()),
196        "focus" => Variant::State("focus".to_string()),
197        "active" => Variant::State("active".to_string()),
198        "disabled" => Variant::State("disabled".to_string()),
199        "visited" => Variant::State("visited".to_string()),
200        "first" => Variant::State("first-child".to_string()),
201        "last" => Variant::State("last-child".to_string()),
202        "odd" => Variant::State("nth-child(odd)".to_string()),
203        "even" => Variant::State("nth-child(even)".to_string()),
204        // Dark mode
205        "dark" => Variant::Dark,
206        _ => Variant::None,
207    }
208}
209
210/// Parse a utility class (without variant prefix) into CSS properties
211fn parse_utility(utility: &str) -> Option<Vec<CssProperty>> {
212    // Try each parser in order
213    None.or_else(|| spacing::parse(utility))
214        .or_else(|| sizing::parse(utility))
215        .or_else(|| colors::parse(utility))
216        .or_else(|| typography::parse(utility))
217        .or_else(|| layout::parse(utility))
218        .or_else(|| borders::parse(utility))
219        .or_else(|| effects::parse(utility))
220        .or_else(|| transforms::parse(utility))
221        .or_else(|| backgrounds::parse(utility))
222        .or_else(|| tables::parse(utility))
223        .or_else(|| interactivity::parse(utility))
224        .or_else(|| misc::parse(utility))
225}
226
227#[cfg(test)]
228mod tests {
229    use super::*;
230
231    #[test]
232    fn test_parse_simple_class() {
233        let output = parse_classes("p-4");
234        assert_eq!(output.base.len(), 1);
235        assert_eq!(output.base[0].property, "padding");
236        assert_eq!(output.base[0].value, "1rem");
237    }
238
239    #[test]
240    fn test_parse_with_variant() {
241        let output = parse_classes("md:p-4");
242        assert!(output.base.is_empty());
243        assert!(output.variants.contains_key("@md"));
244        let md_props = output.variants.get("@md").unwrap();
245        assert_eq!(md_props[0].property, "padding");
246    }
247
248    #[test]
249    fn test_parse_multiple_classes() {
250        let output = parse_classes("p-4 m-2 text-blue-500");
251        assert_eq!(output.base.len(), 3);
252    }
253
254    #[test]
255    fn test_parse_hover_variant() {
256        let output = parse_classes("hover:bg-white");
257        assert!(output.variants.contains_key(":hover"));
258    }
259
260    #[test]
261    fn test_to_props() {
262        let output = parse_classes("p-4 md:p-8");
263        let props = output.to_props();
264        assert_eq!(props.get("padding"), Some(&"1rem".to_string()));
265        assert_eq!(props.get("padding@md"), Some(&"2rem".to_string()));
266    }
267}
hypen_tailwind_parse/parser.rs

hypen_tailwind_parse/
parser.rs
