rustyle_macros/

lib.rs

use lightningcss::{
    stylesheet::{ParserOptions, PrinterOptions, StyleSheet},
    targets::Browsers,
};
use proc_macro::TokenStream;
use quote::quote;
use sha2::{Digest, Sha256};
use std::path::PathBuf;
use syn::{parse_macro_input, LitStr};

fn generate_class_name(css: &str) -> String {
    let mut hasher = Sha256::new();
    hasher.update(css.as_bytes());
    let hash = hasher.finalize();
    let hash_str = format!("{:x}", hash);
    format!("rustyle-{}", &hash_str[..8])
}

fn parse_css(css: &str) -> Result<StyleSheet<'_, '_>, String> {
    StyleSheet::parse(
        css,
        ParserOptions {
            filename: "style.css".to_string(),
            ..Default::default()
        },
    )
    .map_err(|e| format!("CSS parsing error: {:?}", e))
}

/// Advanced CSS scoping using regex-based transformation
/// This properly handles all selector types and @rules
fn scope_css_advanced(css: &str, scope_class: &str) -> String {
    use regex::Regex;

    // Scope class selectors: .class -> .scope-class.class
    let class_re = Regex::new(r"\.([a-zA-Z_-][a-zA-Z0-9_-]*)").unwrap();
    let scoped = class_re.replace_all(css, |caps: &regex::Captures| {
        let class_name = &caps[1];
        // Don't double-scope if already scoped
        if class_name.starts_with("rustyle-") {
            format!(".{}", class_name)
        } else {
            format!(".{}.{}", scope_class, class_name)
        }
    });

    // Scope ID selectors: #id -> .scope-class #id (descendant)
    let id_re = Regex::new(r"#([a-zA-Z_-][a-zA-Z0-9_-]*)").unwrap();
    let scoped = id_re.replace_all(&scoped, |caps: &regex::Captures| {
        format!(".{} #{}", scope_class, &caps[1])
    });

    // Scope element selectors at the start of rules: element -> .scope-class element
    // But be careful not to scope elements in pseudo-selectors or @rules
    let element_re = Regex::new(r"^(\s*)([a-zA-Z][a-zA-Z0-9]*)(\s*\{)").unwrap();
    let scoped = element_re.replace_all(&scoped, |caps: &regex::Captures| {
        format!("{}.{} {}{}", &caps[1], scope_class, &caps[2], &caps[3])
    });

    scoped.to_string()
}

fn process_css(css: &str, scope_class: &str, should_scope: bool) -> Result<String, String> {
    // Parse CSS to validate syntax
    let stylesheet = parse_css(css)?;

    // Convert back to CSS string first
    // Minify in release mode for better performance
    let minify = cfg!(not(debug_assertions));
    let targets = Browsers::default();
    let printer_options = PrinterOptions {
        minify,
        targets: targets.into(),
        ..Default::default()
    };

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

    // Apply scoping if needed
    let final_css = if should_scope {
        scope_css_advanced(&parsed_css.code, scope_class)
    } else {
        parsed_css.code
    };

    Ok(final_css)
}

/// Main style macro for compile-time CSS processing
#[proc_macro]
pub fn style(input: TokenStream) -> TokenStream {
    let css_lit = parse_macro_input!(input as LitStr);
    let css = css_lit.value();

    // Generate class name from CSS content
    let class_name = generate_class_name(&css);

    // Process CSS with proper scoping
    let scoped_css = match process_css(&css, &class_name, true) {
        Ok(scoped) => scoped,
        Err(e) => {
            // Extract line number from error if possible
            let span = css_lit.span();
            let error_msg = format_error_with_context(&e, &css, span);
            return syn::Error::new(span, error_msg).to_compile_error().into();
        }
    };

    // Generate code that registers the style and returns the class name
    let expanded = quote! {
        {
            // Register style at compile time
            static STYLE: &str = #scoped_css;
            static CLASS: &str = #class_name;

            // Register style for SSR
            rustyle::register_style(CLASS, STYLE);

            // Inject style in CSR mode
            #[cfg(all(feature = "csr", target_arch = "wasm32"))]
            {
                rustyle::csr::inject_styles_csr(STYLE);
            }

            CLASS
        }
    };

    TokenStream::from(expanded)
}

