npm - @ape-egg/vibe - Versions diffs - 1.2.0 → 1.3.1 - Mend

@ape-egg/vibe 1.2.0 → 1.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (28) hide show

package/CHANGELOG.md +72 -0
package/README.md +1 -1
package/compiler/native/vibe-compiler-darwin-arm64 +0 -0
package/compiler/src/compiler/compile.rs +204 -51
package/compiler/src/compiler/manifest_builder.rs +432 -0
package/compiler/src/compiler/mod.rs +3 -0
package/compiler/src/compiler/state_extractor.rs +148 -0
package/compiler/src/compiler/value_stamper.rs +222 -0
package/compiler/src/config.rs +0 -5
package/compiler/src/main.rs +45 -20
package/compiler/src/parser/html.rs +22 -8
package/component.js +59 -0
package/index.js +30 -86
package/package.json +3 -1
package/runtime/affected.js +12 -6
package/runtime/cleanup.js +45 -24
package/runtime/component-state.js +1 -1
package/runtime/component.js +20 -13
package/runtime/constants.js +41 -10
package/runtime/debug.js +1 -0
package/runtime/hydrate.js +6 -1
package/runtime/hyperspeed.js +425 -0
package/runtime/index.js +236 -49
package/runtime/iterate.js +3 -0
package/runtime/parse.js +21 -29
package/runtime/scope.js +5 -25
package/runtime/utils.js +4 -13
package/vibe.css +4 -2

package/CHANGELOG.md CHANGED Viewed

@@ -1,5 +1,77 @@
 # Changelog
+## [1.3.1] - 2025-02-06
+### Fixed
+- **Package exports**: Added missing `./component` export to package.json
+  - Enables proper import: `import component from '@ape-egg/vibe/component'`
+  - Previously `component.js` was included in package files but not exposed via exports field
+---
+## [1.3.0] - 2025-02-06
+### Added
+- **Static Analysis Compiler**: Replaced browser-based manifest generation with pure Rust static analysis
+  - New compiler modules: `state_extractor.rs`, `manifest_builder.rs`, `value_stamper.rs`
+  - ~3000x performance improvement (10-100 seconds → ~6ms for manifest generation)
+  - Pre-rendering support for iterations with initial state values
+  - Graceful handling of unparseable state (skips files instead of failing entire compilation)
+- **Enhanced vibe() and component() API**:
+  - Added `config` parameter (second argument) for runtime configuration
+  - Added `targetSelector` parameter (third argument) for custom root element selection
+  - Multiple calls accumulate state, config/targetSelector use "first wins" strategy
+  - Example: `vibe({ count: 0 }, { debug: true }, 'body')`
+- **Expanded Compilation Scope**: Compiler now processes all HTML files recursively
+  - Compiles all `<source-root>/**/*.html` (excluding `components/` directory)
+  - Generates manifests for all `<output-dir>/**/*.html` (excluding `components/`)
+  - Previously limited to `<source-root>/pages/` only
+### Changed
+- **Iteration Restoration**: Improved DOM restoration algorithm
+  - Uses TreeWalker to find iteration comment pairs (more robust)
+  - Avoids index-based lookup that breaks after DOM structure changes
+  - Runtime now fully controls iteration nodes (skipped during manifest merge)
+- **Compiler Output**: Enhanced user experience with better formatting
+  - Manifest generation occurs before "Compilation successful!" message
+  - Verbose mode (`--verbose`) shows only warnings/errors for manifest generation
+  - Clean title: "Generating manifests (static analysis)"
+  - Summary format: `Generated manifests (X files, Y skipped) in Zms`
+  - Positioned between "Compiled HTML" and "Copied files" in output
+- **Debug Logging**: Refined hyperspeed detection messages
+  - Removed redundant path-specific log
+  - Changed to: "Detected vibe-hyperspeed. Applying pre-compiled manifest."
+### Removed
+- **Browser Automation Dependencies**: Eliminated heavy runtime dependencies
+  - Removed: chromiumoxide, tiny_http, tokio, futures
+  - Deleted 414 lines of browser automation code (`manifest.rs`)
+  - Pure Rust implementation with no external processes or async complexity
+### Fixed
+- Manifest merge conflicts between hyperspeed (pre-compiled) and runtime trees
+- Index shifting bugs during restoration phase that caused key mismatches
+- Iteration rendering producing duplicate items (3x3 instead of 3)
+- Pre-rendered iteration content not being properly replaced with reactive templates
+### Performance
+- Manifest generation: 10-100 seconds → ~6ms (~3000x faster)
+- Total compilation time: Typically completes in 200-300ms for medium projects
+- Zero browser startup overhead
+- Reduced memory footprint (no Chromium instance)
+---
 ## [1.2.0] - 2026-02-03
 ### Added

package/README.md CHANGED Viewed

@@ -26,7 +26,7 @@ The core reactive runtime. Works directly in the browser without any build tools
       window.$ = state({ name: 'World', count: 0 });
     </script>
   </head>
