@ape-egg/vibe 2.1.4 → 2.1.7

package/compiler/src/compiler/js_analyzer.rs

@@ -9,17 +9,20 @@ use std::fs;
 
 /// Analyzes JavaScript code to extract state from vibe() calls
 pub struct JsAnalyzer {
-    source_map: Lrc<SourceMap>,
     base_path: PathBuf,
     _module_cache: HashMap<PathBuf, Module>,
+    /// Memoizes resolved imports by (file, export name). Dedupes diamond imports
+    /// (without it, recursive resolution re-parses shared modules exponentially)
+    /// and breaks cycles (an in-progress entry is seeded `None`).
+    import_cache: HashMap<(PathBuf, String), Option<Value>>,
 }
 
 impl JsAnalyzer {
     pub fn new(base_path: PathBuf) -> Self {
         Self {
-            source_map: Lrc::new(SourceMap::default()),
             base_path,
             _module_cache: HashMap::new(),
+            import_cache: HashMap::new(),
         }
     }
 
@@ -34,11 +37,11 @@ impl JsAnalyzer {
         module.visit_with(&mut scope_builder);
         // eprintln!("[JsAnalyzer] Found {} imports", scope_builder.imports.len());
 
-        // Resolve imports to actual Values
+        // Resolve imports to actual Values (keyed by the LOCAL name used in code)
         let mut resolved_imports: HashMap<String, Value> = HashMap::new();
-        for (import_name, import_path) in &scope_builder.imports {
-            if let Some(value) = self.resolve_import_value(&import_path, import_name) {
-                resolved_imports.insert(import_name.clone(), value);
+        for (local_name, (import_path, imported_name)) in scope_builder.imports.clone() {
+            if let Some(value) = self.resolve_import_value(&import_path, &imported_name) {
+                resolved_imports.insert(local_name, value);
             }
         }
 
@@ -50,35 +53,73 @@ impl JsAnalyzer {
         state_extractor.merged_state
     }
 
-    /// Resolve an import and return the exported value (fully resolved)
-    fn resolve_import_value(&mut self, import_path: &str, import_name: &str) -> Option<Value> {
-        // eprintln!("[JsAnalyzer] Resolving import: '{}' name: '{}'", import_path, import_name);
-        // Resolve relative path
+    /// Resolve an import and return the exported value (fully resolved).
+    /// `imported_name` is the EXPORT name to look up ("default" for a default
+    /// import). The imported module's OWN imports are resolved too, so a chain
+    /// like `import appState` → `export default { version: VERSION }` →
+    /// `import VERSION from './version.js'` resolves all the way down.
+    fn resolve_import_value(&mut self, import_path: &str, imported_name: &str) -> Option<Value> {
+        self.resolve_import_value_depth(import_path, imported_name, 0)
+    }
+
+    fn resolve_import_value_depth(
+        &mut self,
+        import_path: &str,
+        imported_name: &str,
+        depth: usize,
+    ) -> Option<Value> {
+        // Guard against pathological depth.
+        if depth > 16 {
+            return None;
+        }
+
         let resolved_path = self.resolve_path(import_path)?;
-        // eprintln!("[JsAnalyzer] Resolved to: {:?}", resolved_path);
+        let cache_key = (resolved_path.clone(), imported_name.to_string());
+        if let Some(cached) = self.import_cache.get(&cache_key) {
+            return cached.clone();
+        }
+        // Seed the in-progress entry so an import cycle resolves to None instead
+        // of recursing forever.
+        self.import_cache.insert(cache_key.clone(), None);
+
+        let result = self.resolve_export_from_file(&resolved_path, imported_name, depth);
+        self.import_cache.insert(cache_key, result.clone());
+        result
+    }
 
-        // Read and parse the module
-        let code = fs::read_to_string(&resolved_path).ok()?;
+    fn resolve_export_from_file(
+        &mut self,
+        resolved_path: &PathBuf,
+        imported_name: &str,
+        depth: usize,
+    ) -> Option<Value> {
+        let code = fs::read_to_string(resolved_path).ok()?;
         let module = self.parse_module(&code)?;
 
-        // Build scope for the imported module
+        // Build scope for the imported module.
         let mut scope_builder = ScopeBuilder::new(resolved_path.parent()?.to_path_buf());
         module.visit_with(&mut scope_builder);
 
-        // Find the exported binding
-        let mut export_finder = ExportFinder::new(
-            import_name.to_string(),
-            scope_builder.bindings.clone(),
-        );
-        module.visit_with(&mut export_finder);
-
-        // Resolve the exported expression with the file's bindings
-        if let Some(expr) = export_finder.found_export {
-            let state_extractor = StateExtractor::new(scope_builder.bindings);
-            return state_extractor.resolve_expr(&expr);
+        // Recursively resolve THIS module's own imports so a property like
+        // `version: VERSION` (itself a default import) can be resolved. Import
+        // paths in this codebase are absolute (`/js/...`), resolved against the
+        // analyzer's fixed base, so no per-module base swap is needed.
+        let mut resolved_imports: HashMap<String, Value> = HashMap::new();
+        for (local_name, (path, name)) in scope_builder.imports.clone() {
+            if let Some(value) = self.resolve_import_value_depth(&path, &name, depth + 1) {
+                resolved_imports.insert(local_name, value);
+            }
         }
 
-        None
+        // Find the requested export.
+        let mut export_finder =
+            ExportFinder::new(imported_name.to_string(), scope_builder.bindings.clone());
+        module.visit_with(&mut export_finder);
+
+        let expr = export_finder.found_export?;
+        let mut state_extractor = StateExtractor::new(scope_builder.bindings);
+        state_extractor.resolved_imports = resolved_imports;
+        state_extractor.resolve_expr(&expr)
     }
 
     /// Resolve import path relative to base_path
@@ -115,9 +156,12 @@ impl JsAnalyzer {
         }
     }
 
-    /// Parse JavaScript/TypeScript module
+    /// Parse JavaScript/TypeScript module. Uses a FRESH source map per call —
+    /// recursive import resolution parses many files, and a shared map would
+    /// accumulate byte positions until they overflow (`start <= end` panic).
     fn parse_module(&self, code: &str) -> Option<Module> {
-        let fm = self.source_map.new_source_file(
+        let source_map: Lrc<SourceMap> = Default::default();
+        let fm = source_map.new_source_file(
             Lrc::new(FileName::Anon),
             code.to_string(),
         );
@@ -147,7 +191,9 @@ impl JsAnalyzer {
 /// Builds a scope of variable bindings and tracks imports
 struct ScopeBuilder {
     bindings: HashMap<String, Expr>,
-    imports: HashMap<String, String>, // import_name -> import_path
+    // local binding name -> (import path, imported export name; "default" for a
+    // default import, "*" for a namespace import)
+    imports: HashMap<String, (String, String)>,
     _base_path: PathBuf,
 }
 
@@ -167,21 +213,29 @@ impl Visit for ScopeBuilder {
 
         for specifier in &import.specifiers {
             match specifier {
-                // import { name } from './file.js'
+                // import { orig as local } from './file.js'
                 ImportSpecifier::Named(named) => {
-                    let _import_name = match &named.imported {
+                    let imported = match &named.imported {
                         Some(ModuleExportName::Ident(ident)) => ident.sym.to_string(),
-                        _ => named.local.sym.to_string(),
+                        Some(ModuleExportName::Str(s)) => s.value.to_string(),
+                        None => named.local.sym.to_string(),
                     };
-                    self.imports.insert(named.local.sym.to_string(), import_path.clone());
+                    self.imports
+                        .insert(named.local.sym.to_string(), (import_path.clone(), imported));
                 }
                 // import name from './file.js' (default import)
                 ImportSpecifier::Default(default) => {
-                    self.imports.insert(default.local.sym.to_string(), import_path.clone());
+                    self.imports.insert(
+                        default.local.sym.to_string(),
+                        (import_path.clone(), "default".to_string()),
+                    );
                 }
-                // import * as name from './file.js'
+                // import * as name from './file.js' (namespace import)
                 ImportSpecifier::Namespace(namespace) => {
-                    self.imports.insert(namespace.local.sym.to_string(), import_path.clone());
+                    self.imports.insert(
+                        namespace.local.sym.to_string(),
+                        (import_path.clone(), "*".to_string()),
+                    );
                 }
             }
         }
@@ -233,6 +287,13 @@ impl ExportFinder {
 }
 
 impl Visit for ExportFinder {
+    // `export default <expr>` — matched when the consumer used a default import.
+    fn visit_export_default_expr(&mut self, export: &ExportDefaultExpr) {
+        if self.target_name == "default" {
+            self.found_export = Some((*export.expr).clone());
+        }
+    }
+
     fn visit_export_decl(&mut self, export: &ExportDecl) {
         match &export.decl {
             Decl::Var(var_decl) => {
@@ -626,4 +687,29 @@ mod tests {
         assert_eq!(state["other"].as_str().unwrap(), "value");
         assert_eq!(state["extra"].as_str().unwrap(), "value");
     }
+
+    #[test]
+    fn resolves_default_import_chain() {
+        // Two nested DEFAULT imports, mirroring boot.js → app.js → version.js:
+        // `import appState` → `export default { version: VERSION }` → `import VERSION`.
+        let dir = std::env::temp_dir().join("vibe_default_import_chain_test");
+        let _ = fs::remove_dir_all(&dir);
+        fs::create_dir_all(&dir).unwrap();
+        fs::write(dir.join("version.js"), "export default '0.1.5';").unwrap();
+        fs::write(
+            dir.join("app.js"),
+            "import VERSION from '/version.js';\nexport default { version: VERSION, coins: 400 };",
+        )
+        .unwrap();
+
+        let mut analyzer = JsAnalyzer::new(dir.clone());
+        let state = analyzer
+            .extract_state("import appState from '/app.js';\nvibe({ ...appState });")
+            .unwrap();
+
+        assert_eq!(state["version"], "0.1.5");
+        assert_eq!(state["coins"].as_f64(), Some(400.0));
+
+        let _ = fs::remove_dir_all(&dir);
+    }
 }

package/compiler/src/compiler/mod.rs

@@ -5,6 +5,7 @@ mod value_stamper;
 mod iteration_optimizer;
 mod js_analyzer;
 mod component_tagger;
+mod reassignment_analyzer;
 pub mod watcher;
 
 pub use compile::Compiler;