vite plugin

Author: Brooooooklyn

Cargo.lock

@@ -105,6 +105,7 @@ multiple_crate_versions = "allow"
 # publish = true
 oxc = { version = "0.105.0", path = "crates/oxc" } # Main entry point
 oxc_allocator = { version = "0.105.0", path = "crates/oxc_allocator" } # Memory management
+oxc_angular_compiler = { path = "crates/oxc_angular_compiler" } # Angular compiler
 oxc_ast = { version = "0.105.0", path = "crates/oxc_ast" } # AST definitions
 oxc_ast_macros = { version = "0.105.0", path = "crates/oxc_ast_macros" } # AST proc macros
 oxc_ast_visit = { version = "0.105.0", path = "crates/oxc_ast_visit" } # AST visitor pattern

Cargo.toml

@@ -16,8 +16,12 @@ doctest = false
 
 [dependencies]
 oxc_allocator = { workspace = true }
+oxc_ast = { workspace = true }
+oxc_codegen = { workspace = true, features = ["sourcemap"] }
 oxc_diagnostics = { workspace = true }
+oxc_parser = { workspace = true }
 oxc_span = { workspace = true }
+miette = { workspace = true }
 rustc-hash = { workspace = true }
 lazy-regex = { workspace = true }
 

crates/oxc_angular_compiler/Cargo.toml

