tailwind_rs_postcss/css_optimizer/
mod.rs1pub mod analyzer;
7pub mod rule_merger;
8pub mod property_optimizer;
9pub mod selector_optimizer;
10pub mod minifier;
11pub mod types;
12
13pub struct CSSOptimizer {
17 analyzer: analyzer::CSSAnalyzer,
18 rule_merger: rule_merger::RuleMerger,
19 property_optimizer: property_optimizer::PropertyOptimizer,
20 selector_optimizer: selector_optimizer::SelectorOptimizer,
21 minifier: minifier::CSSMinifier,
22 config: types::OptimizationConfig,
23}
24
25impl CSSOptimizer {
26 pub fn new() -> Self {
28 Self::with_config(types::OptimizationConfig::default())
29 }
30
31 pub fn with_config(config: types::OptimizationConfig) -> Self {
33 Self {
34 analyzer: analyzer::CSSAnalyzer::new(),
35 rule_merger: rule_merger::RuleMerger::new(),
36 property_optimizer: property_optimizer::PropertyOptimizer::new(),
37 selector_optimizer: selector_optimizer::SelectorOptimizer::new(),
38 minifier: minifier::CSSMinifier::new(),
39 config,
40 }
41 }
42
43 pub fn optimize(&mut self, css: &str) -> Result<types::OptimizationResult, types::OptimizationError> {
45 let start_time = std::time::Instant::now();
46 let original_size = css.len();
47
48 let analysis = self.analyzer.analyze(css)?;
50
51 let mut optimized_css = css.to_string();
53 let mut metrics = types::OptimizationMetrics::new();
54
55 if self.config.merge_rules {
56 let merge_result = self.rule_merger.merge_rules(&optimized_css)?;
57 optimized_css = merge_result.optimized_css;
58 metrics.rules_merged = merge_result.rules_merged;
59 }
60
61 if self.config.optimize_properties {
62 let property_result = self.property_optimizer.optimize_properties(&optimized_css)?;
63 optimized_css = property_result.optimized_css;
64 metrics.properties_optimized = property_result.properties_optimized;
65 metrics.duplicates_removed = property_result.duplicates_removed;
66 }
67
68 if self.config.optimize_selectors {
69 let selector_result = self.selector_optimizer.optimize_selectors(&optimized_css)?;
70 optimized_css = selector_result.optimized_css;
71 metrics.selectors_optimized = selector_result.selectors_optimized;
72 }
73
74 if self.config.minify {
75 let minified = self.minifier.minify(&optimized_css)?;
76 optimized_css = minified;
77 }
78
79 let processing_time = start_time.elapsed();
80 let final_size = optimized_css.len();
81 let size_reduction = if original_size > 0 {
82 ((original_size - final_size) as f64 / original_size as f64) * 100.0
83 } else {
84 0.0
85 };
86
87 metrics.original_size = original_size;
88 metrics.optimized_size = final_size;
89 metrics.size_reduction_percentage = size_reduction;
90 metrics.processing_time = processing_time;
91
92 Ok(types::OptimizationResult {
93 optimized_css,
94 metrics,
95 analysis,
96 })
97 }
98
99 pub fn get_statistics(&self) -> types::OptimizationStatistics {
101 types::OptimizationStatistics {
102 total_optimizations: 0, average_size_reduction: 0.0,
104 processing_time: std::time::Duration::from_secs(0),
105 }
106 }
107}
108
109pub use types::*;