@zenithbuild/bundler 1.3.1

package/src/css.rs

@@ -0,0 +1,266 @@
+//! CSS Buffer and Pruning Module
+//!
+//! Handles buffering CSS from .zen files and pruning unused classes
+//! using lightningcss with ZenManifest.css_classes as the allow-list.
+//!
+//! Uses AST-based pruning via lightningcss to ensure safety and correctness.
+
+use dashmap::DashMap;
+use lightningcss::rules::CssRule;
+use lightningcss::selector::Component;
+use lightningcss::stylesheet::{MinifyOptions, ParserOptions, PrinterOptions, StyleSheet};
+use lightningcss::targets::Browsers;
+use std::collections::HashSet;
+
+/// Thread-safe CSS buffer for collecting styles from .zen files
+#[derive(Debug)]
+pub struct CssBuffer {
+    /// CSS content keyed by file path
+    styles: DashMap<String, String>,
+}
+
+impl CssBuffer {
+    pub fn new() -> Self {
+        Self {
+            styles: DashMap::new(),
+        }
+    }
+
+    /// Insert CSS content for a file
+    pub fn insert(&self, file_id: String, css: String) {
+        self.styles.insert(file_id, css);
+    }
+
+    /// Get all buffered CSS
+    pub fn get_all(&self) -> Vec<String> {
+        self.styles.iter().map(|r| r.value().clone()).collect()
+    }
+
+    /// Stitch all CSS and prune unused classes
+    ///
+    /// Strategy:
+    /// 1. Parse the CSS into AST using lightningcss
+    /// 2. Walk the AST and remove rules/selectors that allow pruning
+    /// 3. Minify and print the result
+    pub fn stitch_and_prune(&self, used_classes: &[String]) -> Result<String, String> {
+        let all_css: String = self
+            .styles
+            .iter()
+            .map(|r| r.value().clone())
+            .collect::<Vec<_>>()
+            .join("\n");
+
+        if all_css.is_empty() {
+            return Ok(String::new());
+        }
+
+        // Build allow-list from used classes
+        let used_set: HashSet<&str> = used_classes.iter().map(|s| s.as_str()).collect();
+
+        // 1. Parse CSS
+        let mut stylesheet = StyleSheet::parse(&all_css, ParserOptions::default())
+            .map_err(|e| format!("CSS parse error: {:?}", e))?;
+
+        // 2. Prune AST (Recursive)
+        // Accessing rules directly requires ensuring we can iterate mutably
+        let rules_vec = &mut stylesheet.rules.0;
+        prune_rules(rules_vec, &used_set);
+
+        // 3. Minify and Print
+
+        stylesheet
+            .minify(MinifyOptions {
+                targets: Browsers::default().into(),
+                ..Default::default()
+            })
+            .map_err(|e| format!("CSS minify error: {:?}", e))?;
+
+        let result = stylesheet
+            .to_css(PrinterOptions {
+                minify: true,
+                ..Default::default()
+            })
+            .map_err(|e| format!("CSS print error: {:?}", e))?;
+
+        Ok(result.code)
+    }
+
+    /// Clear all buffered CSS
+    pub fn clear(&self) {
+        self.styles.clear();
+    }
+}
+
+impl Default for CssBuffer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// Recursively prune CSS rules
+///
+/// Returns true if rule should be kept, false if it should be removed (if single rule context)
+/// But here we operate on Vec<CssRule>, so we use retain_mut.
+fn prune_rules(rules: &mut Vec<CssRule>, used_set: &HashSet<&str>) {
+    rules.retain_mut(|rule| {
+        match rule {
+            CssRule::Style(style_rule) => {
+                // Filter selectors in this rule
+                // style_rule.selectors is SelectorList.
+
+                // We iterate and keep selectors that are "used"
+                style_rule
+                    .selectors
+                    .0
+                    .retain(|selector| is_selector_used(selector, used_set));
+
+                // Determine if we keep the rule:
+                // If NO selectors remain, the rule is empty and should be removed.
+                !style_rule.selectors.0.is_empty()
+            }
+            CssRule::Media(media_rule) => {
+                // Recursively prune rules inside @media
+                // media_rule.rules is CssRuleList (which wraps Vec<CssRule>).
+                // Access via .0
+                prune_rules(&mut media_rule.rules.0, used_set);
+
+                // Keep media rule only if it still has rules inside
+                !media_rule.rules.0.is_empty()
+            }
+            CssRule::Supports(supports_rule) => {
+                prune_rules(&mut supports_rule.rules.0, used_set);
+                !supports_rule.rules.0.is_empty()
+            }
+            // For other rules (Keyframes, FontFace, etc.), we keep them ALWAYS.
+            // We do not prune keyframes based on usage yet (harder analysis).
+            _ => true,
+        }
+    });
+}
+
+/// Determine if a selector usage deems it valid to keep.
+///
+/// POLICY: CONSERVATIVE
+/// - If selector has NO classes -> KEEP (Element, ID, *, etc.)
+/// - If selector has ANY class that is in `used_set` -> KEEP.
+/// - Only remove if ALL classes in the selector are KNOWN UNUSED.
+fn is_selector_used(selector: &lightningcss::selector::Selector, used_set: &HashSet<&str>) -> bool {
+    let mut has_classes = false;
+    let mut any_used = false;
+
+    // Iterate over components in the selector
+    // Selector iteration yields &Component
+    for component in selector.iter() {
+        if let Component::Class(ident) = component {
+            has_classes = true;
+            // ident is Atom or similar string-like. as_ref() works for AsRef<str>.
+            if used_set.contains(ident.as_ref()) {
+                any_used = true;
+            }
+        }
+    }
+
+    if !has_classes {
+        // No classes involved (e.g. "div", "#app", "*"), so keep it.
+        return true;
+    }
+
+    // Has classes. Keep ONLY if at least one class is used.
+    any_used
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_css_buffer_insert_and_get() {
+        let buffer = CssBuffer::new();
+        buffer.insert("a.zen".into(), ".foo { color: red; }".into());
+        buffer.insert("b.zen".into(), ".bar { color: blue; }".into());
+
+        let all = buffer.get_all();
+        assert_eq!(all.len(), 2);
+    }
+
+    #[test]
+    fn test_css_stitch_and_minify() {
+        let buffer = CssBuffer::new();
+        buffer.insert("a.zen".into(), ".foo { color: red; }".into());
+
+        let result = buffer.stitch_and_prune(&["foo".into()]).unwrap();
+        assert!(result.contains("color:") || result.contains("color:red"));
+    }
+
+    #[test]
+    fn test_css_pruning_removes_unused() {
+        let buffer = CssBuffer::new();
+        buffer.insert(
+            "a.zen".into(),
+            ".foo { color: red; } .bar { color: blue; } .baz { color: green; }".into(),
+        );
+
+        // Only "foo" is used, "bar" and "baz" should be pruned
+        let result = buffer.stitch_and_prune(&["foo".into()]).unwrap();
+        assert!(
+            result.contains("red"),
+            "Should keep .foo (used): {}",
+            result
+        );
+        assert!(
+            !result.contains("blue"),
+            "Should prune .bar (unused): {}",
+            result
+        );
+        assert!(
+            !result.contains("green"),
+            "Should prune .baz (unused): {}",
+            result
+        );
+    }
+
+    #[test]
+    fn test_keeps_element_selectors() {
+        let buffer = CssBuffer::new();
+        buffer.insert(
+            "a.zen".into(),
+            "body { margin: 0; } h1 { font-size: 2rem; }".into(),
+        );
+
+        // Element selectors should always be kept
+        let result = buffer.stitch_and_prune(&[]).unwrap();
+        assert!(
+            result.contains("margin") || result.contains("0"),
+            "Should keep body selector: {}",
+            result
+        );
+    }
+
+    #[test]
+    fn test_keeps_id_selectors() {
+        let buffer = CssBuffer::new();
+        buffer.insert("a.zen".into(), "#app { display: flex; }".into());
+
+        // ID selectors should always be kept
+        let result = buffer.stitch_and_prune(&[]).unwrap();
+        assert!(
+            result.contains("flex"),
+            "Should keep #app selector: {}",
+            result
+        );
+    }
+
+    #[test]
+    fn test_keeps_used_class_in_compound() {
+        let buffer = CssBuffer::new();
+        buffer.insert("a.zen".into(), ".foo.bar { color: red; }".into());
+
+        // If either class is used, keep the rule
+        let result = buffer.stitch_and_prune(&["foo".into()]).unwrap();
+        assert!(
+            result.contains("red"),
+            "Should keep .foo.bar when foo is used: {}",
+            result
+        );
+    }
+}

