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

//! ClassBuilder implementation
//!
//! This module contains the ClassBuilder struct and its methods.
//!
//! ## Example
//!
//! ```rust
//! use tailwind_rs_core::ClassBuilder;
//!
//! // Create type-safe Tailwind classes
//! let class_builder = ClassBuilder::new();
//! let class_set = class_builder
//!     .class("bg-blue-500")
//!     .class("text-white")
//!     .class("px-4")
//!     .class("py-2")
//!     .class("rounded-lg")
//!     .class("hover:bg-blue-600")
//!     .build();
//!
//! // Convert to CSS classes
//! let css_classes = class_set.to_css_classes();
//! // Result: "bg-blue-500 text-white px-4 py-2 rounded-lg hover:bg-blue-600"
//! ```

use crate::responsive::Breakpoint;
use super::ClassSet;

/// Builder for creating class sets
#[derive(Debug, Clone)]
pub struct ClassBuilder {
    class_set: ClassSet,
}

impl ClassBuilder {
    /// Create a new class builder
    pub fn new() -> Self {
        Self {
            class_set: ClassSet::new(),
        }
    }

    /// Add a base class
    pub fn class(mut self, class: impl Into<String>) -> Self {
        self.class_set.add_class(class);
        self
    }

    /// Add multiple base classes
    pub fn classes(mut self, classes: impl IntoIterator<Item = String>) -> Self {
        self.class_set.add_classes(classes);
        self
    }

    /// Add a responsive class
    pub fn responsive(mut self, breakpoint: Breakpoint, class: impl Into<String>) -> Self {
        self.class_set.add_responsive_class(breakpoint, class);
        self
    }

    /// Add a conditional class
    pub fn conditional(mut self, condition: impl Into<String>, class: impl Into<String>) -> Self {
        self.class_set.add_conditional_class(condition, class);
        self
    }

    /// Add a custom CSS property
    pub fn custom(mut self, property: impl Into<String>, value: impl Into<String>) -> Self {
        self.class_set.add_custom(property, value);
        self
    }

    /// Add a custom variant class (Tailwind v4.1.13 @custom-variant support)
    pub fn custom_variant(mut self, variant: impl Into<String>, class: impl Into<String>) -> Self {
        let variant = variant.into();
        let class = class.into();
        
        // Add the variant as a conditional class
        self.class_set.add_conditional_class(variant, class);
        self
    }

    /// Add an ARIA variant class
    pub fn aria(self, aria_attr: impl Into<String>, class: impl Into<String>) -> Self {
        let variant = format!("aria-{}", aria_attr.into());
        self.custom_variant(variant, class)
    }

    /// Add a data variant class
    pub fn data(self, data_attr: impl Into<String>, value: Option<String>, class: impl Into<String>) -> Self {
        let variant = if let Some(val) = value {
            format!("data-{}={}", data_attr.into(), val)
        } else {
            format!("data-{}", data_attr.into())
        };
        self.custom_variant(variant, class)
    }

    /// Add a supports variant class
    pub fn supports(self, feature: impl Into<String>, class: impl Into<String>) -> Self {
        let variant = format!("supports-{}", feature.into());
        self.custom_variant(variant, class)
    }

    /// Build the class set
    pub fn build(self) -> ClassSet {
        self.class_set
    }

    /// Build the class set and convert to CSS string
    pub fn build_string(self) -> String {
        self.class_set.to_css_classes()
    }
}

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