-  <body vibe>
+  <body vibe-fouc>
     <h1>Hello, @[name]!</h1>
     <button onclick="$.count++">Clicked @[count] times</button>
   </body>

package/compiler/native/vibe-compiler-darwin-arm64 CHANGED Viewed

Binary file

package/compiler/src/compiler/compile.rs CHANGED Viewed

@@ -100,6 +100,12 @@ pub struct CompileStats {
     pub components_as_is: bool,
 }
+pub struct ManifestStats {
+    pub pages_processed: usize,
+    pub pages_skipped: usize,
+    pub total_time_ms: f64,
+}
 #[derive(Debug, Clone, PartialEq)]
 enum FileOperation {
     Compiled,
@@ -420,7 +426,13 @@ impl Compiler {
         // Track compile and copy times separately
         let compile_start = Instant::now();
-        self.process_directory(&self.config.source.clone(), &parser, "", &mut stats)?;
+        // Process all HTML files in source (excluding components directory)
+        self.process_directory_html_only(&self.config.source.clone(), &parser, "", &mut stats)?;
+        // Process source directory for assets (CSS, JS, images, etc.)
+        self.process_directory_assets_only(&self.config.source.clone(), "", &mut stats)?;
         let process_time = compile_start.elapsed();
         // Print verbose output after processing (components first, then HTML, then copied)
@@ -493,8 +505,112 @@ impl Compiler {
         Ok(stats)
     }
-    /// Recursively walk source, compile HTML, copy CSS/JS (MIRROR_MODE)
-    fn process_directory(
+    /// Generate manifest for a single file
+    fn generate_file_manifest(
+        html: &str,
+        html_path: &Path,
+        output_dir: &Path,
+        relative_path: &str,
+        _verbose: bool,
+    ) -> Result<(), String> {
+        use crate::compiler::state_extractor::StateExtractor;
+        use crate::compiler::manifest_builder::ManifestBuilder;
+        use crate::compiler::value_stamper::ValueStamper;
+        // Extract state
+        let state = StateExtractor::extract_from_html(html)?;
+        // Build manifest
+        let manifest_builder = ManifestBuilder::new();
+        let manifest = manifest_builder.build_from_html(html, &state)?;
+        // Stamp values (pre-render)
+        let stamper = ValueStamper::new(&state);
+        let pre_rendered = stamper.stamp_html(html.to_string())?;
+        // Write pre-rendered HTML
+        fs::write(html_path, pre_rendered)
+            .map_err(|e| format!("Failed to write HTML: {}", e))?;
+        // Write manifest
+        let manifest_path = output_dir
+            .join("vibe-hyperspeed")
+            .join(format!("{}.manifest.js", relative_path));
+        // Ensure directory exists
+        if let Some(parent) = manifest_path.parent() {
+            fs::create_dir_all(parent)
+                .map_err(|e| format!("Failed to create manifest directory: {}", e))?;
+        }
+        let manifest_json = serde_json::to_string(&manifest)
+            .map_err(|e| format!("Failed to serialize manifest: {}", e))?;
+        let manifest_js = format!(
+            "// Pre-compiled manifest for /{}\n// Generated by Vibe compiler\n\nexport default {};\n",
+            relative_path,
+            manifest_json
+        );
+        fs::write(&manifest_path, manifest_js)
+            .map_err(|e| format!("Failed to write manifest: {}", e))?;
+        Ok(())
+    }
+    /// Generate manifests (called separately from main.rs if needed)
+    pub fn generate_manifests(&self) -> Result<ManifestStats, CompileError> {
+        let start = Instant::now();
+        let mut pages_processed = 0;
+        let mut pages_skipped = 0;
+        if self.verbose {
+            println!("\nGenerating manifests (static analysis)");
+        }
+        // Find all HTML files in compiled output (excluding components directory)
+        let html_files = self.find_all_html_files(&self.config.output)?;
+        for html_path in html_files {
+            let relative_path = html_path.strip_prefix(&self.config.output)
+                .unwrap()
+                .to_str()
+                .unwrap();
+            // Read compiled HTML
+            let html = fs::read_to_string(&html_path)
+                .map_err(|e| CompileError::ReadError {
+                    path: html_path.display().to_string(),
+                    source: e,
+                })?;
+            // Try to generate manifest for this file (skip on error)
+            match Self::generate_file_manifest(&html, &html_path, &self.config.output, relative_path, self.verbose) {
+                Ok(()) => {
+                    pages_processed += 1;
+                }
+                Err(e) => {
+                    pages_skipped += 1;
+                    if self.verbose {
+                        println!("  Skipped ({}): {}", e, relative_path);
+                    }
+                    // Don't fail compilation, just skip this file's manifest
+                }
+            }
+        }
+        let total_time_ms = start.elapsed().as_millis() as f64;
+        Ok(ManifestStats {
+            pages_processed,
+            pages_skipped,
+            total_time_ms,
+        })
+    }
+    /// Process directory for HTML files only (used for pages directory)
+    fn process_directory_html_only(
         &mut self,
         dir: &Path,
         parser: &HtmlParser,
@@ -516,7 +632,84 @@ impl Compiler {
                     continue;
                 }
-                // Skip node_modules (handled separately after compilation)
+                // Skip components directory
+                if file_name == self.config.components {
+                    continue;
+                }
+                // Recurse into subdirectory
+                let new_relative = if relative_path.is_empty() {
+                    file_name.to_string()
+                } else {
+                    format!("{}/{}", relative_path, file_name)
+                };
+                self.process_directory_html_only(&path, parser, &new_relative, stats)?;
+            } else if path.extension().and_then(|e| e.to_str()) == Some("html") {
+                let (internal, external, component_srcs) = self.compile_html_file(&path, parser, relative_path)?;
+                stats.files_compiled += 1;
+                stats.internal_components_total += internal;
+                stats.external_components_total += external;
+                // Track unique components
+                for src in &component_srcs {
+                    self.unique_components.insert(src.clone());
+                }
+                // Build component relationships and count occurrences before borrowing logger
+                let (component_relationships, all_srcs) = if self.logger.is_some() && !component_srcs.is_empty() {
+                    let relationships = self.build_component_relationships(&component_srcs);
+                    (Some(relationships), Some(component_srcs))
+                } else {
+                    (None, None)
+                };
+                if let Some(ref mut logger) = self.logger {
+                    logger.log(&path, FileOperation::Compiled, &self.config.source);
+                    // Log each component occurrence (for counting)
+                    if let Some(all_srcs) = all_srcs {
+                        for src in all_srcs {
+                            logger.log_component_occurrence(src);
+                        }
+                    }
+                    // Log unique relationships (for tree structure)
+                    if let Some(relationships) = component_relationships {
+                        for (src, children) in relationships {
+                            logger.log_component_children(src, children);
+                        }
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+    /// Process directory for assets only (CSS, JS, images, etc.) - skip HTML
+    fn process_directory_assets_only(
+        &mut self,
+        dir: &Path,
+        relative_path: &str,
+        stats: &mut CompileStats,
+    ) -> Result<(), CompileError> {
+        let entries = fs::read_dir(dir).map_err(|e| CompileError::ReadError {
+            path: dir.display().to_string(),
+            source: e,
+        })?;
+        for entry in entries.flatten() {
+            let path = entry.path();
+            let file_name = path.file_name().unwrap().to_str().unwrap();
+            if path.is_dir() {
+                // Skip special directories
+                if SKIP_DIRECTORIES.contains(&file_name) {
+                    continue;
+                }
+                // Skip node_modules (handled separately)
                 if file_name == "node_modules" {
                     continue;
                 }
@@ -543,55 +736,15 @@ impl Compiler {
                     format!("{}/{}", relative_path, file_name)
                 };
-                self.process_directory(&path, parser, &new_relative, stats)?;
+                self.process_directory_assets_only(&path, &new_relative, stats)?;
             } else if let Some(ext) = path.extension().and_then(|e| e.to_str()) {
-                match ext {
-                    "html" => {
-                        let (internal, external, component_srcs) = self.compile_html_file(&path, parser, relative_path)?;
-                        stats.files_compiled += 1;
-                        stats.internal_components_total += internal;
-                        stats.external_components_total += external;
-                        // Track unique components
-                        for src in &component_srcs {
-                            self.unique_components.insert(src.clone());
-                        }
-                        // Build component relationships and count occurrences before borrowing logger
-                        let (component_relationships, all_srcs) = if self.logger.is_some() && !component_srcs.is_empty() {
-                            let relationships = self.build_component_relationships(&component_srcs);
-                            (Some(relationships), Some(component_srcs))
-                        } else {
-                            (None, None)
-                        };
-                        if let Some(ref mut logger) = self.logger {
-                            logger.log(&path, FileOperation::Compiled, &self.config.source);
-                            // Log each component occurrence (for counting)
-                            if let Some(all_srcs) = all_srcs {
-                                for src in all_srcs {
-                                    logger.log_component_occurrence(src);
-                                }
-                            }
-                            // Log unique relationships (for tree structure)
-                            if let Some(relationships) = component_relationships {
-                                for (src, children) in relationships {
-                                    logger.log_component_children(src, children);
-                                }
-                            }
-                        }
-                    }
-                    // MIRROR_MODE: Copy CSS/JS as-is
-                    ext if MIRROR_EXTENSIONS.contains(&ext) => {
-                        self.copy_file(&path, relative_path)?;
-                        stats.files_copied += 1;
-                        if let Some(ref mut logger) = self.logger {
-                            logger.log(&path, FileOperation::Copied, &self.config.source);
-                        }
+                // Only copy non-HTML assets
+                if ext != "html" && MIRROR_EXTENSIONS.contains(&ext) {
+                    self.copy_file(&path, relative_path)?;
+                    stats.files_copied += 1;
+                    if let Some(ref mut logger) = self.logger {
+                        logger.log(&path, FileOperation::Copied, &self.config.source);
                     }
-                    _ => {}
                 }
             }
         }