fix: populate source map in transformAngularFile when sourcemap option is enabled

The edit-based transform pipeline never generated source maps, leaving
`TransformResult.map` as `None` even when `sourcemap: true`. Add
`apply_edits_with_sourcemap` that produces a source map by analyzing
which original byte ranges survive in the output, and wire it into the
AOT, JIT, and no-Angular-classes code paths.

- Close #99

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: Brooooooklyn

crates/oxc_angular_compiler/src/component/transform.rs

@@ -15,7 +15,7 @@ use oxc_parser::Parser;
 use oxc_span::{Atom, GetSpan, SourceType, Span};
 use rustc_hash::FxHashMap;
 
-use crate::optimizer::{Edit, apply_edits};
+use crate::optimizer::{Edit, apply_edits, apply_edits_with_sourcemap};
 
 #[cfg(feature = "cross_file_elision")]
 use super::cross_file_elision::CrossFileAnalyzer;
@@ -1126,7 +1126,7 @@ fn transform_angular_file_jit(
     allocator: &Allocator,
     path: &str,
     source: &str,
-    _options: &TransformOptions,
+    options: &TransformOptions,
 ) -> TransformResult {
     let mut result = TransformResult::new();
 
@@ -1213,7 +1213,13 @@ fn transform_angular_file_jit(
 
     if jit_classes.is_empty() {
         // No Angular classes found, return source as-is
-        result.code = source.to_string();
+        if options.sourcemap {
+            let (code, map) = apply_edits_with_sourcemap(source, vec![], path);
+            result.code = code;
+            result.map = map;
+        } else {
+            result.code = source.to_string();
+        }
         return result;
     }
 
@@ -1359,7 +1365,13 @@ fn transform_angular_file_jit(
     }
 
     // Apply all edits
-    result.code = apply_edits(source, edits);
+    if options.sourcemap {
+        let (code, map) = apply_edits_with_sourcemap(source, edits, path);
+        result.code = code;
+        result.map = map;
+    } else {
+        result.code = apply_edits(source, edits);
+    }
 
     result
 }
@@ -2125,8 +2137,13 @@ pub fn transform_angular_file(
     }
 
     // Apply all edits in one pass
-    result.code = apply_edits(source, edits);
-    result.map = None;
+    if options.sourcemap {
+        let (code, map) = apply_edits_with_sourcemap(source, edits, path);
+        result.code = code;
+        result.map = map;
+    } else {
+        result.code = apply_edits(source, edits);
+    }
 
     result
 }

crates/oxc_angular_compiler/src/optimizer/mod.rs

@@ -229,6 +229,170 @@ pub fn apply_edits(code: &str, mut edits: Vec<Edit>) -> String {
     result
 }
 
