@zenithbuild/bundler 1.3.2 → 1.3.4

package/Cargo.toml

@@ -1,65 +0,0 @@
-[package]
-name = "zenith-bundler"
-version = "0.1.0"
-edition = "2021"
-description = "Rolldown Plugin for the Zenith Framework - Zero-Cost Abstraction Bundler"
-license = "MIT"
-
-[lib]
-crate-type = ["cdylib", "rlib"]
-
-[features]
-napi = []
-
-[dependencies]
-# CSS Optimization & Pruning
-lightningcss = "1.0.0-alpha.70"
-
-# Serialization
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-
-# Zenith Compiler (local crate)
-compiler-native = { path = "../zenith-compiler/native/compiler-native", default-features = false }
-
-# Node.js FFI (for TypeScript interface)
-napi = { version = "2.16.0", features = ["async", "serde-json"] }
-napi-derive = "2.16.0"
-
-# Async runtime
-tokio = { version = "1.0", features = ["fs", "macros", "rt-multi-thread"] }
-
-# Concurrent collections for CSS buffering
-dashmap = "5.5"
-
-# ArcStr for Rolldown compatibility
-arcstr = "1.2"
-
-# Error handling
-anyhow = "1.0"
-
-# Regex for CSS class extraction
-regex = "1.10"
-
-# Rolldown from git (latest compatible version)
-# Note: Using git source because crates.io version 0.1.0 has broken oxc_resolver compat
-[dependencies.rolldown]
-git = "https://github.com/rolldown/rolldown"
-branch = "main"
-default-features = false
-
-[dependencies.rolldown_plugin]
-git = "https://github.com/rolldown/rolldown"
-branch = "main"
-default-features = false
-
-[dependencies.rolldown_common]
-git = "https://github.com/rolldown/rolldown"
-branch = "main"
-default-features = false
-
-[build-dependencies]
-napi-build = "2.1.0"
-
-[dev-dependencies]
-pretty_assertions = "1.4"

package/build.rs

@@ -1,5 +0,0 @@
-extern crate napi_build;
-
-fn main() {
-    napi_build::setup();
-}

package/src/bundler.rs

@@ -1,81 +0,0 @@
-//! Zenith Bundler Configuration
-//!
-//! Provides helper functions to create a pre-configured Rolldown bundler
-//! with Zenith's required settings (capability splitting, plugin injection, etc).
-
-use rolldown::{Bundler, BundlerBuilder, BundlerOptions, InputItem};
-use std::sync::Arc;
-
-use crate::plugin::ZenithPlugin;
-
-/// Create a configured Rolldown bundler for a Zenith project
-pub fn create_zenith_bundler(entry_point: &str, components_dir: Option<&str>) -> Bundler {
-    // 1. Initialize the Zenith Plugin
-    let mut plugin = ZenithPlugin::new(entry_point);
-    if let Some(dir) = components_dir {
-        plugin = plugin.with_components_dir(dir);
-    }
-
-    // 2. Configure Bundler Options
-    // Note: manual_chunks is currently experimental in Rolldown Rust API,
-    // we'll need to verify the exact API surface.
-    // For now, we rely on the plugin's dynamic imports to drive chunking naturally,
-    // and we can enhance this with explicit manual_chunks if the API allows.
-
-    let options = BundlerOptions {
-        input: Some(vec![InputItem {
-            name: Some("index".into()),
-            import: "virtual:zenith-entry".into(), // Start with our Hydration Controller
-        }]),
-        // Enable code splitting
-        format: Some(rolldown_common::OutputFormat::Esm),
-        // Ensure we target browser environment
-        platform: Some(rolldown_common::Platform::Browser),
-        // Capability-Based Chunking:
-        // GSAP should be handled as a separate chunk (capability: "anim").
-        // We rely on dynamic imports (import('gsap')) in the user's code to automatically split it.
-        // Explicit manual_chunks can be added here if stricter control is needed.
-        // Capability-based chunking configuration will go here once verified
-        ..Default::default()
-    };
-
-    let builder = BundlerBuilder::default()
-        .with_options(options)
-        .with_plugins(vec![Arc::new(plugin)]);
-
-    builder.build().expect("Failed to build bundler")
-}
-
-/// Create a configured Rolldown bundler for Dev Mode (Watch + HMR + InMemory)
-pub fn create_dev_bundler(
-    entry_point: &str,
-    components_dir: Option<&str>,
-    store: std::sync::Arc<crate::store::AssetStore>,
-) -> Bundler {
-    // 1. Initialize the Zenith Plugin with Store and Dev Mode
-    let mut plugin = ZenithPlugin::new(entry_point)
-        .with_store(store)
-        .with_dev_mode(true);
-
-    if let Some(dir) = components_dir {
-        plugin = plugin.with_components_dir(dir);
-    }
-
-    // 2. Configure Bundler Options (Dev Optimized)
-    let options = BundlerOptions {
-        input: Some(vec![InputItem {
-            name: Some("index".into()),
-            import: "virtual:zenith-entry".into(),
-        }]),
-        format: Some(rolldown_common::OutputFormat::Esm),
-        platform: Some(rolldown_common::Platform::Browser),
-        sourcemap: Some(rolldown_common::SourceMapType::File), // Enable sourcemaps for dev
-        ..Default::default()
-    };
-
-    let builder = BundlerBuilder::default()
-        .with_options(options)
-        .with_plugins(vec![Arc::new(plugin)]);
-
-    builder.build().expect("Failed to build dev bundler")
-}

package/src/css.rs

@@ -1,266 +0,0 @@
-//! 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

@@ -1,147 +0,0 @@
-//! 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

@@ -1,116 +0,0 @@
-//! 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(())
-    }
-}