/// Reactive style macro that supports Leptos signals in CSS values
///
/// Usage:
/// ```rust
/// let (count, _) = create_signal(cx, 0);
/// let class = style_signal! {
///     .counter {
///         font-size: #{(count() * 2 + 16)}px;
///         color: #{if count() > 10 { "red" } else { "blue" }};
///     }
/// };
/// ```
///
/// The macro parses CSS with embedded Rust expressions in `#{...}` blocks,
/// extracts signal dependencies, and generates reactive update code.
#[proc_macro]
pub fn style_signal(input: TokenStream) -> TokenStream {
    let css_lit = parse_macro_input!(input as LitStr);
    let css = css_lit.value();

    // Parse CSS to extract Rust expressions in #{...} blocks
    let (base_css_template, expressions) = extract_reactive_expressions(&css);

    // Generate class name from base CSS
    let class_name = generate_class_name(&base_css_template);

    // Process base CSS (without expressions) for scoping
    let scoped_base_css = match process_css(&base_css_template, &class_name, true) {
        Ok(css) => css,
        Err(e) => {
            return syn::Error::new(css_lit.span(), format!("Failed to process CSS: {}", e))
                .to_compile_error()
                .into();
        }
    };

    // Generate reactive style code
    if expressions.is_empty() {
        // No reactive expressions, just use regular style
        let expanded = quote! {
            {
                static CLASS: &str = #class_name;
                static BASE_CSS: &str = #scoped_base_css;

                rustyle::register_style(CLASS, BASE_CSS);

                #[cfg(all(feature = "csr", target_arch = "wasm32"))]
                {
                    rustyle::csr::inject_styles_csr(BASE_CSS);
                }

                CLASS
            }
        };
        return TokenStream::from(expanded);
    }

    // Generate code for reactive style with signal dependencies
    // The base_css_template already has placeholders from extract_reactive_expressions

    // Generate expression evaluation and replacement code
    let mut eval_and_replace_code = Vec::new();
    for (i, expr) in expressions.iter().enumerate() {
        let placeholder = format!("__RUSTYLE_EXPR_{}__", i);
        let placeholder_lit = placeholder.clone();
        let expr_code = &expr.code;

        // Create unique variable name for each expression
        let var_name = syn::Ident::new(&format!("expr_val_{}", i), proc_macro2::Span::call_site());

        eval_and_replace_code.push(quote! {
            let #var_name = format!("{}", #expr_code);
            css = css.replace(#placeholder_lit, &#var_name);
        });
    }

    // Generate the reactive style builder code
    let expanded = quote! {
        {
            use leptos::*;

            static CLASS: &str = #class_name;
            static BASE_CSS_TEMPLATE: &str = #base_css_template;

            // Build final CSS by evaluating expressions and replacing placeholders
            let mut css = BASE_CSS_TEMPLATE.to_string();
            #(#eval_and_replace_code)*

            // Register the reactive style
            #[cfg(all(feature = "csr", target_arch = "wasm32"))]
            {
                rustyle::reactive::inject_reactive_style(CLASS, &css);
            }

            // Also register for SSR
            rustyle::register_style(CLASS, &css);

            CLASS
        }
    };

    TokenStream::from(expanded)
}

/// Extract Rust expressions from CSS string
/// Returns (base_css_with_placeholders, vec_of_expressions)
fn extract_reactive_expressions(css: &str) -> (String, Vec<ReactiveExpression>) {
    use regex::Regex;

    let mut expressions = Vec::new();
    let mut base_css = css.to_string();

    // Match #{...} blocks
    let expr_re = Regex::new(r"#\{([^}]+)\}").unwrap();

    let mut offset = 0;
    for cap in expr_re.captures_iter(css) {
        let full_match = cap.get(0).unwrap();
        let expr_str = cap.get(1).unwrap().as_str();

        // Try to parse the expression as Rust code
        let expr_code = match syn::parse_str::<syn::Expr>(expr_str) {
            Ok(expr) => expr,
            Err(_) => {
                // If parsing fails, treat as string literal
                continue;
            }
        };

        let placeholder = format!("__RUSTYLE_EXPR_{}__", expressions.len());

        // Replace the #{...} with placeholder
        let start = full_match.start() - offset;
        let end = full_match.end() - offset;
        base_css.replace_range(start..end, &placeholder);
        offset += full_match.len() - placeholder.len();

        expressions.push(ReactiveExpression {
            code: expr_code,
            placeholder,
        });
    }

    (base_css, expressions)
}

/// Represents a reactive expression extracted from CSS
struct ReactiveExpression {
    code: syn::Expr,
    placeholder: String,
}

/// Style macro with CSS variables support
///
/// Usage:
/// ```rust
/// let class = style_with_vars! {
///     --primary-color: #007bff;
///     --spacing: 16px;
///     
///     .component {
///         color: var(--primary-color);
///         padding: var(--spacing);
///     }
/// };
/// ```
///
/// This macro parses CSS variables (--name: value) and regular CSS,
/// ensuring variables are properly scoped and available for use.
#[proc_macro]
pub fn style_with_vars(input: TokenStream) -> TokenStream {
    let css_lit = parse_macro_input!(input as LitStr);
    let css = css_lit.value();

    // Parse CSS to separate variables from regular CSS
    let (variables, regular_css) = parse_css_variables(&css);

    // Generate class name
    let class_name = generate_class_name(&css);

    // Build CSS with variables in :root scope for this component
    let mut full_css = String::new();
    if !variables.is_empty() {
        full_css.push_str(&format!(".{} {{\n", class_name));
        for (var_name, var_value) in &variables {
            full_css.push_str(&format!("  {}: {};\n", var_name, var_value));
        }
        full_css.push_str("}\n\n");
    }

    // Add the regular CSS (which may reference the variables)
    full_css.push_str(&regular_css);

    // Process the full CSS with scoping
    let scoped_css = match process_css(&full_css, &class_name, true) {
        Ok(css) => css,
        Err(e) => {
            return syn::Error::new(
                css_lit.span(),
                format!("Failed to process CSS with variables: {}", e),
            )
            .to_compile_error()
            .into();
        }
    };

    // Generate code that registers the style
    let expanded = quote! {
        {
            static CLASS: &str = #class_name;
            static STYLE: &str = #scoped_css;

            // Register style for SSR
            rustyle::register_style(CLASS, STYLE);

            // Inject style in CSR mode
            #[cfg(all(feature = "csr", target_arch = "wasm32"))]
            {
                rustyle::csr::inject_styles_csr(STYLE);
            }

            CLASS
        }
    };

    TokenStream::from(expanded)
}

/// Parse CSS to extract variables (--name: value) and separate from regular CSS
fn parse_css_variables(css: &str) -> (Vec<(String, String)>, String) {
    use regex::Regex;

    let mut variables = Vec::new();
    let mut regular_css = css.to_string();

    // Match CSS variable declarations: --variable-name: value;
    let var_re = Regex::new(r"--([a-zA-Z0-9_-]+)\s*:\s*([^;]+);").unwrap();

    let mut offset = 0;
    for cap in var_re.captures_iter(css) {
        let full_match = cap.get(0).unwrap();
        let var_name = format!("--{}", cap.get(1).unwrap().as_str());
        let var_value = cap.get(2).unwrap().as_str().trim().to_string();

        variables.push((var_name.clone(), var_value));

        // Remove the variable declaration from regular CSS
        // (it will be added back in the :root scope)
        let start = full_match.start() - offset;
        let end = full_match.end() - offset;
        regular_css.replace_range(start..end, "");
        offset += full_match.len();
    }

    (variables, regular_css)
}

/// Global style macro for un-scoped styles
#[proc_macro]
pub fn global_style(input: TokenStream) -> TokenStream {
    let css_lit = parse_macro_input!(input as LitStr);
    let css = css_lit.value();

    // Process CSS without scoping
    let parsed_css = match process_css(&css, "", false) {
        Ok(css) => css,
        Err(e) => {
            return syn::Error::new(css_lit.span(), format!("Failed to parse CSS: {}", e))
                .to_compile_error()
                .into();
        }
    };

    // Generate code that injects global styles
    let expanded = quote! {
        {
            static STYLE: &str = #parsed_css;

            // Register global style
            rustyle::register_global_style(STYLE);

            #[cfg(all(feature = "csr", target_arch = "wasm32"))]
            {
                rustyle::csr::inject_styles_csr(STYLE);
            }

            ()
        }
    };

    TokenStream::from(expanded)
}

/// Keyframes macro for @keyframes animations
#[proc_macro]
pub fn keyframes(input: TokenStream) -> TokenStream {
    let css_lit = parse_macro_input!(input as LitStr);
    let css = css_lit.value();

    // Process keyframes CSS (no scoping needed)
    let keyframes_css = match process_css(&css, "", false) {
        Ok(css) => css,
        Err(e) => {
            return syn::Error::new(
                css_lit.span(),
                format!("Failed to parse keyframes CSS: {}", e),
            )
            .to_compile_error()
            .into();
        }
    };

    // Generate code that registers keyframes
    let expanded = quote! {
        {
            static KEYFRAMES: &str = #keyframes_css;

            // Register keyframes
            rustyle::register_global_style(KEYFRAMES);

            #[cfg(all(feature = "csr", target_arch = "wasm32"))]
            {
                rustyle::csr::inject_styles_csr(KEYFRAMES);
            }

            ()
        }
    };

    TokenStream::from(expanded)
}

/// Container query style macro
#[proc_macro]
pub fn container_style(input: TokenStream) -> TokenStream {
    let css_lit = parse_macro_input!(input as LitStr);
    let css = css_lit.value();

    // Process container query CSS
    let container_css = match process_css(&css, "", false) {
        Ok(css) => css,
        Err(e) => {
            return syn::Error::new(
                css_lit.span(),
                format!("Failed to parse container query CSS: {}", e),
            )
            .to_compile_error()
            .into();
        }
    };

    // Generate code that registers container styles
    let expanded = quote! {
        {
            static CONTAINER_STYLE: &str = #container_css;

            // Register container style
            rustyle::register_global_style(CONTAINER_STYLE);

            #[cfg(all(feature = "csr", target_arch = "wasm32"))]
            {
                rustyle::csr::inject_styles_csr(CONTAINER_STYLE);
            }

            ()
        }
    };

    TokenStream::from(expanded)
}

/// Layer style macro for @layer
#[proc_macro]
pub fn layer_style(input: TokenStream) -> TokenStream {
    let css_lit = parse_macro_input!(input as LitStr);
    let css = css_lit.value();

    // Process layer CSS
    let layer_css = match process_css(&css, "", false) {
        Ok(css) => css,
        Err(e) => {
            return syn::Error::new(css_lit.span(), format!("Failed to parse layer CSS: {}", e))
                .to_compile_error()
                .into();
        }
    };

    // Generate code that registers layer styles
    let expanded = quote! {
        {
            static LAYER_STYLE: &str = #layer_css;

            // Register layer style
            rustyle::register_global_style(LAYER_STYLE);

            #[cfg(all(feature = "csr", target_arch = "wasm32"))]
            {
                rustyle::csr::inject_styles_csr(LAYER_STYLE);
            }

            ()
        }
    };

    TokenStream::from(expanded)
}

/// Media query style macro
#[proc_macro]
pub fn media_style(input: TokenStream) -> TokenStream {
    let css_lit = parse_macro_input!(input as LitStr);
    let css = css_lit.value();

    // Process media query CSS
    let media_css = match process_css(&css, "", false) {
        Ok(css) => css,
        Err(e) => {
            return syn::Error::new(
                css_lit.span(),
                format!("Failed to parse media query CSS: {}", e),
            )
            .to_compile_error()
            .into();
        }
    };

    // Generate code that registers media query styles
    let expanded = quote! {
        {
            static MEDIA_STYLE: &str = #media_css;

            // Register media query style
            rustyle::register_global_style(MEDIA_STYLE);

            #[cfg(all(feature = "csr", target_arch = "wasm32"))]
            {
                rustyle::csr::inject_styles_csr(MEDIA_STYLE);
            }

            ()
        }
    };

    TokenStream::from(expanded)
}

/// View transition macro
#[proc_macro]
pub fn view_transition(input: TokenStream) -> TokenStream {
    let css_lit = parse_macro_input!(input as LitStr);
    let css = css_lit.value();

    // Process view transition CSS
    let transition_css = match process_css(&css, "", false) {
        Ok(css) => css,
        Err(e) => {
            return syn::Error::new(
                css_lit.span(),
                format!("Failed to parse view transition CSS: {}", e),
            )
            .to_compile_error()
            .into();
        }
    };

    // Generate code that registers view transition
    let expanded = quote! {
        {
            static TRANSITION: &str = #transition_css;

            // Register view transition
            rustyle::register_view_transition(TRANSITION);

            #[cfg(all(feature = "csr", target_arch = "wasm32"))]
            {
                rustyle::csr::inject_styles_csr(TRANSITION);
            }

            ()
        }
    };

    TokenStream::from(expanded)
}

/// @scope rule macro
#[proc_macro]
pub fn scope_style(input: TokenStream) -> TokenStream {
    let css_lit = parse_macro_input!(input as LitStr);
    let css = css_lit.value();

    // Process scope CSS
    let scope_css = match process_css(&css, "", false) {
        Ok(css) => css,
        Err(e) => {
            return syn::Error::new(css_lit.span(), format!("Failed to parse scope CSS: {}", e))
                .to_compile_error()
                .into();
        }
    };

    // Generate code that registers scope style
    let expanded = quote! {
        {
            static SCOPE_STYLE: &str = #scope_css;

            // Register scope style
            rustyle::register_global_style(SCOPE_STYLE);

            #[cfg(all(feature = "csr", target_arch = "wasm32"))]
            {
                rustyle::csr::inject_styles_csr(SCOPE_STYLE);
            }

            ()
        }
    };

    TokenStream::from(expanded)
}

/// @starting-style macro
#[proc_macro]
pub fn starting_style(input: TokenStream) -> TokenStream {
    let css_lit = parse_macro_input!(input as LitStr);
    let css = css_lit.value();

    // Process starting style CSS
    let starting_css = match process_css(&css, "", false) {
        Ok(css) => css,
        Err(e) => {
            return syn::Error::new(
                css_lit.span(),
                format!("Failed to parse starting style CSS: {}", e),
            )
            .to_compile_error()
            .into();
        }
    };

    // Generate code that registers starting style
    let expanded = quote! {
        {
            static STARTING_STYLE: &str = #starting_css;

            // Register starting style
            rustyle::register_global_style(STARTING_STYLE);

            #[cfg(all(feature = "csr", target_arch = "wasm32"))]
            {
                rustyle::csr::inject_styles_csr(STARTING_STYLE);
            }

            ()
        }
    };

    TokenStream::from(expanded)
}

/// CSS Module macro for loading CSS files at compile time
///
/// Usage:
/// ```rust
/// let module = css_module!("styles/button.css");
/// let button_class = module.class("button");
/// ```
///
/// This macro:
/// - Reads the CSS file at compile time
/// - Generates scoped class names
/// - Creates a type-safe accessor for class names
/// - Registers the styles automatically
#[proc_macro]
pub fn css_module(input: TokenStream) -> TokenStream {
    let path_lit = parse_macro_input!(input as LitStr);
    let path_str = path_lit.value();

    // Resolve the file path
    // First try relative to CARGO_MANIFEST_DIR (works in build scripts)
    let file_path = if let Ok(manifest_dir) = std::env::var("CARGO_MANIFEST_DIR") {
        let mut path = PathBuf::from(manifest_dir);
        path.push(&path_str);
        path
    } else {
        // Fallback: try relative to current directory
        PathBuf::from(&path_str)
    };

    // Read the CSS file
    let css_content = match std::fs::read_to_string(&file_path) {
        Ok(content) => content,
        Err(e) => {
            return syn::Error::new(
                path_lit.span(),
                format!("Failed to read CSS file {}: {}. Make sure the path is relative to your Cargo.toml or use an absolute path.", path_str, e),
            )
            .to_compile_error()
            .into();
        }
    };

    // Generate module ID from file path
    let module_id = generate_class_name(&format!("{}{}", path_str, css_content));

    // Extract class names from CSS
    let class_names = extract_css_classes(&css_content);

    // Generate scoped class names
    let scoped_class_map: Vec<(String, String)> = class_names
        .iter()
        .map(|class| {
            let scoped = format!("{}-{}", module_id, class);
            (class.clone(), scoped)
        })
        .collect();

    // Scope the CSS
    let scoped_css = scope_css_with_class_map(&css_content, &module_id, &scoped_class_map);

    // Process CSS through parser
    let processed_css = match process_css(&scoped_css, &module_id, false) {
        Ok(css) => css,
        Err(e) => {
            return syn::Error::new(
                path_lit.span(),
                format!("Failed to process CSS from {}: {}", path_str, e),
            )
            .to_compile_error()
            .into();
        }
    };

    // Generate code that creates the module and registers styles
    let class_insertions: Vec<_> = scoped_class_map
        .iter()
        .map(|(orig, scoped)| {
            let orig_str = orig.clone();
            let scoped_str = scoped.clone();
            quote! {
                class_names.insert(#orig_str.to_string(), #scoped_str.to_string());
            }
        })
        .collect();

    let expanded = quote! {
        {
            use std::collections::HashMap;

            // Create class name map
            let mut class_names = HashMap::new();
            #(#class_insertions)*

            // Create CSS module
            let module = rustyle::CssModule {
                name: #path_str.to_string(),
                css: #processed_css.to_string(),
                class_names,
                module_id: #module_id.to_string(),
            };

            // Register the module
            module.register();

            // Create type-safe accessor
            rustyle::CssModuleClasses::new(module)
        }
    };

    TokenStream::from(expanded)
}

/// Extract class names from CSS content
fn extract_css_classes(css: &str) -> Vec<String> {
    use regex::Regex;

    let class_re = Regex::new(r"\.([a-zA-Z_-][a-zA-Z0-9_-]*)").unwrap();
    let mut classes = std::collections::HashSet::new();

    for cap in class_re.captures_iter(css) {
        let class_name = &cap[1];
        // Skip if already scoped
        if !class_name.starts_with("rustyle-") {
            classes.insert(class_name.to_string());
        }
    }

    classes.into_iter().collect()
}

/// Format error message with context and suggestions
fn format_error_with_context(error: &str, css: &str, _span: proc_macro2::Span) -> String {
    let mut msg = format!("❌ CSS Processing Error: {}\n", error);

    // Add code context (first few lines of CSS)
    let lines: Vec<&str> = css.lines().take(5).collect();
    if !lines.is_empty() {
        msg.push_str("\n\nCode context:\n");
        for (i, line) in lines.iter().enumerate() {
            msg.push_str(&format!("   {:4} | {}\n", i + 1, line));
        }
        if css.lines().count() > 5 {
            msg.push_str("   ...\n");
        }
    }

    // Add suggestions for common errors
    if error.contains("parse") || error.contains("syntax") {
        msg.push_str("\n💡 Common fixes:");
        msg.push_str("\n   - Check for missing semicolons (;)");
        msg.push_str("\n   - Ensure all braces { } are balanced");
        msg.push_str("\n   - Verify property names are spelled correctly");
    }

    msg.push_str("\n\nFor help, visit: https://github.com/usvx/rustyle");
    msg
}

/// Scope CSS by replacing class names with scoped versions
fn scope_css_with_class_map(css: &str, _module_id: &str, class_map: &[(String, String)]) -> String {
    use regex::Regex;

    let mut scoped = css.to_string();

    // Replace each class selector with its scoped version
    for (original, scoped_name) in class_map {
        // Match .original (word boundary to avoid partial matches)
        let pattern = format!(r"\.({})(?![a-zA-Z0-9_-])", regex::escape(original));
        if let Ok(re) = Regex::new(&pattern) {
            scoped = re
                .replace_all(&scoped, |_caps: &regex::Captures| {
                    format!(".{}", scoped_name)
                })
                .to_string();
        }
    }

    scoped
}