vite plugin fix

Author: Brooooooklyn

Cargo.lock

@@ -17,7 +17,6 @@ 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 }

crates/oxc_angular_compiler/Cargo.toml

@@ -7,7 +7,7 @@ use oxc_allocator::{Allocator, Vec};
 use oxc_ast::ast::{
     Argument, ArrayExpressionElement, Class, Decorator, Expression, ObjectPropertyKind, PropertyKey,
 };
-use oxc_span::Atom;
+use oxc_span::{Atom, Span};
 
 use super::metadata::{
     ChangeDetectionStrategy, ComponentMetadata, HostMetadata, ViewEncapsulation,
@@ -132,6 +132,14 @@ fn find_component_decorator<'a>(decorators: &'a [Decorator<'a>]) -> Option<&'a D
     })
 }
 
+/// Find the span of the @Component decorator on a class.
+///
+/// Returns the span including any leading whitespace/newlines that should be removed
+/// along with the decorator.
+pub fn find_component_decorator_span(class: &Class<'_>) -> Option<Span> {
+    find_component_decorator(&class.decorators).map(|d| d.span)
+}
+
 /// Check if a callee expression is a call to 'Component'.
 fn is_component_call(callee: &Expression<'_>) -> bool {
     match callee {

crates/oxc_angular_compiler/src/component/decorator.rs

@@ -120,7 +120,7 @@ impl<'a> ComponentMetadata<'a> {
             template_url: None,
             styles: Vec::new_in(allocator),
             style_urls: Vec::new_in(allocator),
-            standalone: false,
+            standalone: true, // Angular v17+ defaults to standalone
             encapsulation: ViewEncapsulation::default(),
             change_detection: ChangeDetectionStrategy::default(),
             host: None,

crates/oxc_angular_compiler/src/component/metadata.rs

@@ -4,16 +4,14 @@
 //! containing Angular components into compiled JavaScript.
 
 use std::collections::HashMap;
-use std::path::PathBuf;
 
 use oxc_allocator::Allocator;
 use oxc_ast::ast::{Declaration, ExportDefaultDeclarationKind, Statement};
-use oxc_codegen::{Codegen, CodegenOptions};
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_parser::Parser;
-use oxc_span::{Atom, SourceType};
+use oxc_span::{Atom, SourceType, Span};
 
-use super::decorator::extract_component_metadata;
+use super::decorator::{extract_component_metadata, find_component_decorator_span};
 use super::definition::generate_component_definitions;
 use super::metadata::ComponentMetadata;
 use crate::output::ast::FunctionExpr;
@@ -162,8 +160,9 @@ pub fn transform_angular_file(
         // Still continue to try to generate output for partial results
     }
 
-    // Collect component definitions to append after codegen
+    // Collect component definitions to append and decorator spans to remove
     let mut component_definitions: Vec<String> = Vec::new();
+    let mut decorator_spans_to_remove: Vec<Span> = Vec::new();
     let mut needs_angular_core_import = false;
 
     // 2. Walk AST to find @Component decorated classes and extract metadata
@@ -201,9 +200,16 @@ pub fn transform_angular_file(
                                 );
                             }
 
+                            // Track the decorator span to remove
+                            if let Some(span) = find_component_decorator_span(class) {
+                                decorator_spans_to_remove.push(span);
+                            }
+
                             // Store the ɵcmp/ɵfac definitions to append later
+                            // Include declarations (child view functions) before ɵcmp
                             component_definitions.push(format!(
-                                "{}.ɵcmp = {};\n{}.ɵfac = {};",
+                                "{}{}.ɵcmp = {};\n{}.ɵfac = {};",
+                                compilation_result.declarations_js,
                                 class_name,
                                 compilation_result.cmp_js,
                                 class_name,
@@ -236,13 +242,36 @@ pub fn transform_angular_file(
         }
     }
 
-    // 5. Generate output code using oxc_codegen
-    let codegen_options = CodegenOptions {
-        single_quote: true,
-        source_map_path: if options.sourcemap { Some(PathBuf::from(path)) } else { None },
-        ..Default::default()
-    };
-    let codegen_ret = Codegen::new().with_options(codegen_options).build(&parser_ret.program);
+    // 5. Generate output code by modifying the original source
+    // We use string manipulation instead of oxc_codegen to preserve
+    // the original code structure and avoid decorator placement issues.
+
+    // Sort decorator spans in reverse order so we can remove them from back to front
+    decorator_spans_to_remove.sort_by(|a, b| b.start.cmp(&a.start));
+
+    // Start with the original source
+    let mut modified_source = source.to_string();
+
+    // Remove each decorator span from the source
+    for span in decorator_spans_to_remove {
+        let start = span.start as usize;
+        let end = span.end as usize;
+
+        // Find any trailing whitespace/newline after the decorator to also remove
+        let mut actual_end = end;
+        let bytes = modified_source.as_bytes();
+        while actual_end < bytes.len() {
+            let c = bytes[actual_end];
+            if c == b' ' || c == b'\t' || c == b'\n' || c == b'\r' {
+                actual_end += 1;
+            } else {
+                break;
+            }
+        }
+
+        // Remove the decorator and trailing whitespace
+        modified_source.replace_range(start..actual_end, "");
+    }
 
     // Build final code with imports and definitions
     let mut code = String::new();
@@ -252,8 +281,8 @@ pub fn transform_angular_file(
         code.push_str("import * as i0 from '@angular/core';\n");
     }
 
-    // Append the original code
-    code.push_str(&codegen_ret.code);
+    // Append the modified original code
+    code.push_str(&modified_source);
 
     // Append ɵcmp/ɵfac definitions after the generated code
     if !component_definitions.is_empty() {
@@ -265,7 +294,8 @@ pub fn transform_angular_file(
     }
 
     result.code = code;
-    result.map = codegen_ret.map.map(|m| m.to_json_string());
+    // Note: source maps not supported with string manipulation approach
+    result.map = None;
 
     result
 }
@@ -280,6 +310,9 @@ struct FullCompilationResult {
 
     /// ɵfac factory function as JavaScript.
     fac_js: String,
+
+    /// Additional declarations (child view functions, constants).
+    declarations_js: String,
 }
 
 /// Compile a component template and generate ɵcmp/ɵfac definitions.
@@ -332,6 +365,13 @@ fn compile_component_full<'a>(
     // Emit JavaScript
     let emitter = JsEmitter::new();
 
+    // Emit declarations (child view functions, constants)
+    let mut declarations_js = String::new();
+    for decl in compiled.declarations.iter() {
+        declarations_js.push_str(&emitter.emit_statement(decl));
+        declarations_js.push('\n');
+    }
+
     // For HMR, we emit the template separately using compile_template_to_js
     // The ɵcmp already contains the template function inline
     let template_js =
@@ -354,7 +394,7 @@ fn compile_component_full<'a>(
         // Errors would have been caught earlier in parsing/transformation
     }
 
-    Ok(FullCompilationResult { template_js, cmp_js, fac_js })
+    Ok(FullCompilationResult { template_js, cmp_js, fac_js, declarations_js })
 }
 
 /// Resolve template content from inline or external source.

crates/oxc_angular_compiler/src/component/transform.rs

@@ -118,12 +118,12 @@ fn get_slot_dependency_target(op: &UpdateOp<'_>) -> Option<XrefId> {
         UpdateOp::Animation(anim) => Some(anim.target),
         UpdateOp::AnimationBinding(anim) => Some(anim.target),
         UpdateOp::Control(ctrl) => Some(ctrl.target),
+        UpdateOp::Repeater(rep) => Some(rep.target),
+        UpdateOp::Conditional(cond) => Some(cond.target),
         // These operations don't depend on slot context
         UpdateOp::ListEnd(_)
         | UpdateOp::Advance(_)
-        | UpdateOp::Repeater(_)
         | UpdateOp::StoreLet(_)
-        | UpdateOp::Conditional(_)
         | UpdateOp::I18nApply(_)
         | UpdateOp::Variable(_)
         | UpdateOp::DeferWhen(_)

crates/oxc_angular_compiler/src/pipeline/phases/generate_advance.rs

@@ -16,7 +16,7 @@ use oxc_allocator::Box;
 use oxc_span::Atom;
 
 use crate::ir::enums::{SemanticVariableKind, VariableFlags};
-use crate::ir::expression::{ContextExpr, GetCurrentViewExpr, IrExpression};
+use crate::ir::expression::{ContextExpr, GetCurrentViewExpr, IrExpression, NextContextExpr};
 use crate::ir::ops::{CreateOp, UpdateOp, UpdateVariableOp, VariableOp, XrefId};
 use crate::pipeline::compilation::ComponentCompilationJob;
 
@@ -48,12 +48,14 @@ pub fn generate_variables(job: &mut ComponentCompilationJob<'_>) {
         };
 
         // Generate context variable for embedded views
+        // This goes in the UPDATE phase, not create, following Angular's pattern
         if needs_context {
             let ctx_var_xref = job.allocate_xref_id();
-            let context_var = create_context_variable(allocator, ctx_var_xref, root_xref);
+            let context_var =
+                create_context_variable_for_update(allocator, ctx_var_xref, root_xref);
 
             if let Some(view) = job.views.get_mut(&view_xref) {
-                view.create.push_front(context_var);
+                view.update.push_front(context_var);
             }
         }
 
@@ -92,22 +94,23 @@ fn has_listeners(create_ops: &crate::ir::list::CreateOpList<'_>) -> bool {
     false
 }
 
-/// Creates a context variable operation.
+/// Creates a context variable operation for the UPDATE phase.
 ///
-/// Context variables store a reference to the component context for use in
-/// embedded views that need to access component properties.
-fn create_context_variable<'a>(
+/// Context variables in embedded views use `NextContextExpr` to navigate to the
+/// parent view's context. This is added to the update phase, not create.
+fn create_context_variable_for_update<'a>(
     allocator: &'a oxc_allocator::Allocator,
     xref: XrefId,
     context_view: XrefId,
-) -> CreateOp<'a> {
-    // Create context expression as initializer
-    let initializer = IrExpression::Context(Box::new_in(
-        ContextExpr { view: context_view, source_span: None },
+) -> UpdateOp<'a> {
+    // Use NextContextExpr to navigate to parent context
+    // This is what Angular uses for embedded views accessing parent context
+    let initializer = IrExpression::NextContext(Box::new_in(
+        NextContextExpr { steps: 1, source_span: None },
         allocator,
     ));
 
-    CreateOp::Variable(VariableOp {
+    UpdateOp::Variable(UpdateVariableOp {
         base: Default::default(),
         xref,
         kind: SemanticVariableKind::Context,