@ape-egg/vibe 1.3.1 → 1.6.0

package/compiler/src/config.rs

@@ -29,17 +29,21 @@ pub struct VibeCompilerConfig {
     #[serde(default)]
     pub minify: bool,
     #[serde(default)]
-    pub accessibility: bool,
+    pub elements_as_is: bool,
     #[serde(default)]
     pub validate: bool,
     #[serde(default)]
     pub source_maps: bool,
     #[serde(default)]
-    pub exclude_tags: Vec<String>,
+    pub reserved_elements: Vec<String>,
     #[serde(default)]
     pub node_modules_as_is: bool,
     #[serde(default)]
     pub components_as_is: bool,
+    #[serde(default)]
+    pub runtime_as_is: bool,
+    #[serde(default)]
+    pub iterations_as_is: bool,
 }
 
 fn default_source() -> String { "./".to_string() }
@@ -48,6 +52,35 @@ fn default_components() -> String { "components".to_string() }
 fn default_pages() -> String { "pages".to_string() }
 fn default_assets() -> String { "assets".to_string() }
 
+/// Get list of standard HTML5 elements + "component"
+/// Component names matching these are reserved and not allowed
+pub fn get_default_reserved_elements() -> Vec<String> {
+    vec![
+        "a", "abbr", "address", "area", "article", "aside", "audio",
+        "b", "base", "bdi", "bdo", "blockquote", "body", "br", "button",
+        "canvas", "caption", "cite", "code", "col", "colgroup",
+        "data", "datalist", "dd", "del", "details", "dfn", "dialog", "div", "dl", "dt",
+        "em", "embed",
+        "fieldset", "figcaption", "figure", "footer", "form",
+        "h1", "h2", "h3", "h4", "h5", "h6", "head", "header", "hgroup", "hr", "html",
+        "i", "iframe", "img", "input", "ins",
+        "kbd",
+        "label", "legend", "li", "link",
+        "main", "map", "mark", "menu", "meta", "meter",
+        "nav", "noscript",
+        "object", "ol", "optgroup", "option", "output",
+        "p", "param", "picture", "pre", "progress",
+        "q",
+        "rp", "rt", "ruby",
+        "s", "samp", "script", "search", "section", "select", "slot", "small", "source", "span", "strong", "style", "sub", "summary", "sup", "svg",
+        "table", "tbody", "td", "template", "textarea", "tfoot", "th", "thead", "time", "title", "tr", "track",
+        "u", "ul",
+        "var", "video",
+        "wbr",
+        "component", // Always reserved
+    ].into_iter().map(|s| s.to_string()).collect()
+}
+
 impl Default for VibeCompilerConfig {
     fn default() -> Self {
         Self {
@@ -58,12 +91,14 @@ impl Default for VibeCompilerConfig {
             assets: default_assets(),
             root: None,
             minify: false,
-            accessibility: false,
+            elements_as_is: false,
             validate: false,
             source_maps: false,
-            exclude_tags: vec![],
+            reserved_elements: vec![],
             node_modules_as_is: false,
             components_as_is: false,
+            runtime_as_is: false,
+            iterations_as_is: false,
         }
     }
 }
@@ -79,12 +114,14 @@ pub struct Config {
     pub _assets: String,
     pub _root: Option<String>,
     pub minify: bool,
-    pub accessibility: bool,
+    pub elements_as_is: bool,
     pub validate: bool,
     pub source_maps: bool,
-    pub exclude_tags: Vec<String>,
+    pub reserved_elements: Vec<String>,
     pub node_modules_as_is: bool,
     pub components_as_is: bool,
+    pub runtime_as_is: bool,
+    pub iterations_as_is: bool,
     pub working_dir: PathBuf,
 }
 
@@ -109,6 +146,10 @@ impl Config {
         let source = working_dir.join(&config.source);
         let output = working_dir.join(&config.output);
 
+        // Combine default reserved elements with user-provided ones
+        let mut reserved_elements = get_default_reserved_elements();
+        reserved_elements.extend(config.reserved_elements);
+
         Self {
             source,
             output,
@@ -119,12 +160,14 @@ impl Config {
             _assets: config.assets,
             _root: config.root,
             minify: config.minify,
-            accessibility: config.accessibility,
+            elements_as_is: config.elements_as_is,
             validate: config.validate,
             source_maps: config.source_maps,
-            exclude_tags: config.exclude_tags,
+            reserved_elements,
             node_modules_as_is: config.node_modules_as_is,
             components_as_is: config.components_as_is,
+            runtime_as_is: config.runtime_as_is,
+            iterations_as_is: config.iterations_as_is,
             working_dir,
         }
     }

package/compiler/src/main.rs

@@ -7,19 +7,19 @@ use colored::Colorize;
 use std::path::PathBuf;
 
 use config::Config;
-use compiler::compile::CompileError;
 use compiler::Compiler;
 
 /// Track which config values were overridden by flags
 #[derive(Debug, Default)]
 struct ConfigOverrides {
     minify: bool,
-    accessibility: bool,
+    elements_as_is: bool,
     validate: bool,
     source_maps: bool,
     node_modules_as_is: bool,
     components_as_is: bool,
     runtime_as_is: bool,
+    iterations_as_is: bool,
 }
 
 /// Vibe Compiler - Compiles Vibe source files into optimized output
@@ -45,9 +45,9 @@ struct Args {
     #[arg(long)]
     verbose: bool,
 
-    /// Transform custom HTML elements to divs with classes for accessibility
-    #[arg(long)]
-    accessibility: bool,
+    /// Keep custom HTML elements as-is (don't transform to divs for accessibility)
+    #[arg(long, name = "elements-as-is")]
+    elements_as_is: bool,
 
     /// Generate source maps
     #[arg(long, name = "source-maps")]
@@ -80,6 +80,10 @@ struct Args {
     /// Skip manifest generation - output will use runtime-only mode (no FOUC prevention)
     #[arg(long, name = "runtime-as-is")]
     runtime_as_is: bool,
+
+    /// Skip iteration optimization - use runtime DOM cloning instead of compiled batch functions
+    #[arg(long, name = "iterations-as-is")]
+    iterations_as_is: bool,
 }
 
 fn main() {
@@ -114,11 +118,13 @@ fn main() {
 
     // Store original config values before applying flag overrides
     let original_minify = config.minify;
-    let original_accessibility = config.accessibility;
+    let original_elements_as_is = config.elements_as_is;
     let original_validate = config.validate;
     let original_source_maps = config.source_maps;
     let original_node_modules_as_is = config.node_modules_as_is;
     let original_components_as_is = config.components_as_is;
+    let original_runtime_as_is = config.runtime_as_is;
+    let original_iterations_as_is = config.iterations_as_is;
 
     // Track overrides for verbose output
     let mut overrides = ConfigOverrides::default();
@@ -127,9 +133,9 @@ fn main() {
         overrides.minify = !original_minify;
         config.minify = true;
     }
-    if args.accessibility {
-        overrides.accessibility = !original_accessibility;
-        config.accessibility = true;
+    if args.elements_as_is {
+        overrides.elements_as_is = !original_elements_as_is;
+        config.elements_as_is = true;
     }
     if args.validate {
         overrides.validate = !original_validate;
@@ -147,6 +153,14 @@ fn main() {
         overrides.components_as_is = !original_components_as_is;
         config.components_as_is = true;
     }
+    if args.runtime_as_is {
+        overrides.runtime_as_is = !original_runtime_as_is;
+        config.runtime_as_is = true;
+    }
+    if args.iterations_as_is {
+        overrides.iterations_as_is = !original_iterations_as_is;
+        config.iterations_as_is = true;
+    }
 
     if args.verbose {
         println!("{}", "Vibe Compiler".cyan().bold());
@@ -178,31 +192,43 @@ fn main() {
         }
 
         // Alphabetically ordered with padding (longest key is "node-modules-as-is" = 18 chars)
-        println!("  {}: {}", format!("{:<18}", "accessibility").cyan(), format_bool_with_flag(config.accessibility, overrides.accessibility, original_accessibility));
         println!("  {}: {}", format!("{:<18}", "assets").cyan(), format_value_no_flag(&config._assets));
         println!("  {}: {}", format!("{:<18}", "components").cyan(), format_value_no_flag(&config.components));
         println!("  {}: {}", format!("{:<18}", "components-as-is").cyan(), format_bool_with_flag(config.components_as_is, overrides.components_as_is, original_components_as_is));
-        println!("  {}: {}", format!("{:<18}", "exclude-tags").cyan(), format_value_no_flag(format!("{:?}", config.exclude_tags)));
+        println!("  {}: {}", format!("{:<18}", "elements-as-is").cyan(), format_bool_with_flag(config.elements_as_is, overrides.elements_as_is, original_elements_as_is));
+        println!("  {}: {}", format!("{:<18}", "exclude-tags").cyan(), format_value_no_flag(format!("{:?}", config.reserved_elements)));
         println!("  {}: {}", format!("{:<18}", "minify").cyan(), format_bool_with_flag(config.minify, overrides.minify, original_minify));
         println!("  {}: {}", format!("{:<18}", "node-modules-as-is").cyan(), format_bool_with_flag(config.node_modules_as_is, overrides.node_modules_as_is, original_node_modules_as_is));
         println!("  {}: {}", format!("{:<18}", "output").cyan(), format_value_no_flag(&config._output_str));
         println!("  {}: {}", format!("{:<18}", "pages").cyan(), format_value_no_flag(&config.pages));
         println!("  {}: {}", format!("{:<18}", "root").cyan(), format_value_no_flag(config._root.as_ref().map(|s| s.as_str()).unwrap_or("null")));
-        println!("  {}: {}", format!("{:<18}", "runtime-as-is").cyan(), if overrides.runtime_as_is { "true (flag)".green().to_string() } else { "false".to_string() });
+        println!("  {}: {}", format!("{:<18}", "runtime-as-is").cyan(), format_bool_with_flag(config.runtime_as_is, overrides.runtime_as_is, original_runtime_as_is));
         println!("  {}: {}", format!("{:<18}", "source").cyan(), format_value_no_flag(&config._source_str));
         println!("  {}: {}", format!("{:<18}", "source-maps").cyan(), format_bool_with_flag(config.source_maps, overrides.source_maps, original_source_maps));
         println!("  {}: {}", format!("{:<18}", "validate").cyan(), format_bool_with_flag(config.validate, overrides.validate, original_validate));
         println!();
     }
 
+    // Handle watch mode
+    if args.watch {
+        if let Err(e) = compiler::watcher::watch(config, args.verbose) {
+            eprintln!("{}: {}", "Error".red(), e);
+            std::process::exit(1);
+        }
+        return;
+    }
+
+    // Save runtime_as_is before moving config
+    let runtime_as_is = config.runtime_as_is;
+
     let mut compiler = Compiler::new(config, args.verbose);
 
     match compiler.compile() {
         Ok(stats) => {
-            // Generate manifests BEFORE showing success (unless --runtime-as-is flag is passed)
+            // Generate manifests BEFORE showing success (unless runtime-as-is is enabled)
             let mut manifest_time_ms = 0.0;
             let mut manifest_stats_result = None;
-            if !args.runtime_as_is {
+            if !runtime_as_is {
                 match compiler.generate_manifests() {
                     Ok(manifest_stats) => {
                         manifest_time_ms = manifest_stats.total_time_ms;
@@ -289,20 +315,7 @@ fn main() {
             std::process::exit(0);
         }
         Err(e) => {
-            match e {
-                CompileError::ComponentValidationFailed(errors) => {
-                    eprintln!("\n{}: Component validation failed\n", "Error".red());
-                    for err in errors {
-                        eprintln!("  {} {}", "✗".red(), err.component_src);
-                        eprintln!("    Referenced in: {}", err.referenced_in);
-                        eprintln!("    Error: {}\n", err.error_message);
-                    }
-                    eprintln!("Fix the errors above and try again.");
-                }
-                _ => {
-                    eprintln!("{}: {}", "Error".red(), e);
-                }
-            }
+            eprintln!("{}: {}", "Error".red(), e);
             std::process::exit(1);
         }
     }