+/// Apply edits to source code and generate a source map.
+///
+/// Uses the same edit-application algorithm as `apply_edits`, then generates
+/// a source map by computing which byte ranges of the original source survive
+/// in the output and where they appear.
+pub fn apply_edits_with_sourcemap(
+    code: &str,
+    edits: Vec<Edit>,
+    filename: &str,
+) -> (String, Option<String>) {
+    // Generate the output using the existing algorithm
+    let output = apply_edits(code, edits.clone());
+
+    // Generate sourcemap by analyzing how edits transform the source
+    let map = generate_sourcemap_from_edits(code, &output, edits, filename);
+    (output, Some(map))
+}
+
+/// Generate a source map by analyzing how edits transform source positions.
+///
+/// This works by normalizing and flattening all edits into non-overlapping ranges,
+/// then walking through the source to determine which original byte ranges
+/// appear in the output and at what positions.
+fn generate_sourcemap_from_edits(
+    source: &str,
+    _output: &str,
+    mut edits: Vec<Edit>,
+    filename: &str,
+) -> String {
+    let mut builder = oxc_sourcemap::SourceMapBuilder::default();
+    builder.set_source_and_content(filename, source);
+
+    if edits.is_empty() {
+        // Identity mapping
+        add_line_mappings_for_segment(&mut builder, source, 0, 0, 0, 0);
+        return builder.into_sourcemap().to_json_string();
+    }
+
+    // Sort edits ascending by start, then by priority
+    edits.sort_by(|a, b| match a.start.cmp(&b.start) {
+        std::cmp::Ordering::Equal => a.priority.cmp(&b.priority),
+        other => other,
+    });
+
+    // Flatten edits into non-overlapping "consumed source ranges" and their replacements.
+    // The key insight: the old apply_edits processes edits reverse, mutating the string.
+    // We need to figure out the net effect: which source byte ranges are kept, which are
+    // replaced, and what text appears in their place.
+    //
+    // We merge edits that target the same source position or overlap.
+    let mut merged: Vec<(u32, u32, String)> = Vec::new(); // (src_start, src_end, replacement)
+    let code_len = source.len() as u32;
+
+    for edit in &edits {
+        if edit.start > code_len || edit.end > code_len || edit.start > edit.end {
+            continue;
+        }
+        if let Some(last) = merged.last_mut() {
+            if edit.start <= last.1 {
+                // Overlapping or adjacent: extend the range and append replacement
+                last.1 = last.1.max(edit.end);
+                last.2.push_str(&edit.replacement);
+                continue;
+            }
+        }
+        merged.push((edit.start, edit.end, edit.replacement.clone()));
+    }
+
+    // Now walk through source with the merged edits to build the sourcemap
+    let mut src_pos: u32 = 0;
+    let mut out_line: u32 = 0;
+    let mut out_col: u32 = 0;
+
+    for (edit_start, edit_end, replacement) in &merged {
+        // Unchanged segment before this edit
+        if *edit_start > src_pos {
+            let segment = &source[src_pos as usize..*edit_start as usize];
+            let (src_line, src_col) = byte_offset_to_line_col(source, src_pos as usize);
+            add_line_mappings_for_segment(
+                &mut builder,
+                segment,
+                out_line,
+                out_col,
+                src_line,
+                src_col,
+            );
+            // Advance output position
+            for ch in segment.chars() {
+                if ch == '\n' {
+                    out_line += 1;
+                    out_col = 0;
+                } else {
+                    out_col += ch.len_utf8() as u32;
+                }
+            }
+        }
+
+        // Replacement text (no source mapping)
+        for ch in replacement.chars() {
+            if ch == '\n' {
+                out_line += 1;
+                out_col = 0;
+            } else {
+                out_col += ch.len_utf8() as u32;
+            }
+        }
+
+        src_pos = *edit_end;
+    }
+
+    // Remaining unchanged source after the last edit
+    if (src_pos as usize) < source.len() {
+        let segment = &source[src_pos as usize..];
+        let (src_line, src_col) = byte_offset_to_line_col(source, src_pos as usize);
+        add_line_mappings_for_segment(&mut builder, segment, out_line, out_col, src_line, src_col);
+    }
+
+    builder.into_sourcemap().to_json_string()
+}
+
+/// Compute line and column for a byte offset in the source string.
+fn byte_offset_to_line_col(source: &str, offset: usize) -> (u32, u32) {
+    let mut line: u32 = 0;
+    let mut col: u32 = 0;
+    for (i, ch) in source.char_indices() {
+        if i >= offset {
+            break;
+        }
+        if ch == '\n' {
+            line += 1;
+            col = 0;
+        } else {
+            col += ch.len_utf8() as u32;
+        }
+    }
+    (line, col)
+}
+
+/// Add source map mappings for an unchanged segment of source code.
+///
+/// Adds a mapping at the start of the segment and at the beginning of each new line.
+fn add_line_mappings_for_segment(
+    builder: &mut oxc_sourcemap::SourceMapBuilder,
+    segment: &str,
+    mut out_line: u32,
+    mut out_col: u32,
+    mut src_line: u32,
+    mut src_col: u32,
+) {
+    // Add mapping at the start of this segment
+    builder.add_token(out_line, out_col, src_line, src_col, Some(0), None);
+
+    for ch in segment.chars() {
+        if ch == '\n' {
+            out_line += 1;
+            out_col = 0;
+            src_line += 1;
+            src_col = 0;
+            // Add mapping at the start of each new line
+            builder.add_token(out_line, out_col, src_line, src_col, Some(0), None);
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/oxc_angular_compiler/tests/integration_test.rs

@@ -6356,3 +6356,150 @@ export class TestComponent {
 
     insta::assert_snapshot!("jit_union_type_ctor_params", result.code);
 }
+
+// =========================================================================
+// Source map tests
+// =========================================================================
+
+#[test]
+fn test_sourcemap_aot_mode() {
+    // Issue #99: transformAngularFile should return a source map when sourcemap: true
+    let allocator = Allocator::default();
+    let source = r#"import { Component } from '@angular/core';
+
+@Component({
+    selector: 'app-test',
+    template: '<h1>Hello World</h1>',
+    standalone: true,
+})
+export class TestComponent {
+}
+"#;
+
+    let options = ComponentTransformOptions { sourcemap: true, ..Default::default() };
+
+    let result = transform_angular_file(&allocator, "app.component.ts", source, &options, None);
+
+    assert!(
+        result.map.is_some(),
+        "AOT mode should return a source map when sourcemap: true, but map was None"
+    );
+
+    let map = result.map.unwrap();
+    // Verify it's valid JSON
+    assert!(
+        map.starts_with('{'),
+        "Source map should be valid JSON, got: {}",
+        &map[..50.min(map.len())]
+    );
+    // Verify it contains expected sourcemap fields
+    assert!(map.contains("\"version\":3"), "Source map should have version 3");
+    assert!(map.contains("\"mappings\""), "Source map should have mappings");
+    assert!(map.contains("app.component.ts"), "Source map should reference the source file");
+}
+
+#[test]
+fn test_sourcemap_jit_mode() {
+    // Issue #99: JIT mode should also return a source map when sourcemap: true
+    let allocator = Allocator::default();
+    let source = r#"import { Component } from '@angular/core';
+
+@Component({
+    selector: 'app-test',
+    template: '<h1>Hello World</h1>',
+    standalone: true,
+})
+export class TestComponent {
+}
+"#;
+
+    let options = ComponentTransformOptions { sourcemap: true, jit: true, ..Default::default() };
+
+    let result = transform_angular_file(&allocator, "app.component.ts", source, &options, None);
+
+    assert!(
+        result.map.is_some(),
+        "JIT mode should return a source map when sourcemap: true, but map was None"
+    );
+
+    let map = result.map.unwrap();
+    assert!(map.starts_with('{'), "Source map should be valid JSON");
+    assert!(map.contains("\"version\":3"), "Source map should have version 3");
+}
+
+#[test]
+fn test_sourcemap_disabled_by_default() {
+    // When sourcemap is false (default), map should be None
+    let allocator = Allocator::default();
+    let source = r#"import { Component } from '@angular/core';
+
+@Component({
+    selector: 'app-test',
+    template: '<h1>Hello</h1>',
+    standalone: true,
+})
+export class TestComponent {
+}
+"#;
+
+    let result = transform_angular_file(
+        &allocator,
+        "app.component.ts",
+        source,
+        &ComponentTransformOptions::default(),
+        None,
+    );
+
+    assert!(result.map.is_none(), "Source map should be None when sourcemap option is false");
+}
+
+#[test]
+fn test_sourcemap_with_external_template() {
+    // Source map should work with resolved external templates
+    let allocator = Allocator::default();
+    let source = r#"import { Component } from '@angular/core';
+
+@Component({
+    selector: 'app-test',
+    templateUrl: './app.html',
+    standalone: true,
+})
+export class TestComponent {
+}
+"#;
+
+    let mut templates = std::collections::HashMap::new();
+    templates.insert("./app.html".to_string(), "<h1>Hello World</h1>".to_string());
+    let resolved = ResolvedResources { templates, styles: std::collections::HashMap::new() };
+
+    let options = ComponentTransformOptions { sourcemap: true, ..Default::default() };
+
+    let result =
+        transform_angular_file(&allocator, "app.component.ts", source, &options, Some(&resolved));
+
+    assert!(
+        result.map.is_some(),
+        "AOT with external template should return a source map when sourcemap: true"
+    );
+}
+
+#[test]
+fn test_sourcemap_no_angular_classes() {
+    // A file with no Angular classes should still return a source map if requested
+    let allocator = Allocator::default();
+    let source = r#"export class PlainService {
+    getData() { return 42; }
+}
+"#;
+
+    let options = ComponentTransformOptions { sourcemap: true, ..Default::default() };
+
+    let result = transform_angular_file(&allocator, "plain.ts", source, &options, None);
+
+    // Even for files with no Angular components, if sourcemap is requested,
+    // a trivial identity source map should be returned
+    assert!(
+        result.map.is_some(),
+        "Should return a source map even for files with no Angular classes when sourcemap: true"
+    );
+}