tailwind-rs-core 0.15.4

Core types and utilities for tailwind-rs
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

//! Flexbox Utilities Parser
//!
//! This module provides parsing logic for flexbox-related Tailwind CSS utilities,
//! including display, direction, wrapping, alignment, and justification.

use super::{UtilityParser, ParserCategory};
use crate::css_generator::types::CssProperty;

#[derive(Debug, Clone)]
pub struct FlexboxParser;

impl FlexboxParser {
    pub fn new() -> Self { Self }

    /// Parse flex display classes
    fn parse_flex_display_class(&self, class: &str) -> Option<Vec<CssProperty>> {
        match class {
            "flex" => Some(vec![CssProperty { name: "display".to_string(), value: "flex".to_string(), important: false }]),
            "inline-flex" => Some(vec![CssProperty { name: "display".to_string(), value: "inline-flex".to_string(), important: false }]),
            "flex-none" => Some(vec![CssProperty { name: "flex".to_string(), value: "none".to_string(), important: false }]),
            "flex-grow" => Some(vec![CssProperty { name: "flex-grow".to_string(), value: "1".to_string(), important: false }]),
            "flex-shrink" => Some(vec![CssProperty { name: "flex-shrink".to_string(), value: "1".to_string(), important: false }]),
            _ => None,
        }
    }

    /// Parse flex direction classes
    fn parse_flex_direction_class(&self, class: &str) -> Option<Vec<CssProperty>> {
        match class {
            "flex-row" => Some(vec![CssProperty { name: "flex-direction".to_string(), value: "row".to_string(), important: false }]),
            "flex-row-reverse" => Some(vec![CssProperty { name: "flex-direction".to_string(), value: "row-reverse".to_string(), important: false }]),
            "flex-col" => Some(vec![CssProperty { name: "flex-direction".to_string(), value: "column".to_string(), important: false }]),
            "flex-col-reverse" => Some(vec![CssProperty { name: "flex-direction".to_string(), value: "column-reverse".to_string(), important: false }]),
            _ => None,
        }
    }

    /// Parse flex wrap classes
    fn parse_flex_wrap_class(&self, class: &str) -> Option<Vec<CssProperty>> {
        match class {
            "flex-wrap" => Some(vec![CssProperty { name: "flex-wrap".to_string(), value: "wrap".to_string(), important: false }]),
            "flex-wrap-reverse" => Some(vec![CssProperty { name: "flex-wrap".to_string(), value: "wrap-reverse".to_string(), important: false }]),
            "flex-nowrap" => Some(vec![CssProperty { name: "flex-wrap".to_string(), value: "nowrap".to_string(), important: false }]),
            _ => None,
        }
    }

    /// Parse justify content classes
    fn parse_justify_content_class(&self, class: &str) -> Option<Vec<CssProperty>> {
        match class {
            "justify-start" => Some(vec![CssProperty { name: "justify-content".to_string(), value: "flex-start".to_string(), important: false }]),
            "justify-end" => Some(vec![CssProperty { name: "justify-content".to_string(), value: "flex-end".to_string(), important: false }]),
            "justify-center" => Some(vec![CssProperty { name: "justify-content".to_string(), value: "center".to_string(), important: false }]),
            "justify-between" => Some(vec![CssProperty { name: "justify-content".to_string(), value: "space-between".to_string(), important: false }]),
            "justify-around" => Some(vec![CssProperty { name: "justify-content".to_string(), value: "space-around".to_string(), important: false }]),
            "justify-evenly" => Some(vec![CssProperty { name: "justify-content".to_string(), value: "space-evenly".to_string(), important: false }]),
            _ => None,
        }
    }

    /// Parse align items classes
    fn parse_align_items_class(&self, class: &str) -> Option<Vec<CssProperty>> {
        match class {
            "items-start" => Some(vec![CssProperty { name: "align-items".to_string(), value: "flex-start".to_string(), important: false }]),
            "items-end" => Some(vec![CssProperty { name: "align-items".to_string(), value: "flex-end".to_string(), important: false }]),
            "items-center" => Some(vec![CssProperty { name: "align-items".to_string(), value: "center".to_string(), important: false }]),
            "items-baseline" => Some(vec![CssProperty { name: "align-items".to_string(), value: "baseline".to_string(), important: false }]),
            "items-stretch" => Some(vec![CssProperty { name: "align-items".to_string(), value: "stretch".to_string(), important: false }]),
            _ => None,
        }
    }

    /// Parse align self classes
    fn parse_align_self_class(&self, class: &str) -> Option<Vec<CssProperty>> {
        match class {
            "self-auto" => Some(vec![CssProperty { name: "align-self".to_string(), value: "auto".to_string(), important: false }]),
            "self-start" => Some(vec![CssProperty { name: "align-self".to_string(), value: "flex-start".to_string(), important: false }]),
            "self-end" => Some(vec![CssProperty { name: "align-self".to_string(), value: "flex-end".to_string(), important: false }]),
            "self-center" => Some(vec![CssProperty { name: "align-self".to_string(), value: "center".to_string(), important: false }]),
            "self-stretch" => Some(vec![CssProperty { name: "align-self".to_string(), value: "stretch".to_string(), important: false }]),
            "self-baseline" => Some(vec![CssProperty { name: "align-self".to_string(), value: "baseline".to_string(), important: false }]),
            _ => None,
        }
    }

    /// Parse flex grow/shrink classes
    fn parse_flex_grow_shrink_class(&self, class: &str) -> Option<Vec<CssProperty>> {
        match class {
            "flex-1" => Some(vec![
                CssProperty { name: "flex".to_string(), value: "1 1 0%".to_string(), important: false }
            ]),
            "flex-auto" => Some(vec![
                CssProperty { name: "flex".to_string(), value: "1 1 auto".to_string(), important: false }
            ]),
            "flex-initial" => Some(vec![
                CssProperty { name: "flex".to_string(), value: "0 1 auto".to_string(), important: false }
            ]),
            "flex-none" => Some(vec![
                CssProperty { name: "flex".to_string(), value: "none".to_string(), important: false }
            ]),
            _ => None,
        }
    }
}

impl UtilityParser for FlexboxParser {
    fn parse_class(&self, class: &str) -> Option<Vec<CssProperty>> {
        // Try each parser in order of specificity
        if let Some(properties) = self.parse_flex_display_class(class) {
            return Some(properties);
        }
        if let Some(properties) = self.parse_flex_direction_class(class) {
            return Some(properties);
        }
        if let Some(properties) = self.parse_flex_wrap_class(class) {
            return Some(properties);
        }
        if let Some(properties) = self.parse_justify_content_class(class) {
            return Some(properties);
        }
        if let Some(properties) = self.parse_align_items_class(class) {
            return Some(properties);
        }
        if let Some(properties) = self.parse_align_self_class(class) {
            return Some(properties);
        }
        if let Some(properties) = self.parse_flex_grow_shrink_class(class) {
            return Some(properties);
        }
        None
    }

    fn get_supported_patterns(&self) -> Vec<&'static str> {
        vec![
            "flex", "inline-flex", "flex-none",
            "flex-row", "flex-row-reverse", "flex-col", "flex-col-reverse",
            "flex-wrap", "flex-wrap-reverse", "flex-nowrap",
            "justify-*", "items-*", "self-*",
            "flex-1", "flex-auto", "flex-initial", "flex-none"
        ]
    }

    fn get_priority(&self) -> u32 { 60 }
    fn get_category(&self) -> ParserCategory { ParserCategory::Flexbox }
}

impl Default for FlexboxParser {
    fn default() -> Self { Self::new() }
}