@ape-egg/vibe-compiler 4.3.23 → 4.3.25

package/package.json

@@ -1,9 +1,14 @@
 {
   "name": "@ape-egg/vibe-compiler",
-  "version": "4.3.23",
+  "version": "4.3.25",
   "type": "module",
-  "description": "Optional Rust compiler for Vibe \u2014 pre-renders, inlines components, and optimizes iterations. The runtime never needs it.",
+  "description": "Optional Rust compiler for Vibe — pre-renders, inlines components, and optimizes iterations. The runtime never needs it.",
   "homepage": "https://vibe.korte.kim",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kkortes/ape-egg.git",
+    "directory": "packages/vibe-compiler"
+  },
   "bin": {
     "vibe": "./bin/vibe-compile.js"
   },
@@ -29,7 +34,8 @@
   "author": "kkortes",
   "license": "ISC",
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
   },
   "dependencies": {}
 }

package/src/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "vibe-compiler"
-version = "4.3.23"
+version = "4.3.25"
 edition = "2021"
 description = "Vibe framework compiler - compiles Vibe source files into optimized output"
 authors = ["Kim Korte"]

package/src/compiler/compile.rs

@@ -11,7 +11,7 @@ use rayon::prelude::*;
 use serde_json::{Map, Value};
 
 use crate::config::Config;
-use crate::parser::HtmlParser;
+use crate::parser::{HtmlParser, component_key};
 
 /// Map an output-relative HTML path to the URL path the runtime resolves a
 /// manifest from. Strips the `root` dir (served at /) and collapses dynamic
