rustyle_css/optimization/

minify.rs

//! CSS minification utilities
//!
//! Provides CSS minification and tree shaking capabilities.

use lightningcss::{
    stylesheet::{ParserOptions, PrinterOptions, StyleSheet},
    targets::Browsers,
};

/// Minify CSS using lightningcss
pub fn minify_css(css: &str) -> Result<String, String> {
    let stylesheet = StyleSheet::parse(
        css,
        ParserOptions {
            filename: "style.css".to_string(),
            ..Default::default()
        },
    )
    .map_err(|e| format!("CSS parsing error: {:?}", e))?;

    let targets = Browsers::default();
    let printer_options = PrinterOptions {
        minify: true,
        targets: targets.into(),
        ..Default::default()
    };

    let result = stylesheet
        .to_css(printer_options)
        .map_err(|e| format!("CSS generation error: {:?}", e))?;

    Ok(result.code)
}

/// Remove unused CSS rules (tree shaking)
///
/// This function analyzes CSS and removes rules that don't match any of the
/// provided used selectors. This is useful for eliminating dead CSS code.
///
/// # Arguments
/// * `css` - The CSS stylesheet to analyze
/// * `used_selectors` - A list of selectors that are actually used in the application
///
/// # Returns
/// The CSS with unused rules removed
pub fn remove_unused_css(css: &str, used_selectors: &[&str]) -> String {
    if used_selectors.is_empty() {
        // If no selectors provided, return empty (or minimal CSS)
        return String::new();
    }

    let used_set: std::collections::HashSet<&str> = used_selectors.iter().copied().collect();

    // Split CSS into rules
    let rules = split_css_into_rules(css);

    // Filter rules that match used selectors
    let used_rules: Vec<String> = rules
        .into_iter()
        .filter(|rule| {
            // Check if rule matches any used selector
            let matches = rule_matches_any_selector(rule, &used_set);
            // Also keep rules that contain common patterns
            matches || rule.contains("body") || rule.contains("html") || rule.contains("*")
        })
        .collect();

    // Always keep @rules (media queries, keyframes, etc.) as they may be needed
    let at_rules = extract_at_rules(css);

    // Combine used rules and @rules
    let mut result = used_rules.join("\n\n");
    if !at_rules.is_empty() {
        if !result.is_empty() {
            result.push_str("\n\n");
        }
        result.push_str(&at_rules.join("\n\n"));
    }

    result
}

/// Split CSS into individual rules
fn split_css_into_rules(css: &str) -> Vec<String> {
    let mut rules = Vec::new();
    let mut current_rule = String::new();
    let mut brace_depth = 0;
    let mut in_string = false;
    let mut string_char = '\0';

    for ch in css.chars() {
        match ch {
            '{' if !in_string => {
                brace_depth += 1;
                current_rule.push(ch);
            }
            '}' if !in_string => {
                current_rule.push(ch);
                brace_depth -= 1;
                if brace_depth == 0 {
                    let rule = current_rule.trim().to_string();
                    if !rule.is_empty() {
                        rules.push(rule);
                    }
                    current_rule.clear();
                }
            }
            '"' | '\'' if !in_string => {
                in_string = true;
                string_char = ch;
                current_rule.push(ch);
            }
            _ if in_string && ch == string_char => {
                in_string = false;
                current_rule.push(ch);
            }
            _ => {
                if brace_depth > 0 || !current_rule.trim().is_empty() {
                    current_rule.push(ch);
                }
            }
        }
    }

    if !current_rule.trim().is_empty() {
        rules.push(current_rule.trim().to_string());
    }

    rules
}

/// Check if a CSS rule matches any of the used selectors
fn rule_matches_any_selector(rule: &str, used_selectors: &std::collections::HashSet<&str>) -> bool {
    // Extract selectors from the rule (before the first '{')
    if let Some(selector_part) = rule.split('{').next() {
        let selector_part = selector_part.trim();

        // Split by comma to get individual selectors
        for selector in selector_part.split(',') {
            let selector = selector.trim();

            // Check if this selector matches any used selector
            for used_sel in used_selectors {
                if selector_contains(selector, used_sel) {
                    return true;
                }
            }

            // Also check for partial matches (e.g., ".button" matches ".button-primary")
            for used_sel in used_selectors {
                if selector.contains(used_sel) || used_sel.contains(selector) {
                    return true;
                }
            }
        }
    }

    false
}

/// Check if a CSS selector contains a used selector
fn selector_contains(selector: &str, used: &str) -> bool {
    // Exact match
    if selector == used {
        return true;
    }

    // Class selector matching
    if used.starts_with('.') && selector.contains(used) {
        return true;
    }

    // ID selector matching
    if used.starts_with('#') && selector.contains(used) {
        return true;
    }

    // Element selector matching
    if !used.starts_with('.') && !used.starts_with('#') {
        // Check if used element appears in selector
        if selector.split_whitespace().any(|part| part == used) {
            return true;
        }
    }

    false
}

/// Extract @rules (media queries, keyframes, etc.)
fn extract_at_rules(css: &str) -> Vec<String> {
    let mut at_rules = Vec::new();

    // Match @rules with their content (handles nested braces)
    let mut in_at_rule = false;
    let mut current_rule = String::new();
    let mut brace_depth = 0;

    for line in css.lines() {
        if line.trim().starts_with('@') && !in_at_rule {
            in_at_rule = true;
            current_rule = line.to_string();
            brace_depth = line.matches('{').count() as i32 - line.matches('}').count() as i32;
        } else if in_at_rule {
            current_rule.push('\n');
            current_rule.push_str(line);
            brace_depth += line.matches('{').count() as i32 - line.matches('}').count() as i32;

            if brace_depth == 0 {
                at_rules.push(current_rule.trim().to_string());
                current_rule.clear();
                in_at_rule = false;
            }
        }
    }

    // If we have an incomplete @rule, add it anyway
    if !current_rule.trim().is_empty() {
        at_rules.push(current_rule.trim().to_string());
    }

    at_rules
}