@@ -0,0 +1,316 @@
+//! Angular `@Component` decorator parser.
+//!
+//! This module extracts metadata from `@Component({...})` decorators
+//! on TypeScript class declarations.
+
+use oxc_allocator::{Allocator, Vec};
+use oxc_ast::ast::{
+    Argument, ArrayExpressionElement, Class, Decorator, Expression, ObjectPropertyKind, PropertyKey,
+};
+use oxc_span::Atom;
+
+use super::metadata::{
+    ChangeDetectionStrategy, ComponentMetadata, HostMetadata, ViewEncapsulation,
+};
+
+/// Extract component metadata from a class with decorators.
+///
+/// Searches for a `@Component({...})` decorator and parses its properties.
+/// Returns `None` if no `@Component` decorator is found.
+///
+/// # Example
+///
+/// ```typescript
+/// @Component({
+///   selector: 'app-root',
+///   template: '<h1>Hello</h1>',
+///   standalone: true,
+/// })
+/// export class AppComponent {}
+/// ```
+pub fn extract_component_metadata<'a>(
+    allocator: &'a Allocator,
+    class: &'a Class<'a>,
+) -> Option<ComponentMetadata<'a>> {
+    // Get the class name
+    let class_name = class.id.as_ref()?.name.clone();
+    let class_span = class.span;
+
+    // Find the @Component decorator
+    let component_decorator = find_component_decorator(&class.decorators)?;
+
+    // Get the decorator call arguments
+    let call_expr = match &component_decorator.expression {
+        Expression::CallExpression(call) => call,
+        _ => return None,
+    };
+
+    // Verify it's calling 'Component'
+    if !is_component_call(&call_expr.callee) {
+        return None;
+    }
+
+    // Get the first argument (the config object)
+    let config_arg = call_expr.arguments.first()?;
+    let config_obj = match config_arg {
+        Argument::ObjectExpression(obj) => obj,
+        _ => return None,
+    };
+
+    // Create metadata with defaults
+    let mut metadata = ComponentMetadata::new(allocator, class_name, class_span);
+
+    // Parse each property in the config object
+    for prop in &config_obj.properties {
+        if let ObjectPropertyKind::ObjectProperty(prop) = prop {
+            let key_name = get_property_key_name(&prop.key)?;
+
+            match key_name.as_str() {
+                "selector" => {
+                    metadata.selector = extract_string_value(&prop.value);
+                }
+                "template" => {
+                    metadata.template = extract_string_value(&prop.value);
+                }
+                "templateUrl" => {
+                    metadata.template_url = extract_string_value(&prop.value);
+                }
+                "styles" => {
+                    if let Some(styles) = extract_string_array(allocator, &prop.value) {
+                        metadata.styles = styles;
+                    } else if let Some(style) = extract_string_value(&prop.value) {
+                        // Single style string (legacy support)
+                        metadata.styles.push(style);
+                    }
+                }
+                "styleUrls" | "styleUrl" => {
+                    if let Some(urls) = extract_string_array(allocator, &prop.value) {
+                        metadata.style_urls = urls;
+                    } else if let Some(url) = extract_string_value(&prop.value) {
+                        metadata.style_urls.push(url);
+                    }
+                }
+                "standalone" => {
+                    metadata.standalone = extract_boolean_value(&prop.value).unwrap_or(false);
+                }
+                "encapsulation" => {
+                    metadata.encapsulation = extract_encapsulation(&prop.value);
+                }
+                "changeDetection" => {
+                    metadata.change_detection = extract_change_detection(&prop.value);
+                }
+                "host" => {
+                    metadata.host = extract_host_metadata(allocator, &prop.value);
+                }
+                "imports" => {
+                    // For standalone components - we just need the identifiers
+                    metadata.imports = extract_identifier_array(allocator, &prop.value);
+                }
+                "exportAs" => {
+                    metadata.export_as = extract_string_value(&prop.value);
+                }
+                "preserveWhitespaces" => {
+                    metadata.preserve_whitespaces =
+                        extract_boolean_value(&prop.value).unwrap_or(false);
+                }
+                _ => {
+                    // Unknown property - ignore
+                }
+            }
+        }
+    }
+
+    Some(metadata)
+}
+
+/// Find the @Component decorator in a list of decorators.
+fn find_component_decorator<'a>(decorators: &'a [Decorator<'a>]) -> Option<&'a Decorator<'a>> {
+    decorators.iter().find(|d| match &d.expression {
+        Expression::CallExpression(call) => is_component_call(&call.callee),
+        Expression::Identifier(id) => id.name == "Component",
+        _ => false,
+    })
+}
+
+/// Check if a callee expression is a call to 'Component'.
+fn is_component_call(callee: &Expression<'_>) -> bool {
+    match callee {
+        Expression::Identifier(id) => id.name == "Component",
+        // Handle namespaced imports like ng.Component or core.Component
+        Expression::StaticMemberExpression(member) => {
+            matches!(&member.property.name.as_str(), &"Component")
+        }
+        _ => false,
+    }
+}
+
+/// Get the name of a property key as a string.
+fn get_property_key_name<'a>(key: &PropertyKey<'a>) -> Option<Atom<'a>> {
+    match key {
+        PropertyKey::StaticIdentifier(id) => Some(id.name.clone()),
+        PropertyKey::StringLiteral(lit) => Some(lit.value.clone()),
+        _ => None,
+    }
+}
+
+/// Extract a string value from an expression.
+fn extract_string_value<'a>(expr: &Expression<'a>) -> Option<Atom<'a>> {
+    match expr {
+        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())
+        }
+        _ => None,
+    }
+}
+
+/// Extract a boolean value from an expression.
+fn extract_boolean_value(expr: &Expression<'_>) -> Option<bool> {
+    match expr {
+        Expression::BooleanLiteral(lit) => Some(lit.value),
+        _ => None,
+    }
+}
+
+/// Extract an array of strings from an expression.
+fn extract_string_array<'a>(
+    allocator: &'a Allocator,
+    expr: &Expression<'a>,
+) -> Option<Vec<'a, Atom<'a>>> {
+    let Expression::ArrayExpression(arr) = expr else {
+        return None;
+    };
+
+    let mut result = Vec::new_in(allocator);
+    for element in &arr.elements {
+        if let ArrayExpressionElement::StringLiteral(lit) = element {
+            result.push(lit.value.clone());
+        } else if let ArrayExpressionElement::TemplateLiteral(tpl) = element {
+            if tpl.expressions.is_empty() {
+                if let Some(quasi) = tpl.quasis.first() {
+                    result.push(quasi.value.raw.clone());
+                }
+            }
+        }
+    }
+
+    Some(result)
+}
+
+/// Extract an array of identifiers (for imports).
+fn extract_identifier_array<'a>(
+    allocator: &'a Allocator,
+    expr: &Expression<'a>,
+) -> Vec<'a, Atom<'a>> {
+    let mut result = Vec::new_in(allocator);
+
+    let Expression::ArrayExpression(arr) = expr else {
+        return result;
+    };
+
+    for element in &arr.elements {
+        match element {
+            ArrayExpressionElement::Identifier(id) => {
+                result.push(id.name.clone());
+            }
+            // Handle spread elements, etc. - for now just collect identifiers
+            _ => {}
+        }
+    }
+
+    result
+}
+
+/// Extract ViewEncapsulation from an expression.
+fn extract_encapsulation(expr: &Expression<'_>) -> ViewEncapsulation {
+    // Look for patterns like:
+    // - ViewEncapsulation.None
+    // - ViewEncapsulation.Emulated
+    // - ViewEncapsulation.ShadowDom
+    // - 0, 2, 3 (numeric values)
+    match expr {
+        Expression::StaticMemberExpression(member) => match member.property.name.as_str() {
+            "None" => ViewEncapsulation::None,
+            "ShadowDom" => ViewEncapsulation::ShadowDom,
+            "Emulated" => ViewEncapsulation::Emulated,
+            _ => ViewEncapsulation::default(),
+        },
+        Expression::NumericLiteral(num) => {
+            // Angular's numeric values: Emulated = 0, None = 2, ShadowDom = 3
+            match num.value as i32 {
+                0 => ViewEncapsulation::Emulated,
+                2 => ViewEncapsulation::None,
+                3 => ViewEncapsulation::ShadowDom,
+                _ => ViewEncapsulation::default(),
+            }
+        }
+        _ => ViewEncapsulation::default(),
+    }
+}
+
+/// Extract ChangeDetectionStrategy from an expression.
+fn extract_change_detection(expr: &Expression<'_>) -> ChangeDetectionStrategy {
+    match expr {
+        Expression::StaticMemberExpression(member) => match member.property.name.as_str() {
+            "OnPush" => ChangeDetectionStrategy::OnPush,
+            "Default" => ChangeDetectionStrategy::Default,
+            _ => ChangeDetectionStrategy::default(),
+        },
+        Expression::NumericLiteral(num) => {
+            // Angular's numeric values: Default = 0, OnPush = 1
+            match num.value as i32 {
+                1 => ChangeDetectionStrategy::OnPush,
+                _ => ChangeDetectionStrategy::default(),
+            }
+        }
+        _ => ChangeDetectionStrategy::default(),
+    }
+}
+
+/// Extract host metadata from a host object expression.
+fn extract_host_metadata<'a>(
+    allocator: &'a Allocator,
+    expr: &Expression<'a>,
+) -> Option<HostMetadata<'a>> {
+    let Expression::ObjectExpression(obj) = expr else {
+        return None;
+    };
+
+    let mut host = HostMetadata {
+        properties: Vec::new_in(allocator),
+        attributes: Vec::new_in(allocator),
+        listeners: Vec::new_in(allocator),
+    };
+
+    for prop in &obj.properties {
+        if let ObjectPropertyKind::ObjectProperty(prop) = prop {
+            let Some(key_name) = get_property_key_name(&prop.key) else {
+                continue;
+            };
+            let Some(value) = extract_string_value(&prop.value) else {
+                continue;
+            };
+
+            let key_str = key_name.as_str();
+
+            if key_str.starts_with('[') && key_str.ends_with(']') {
+                // Property binding: [class.active]
+                host.properties.push((key_name, value));
+            } else if key_str.starts_with('(') && key_str.ends_with(')') {
+                // Event listener: (click)
+                host.listeners.push((key_name, value));
+            } else {
+                // Static attribute
+                host.attributes.push((key_name, value));
+            }
+        }
+    }
+
+    Some(host)
+}
+
+#[cfg(test)]
+mod tests {
+    // Tests will be added when oxc_ast is available as a dependency
+}