@@ -239,13 +239,13 @@ fn extract_event_handlers(html: &str) -> Vec<String> {
 /// the inliner's `src=` regex won't match the renamed attribute, so it stops
 /// re-expanding. `process_html_with_cache` restores the attribute to plain
 /// `src=` at the end of compilation so the runtime fetches it normally.
-fn escape_recursive_src(content: &str, component_src: &str) -> String {
-    let pattern = format!(
-        r#"(<(?:component|div)\s+[^>]*\b)src="{}""#,
-        regex::escape(component_src),
-    );
-    let re = Regex::new(&pattern).unwrap();
-    re.replace_all(content, format!(r#"$1{}="{}""#, RECURSIVE_SRC_ATTR, component_src))
+fn escape_recursive_src(content: &str, key: &str) -> String {
+    Regex::new(r#"(<(?:component|div)\s(?:[^>]*\s)?)src="([^"]+)""#)
+        .unwrap()
+        .replace_all(content, |cap: &regex::Captures| match component_key(&cap[2]) == key {
+            true => format!(r#"{}{}="{}""#, &cap[1], RECURSIVE_SRC_ATTR, &cap[2]),
+            false => cap[0].to_string(),
+        })
         .into_owned()
 }
 
@@ -1875,19 +1875,19 @@ impl Compiler {
     }
 
     fn collect_component_children(&mut self, component_src: &str, relationships: &mut Vec<(String, Vec<String>)>, visited: &mut HashSet<String>) {
-        if visited.contains(component_src) {
+        let key = component_key(component_src);
+        if !visited.insert(key.clone()) {
             return;
         }
-        visited.insert(component_src.to_string());
 
         // Read component content
-        let content = if component_src.starts_with("http://") || component_src.starts_with("https://") {
-            match self.fetch_external_component_raw(component_src) {
+        let content = if key.starts_with("http://") || key.starts_with("https://") {
+            match self.fetch_external_component_raw(&key) {
                 Ok(c) => c,
                 Err(_) => return,
             }
         } else {
-            match self.resolve_component_path(component_src) {
+            match self.resolve_component_path(&key) {
                 Ok(path) => match fs::read_to_string(&path) {
                     Ok(c) => c,
                     Err(_) => return,
@@ -2050,17 +2050,7 @@ impl Compiler {
         parser: &HtmlParser,
         visiting: &mut std::collections::HashSet<String>,
     ) -> Option<String> {
-        // Normalize path: ensure it starts with / (unless it's a URL)
-        let normalized_src = if component_src.starts_with("http://") || component_src.starts_with("https://") {
-            component_src.to_string()
-        } else {
-            let without_prefix = component_src.trim_start_matches("./");
-            if without_prefix.starts_with('/') {
-                without_prefix.to_string()
-            } else {
-                format!("/{}", without_prefix)
-            }
-        };
+        let normalized_src = component_key(component_src);
 
         // Return cached if already fetched and fully resolved
         if let Some(cached) = self.component_cache.get(&normalized_src) {
@@ -2744,6 +2734,19 @@ fn count_newlines(bytes: &[u8]) -> usize {
 mod tests {
     use super::*;
 
+    #[test]
+    fn escape_recursive_src_matches_a_cycle_written_without_extension() {
+        let out = escape_recursive_src(
+            r#"<component src="/tree"></component><component src="/leaf.html"></component>"#,
+            "/tree.html",
+        );
+        assert_eq!(
+            out,
+            format!(r#"<component {RECURSIVE_SRC_ATTR}="/tree"></component><component src="/leaf.html"></component>"#),
+        );
+        assert_eq!(escape_recursive_src(&out, "/tree.html"), out, "an escaped src was escaped again");
+    }
+
     #[test]
     fn minify_preserves_script_newlines_so_line_comments_dont_swallow_code() {
         // A `//` line comment inside a component script relies on its trailing

package/src/compiler/spa.rs

@@ -622,10 +622,10 @@ mod tests {
     #[test]
     fn harvests_and_derives_shell_imports() {
         assert_eq!(
-            harvest_vibe_import("import vibe from '/nodemodules/@ape-egg/vibe/index.js';"),
-            Some("/nodemodules/@ape-egg/vibe/index.js".to_string())
+            harvest_vibe_import("import vibe from '/node_modules/@ape-egg/vibe/index.js';"),
+            Some("/node_modules/@ape-egg/vibe/index.js".to_string())
         );
-        assert_eq!(spa_import_for("/nodemodules/@ape-egg/vibe/index.js"), "/nodemodules/@ape-egg/vibe/spa.js");
+        assert_eq!(spa_import_for("/node_modules/@ape-egg/vibe/index.js"), "/node_modules/@ape-egg/vibe/spa.js");
         assert_eq!(spa_import_for("@ape-egg/vibe"), "@ape-egg/vibe/spa");
     }
 

package/src/compiler/watcher.rs

@@ -8,6 +8,7 @@ use regex::Regex;
 
 use super::{Compiler, compile::should_skip_path, shutdown};
 use crate::config::Config;
+use crate::parser::component_key;
 use crate::constants::{HYPERSPEED_DIR, MANIFEST_SUFFIX};
 
 /// Tracks which pages and components depend on which components
@@ -159,8 +160,7 @@ pub fn extract_component_dependencies(html: &str, components_dir: &Path) -> Hash
     let component_tag_re = Regex::new(r#"<component\s+[^>]*src=["']([^"']+)["']"#).unwrap();
     for cap in component_tag_re.captures_iter(html) {
         if let Some(src) = cap.get(1) {
-            let src_path = src.as_str().trim_start_matches('/');
-            deps.insert(PathBuf::from(src_path));
+            deps.insert(PathBuf::from(component_key(src.as_str()).trim_start_matches('/')));
         }
     }
 

package/src/parser/html.rs

@@ -7,6 +7,22 @@ use super::element::{Element, ElementCache};
 use crate::inert::Inert;
 use crate::constants::{RECURSIVE_SRC_ATTR, MODULE_SCRIPT_TYPE};
 
+/// The key a `<component src>` is fetched and cached under: rooted at `/` unless
+/// it is a URL, with `.html` appended when its last path segment has no
+/// extension, so `/vibe/counter` and `/vibe/counter.html` are one component.
+/// Mirrors `fetchComponentTemplate` in the vibe runtime.
+pub fn component_key(src: &str) -> String {
+    let rooted = if src.starts_with("http://") || src.starts_with("https://") {
+        src.to_string()
+    } else {
+        format!("/{}", src.trim_start_matches("./").trim_start_matches('/'))
+    };
+    regex::Regex::new(r"^((?:[^?#]*/)?[^/?#.]+)([?#].*)?$")
+        .unwrap()
+        .replace(&rooted, "$1.html$2")
+        .into_owned()
+}
+
 #[derive(Error, Debug)]
 pub enum ParseError {
     #[error("Failed to read file {path}: {source}")]
@@ -449,18 +465,7 @@ impl HtmlParser {
 
             let mut applied = false;
             for (start, end, src, props, slot_content) in sorted {
-                let normalized_src = if src.starts_with("http://") || src.starts_with("https://") {
-                    src.to_string()
-                } else {
-                    let without_prefix = src.trim_start_matches("./");
-                    if without_prefix.starts_with('/') {
-                        without_prefix.to_string()
-                    } else {
-                        format!("/{}", without_prefix)
-                    }
-                };
-
-                if let Some(template) = external_cache.get(&normalized_src) {
+                if let Some(template) = external_cache.get(&component_key(&src)) {
                     // Iter-prop components stay as runtime `<component src>` tags so the
                     // runtime renders them via its __vibe.iterProps path — inlining
                     // breaks the enclosing loop's scope (see is_iter_prop_root).
@@ -891,6 +896,36 @@ fn transform_custom_tags(content: &str, reserved_elements: &[String]) -> String
 mod tests {
     use super::*;
 
+    #[test]
+    fn component_key_appends_html_to_an_extensionless_src() {
+        let cases = [
+            ("/vibe/counter", "/vibe/counter.html"),
+            ("vibe/counter", "/vibe/counter.html"),
+            ("./vibe/counter", "/vibe/counter.html"),
+            ("/vibe/counter.html", "/vibe/counter.html"),
+            ("/vibe/counter/v2.html", "/vibe/counter/v2.html"),
+            ("/vibe/counter?v=2", "/vibe/counter.html?v=2"),
+            ("https://x.com/vibe/counter#a", "https://x.com/vibe/counter.html#a"),
+            ("/v1.2/counter", "/v1.2/counter.html"),
+            ("/a/b.html?x=/y", "/a/b.html?x=/y"),
+            ("/dir/", "/dir/"),
+        ];
+        for (src, key) in cases {
+            assert_eq!(component_key(src), key, "src {src}");
+        }
+    }
+
+    #[test]
+    fn inline_component_without_extension_uses_the_html_template() {
+        let parser = HtmlParser::new(std::path::PathBuf::from("."));
+        let mut cache = HashMap::new();
+        cache.insert("/components/Potion.html".to_string(), "<icon potion></icon>".to_string());
+
+        let out = parser.inline_component_elements("<wrap><component src=\"/components/Potion\"></component></wrap>", &cache);
+
+        assert_eq!(out, "<wrap><component><icon potion></icon></component></wrap>");
+    }
+
     #[test]
     fn find_matching_close_tolerates_whitespace_in_end_tag() {
         // Whitespace-controlled markup splits an end tag across lines, e.g.

package/src/parser/mod.rs

@@ -1,7 +1,7 @@
 pub mod html;
 mod element;
 
-pub use html::HtmlParser;
+pub use html::{HtmlParser, component_key};
 #[allow(unused_imports)]
 pub use html::ParseError;
 #[allow(unused_imports)]