fix: further issues from Astro test suite

Author: Princesseuh

.changeset/ninety-mammals-unite.md

@@ -0,0 +1,5 @@
+---
+"@astrojs/compiler-rs": patch
+---
+
+Fixes further issues found in the Astro tests, especially around HTML escaping in set:html

crates/astro_codegen/src/printer/components.rs

@@ -339,7 +339,7 @@ impl<'a> AstroCodegen<'a> {
         // Pre-scan for transition attributes
         let mut transition_name: Option<(String, oxc_span::Span)> = None;
         let mut transition_animate: Option<(String, oxc_span::Span)> = None;
-        let mut transition_persist: Option<oxc_span::Span> = None;
+        let mut transition_persist: Option<(String, oxc_span::Span)> = None;
         let mut transition_persist_props: Option<(String, oxc_span::Span)> = None;
 
         for attr in attrs {
@@ -350,7 +350,7 @@ impl<'a> AstroCodegen<'a> {
                 } else if name == "transition:animate" {
                     transition_animate = Some((Self::get_attr_value_string(attr), attr.span));
                 } else if name == "transition:persist" {
-                    transition_persist = Some(attr.span);
+                    transition_persist = Some((Self::get_attr_value_string_or_empty(attr), attr.span));
                 } else if name == "transition:persist-props" {
                     transition_persist_props = Some((Self::get_attr_value_string(attr), attr.span));
                 }
@@ -499,7 +499,7 @@ impl<'a> AstroCodegen<'a> {
             } else if let Some((_, span)) = &transition_animate {
                 self.add_source_mapping_for_span(*span);
             }
-            let name_val = transition_name.map_or_else(|| "\"\"".to_string(), |(v, _)| v);
+            let name_val = transition_name.as_ref().map_or_else(|| "\"\"".to_string(), |(v, _)| v.clone());
             let animate_val = transition_animate.map_or_else(|| "\"\"".to_string(), |(v, _)| v);
             let hash = self.generate_transition_hash();
             self.print(&format!(
@@ -524,19 +524,31 @@ impl<'a> AstroCodegen<'a> {
             ));
         }
 
-        if let Some(persist_span) = transition_persist {
+        if let Some((ref persist_val, persist_span)) = transition_persist {
             if !first {
                 self.print(",");
             }
             first = false;
             self.add_source_mapping_for_span(persist_span);
-            let hash = self.generate_transition_hash();
-            self.print(&format!(
-                "\"data-astro-transition-persist\":({}({}, \"{}\"))",
-                runtime::CREATE_TRANSITION_SCOPE,
-                runtime::RESULT,
-                hash
-            ));
+            // Priority order for the persist ID:
+            // 1. Explicit string value on transition:persist (e.g. transition:persist="form")
+            // 2. transition:name value
+            // 3. Generated hash via $$createTransitionScope
+            let clean_persist = persist_val.trim_matches('"');
+            if !clean_persist.is_empty() {
+                self.print(&format!("\"data-astro-transition-persist\":\"{clean_persist}\""));
+            } else if let Some((ref name_val, _)) = transition_name {
+                let clean_val = name_val.trim_matches('"');
+                self.print(&format!("\"data-astro-transition-persist\":\"{clean_val}\""));
+            } else {
+                let hash = self.generate_transition_hash();
+                self.print(&format!(
+                    "\"data-astro-transition-persist\":({}({}, \"{}\"))",
+                    runtime::CREATE_TRANSITION_SCOPE,
+                    runtime::RESULT,
+                    hash
+                ));
+            }
         }
 
         // Add scope identifier as a prop if not already merged into an existing class attribute.

crates/astro_codegen/src/printer/elements.rs

@@ -308,10 +308,12 @@ impl<'a> AstroCodegen<'a> {
                                 value_str = expr_to_string(e);
                                 is_template_literal = matches!(e, Expression::TemplateLiteral(_));
                             }
-                            // set:html needs $$unescapeHTML for expressions, but NOT for
-                            // template literals — the Go compiler passes template literals
-                            // through as-is without unescaping.
-                            let needs_unescape = directive_type == "html" && !is_template_literal;
+                            // set:html always needs $$unescapeHTML — the $$render tagged
+                            // template escapes HTML by default, so all expressions (including
+                            // template literals) must be wrapped in $$unescapeHTML to be
+                            // rendered as raw HTML.
+                            let _ = is_template_literal;
+                            let needs_unescape = directive_type == "html";
                             (value_str, needs_unescape, false)
                         }
                         _ => ("void 0".to_string(), false, false),
@@ -378,11 +380,18 @@ impl<'a> AstroCodegen<'a> {
         // If both class and class:list exist, merge them
         let has_merged_class = static_class.is_some() && class_list_expr.is_some();
 
-        // Handle transition:persist — if there's a transition:name, use that for persist value.
-        // Otherwise use $$createTransitionScope.
-        if let Some((ref _persist_val, persist_span)) = transition_persist {
+        // Handle transition:persist — priority order for the persist ID:
+        // 1. If transition:persist has an explicit string value (e.g. transition:persist="form"),
+        //    use that value directly.
+        // 2. If transition:name is present, use its value.
+        // 3. Otherwise generate a unique hash via $$createTransitionScope.
+        if let Some((ref persist_val, persist_span)) = transition_persist {
             self.add_source_mapping_for_span(persist_span);
-            if let Some((ref name_val, _)) = transition_name {
+            let clean_persist = persist_val.trim_matches('"');
+            if !clean_persist.is_empty() {
+                // Explicit string value on transition:persist — use it directly.
+                self.print(&format!(" data-astro-transition-persist=\"{clean_persist}\""));
+            } else if let Some((ref name_val, _)) = transition_name {
                 let clean_val = name_val.trim_matches('"');
                 self.print(&format!(" data-astro-transition-persist=\"{clean_val}\""));
             } else {

crates/astro_codegen/src/printer/expressions.rs

@@ -199,6 +199,33 @@ impl<'a> AstroCodegen<'a> {
                 self.print("await ");
                 self.print_expression(&await_expr.argument);
             }
+            Expression::ArrayExpression(arr) => {
+                self.add_source_mapping_for_span(expr.span());
+                // Arrays may contain JSX elements — iterate and transform each element.
+                self.print("[");
+                let mut first = true;
+                for element in &arr.elements {
+                    if !first {
+                        self.print(", ");
+                    }
+                    first = false;
+                    match element {
+                        oxc_ast::ast::ArrayExpressionElement::SpreadElement(spread) => {
+                            self.print("...");
+                            self.print_expression(&spread.argument);
+                        }
+                        oxc_ast::ast::ArrayExpressionElement::Elision(_) => {
+                            // Elision — empty slot, e.g. [1,,3]
+                        }
+                        _ => {
+                            if let Some(e) = element.as_expression() {
+                                self.print_expression(e);
+                            }
+                        }
+                    }
+                }
+                self.print("]");
+            }
             _ => {
                 self.add_source_mapping_for_span(expr.span());
                 // For all other expressions, use regular codegen

crates/astro_codegen/src/printer/mod.rs

@@ -2122,41 +2122,48 @@ fn try_anchor_supplement(
         // Find the nearest anchor with inter_col <= token_col
         // (the last one in sorted order that doesn't exceed it).
         let nearest = anchors.iter().rev().find(|&&(ic, _, _)| ic <= token_col);
-        let &(anchor_ic, anchor_fl, anchor_fc) = nearest?;
-        let delta = i64::from(anchor_fc) - i64::from(anchor_ic);
-        let candidate_col = u32::try_from((i64::from(token_col) + delta).max(0))
-            .expect("candidate col exceeds u32");
-
-        // Verify: the text at the candidate final position must match the
-        // intermediate text at the token position.  This confirms we are in
-        // a quasi region (not a reformatted expression).
-        let i_text = ctx.inter_lines.get(gen_line).copied().unwrap_or("");
-        let f_text = ctx
-            .final_lines
-            .get(anchor_fl as usize)
-            .copied()
-            .unwrap_or("");
-        let tc = token_col as usize;
-        let cc = candidate_col as usize;
-        // Use a short verification window; 2 bytes is enough to confirm
-        // we're at the same quasi text (e.g. "<p", "</", etc.).
-        let verify_len = 2;
-        let text_matches = tc + verify_len <= i_text.len()
-            && cc + verify_len <= f_text.len()
-            && i_text.as_bytes()[tc..tc + verify_len] == f_text.as_bytes()[cc..cc + verify_len];
 
-        if text_matches {
-            Some((anchor_fl, candidate_col))
-        } else {
-            None
+        if let Some(&(anchor_ic, anchor_fl, anchor_fc)) = nearest {
+            let delta = i64::from(anchor_fc) - i64::from(anchor_ic);
+            let candidate_col = u32::try_from((i64::from(token_col) + delta).max(0))
+                .expect("candidate col exceeds u32");
+
+            // Verify: the text at the candidate final position must match the
+            // intermediate text at the token position.  This confirms we are in
+            // a quasi region (not a reformatted expression).
+            let i_text = ctx.inter_lines.get(gen_line).copied().unwrap_or("");
+            let f_text = ctx
+                .final_lines
+                .get(anchor_fl as usize)
+                .copied()
+                .unwrap_or("");
+            let tc = token_col as usize;
+            let cc = candidate_col as usize;
+            // Use a short verification window; 2 bytes is enough to confirm
+            // we're at the same quasi text (e.g. "<p", "</", etc.).
+            let verify_len = 2;
+            let text_matches = tc + verify_len <= i_text.len()
+                && cc + verify_len <= f_text.len()
+                && i_text.as_bytes()[tc..tc + verify_len] == f_text.as_bytes()[cc..cc + verify_len];
+
+            if text_matches {
+                return Some((anchor_fl, candidate_col));
+            }
         }
-    } else {
-        // No Phase-2 anchors for this intermediate line.
+        // No anchor at or before token_col (or text mismatch): the token is in
+        // a quasi text region that starts before all Phase-2 anchors on this
+        // line (e.g. `<span>` at col 0 when the JS suffix starts at col 25).
+        // Fall through to the window search below.
+    }
+
+    {
+        // Either: no Phase-2 anchors exist for this intermediate line (pure
+        // quasi text), or all anchors are after the token's column (token is
+        // in a quasi region before the first interpolation on this line).
         //
-        // This happens for lines that are pure template literal quasi text
-        // (no JS expressions).  Phase-2 reformatting may shift these lines
-        // by inserting extra lines for object literal properties, but the
-        // text content remains identical.
+        // Phase-2 reformatting may shift these lines by inserting extra lines
+        // for object literal properties, but the text content remains
+        // identical in the quasi regions.
         //
         // Search a window of final lines around the expected position for
         // a line containing the same text at the token's column.
@@ -4058,22 +4065,20 @@ const html = '<b>bold</b>';
     }
 
     #[test]
-    fn test_set_html_template_literal_no_unescape_html() {
-        // `set:html={`template ${literal}`}` must NOT wrap with $$unescapeHTML.
-        // The Go compiler passes template literals through as-is — matching Go behavior.
+    fn test_set_html_template_literal_uses_unescape_html() {
+        // `set:html={`template ${literal}`}` must wrap with $$unescapeHTML.
+        // The $$render tagged template escapes HTML by default, so all set:html
+        // expressions — including template literals — need $$unescapeHTML to render
+        // as raw HTML.
         let source = r#"---
 const name = 'world';
 ---
 <div set:html={`Hello <b>${name}</b>`} />"#;
         let output = compile_astro(source);
 
         assert!(
-            !output.contains("$$unescapeHTML(`"),
-            "set:html with template literal must NOT use $$unescapeHTML: {output}"
-        );
-        assert!(
-            output.contains("`Hello <b>${name}</b>`"),
-            "set:html template literal should be passed through as-is: {output}"
+            output.contains("$$unescapeHTML(`Hello <b>${name}</b>`)"),
+            "set:html with template literal must use $$unescapeHTML: {output}"
         );
     }
 
@@ -4230,4 +4235,93 @@ import { CompA, CompB } from 'test';
             "Mixed import must not be suppressed when one specifier is used normally: {output}"
         );
     }
+
+    // -------------------------------------------------------------------------
+    // transition:persist tests
+    // -------------------------------------------------------------------------
+
+    #[test]
+    fn test_transition_persist_with_explicit_value_on_html_element() {
+        // transition:persist="form" on an HTML element should use the string value
+        // directly as data-astro-transition-persist, not a generated hash.
+        let source = r#"<form transition:persist="form"><input /></form>"#;
+        let output = compile_astro(source);
+
+        assert!(
+            output.contains(r#"data-astro-transition-persist="form""#),
+            "transition:persist with explicit value must use that value: {output}"
+        );
+        // The output must not contain a $$createTransitionScope( call (only the import alias is ok)
+        assert!(
+            !output.contains("$$createTransitionScope("),
+            "transition:persist with explicit value must not call $$createTransitionScope: {output}"
+        );
+    }
+
+    #[test]
+    fn test_transition_persist_with_transition_name_on_html_element() {
+        // transition:persist + transition:name="counter" — persist ID should be "counter"
+        let source = r#"<div transition:persist transition:name="counter"></div>"#;
+        let output = compile_astro(source);
+
+        assert!(
+            output.contains(r#"data-astro-transition-persist="counter""#),
+            "transition:persist must use transition:name value as persist ID: {output}"
+        );
+    }
+
+    #[test]
+    fn test_transition_persist_with_explicit_value_on_component() {
+        // transition:persist="form" on a component should use the string value directly.
+        let source = r#"---
+import MyComp from './MyComp.astro';
+---
+<MyComp transition:persist="form" />"#;
+        let output = compile_astro(source);
+
+        assert!(
+            output.contains(r#""data-astro-transition-persist": "form""#),
+            "component transition:persist with explicit value must use that value: {output}"
+        );
+        assert!(
+            !output.contains("$$createTransitionScope("),
+            "component transition:persist with explicit value must not call $$createTransitionScope: {output}"
+        );
+    }
+
+    #[test]
+    fn test_transition_persist_with_transition_name_on_component() {
+        // transition:persist + transition:name="counter" on a component.
+        let source = r#"---
+import MyComp from './MyComp.astro';
+---
+<MyComp transition:persist transition:name="counter" />"#;
+        let output = compile_astro(source);
+
+        assert!(
+            output.contains(r#""data-astro-transition-persist": "counter""#),
+            "component transition:persist must use transition:name value: {output}"
+        );
+    }
+
+    #[test]
+    fn test_array_expression_in_jsx_transforms_children() {
+        // JSX elements inside array expressions must be transformed.
+        // Previously they were left as raw JSX in output.
+        let source = r#"---
+import Foo from './Foo.astro';
+import Bar from './Bar.astro';
+---
+<div>{[<Foo/>, <Bar/>]}</div>"#;
+        let output = compile_astro(source);
+
+        assert!(
+            !output.contains("<Foo/>") && !output.contains("<Bar/>"),
+            "JSX elements inside arrays must be transformed: {output}"
+        );
+        assert!(
+            output.contains("$$renderComponent"),
+            "JSX elements inside arrays must use $$renderComponent: {output}"
+        );
+    }
 }

crates/astro_codegen/src/printer/slots.rs

@@ -307,7 +307,7 @@ impl<'a> AstroCodegen<'a> {
         // Also track dynamic slots separately (elements with slot={expr})
         let mut dynamic_slots: Vec<(String, oxc_span::Span, Vec<&JSXChild<'a>>)> = Vec::new();
 
-        for child in children {
+        for (i, child) in children.iter().enumerate() {
             // Skip HTML comments in slots if configured
             if self.options.strip_slot_comments && matches!(child, JSXChild::AstroComment(_)) {
                 continue;
@@ -350,6 +350,29 @@ impl<'a> AstroCodegen<'a> {
                         }
                     }
                 }
+                JSXChild::Text(text) => {
+                    // A whitespace-only text node is dropped when it sits
+                    // immediately adjacent to an expression container —
+                    // specifically when it is:
+                    //   • the first child and its next sibling is an expression, OR
+                    //   • directly after an expression sibling.
+                    // This matches the Go compiler's slot child filtering exactly
+                    // and avoids passing leading/trailing whitespace through to
+                    // framework slot renderers (e.g. Vue's <slot />).
+                    if text.value.trim().is_empty() {
+                        let prev_is_expr =
+                            i > 0 && matches!(children[i - 1], JSXChild::ExpressionContainer(_));
+                        let next_is_expr = i + 1 < children.len()
+                            && matches!(children[i + 1], JSXChild::ExpressionContainer(_));
+                        let is_first = i == 0;
+                        // Drop if: leading node whose next sibling is an expression,
+                        //       or: node immediately following an expression.
+                        if (is_first && next_is_expr) || prev_is_expr {
+                            continue;
+                        }
+                    }
+                    default_children.push(child);
+                }
                 _ => {
                     default_children.push(child);
                 }