tailwind-rs-postcss 0.15.4

PostCSS integration for Tailwind-RS Core
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

//! Types and data structures for CSS purging

use std::collections::HashSet;
use thiserror::Error;

/// Configuration for CSS purging
#[derive(Debug, Clone)]
pub struct PurgeConfig {
    pub content_paths: Vec<String>,
    pub safelist: Vec<String>,
    pub blocklist: Vec<String>,
    pub preserve_comments: bool,
    pub preserve_keyframes: bool,
    pub preserve_media_queries: bool,
}

impl Default for PurgeConfig {
    fn default() -> Self {
        Self {
            content_paths: Vec::new(),
            safelist: Vec::new(),
            blocklist: Vec::new(),
            preserve_comments: true,
            preserve_keyframes: true,
            preserve_media_queries: true,
        }
    }
}

/// Advanced purge options
#[derive(Debug, Clone)]
pub struct PurgeOptions {
    pub include_patterns: Vec<String>,
    pub exclude_patterns: Vec<String>,
    pub custom_extractors: Vec<String>,
    pub preserve_whitespace: bool,
    pub minify_output: bool,
}

impl Default for PurgeOptions {
    fn default() -> Self {
        Self {
            include_patterns: Vec::new(),
            exclude_patterns: Vec::new(),
            custom_extractors: Vec::new(),
            preserve_whitespace: false,
            minify_output: true,
        }
    }
}

/// Result of CSS purging
#[derive(Debug, Clone)]
pub struct PurgeResult {
    pub purged_css: String,
    pub used_classes: usize,
    pub removed_classes: usize,
    pub original_size: usize,
    pub purged_size: usize,
    pub size_reduction_percentage: f64,
    pub processing_time: std::time::Duration,
}

/// Purge statistics
#[derive(Debug, Clone)]
pub struct PurgeStatistics {
    pub total_purges: usize,
    pub average_size_reduction: f64,
    pub processing_time: std::time::Duration,
}

/// Content file information
#[derive(Debug, Clone)]
pub struct ContentFile {
    pub path: String,
    pub content: String,
    pub file_type: FileType,
    pub classes: HashSet<String>,
}

/// File type for content scanning
#[derive(Debug, Clone, PartialEq)]
pub enum FileType {
    Html,
    JavaScript,
    TypeScript,
    Rust,
    Vue,
    Svelte,
    Other(String),
}

/// Class extraction result
#[derive(Debug, Clone)]
pub struct ClassExtractionResult {
    pub classes: HashSet<String>,
    pub extraction_time: std::time::Duration,
}

/// Rule filtering result
#[derive(Debug, Clone)]
pub struct RuleFilterResult {
    pub filtered_css: String,
    pub rules_removed: usize,
    pub rules_kept: usize,
    pub filtering_time: std::time::Duration,
}

/// Error types for CSS purging
#[derive(Debug, Error)]
pub enum PurgeError {
    #[error("Content scanning failed: {error}")]
    ContentScanningFailed { error: String },

    #[error("Class extraction failed: {error}")]
    ClassExtractionFailed { error: String },

    #[error("Rule filtering failed: {error}")]
    RuleFilteringFailed { error: String },

    #[error("File reading failed: {path} - {error}")]
    FileReadingFailed { path: String, error: String },

    #[error("Invalid configuration: {error}")]
    InvalidConfiguration { error: String },

    #[error("Memory limit exceeded")]
    MemoryLimitExceeded,

    #[error("Processing timeout")]
    ProcessingTimeout,
}