align html escape

Author: Brooooooklyn

crates/oxc_angular_compiler/src/ast/html.rs

@@ -95,7 +95,15 @@ pub struct HtmlText<'a> {
 #[derive(Debug)]
 pub struct HtmlElement<'a> {
     /// The element tag name.
+    /// For regular elements: the tag name (e.g., "div", ":svg:rect").
+    /// For selectorless components: the component name (e.g., "MyComp").
     pub name: Atom<'a>,
+    /// For selectorless components: the namespace prefix (e.g., "svg" in `<ng-component:MyComp:svg:rect>`).
+    /// None for regular elements or selectorless components without namespace.
+    pub component_prefix: Option<Atom<'a>>,
+    /// For selectorless components: the HTML tag name (e.g., "rect" in `<ng-component:MyComp:svg:rect>`).
+    /// None for regular elements or selectorless components without tag name.
+    pub component_tag_name: Option<Atom<'a>>,
     /// The element attributes.
     pub attrs: Vec<'a, HtmlAttribute<'a>>,
     /// Selectorless directives (e.g., @Dir, @Dir(attr="value")).
@@ -451,6 +459,8 @@ mod tests {
         // Create a simple tree: root element with two child elements
         let child1 = HtmlElement {
             name: Atom::from("span"),
+            component_prefix: None,
+            component_tag_name: None,
             attrs: Vec::new_in(&allocator),
             directives: Vec::new_in(&allocator),
             children: Vec::new_in(&allocator),
@@ -463,6 +473,8 @@ mod tests {
 
         let child2 = HtmlElement {
             name: Atom::from("p"),
+            component_prefix: None,
+            component_tag_name: None,
             attrs: Vec::new_in(&allocator),
             directives: Vec::new_in(&allocator),
             children: Vec::new_in(&allocator),
@@ -479,6 +491,8 @@ mod tests {
 
         let root = HtmlElement {
             name: Atom::from("div"),
+            component_prefix: None,
+            component_tag_name: None,
             attrs: Vec::new_in(&allocator),
             directives: Vec::new_in(&allocator),
             children,

crates/oxc_angular_compiler/src/component/decorator.rs

@@ -178,7 +178,9 @@ fn extract_string_value<'a>(expr: &Expression<'a>) -> Option<Atom<'a>> {
         Expression::StringLiteral(lit) => Some(lit.value.clone()),
         Expression::TemplateLiteral(tpl) if tpl.expressions.is_empty() => {
             // Simple template literal with no expressions: `template string`
-            tpl.quasis.first().map(|q| q.value.raw.clone())
+            // Use cooked value to properly interpret escape sequences (\n -> newline)
+            // Angular evaluates template literals, so we need cooked, not raw
+            tpl.quasis.first().and_then(|q| q.value.cooked.clone())
         }
         _ => None,
     }
@@ -207,8 +209,11 @@ fn extract_string_array<'a>(
             result.push(lit.value.clone());
         } else if let ArrayExpressionElement::TemplateLiteral(tpl) = element {
             if tpl.expressions.is_empty() {
+                // Use cooked value to properly interpret escape sequences
                 if let Some(quasi) = tpl.quasis.first() {
-                    result.push(quasi.value.raw.clone());
+                    if let Some(cooked) = &quasi.value.cooked {
+                        result.push(cooked.clone());
+                    }
                 }
             }
         }

crates/oxc_angular_compiler/src/component/transform.rs

@@ -419,12 +419,14 @@ fn compile_component_full<'a>(
 
     // Stage 1: Parse HTML
     // Build parse options from component metadata
+    // Angular always forces tokenizeExpansionForms: true in parseTemplate()
     let parse_options = ParseTemplateOptions {
         preserve_whitespaces: metadata.preserve_whitespaces,
         // Enable modern syntax features (block syntax, let declarations)
         enable_block_syntax: true,
         enable_let_syntax: true,
-        // Other options left at defaults for now
+        // Always enable ICU expansion forms - Angular forces this in template.ts:152
+        tokenize_expansion_forms: true,
         ..Default::default()
     };
     let parser = HtmlParser::with_options(allocator, template, file_path, &parse_options);
@@ -636,10 +638,13 @@ pub fn compile_component_template<'a>(
     let mut diagnostics = Vec::new();
 
     // Stage 1: Parse HTML with default options
+    // Angular always forces tokenizeExpansionForms: true in parseTemplate()
     let parse_options = ParseTemplateOptions {
         // Enable modern syntax features (block syntax, let declarations)
         enable_block_syntax: true,
         enable_let_syntax: true,
+        // Always enable ICU expansion forms - Angular forces this in template.ts:152
+        tokenize_expansion_forms: true,
         // preserve_whitespaces defaults to false, matching Angular's default
         ..Default::default()
     };
@@ -730,10 +735,13 @@ pub fn compile_template_to_js_with_options<'a>(
     let mut diagnostics = Vec::new();
 
     // Stage 1: Parse HTML with default options
+    // Angular always forces tokenizeExpansionForms: true in parseTemplate()
     let parse_options = ParseTemplateOptions {
         // Enable modern syntax features (block syntax, let declarations)
         enable_block_syntax: true,
         enable_let_syntax: true,
+        // Always enable ICU expansion forms - Angular forces this in template.ts:152
+        tokenize_expansion_forms: true,
         // preserve_whitespaces defaults to false, matching Angular's default
         ..Default::default()
     };

crates/oxc_angular_compiler/src/ir/ops.rs

@@ -1150,6 +1150,10 @@ pub struct RepeaterCreateOp<'a> {
     pub vars: Option<u32>,
     /// Var names for template.
     pub var_names: RepeaterVarNames<'a>,
+    /// HTML tag name (for content projection).
+    pub tag: Option<Atom<'a>>,
+    /// HTML tag name for empty view (for content projection).
+    pub empty_tag: Option<Atom<'a>>,
     /// I18n placeholder data (start_name and close_name for @for block).
     pub i18n_placeholder: Option<I18nPlaceholder<'a>>,
     /// I18n placeholder data for @empty view.
@@ -1535,6 +1539,12 @@ pub struct AttributeOp<'a> {
     pub i18n_context: Option<XrefId>,
     /// I18n message.
     pub i18n_message: Option<XrefId>,
+    /// Whether this is a text attribute (static attribute from template).
+    ///
+    /// Text attributes are extractable to the consts array and don't need
+    /// runtime updates. This is used by attribute_extraction to determine
+    /// if the attribute should be extracted.
+    pub is_text_attribute: bool,
 }
 
 /// DOM property binding.

crates/oxc_angular_compiler/src/parser/html/lexer.rs

@@ -545,6 +545,9 @@ pub struct HtmlLexer<'a> {
     /// Enable block tokenization (default: true).
     /// When enabled, standalone `}` characters become BLOCK_CLOSE tokens.
     tokenize_blocks: bool,
+    /// Enable @let tokenization (default: true).
+    /// When disabled, @let is treated as text or incomplete block.
+    tokenize_let: bool,
     /// Characters to consider as leading trivia (for source map optimization).
     leading_trivia_chars: Option<Vec<char>>,
     /// Range start position (for processing a sub-range of input).
@@ -577,6 +580,7 @@ impl<'a> HtmlLexer<'a> {
             expansion_case_stack: Vec::new(),
             escaped_string: false,
             tokenize_blocks: true, // default to true like Angular
+            tokenize_let: true,    // default to true like Angular
             leading_trivia_chars: None,
             range_start_pos: 0,
             range_end_pos: length,
@@ -616,6 +620,12 @@ impl<'a> HtmlLexer<'a> {
         self
     }
 
+    /// Enables or disables @let tokenization.
+    pub fn with_let(mut self, enabled: bool) -> Self {
+        self.tokenize_let = enabled;
+        self
+    }
+
     /// Sets the leading trivia characters for source map optimization.
     pub fn with_leading_trivia_chars(mut self, chars: Vec<char>) -> Self {
         self.leading_trivia_chars = Some(chars);
@@ -988,8 +998,8 @@ impl<'a> HtmlLexer<'a> {
             return;
         }
 
-        // Check for @let declarations
-        if self.peek() == '@' && self.starts_with("@let") {
+        // Check for @let declarations (only if tokenize_let is enabled)
+        if self.tokenize_let && self.peek() == '@' && self.starts_with("@let") {
             // Make sure "@let" is followed by whitespace (not "@letter")
             let next_char_index = self.index as usize + 4;
             if next_char_index < self.input.len() {
@@ -1018,7 +1028,7 @@ impl<'a> HtmlLexer<'a> {
 
         // Check for block start (@if, @for, etc.)
         // Only match supported block keywords - `@` followed by non-keyword is text
-        if self.is_block_start() {
+        if self.tokenize_blocks && self.is_block_start() {
             self.scan_block(start);
             return;
         }

crates/oxc_angular_compiler/src/parser/html/parser.rs

@@ -63,17 +63,17 @@ pub struct HtmlParser<'a> {
 impl<'a> HtmlParser<'a> {
     /// Creates a new parser.
     pub fn new(allocator: &'a Allocator, source: &'a str, url: &str) -> Self {
-        Self::new_internal(allocator, source, url, false, false, None)
+        Self::new_internal(allocator, source, url, false, false, None, true, true, None)
     }
 
     /// Creates a new parser with selectorless mode enabled.
     pub fn with_selectorless(allocator: &'a Allocator, source: &'a str, url: &str) -> Self {
-        Self::new_internal(allocator, source, url, true, false, None)
+        Self::new_internal(allocator, source, url, true, false, None, true, true, None)
     }
 
     /// Creates a new parser with expansion forms (ICU messages) enabled.
     pub fn with_expansion_forms(allocator: &'a Allocator, source: &'a str, url: &str) -> Self {
-        Self::new_internal(allocator, source, url, false, true, None)
+        Self::new_internal(allocator, source, url, false, true, None, true, true, None)
     }
 
     /// Creates a new parser with expansion forms and leading trivia chars enabled.
@@ -83,7 +83,17 @@ impl<'a> HtmlParser<'a> {
         url: &str,
         leading_trivia_chars: std::vec::Vec<char>,
     ) -> Self {
-        Self::new_internal(allocator, source, url, false, true, Some(leading_trivia_chars))
+        Self::new_internal(
+            allocator,
+            source,
+            url,
+            false,
+            true,
+            Some(leading_trivia_chars),
+            true,
+            true,
+            None,
+        )
     }
 
     /// Creates a new parser with the given template options.
@@ -103,6 +113,9 @@ impl<'a> HtmlParser<'a> {
             options.enable_selectorless,
             options.tokenize_expansion_forms,
             options.leading_trivia_chars.clone(),
+            options.enable_block_syntax,
+            options.enable_let_syntax,
+            options.interpolation.as_ref().map(|(s, e)| (s.as_str(), e.as_str())),
         )
     }
 
@@ -114,15 +127,24 @@ impl<'a> HtmlParser<'a> {
         selectorless: bool,
         expansion_forms: bool,
         leading_trivia_chars: Option<std::vec::Vec<char>>,
+        tokenize_blocks: bool,
+        tokenize_let: bool,
+        interpolation: Option<(&str, &str)>,
     ) -> Self {
         let mut lexer = HtmlLexer::new(source)
             .with_selectorless(selectorless)
-            .with_expansion_forms(expansion_forms);
+            .with_expansion_forms(expansion_forms)
+            .with_blocks(tokenize_blocks)
+            .with_let(tokenize_let);
 
         if let Some(chars) = leading_trivia_chars {
             lexer = lexer.with_leading_trivia_chars(chars);
         }
 
+        if let Some((start, end)) = interpolation {
+            lexer = lexer.with_interpolation(start, end);
+        }
+
         let result = lexer.tokenize();
         let source_file = Arc::new(ParseSourceFile::new(source.to_string(), url.to_string()));
 
@@ -208,6 +230,8 @@ impl<'a> HtmlParser<'a> {
                         &mut self.elements[idx],
                         HtmlElement {
                             name: Atom::from(""),
+                            component_prefix: None,
+                            component_tag_name: None,
                             attrs: Vec::new_in(self.allocator),
                             directives: Vec::new_in(self.allocator),
                             children: Vec::new_in(self.allocator),
@@ -335,6 +359,8 @@ impl<'a> HtmlParser<'a> {
                         &mut self.elements[idx],
                         HtmlElement {
                             name: Atom::from(""),
+                            component_prefix: None,
+                            component_tag_name: None,
                             attrs: Vec::new_in(self.allocator),
                             directives: Vec::new_in(self.allocator),
                             children: Vec::new_in(self.allocator),
@@ -376,6 +402,8 @@ impl<'a> HtmlParser<'a> {
             &mut self.elements[match_elem_idx],
             HtmlElement {
                 name: Atom::from(""),
+                component_prefix: None,
+                component_tag_name: None,
                 attrs: Vec::new_in(self.allocator),
                 directives: Vec::new_in(self.allocator),
                 children: Vec::new_in(self.allocator),
@@ -521,11 +549,20 @@ impl<'a> HtmlParser<'a> {
         let start = start_token.start;
         // TagOpenStart has parts [prefix, name]
         // ComponentOpenStart has parts [component_name, prefix, tag_name]
-        let (tag_name, local_name, has_ns_prefix) =
+        let (tag_name, local_name, has_ns_prefix, component_prefix, component_tag_name) =
             if start_token.token_type == HtmlTokenType::ComponentOpenStart {
-                // For components, use the component name (first part)
-                let name = start_token.value().to_string();
-                (name.clone(), name, false)
+                // For components, extract all three parts:
+                // parts[0] = component_name, parts[1] = prefix, parts[2] = tag_name
+                let component_name = start_token.parts.first().cloned().unwrap_or_default();
+                let prefix = start_token.parts.get(1).cloned().unwrap_or_default();
+                let raw_tag_name = start_token.parts.get(2).cloned().unwrap_or_default();
+
+                // Store prefix and tag_name for HtmlElement
+                let prefix_opt = if prefix.is_empty() { None } else { Some(prefix.clone()) };
+                let tag_opt =
+                    if raw_tag_name.is_empty() { None } else { Some(raw_tag_name.clone()) };
+
+                (component_name.clone(), component_name, false, prefix_opt, tag_opt)
             } else {
                 // For regular tags, include the namespace prefix if present
                 // Angular uses :prefix:name format for namespaced elements
@@ -534,7 +571,7 @@ impl<'a> HtmlParser<'a> {
                 let has_prefix = !prefix.is_empty();
                 let full_name =
                     if has_prefix { format!(":{}:{}", prefix, name) } else { name.to_string() };
-                (full_name, name.to_string(), has_prefix)
+                (full_name, name.to_string(), has_prefix, None, None)
             };
 
         // Check if we need to auto-close the current element (HTML5 optional end tags)
@@ -596,6 +633,8 @@ impl<'a> HtmlParser<'a> {
 
         let element = HtmlElement {
             name: Atom::from_in(tag_name.clone(), self.allocator),
+            component_prefix: component_prefix.map(|p| Atom::from_in(p, self.allocator)),
+            component_tag_name: component_tag_name.map(|t| Atom::from_in(t, self.allocator)),
             attrs,
             directives,
             children: Vec::new_in(self.allocator),
@@ -1071,6 +1110,8 @@ impl<'a> HtmlParser<'a> {
         // Note: is_self_closing is false because this is an incomplete tag, not explicitly self-closing
         let element = HtmlElement {
             name: Atom::from_in(tag_name.clone(), self.allocator),
+            component_prefix: None,
+            component_tag_name: None,
             attrs: Vec::new_in(self.allocator),
             directives: Vec::new_in(self.allocator),
             children: Vec::new_in(self.allocator),

crates/oxc_angular_compiler/src/parser/html/whitespace.rs

@@ -335,6 +335,8 @@ impl<'a> WhitespaceVisitor<'a> {
     fn clone_element_shallow(&self, el: &HtmlElement<'a>) -> HtmlElement<'a> {
         HtmlElement {
             name: el.name.clone(),
+            component_prefix: el.component_prefix.clone(),
+            component_tag_name: el.component_tag_name.clone(),
             attrs: self.clone_attributes(&el.attrs),
             directives: self.clone_directives(&el.directives),
             children: self.clone_children(&el.children),
@@ -510,6 +512,8 @@ impl<'a> WhitespaceVisitor<'a> {
             return Some(HtmlNode::Element(Box::new_in(
                 HtmlElement {
                     name: element.name.clone(),
+                    component_prefix: element.component_prefix.clone(),
+                    component_tag_name: element.component_tag_name.clone(),
                     attrs,
                     directives: self.clone_directives(&element.directives),
                     children: self.clone_children(&element.children),
@@ -529,6 +533,8 @@ impl<'a> WhitespaceVisitor<'a> {
         Some(HtmlNode::Element(Box::new_in(
             HtmlElement {
                 name: element.name.clone(),
+                component_prefix: element.component_prefix.clone(),
+                component_tag_name: element.component_tag_name.clone(),
                 attrs: self.clone_attributes(&element.attrs),
                 directives: self.clone_directives(&element.directives),
                 children,