package/src/html.rs

@@ -0,0 +1,147 @@
+//! HTML Injector Module
+//!
+//! Injects hashed asset links into index.html:
+//! - `<script type="module" src="...">` for the Entry Chunk
+//! - `<link rel="stylesheet">` for the CSS Asset
+//! - `<link rel="modulepreload">` for critical chunks
+
+/// Asset information for HTML injection
+#[derive(Debug, Clone)]
+pub struct AssetInfo {
+    pub filename: String,
+    pub is_entry: bool,
+    pub is_css: bool,
+}
+
+/// The HTML Injector that updates index.html with hashed asset paths
+pub struct HtmlInjector {
+    /// Template HTML content
+    template: String,
+}
+
+impl HtmlInjector {
+    pub fn new(template: String) -> Self {
+        Self { template }
+    }
+
+    /// Load template from file
+    pub fn from_file(path: &str) -> Result<Self, std::io::Error> {
+        let template = std::fs::read_to_string(path)?;
+        Ok(Self::new(template))
+    }
+
+    /// Inject asset references into the HTML template
+    pub fn inject(&self, assets: &[AssetInfo], preload_chunks: &[String]) -> String {
+        let mut html = self.template.clone();
+
+        // Build injection strings
+        let mut script_tags = String::new();
+        let mut css_links = String::new();
+        let mut preload_links = String::new();
+
+        // CSS links
+        for asset in assets.iter().filter(|a| a.is_css) {
+            css_links.push_str(&format!(
+                r#"    <link rel="stylesheet" href="/{}">"#,
+                asset.filename
+            ));
+            css_links.push('\n');
+        }
+
+        // Modulepreload for critical chunks
+        for chunk in preload_chunks {
+            preload_links.push_str(&format!(
+                r#"    <link rel="modulepreload" href="/{}">"#,
+                chunk
+            ));
+            preload_links.push('\n');
+        }
+
+        // Entry script (should be last, after preloads)
+        for asset in assets.iter().filter(|a| a.is_entry && !a.is_css) {
+            script_tags.push_str(&format!(
+                r#"    <script type="module" src="/{}"></script>"#,
+                asset.filename
+            ));
+            script_tags.push('\n');
+        }
+
+        // Inject before </head>
+        let head_injection = format!("{}{}", css_links, preload_links);
+        if let Some(pos) = html.find("</head>") {
+            html.insert_str(pos, &head_injection);
+        }
+
+        // Inject scripts before </body>
+        if let Some(pos) = html.find("</body>") {
+            html.insert_str(pos, &script_tags);
+        }
+
+        html
+    }
+
+    /// Generate a minimal HTML template if none exists
+    pub fn generate_default(title: &str) -> String {
+        format!(
+            r#"<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{}</title>
+</head>
+<body>
+    <div id="app"></div>
+</body>
+</html>
+"#,
+            title
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_inject_assets() {
+        let template = r#"<!DOCTYPE html>
+<html>
+<head>
+    <title>Test</title>
+</head>
+<body>
+    <div id="app"></div>
+</body>
+</html>"#;
+
+        let injector = HtmlInjector::new(template.to_string());
+        let assets = vec![
+            AssetInfo {
+                filename: "app-x82z.js".into(),
+                is_entry: true,
+                is_css: false,
+            },
+            AssetInfo {
+                filename: "zenith-abc1.css".into(),
+                is_entry: false,
+                is_css: true,
+            },
+        ];
+        let preloads = vec!["runtime-core-def2.js".into()];
+
+        let result = injector.inject(&assets, &preloads);
+
+        assert!(result.contains(r#"<link rel="stylesheet" href="/zenith-abc1.css">"#));
+        assert!(result.contains(r#"<link rel="modulepreload" href="/runtime-core-def2.js">"#));
+        assert!(result.contains(r#"<script type="module" src="/app-x82z.js"></script>"#));
+    }
+
+    #[test]
+    fn test_generate_default_template() {
+        let html = HtmlInjector::generate_default("My App");
+        assert!(html.contains("<title>My App</title>"));
+        assert!(html.contains("<div id=\"app\"></div>"));
+    }
+}

package/src/lib.rs

@@ -0,0 +1,116 @@
+//! Zenith Bundler
+//!
+//! Rolldown Plugin for the Zenith Framework.
+//!
+//! This crate acts as the **Intelligence Layer** that feeds the Zenith compiler
+//! output to Rolldown, implementing:
+//!
+//! - **Deferred Hydration**: Bootstrap loader with dynamic imports
+//! - **Capability-Based Chunking**: Separate runtime-core and runtime-anim
+//! - **CSS Pruning**: Tree-shake unused Tailwind via ZenManifest.css_classes
+//! - **HTML Injection**: Inject hashed script/CSS links and modulepreload
+//!
+//! # Architecture
+//!
+//! ```text
+//! .zen files → ZenithPlugin (resolve_id/load) → Rolldown Engine → Optimized Output
+//! ```
+
+pub mod bundler;
+pub mod css;
+pub mod html;
+pub mod plugin;
+pub mod store;
+
+pub use css::CssBuffer;
+pub use html::HtmlInjector;
+pub use plugin::ZenithPlugin;
+
+// Re-export Rolldown types for convenience
+pub use rolldown::{Bundler, BundlerBuilder, BundlerOptions};
+pub use rolldown_plugin::Plugin;
+
+// --- NAPI Integration ---
+
+#[cfg(feature = "napi")]
+use napi_derive::napi;
+#[cfg(feature = "napi")]
+use std::sync::Arc;
+#[cfg(feature = "napi")]
+use crate::store::AssetStore;
+#[cfg(feature = "napi")]
+use tokio::sync::{mpsc, oneshot};
+
+#[cfg(feature = "napi")]
+#[napi]
+pub struct ZenithDevController {
+    store: Arc<AssetStore>,
+    rebuild_tx: mpsc::Sender<oneshot::Sender<()>>,
+}
+
+#[cfg(feature = "napi")]
+#[napi]
+impl ZenithDevController {
+    #[napi(constructor)]
+    pub fn new(project_root: String) -> Self {
+        let store = Arc::new(AssetStore::new());
+        let store_clone = store.clone();
+        
+        // Channel for rebuild signals (Robust HMR Pattern)
+        // Main thread sends (reply_channel) -> Builder builds -> Builder replies
+        let (tx, mut rx) = mpsc::channel::<oneshot::Sender<()>>(1);
+
+        // Spawn Watcher/Builder Thread
+        std::thread::spawn(move || {
+            let rt = tokio::runtime::Runtime::new().unwrap();
+            rt.block_on(async move {
+                let mut bundler = crate::bundler::create_dev_bundler(
+                    &format!("{}/src/main.zen", project_root),
+                    Some(&format!("{}/src/components", project_root)),
+                    store_clone
+                );
+                
+                // Initial Build
+                match bundler.write().await {
+                    Ok(_outputs) => {}, // println! removed
+                    Err(_e) => {}, // eprintln! removed for silence? Or keep errors? User said "all logs". I'll keep errors if critical, but silence is cleaner for "library".
+                }
+
+                // Internal Watch Loop (Driven by NAPI calls)
+                while let Some(reply_tx) = rx.recv().await {
+                    match bundler.write().await {
+                        Ok(_) => {
+                            let _ = reply_tx.send(());
+                        }
+                        Err(_e) => {
+                            let _ = reply_tx.send(()); 
+                        }
+                    }
+                }
+            });
+        });
+
+        Self { store, rebuild_tx: tx }
+    }
+
+    #[napi]
+    pub fn get_asset(&self, path: String) -> Option<String> {
+        self.store.get(&path)
+    }
+
+    /// Trigger a rebuild and wait for completion
+    #[napi]
+    pub async fn rebuild(&self) -> napi::Result<()> {
+        let (reply_tx, reply_rx) = oneshot::channel();
+        self.rebuild_tx
+            .send(reply_tx)
+            .await
+            .map_err(|_| napi::Error::from_reason("Builder thread disconnected"))?;
+            
+        reply_rx
+            .await
+            .map_err(|_| napi::Error::from_reason("Builder failed to reply"))?;
+            
+        Ok(())
+    }
+}