tailwind_rs_postcss/css_optimizer/
mod.rs

1//! CSS Optimization System
2//! 
3//! This module provides comprehensive CSS optimization functionality including
4//! rule merging, property optimization, selector optimization, and CSS minification.
5
6pub mod analyzer;
7pub mod rule_merger;
8pub mod property_optimizer;
9pub mod selector_optimizer;
10pub mod minifier;
11pub mod types;
12
13// Re-export types for convenience
14
15/// Main CSS optimizer for comprehensive CSS optimization
16pub 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    /// Create a new CSS optimizer with default configuration
27    pub fn new() -> Self {
28        Self::with_config(types::OptimizationConfig::default())
29    }
30    
31    /// Create a new CSS optimizer with custom configuration
32    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    /// Optimize CSS with comprehensive analysis and optimization
44    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        // Step 1: Analyze CSS for optimization opportunities
49        let analysis = self.analyzer.analyze(css)?;
50        
51        // Step 2: Apply optimizations based on configuration
52        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    /// Get optimization statistics
100    pub fn get_statistics(&self) -> types::OptimizationStatistics {
101        types::OptimizationStatistics {
102            total_optimizations: 0, // Will be updated during optimization
103            average_size_reduction: 0.0,
104            processing_time: std::time::Duration::from_secs(0),
105        }
106    }
107}
108
109// Re-export types for convenience
110pub use types::*;