@ape-egg/vibe 2.3.0 → 3.0.1

package/compiler/src/compiler/iteration_optimizer.rs

@@ -1,455 +0,0 @@
-use regex::Regex;
-use serde::{Serialize, Deserialize};
-use std::collections::HashMap;
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CompiledIteration {
-    pub item_alias: String,
-    pub index_alias: String,
-    pub state_path: String,
-    pub batch_fn: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct IterationOptimizations {
-    pub iterations: HashMap<String, CompiledIteration>,
-}
-
-/// Generate compiled batch functions for iterations in HTML
-pub fn build_iteration_optimizations(html: &str) -> Option<IterationOptimizations> {
-    let iterations = extract_and_compile_iterations(html);
-
-    if iterations.is_empty() {
-        None
-    } else {
-        Some(IterationOptimizations { iterations })
-    }
-}
-
-/// Extract <!-- each --> blocks and compile them to batch functions
-fn extract_and_compile_iterations(html: &str) -> HashMap<String, CompiledIteration> {
-    let mut result = HashMap::new();
-
-    // Match: <!-- each arrayPath as item, index -->
-    let each_re = Regex::new(r"<!--\s*each\s+([^\s]+)\s+as\s+([^\s,]+)(?:\s*,\s*([^\s]+))?\s*-->").unwrap();
-
-    let mut search_start = 0;
-
-    while let Some(start_match) = each_re.find_at(html, search_start) {
-        let captures = each_re.captures(&html[start_match.start()..]).unwrap();
-        let state_path = captures.get(1).unwrap().as_str();
-        let item_alias = captures.get(2).unwrap().as_str();
-        let index_alias = captures.get(3).map(|m| m.as_str()).unwrap_or("index");
-
-        let template_start = start_match.end();
-
-        // Find matching <!-- /each --> using depth counting
-        if let Some((end_pos, end_after)) = find_matching_each_end(html, template_start) {
-            let template_html = &html[template_start..end_pos];
-
-            // Skip if this iteration is inside a conditional (parent won't be compiled)
-            if is_in_conditional_context(html, start_match.start()) {
-                search_start = end_after;
-                continue;
-            }
-
-            // Check if template has nested structures (skip if so)
-            if has_nested_structures(template_html) {
-                search_start = end_after;
-                continue;
-            }
-
-            // Raw-HTML bindings can't ride a template literal: a batch function
-            // interpolates RawHtml via toString(), which escapes. Skip the batch
-            // function so the runtime renders these rows through clone+hydrate —
-            // the one place that implements $.unsafe semantics (innerHTML +
-            // inert subtree).
-            if template_html.contains("$.unsafe(") {
-                search_start = end_after;
-                continue;
-            }
-
-            // Generate hash for this template
-            let hash = generate_template_hash(template_html);
-
-            // Compile template to batch function
-            let batch_fn = compile_template_to_batch_fn(
-                template_html,
-                item_alias,
-                index_alias,
-            );
-
-            result.insert(hash, CompiledIteration {
-                item_alias: item_alias.to_string(),
-                index_alias: index_alias.to_string(),
-                state_path: state_path.to_string(),
-                batch_fn,
-            });
-
-            search_start = end_after;
-        } else {
-            break;
-        }
-    }
-
-    result
-}
-
-/// Check if template contains conditionals (we skip these)
-/// Nested iterations are supported, but not if parent has conditionals
-fn has_nested_structures(template: &str) -> bool {
-    template.contains("<!-- if")
-}
-
-/// Check if we're inside a non-compiled parent iteration
-/// This happens when the template contains conditionals that prevent compilation
-fn is_in_conditional_context(html: &str, pos: usize) -> bool {
-    // Look backwards from current position for unclosed conditionals
-    let before = &html[..pos];
-    let if_count = before.matches("<!-- if").count();
-    let endif_count = before.matches("<!-- /if").count();
-    if_count > endif_count
-}
-
-/// Generate a stable hash for a template
-fn generate_template_hash(template: &str) -> String {
-    use std::collections::hash_map::DefaultHasher;
-    use std::hash::{Hash, Hasher};
-
-    let mut hasher = DefaultHasher::new();
-    template.trim().hash(&mut hasher);
-    let hash = hasher.finish();
-    format!("iter_{:x}", hash)
-}
-
-/// DOM element properties — set on the element, kept as value attributes in
-/// batch output. Mirrors DOM_PROPERTIES in runtime/constants.js.
-const DOM_PROPERTIES: &[&str] = &["value", "checked", "selected"];
-
-/// Attributes that keep their string value verbatim (never boolean-coerced).
-/// Mirrors VALUE_ATTRS in runtime/constants.js — the two lists must stay in
-/// lockstep or batch and clone paths render different attributes.
-const VALUE_ATTRS: &[&str] = &[
-    "class", "style", "id", "title", "lang", "dir", "tabindex", "accesskey",
-    "slot", "part", "is", "nonce", "popover", "anchor",
-    "contenteditable", "draggable", "spellcheck", "translate",
-    "autocapitalize", "inputmode", "enterkeyhint", "virtualkeyboardpolicy",
-    "href", "src", "action", "cite", "data", "poster", "srcset",
-    "imagesrcset", "formaction", "ping", "usemap", "manifest", "codebase",
-    "name", "type", "value", "placeholder", "pattern", "min", "max", "step",
-    "minlength", "maxlength", "size", "accept", "autocomplete", "list",
-    "form", "formmethod", "formtarget", "formenctype", "wrap", "method",
-    "enctype", "for", "dirname",
-    "alt", "label", "summary", "abbr",
-    "width", "height", "cols", "rows", "span", "rowspan", "colspan",
-    "low", "high", "optimum",
-    "target", "rel", "hreflang", "download", "as", "media", "charset",
-    "crossorigin", "integrity", "loading", "decoding", "fetchpriority",
-    "referrerpolicy", "blocking", "imagesizes", "sizes",
-    "preload", "kind", "srclang",
-    "content", "http-equiv",
-    "sandbox", "allow", "srcdoc", "credentialless",
-    "headers", "scope",
-    "datetime",
-    "coords", "shape",
-];
-
-/// Whether an attribute keeps its string value (vs boolean coercion).
-/// Mirrors isValueStyleAttr in runtime/iterate.js.
-/// Turn ` data-vibe-namebind="@[A]@[B]"` back into ` @[A]="" @[B]=""` so each relocated
-/// binding is rendered as a name-binding (` resolvedName=""`) rather than having its
-/// resolved value written into the transport attribute. See name_binding_protect.
-fn restore_relocated_name_bindings(template: &str) -> String {
-    let wrapper = Regex::new(
-        r#"\s+data-vibe-namebind="((?:@\[(?:[^\[\]'"]|\[[^\]]*\]|'[^']*'|"[^"]*")+\])+)""#,
-    )
-    .unwrap();
-    let one = Regex::new(r#"@\[(?:[^\[\]'"]|\[[^\]]*\]|'[^']*'|"[^"]*")+\]"#).unwrap();
-    wrapper
-        .replace_all(template, |caps: &regex::Captures| {
-            let mut s = String::new();
-            for m in one.find_iter(&caps[1]) {
-                s.push(' ');
-                s.push_str(m.as_str());
-                s.push_str("=\"\"");
-            }
-            s
-        })
-        .to_string()
-}
-
-fn is_value_style_attr(name: &str) -> bool {
-    VALUE_ATTRS.contains(&name)
-        || name.starts_with("data-")
-        || name.starts_with("aria-")
-        || name.starts_with("on")
-}
-
-/// Escape a static text chunk for a JS template-literal context.
-fn escape_tpl_text(text: &str) -> String {
-    text.replace('\\', "\\\\")
-        .replace('`', "\\`")
-        .replace("${", "\\${")
-}
-
-/// Compile template HTML to a batch function string
-/// Supports nested <!-- each --> blocks
-fn compile_template_to_batch_fn(
-    template: &str,
-    item_alias: &str,
-    index_alias: &str,
-) -> String {
-    // Normalize static boolean attributes: <div attr=""> → <div attr>
-    // (matches CSS attribute selectors). Runs on raw template text, before
-    // emission — emitted JS below also contains attr="" inside string
-    // literals, which must not be touched.
-    let boolean_attr_re = Regex::new(r#"(\w+)="""#).unwrap();
-    let cleaned = boolean_attr_re.replace_all(template, "$1");
-
-    let body = emit_template_literal(&cleaned);
-
-    format!(
-        r#"(arr, $) => {{ let html = ''; const len = arr.length; for (let {index} = 0; {index} < len; {index}++) {{ const {item} = arr[{index}]; html += `{body}`; }} return html; }}"#,
-        index = index_alias,
-        item = item_alias,
-        body = body
-    )
-}
-
-/// Emit the body of a JS template literal for a template chunk:
-///   - static text escaped for template-literal context
-///   - attribute pure bindings classified like hydrate.js / compileBatchFn:
-///     DOM properties and value-style attributes keep `attr="${expr}"`,
-///     boolean-coerced attributes become `${(expr) ? ' attr=""' : ''}` so the
-///     attribute is ABSENT when falsy and present-empty when truthy
-///   - remaining @[expr] bindings (text content, partial attribute values)
-///     become `${expr}` interpolations
-///   - nested <!-- each --> blocks become inline IIFE loops, recursively
-///
-/// Anything the runtime clone+hydrate path renders, this output has to render
-/// identically — it is the compiled twin of compileBatchFn in runtime/iterate.js.
-fn emit_template_literal(template: &str) -> String {
-    // Restore name-bindings the compiler relocated into `data-vibe-namebind` (their
-    // expression has whitespace, so it could not be an HTML attribute name) back to the
-    // `@[expr]=""` form the binding pass below renders as ` resolvedName=""`. The compiled
-    // twin of the same step in runtime/iterate.js compileBatchFn.
-    let template = &restore_relocated_name_bindings(template);
-
-    let each_re = Regex::new(r"<!--\s*each\s+([^\s]+)\s+as\s+([^\s,]+)(?:\s*,\s*([^\s]+))?\s*-->").unwrap();
-    let end_re = Regex::new(r"<!--\s*/each\s*-->").unwrap();
-    let attr_binding_re = Regex::new(r#"(\s)([\w-]+)="@\[([^\]]+)\]""#).unwrap();
-    let binding_re = Regex::new(r"@\[([^\]]+)\]").unwrap();
-
-    let mut out = String::new();
-    let mut pos = 0;
-
-    while pos < template.len() {
-        let next_each = each_re.find_at(template, pos);
-        let next_attr = attr_binding_re.find_at(template, pos);
-        let next_binding = binding_re.find_at(template, pos);
-
-        // Earliest match wins; attr-binding outranks plain binding at the same
-        // region (the plain regex would match inside the attr form).
-        let candidates = [
-            next_each.map(|m| (m.start(), 0u8)),
-            next_attr.map(|m| (m.start(), 1u8)),
-            next_binding.map(|m| (m.start(), 2u8)),
-        ];
-        let Some(&(start, kind)) = candidates
-            .iter()
-            .flatten()
-            .min_by_key(|(s, k)| (*s, *k))
-        else {
-            out.push_str(&escape_tpl_text(&template[pos..]));
-            break;
-        };
-
-        out.push_str(&escape_tpl_text(&template[pos..start]));
-
-        match kind {
-            0 => {
-                // Nested <!-- each --> → inline IIFE loop
-                let m = next_each.unwrap();
-                let caps = each_re.captures(&template[m.start()..]).unwrap();
-                let arr = caps.get(1).unwrap().as_str();
-                let item = caps.get(2).unwrap().as_str();
-                let idx = caps.get(3).map(|c| c.as_str()).unwrap_or("index");
-
-                if let Some((end_pos, _)) = find_matching_each_end(template, m.end()) {
-                    let inner = emit_template_literal(&template[m.end()..end_pos]);
-                    out.push_str(&format!(
-                        "${{(() => {{ let inner = ''; const len_{idx} = {arr}.length; for (let {idx} = 0; {idx} < len_{idx}; {idx}++) {{ const {item} = {arr}[{idx}]; inner += `{inner_body}`; }} return inner; }})()}}",
-                        idx = idx,
-                        arr = arr,
-                        item = item,
-                        inner_body = inner
-                    ));
-                    let end_match = end_re.find_at(template, end_pos).unwrap();
-                    pos = end_match.end();
-                } else {
-                    // Unbalanced each — emit as text and move on
-                    out.push_str(&escape_tpl_text(&template[m.start()..m.end()]));
-                    pos = m.end();
-                }
-            }
-            1 => {
-                // Attribute pure binding: attr="@[expr]"
-                let m = next_attr.unwrap();
-                let caps = attr_binding_re.captures(&template[m.start()..]).unwrap();
-                let ws = caps.get(1).unwrap().as_str();
-                let name = caps.get(2).unwrap().as_str();
-                let expr = caps.get(3).unwrap().as_str();
-                let name_lc = name.to_lowercase();
-
-                if DOM_PROPERTIES.contains(&name_lc.as_str()) || is_value_style_attr(&name_lc) {
-                    out.push_str(&format!("{ws}{name}=\"${{{expr}}}\""));
-                } else {
-                    out.push_str(&format!("${{({expr}) ? ' {name}=\"\"' : ''}}"));
-                }
-                pos = m.end();
-            }
-            _ => {
-                // Plain binding: text content or partial attribute value
-                let m = next_binding.unwrap();
-                let caps = binding_re.captures(&template[m.start()..]).unwrap();
-                out.push_str(&format!("${{{}}}", caps.get(1).unwrap().as_str()));
-                pos = m.end();
-            }
-        }
-    }
-
-    out
-}
-
-/// Find matching <!-- /each --> comment using depth counting
-/// Returns (position_before_comment, position_after_comment)
-fn find_matching_each_end(html: &str, start_pos: usize) -> Option<(usize, usize)> {
-    let each_re = Regex::new(r"<!--\s*each\s+").unwrap();
-    let end_re = Regex::new(r"<!--\s*/each\s*-->").unwrap();
-
-    let mut depth = 1;
-    let mut search_pos = start_pos;
-
-    while depth > 0 {
-        let next_start = each_re.find_at(html, search_pos);
-        let next_end = end_re.find_at(html, search_pos);
-
-        match (next_start, next_end) {
-            (Some(start_match), Some(end_match)) if start_match.start() < end_match.start() => {
-                // Found nested <!-- each --> before <!-- /each -->
-                depth += 1;
-                search_pos = start_match.end();
-            }
-            (_, Some(end_match)) => {
-                // Found <!-- /each -->
-                depth -= 1;
-                if depth == 0 {
-                    return Some((end_match.start(), end_match.end()));
-                }
-                search_pos = end_match.end();
-            }
-            _ => return None, // No matching end found
-        }
-    }
-
-    None
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_simple_iteration() {
-        let html = r#"
-            <!-- each items as item -->
-            <li>@[item.name]</li>
-            <!-- /each -->
-        "#;
-
-        let opts = build_iteration_optimizations(html);
-        assert!(opts.is_some());
-
-        let iterations = &opts.unwrap().iterations;
-        assert_eq!(iterations.len(), 1);
-
-        let (_, compiled) = iterations.iter().next().unwrap();
-        assert_eq!(compiled.item_alias, "item");
-        assert_eq!(compiled.index_alias, "index");
-        assert_eq!(compiled.state_path, "items");
-        assert!(compiled.batch_fn.contains("html += `"));
-    }
-
-    #[test]
-    fn test_iteration_with_index() {
-        let html = r#"
-            <!-- each items as item, idx -->
-            <li>[@[idx]] @[item.name]</li>
-            <!-- /each -->
-        "#;
-
-        let opts = build_iteration_optimizations(html);
-        let iterations = &opts.unwrap().iterations;
-        let (_, compiled) = iterations.iter().next().unwrap();
-        assert_eq!(compiled.index_alias, "idx");
-    }
-
-    #[test]
-    fn test_boolean_attr_binding_emits_conditional_presence() {
-        let html = r#"
-            <!-- each items as item -->
-            <attr-target open="@[flag]" href="@[item.url]" value="@[item.v]"></attr-target>
-            <!-- /each -->
-        "#;
-
-        let opts = build_iteration_optimizations(html);
-        let iterations = &opts.unwrap().iterations;
-        let (_, compiled) = iterations.iter().next().unwrap();
-
-        // Boolean-coerced attribute: absent when falsy, present-empty when truthy
-        assert!(compiled.batch_fn.contains(r#"${(flag) ? ' open=""' : ''}"#));
-        // Value-style attribute keeps its string value
-        assert!(compiled.batch_fn.contains(r#"href="${item.url}""#));
-        // DOM property keeps its value form
-        assert!(compiled.batch_fn.contains(r#"value="${item.v}""#));
-    }
-
-    #[test]
-    fn test_unsafe_template_skips_batch_fn() {
-        let html = r#"
-            <!-- each rows as row -->
-            <li>@[$.unsafe(row.markup)]</li>
-            <!-- /each -->
-        "#;
-
-        // RawHtml semantics can't ride a template literal — no batch function
-        assert!(build_iteration_optimizations(html).is_none());
-    }
-
-    #[test]
-    fn test_nested_iteration_compiled() {
-        let html = r#"
-            <!-- each categories as cat -->
-            <div>
-                <!-- each cat.items as item -->
-                <span>@[item]</span>
-                <!-- /each -->
-            </div>
-            <!-- /each -->
-        "#;
-
-        let opts = build_iteration_optimizations(html);
-        // Should compile nested iterations
-        assert!(opts.is_some());
-
-        let iterations = &opts.unwrap().iterations;
-        assert_eq!(iterations.len(), 1);
-
-        let (_, compiled) = iterations.iter().next().unwrap();
-        // Should contain nested loop code with template literals
-        assert!(compiled.batch_fn.contains("cat.items"));
-        assert!(compiled.batch_fn.contains("let inner = ''"));
-        assert!(compiled.batch_fn.contains("inner += `"));
-    }
-}