tsz_common/

source_map.rs

//! Source Map Generation
//!
//! Implements Source Map v3 specification for mapping generated JavaScript
//! back to original TypeScript source.
//!
//! Format: <https://sourcemaps.info/spec.html>

use std::fmt::Write;

use memchr;
use serde::Serialize;

/// A single mapping from generated position to original position
#[derive(Debug, Clone)]
pub struct Mapping {
    /// Generated line (0-indexed)
    pub generated_line: u32,
    /// Generated column (0-indexed)
    pub generated_column: u32,
    /// Source file index
    pub source_index: u32,
    /// Original line (0-indexed)
    pub original_line: u32,
    /// Original column (0-indexed)
    pub original_column: u32,
    /// Name index (optional)
    pub name_index: Option<u32>,
}

/// Source Map v3 output format
#[derive(Debug, Serialize)]
pub struct SourceMap {
    pub version: u32,
    pub file: String,
    #[serde(rename = "sourceRoot")]
    pub source_root: String,
    pub sources: Vec<String>,
    #[serde(rename = "sourcesContent")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sources_content: Option<Vec<String>>,
    pub names: Vec<String>,
    pub mappings: String,
}

/// Builder for source maps
pub struct SourceMapGenerator {
    file: String,
    source_root: String,
    sources: Vec<String>,
    sources_content: Vec<Option<String>>,
    names: Vec<String>,
    mappings: Vec<Mapping>,

    // State for VLQ encoding
    prev_generated_column: i32,
    prev_original_line: i32,
    prev_original_column: i32,
    prev_source_index: i32,
    prev_name_index: i32,
}

impl SourceMapGenerator {
    #[must_use]
    pub const fn new(file: String) -> Self {
        Self {
            file,
            source_root: String::new(),
            sources: Vec::new(),
            sources_content: Vec::new(),
            names: Vec::new(),
            mappings: Vec::new(),
            prev_generated_column: 0,
            prev_original_line: 0,
            prev_original_column: 0,
            prev_source_index: 0,
            prev_name_index: 0,
        }
    }

    /// Set the source root
    pub fn set_source_root(&mut self, root: String) {
        self.source_root = root;
    }

    /// Add a source file
    #[must_use]
    pub fn add_source(&mut self, source: String) -> u32 {
        let index = u32::try_from(self.sources.len()).unwrap_or(u32::MAX);
        self.sources.push(source);
        self.sources_content.push(None);
        index
    }

    /// Add a source file with content
    #[must_use]
    pub fn add_source_with_content(&mut self, source: String, content: String) -> u32 {
        let index = u32::try_from(self.sources.len()).unwrap_or(u32::MAX);
        self.sources.push(source);
        self.sources_content.push(Some(content));
        index
    }

    /// Add a name to the names array
    #[must_use]
    pub fn add_name(&mut self, name: String) -> u32 {
        // Check if name already exists
        for (i, n) in self.names.iter().enumerate() {
            if n == &name {
                return u32::try_from(i).unwrap_or(u32::MAX);
            }
        }
        let index = u32::try_from(self.names.len()).unwrap_or(u32::MAX);
        self.names.push(name);
        index
    }

    /// Add a mapping
    pub fn add_mapping(
        &mut self,
        generated_line: u32,
        generated_column: u32,
        source_index: u32,
        original_line: u32,
        original_column: u32,
        name_index: Option<u32>,
    ) {
        self.mappings.push(Mapping {
            generated_line,
            generated_column,
            source_index,
            original_line,
            original_column,
            name_index,
        });
    }

    /// Add a simple mapping (no name)
    pub fn add_simple_mapping(
        &mut self,
        generated_line: u32,
        generated_column: u32,
        source_index: u32,
        original_line: u32,
        original_column: u32,
    ) {
        self.add_mapping(
            generated_line,
            generated_column,
            source_index,
            original_line,
            original_column,
            None,
        );
    }

    /// Shift all mappings at or after `from_line` by `delta` lines.
    /// Used when inserting generated lines (e.g., hoisted temp var declarations)
    /// into the output after emit is complete.
    pub fn shift_generated_lines(&mut self, from_line: u32, delta: u32) {
        for mapping in &mut self.mappings {
            if mapping.generated_line >= from_line {
                mapping.generated_line += delta;
            }
        }
    }

    /// Generate the source map
    pub fn generate(&mut self) -> SourceMap {
        // Sort mappings by generated position
        self.mappings.sort_by(|a, b| {
            if a.generated_line == b.generated_line {
                a.generated_column.cmp(&b.generated_column)
            } else {
                a.generated_line.cmp(&b.generated_line)
            }
        });

        // Encode mappings
        let mappings_str = self.encode_mappings();

        // Build sources content if any are present
        let sources_content = self.sources_content.iter().any(Option::is_some).then(|| {
            self.sources_content
                .iter()
                .map(|c| c.as_deref().unwrap_or_default().to_string())
                .collect()
        });

        SourceMap {
            version: 3,
            file: self.file.clone(),
            source_root: self.source_root.clone(),
            sources: self.sources.clone(),
            sources_content,
            names: self.names.clone(),
            mappings: mappings_str,
        }
    }

    /// Generate source map as JSON string
    #[must_use]
    pub fn generate_json(&mut self) -> String {
        let map = self.generate();
        serde_json::to_string(&map).unwrap_or_default()
    }

    /// Alias for `generate_json` (compatibility)
    #[must_use]
    pub fn to_json(&mut self) -> String {
        self.generate_json()
    }

    /// Generate inline source map comment
    pub fn generate_inline(&mut self) -> String {
        let json = self.generate_json();
        let base64 = base64_encode(json.as_bytes());
        format!("//# sourceMappingURL=data:application/json;base64,{base64}")
    }

    /// Alias for `generate_inline` (compatibility)
    #[must_use]
    pub fn to_inline_comment(&mut self) -> String {
        self.generate_inline()
    }

    /// Add a mapping with a name reference (compatibility)
    pub fn add_named_mapping(
        &mut self,
        generated_line: u32,
        generated_column: u32,
        source_index: u32,
        original_line: u32,
        original_column: u32,
        name_index: u32,
    ) {
        self.add_mapping(
            generated_line,
            generated_column,
            source_index,
            original_line,
            original_column,
            Some(name_index),
        );
    }

    fn encode_mappings(&mut self) -> String {
        let mut result = String::new();

        // Reset state
        self.prev_generated_column = 0;
        self.prev_original_line = 0;
        self.prev_original_column = 0;
        self.prev_source_index = 0;
        self.prev_name_index = 0;

        let mut current_line: u32 = 0;
        let mut first_in_line = true;

        // Clone mappings to avoid borrow issues
        let mappings = self.mappings.clone();
        for mapping in &mappings {
            // Handle line changes
            while current_line < mapping.generated_line {
                result.push(';');
                current_line += 1;
                self.prev_generated_column = 0;
                first_in_line = true;
            }

            if !first_in_line {
                result.push(',');
            }
            first_in_line = false;

            // Encode segment
            let segment = self.encode_segment(mapping);
            result.push_str(&segment);
        }

        result
    }

    fn encode_segment(&mut self, mapping: &Mapping) -> String {
        // Pre-allocate for typical VLQ segment (4-5 values * ~2 chars each)
        let mut segment = String::with_capacity(16);

        // Generated column (relative to previous) - using zero-allocation encode_to
        let gen_col = i32::try_from(mapping.generated_column).unwrap_or(i32::MAX);
        vlq::encode_to(gen_col - self.prev_generated_column, &mut segment);
        self.prev_generated_column = gen_col;

        // Source index (relative)
        let src_idx = i32::try_from(mapping.source_index).unwrap_or(i32::MAX);
        vlq::encode_to(src_idx - self.prev_source_index, &mut segment);
        self.prev_source_index = src_idx;

        // Original line (relative)
        let orig_line = i32::try_from(mapping.original_line).unwrap_or(i32::MAX);
        vlq::encode_to(orig_line - self.prev_original_line, &mut segment);
        self.prev_original_line = orig_line;

        // Original column (relative)
        let orig_col = i32::try_from(mapping.original_column).unwrap_or(i32::MAX);
        vlq::encode_to(orig_col - self.prev_original_column, &mut segment);
        self.prev_original_column = orig_col;

        // Name index (relative, optional)
        if let Some(name_idx) = mapping.name_index {
            let name_idx = i32::try_from(name_idx).unwrap_or(i32::MAX);
            vlq::encode_to(name_idx - self.prev_name_index, &mut segment);
            self.prev_name_index = name_idx;
        }

        segment
    }
}

/// VLQ (Variable-Length Quantity) encoding module for source maps
pub mod vlq {
    const VLQ_BASE_SHIFT: i32 = 5;
    const VLQ_BASE: i32 = 1 << VLQ_BASE_SHIFT;
    const VLQ_BASE_MASK: i32 = VLQ_BASE - 1;
    const VLQ_CONTINUATION_BIT: i32 = VLQ_BASE;

    const BASE64_CHARS: &[u8; 64] =
        b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

    /// Encode a signed integer as VLQ (allocates String)
    #[must_use]
    pub fn encode(value: i32) -> String {
        let mut result = String::with_capacity(8);
        encode_to(value, &mut result);
        result
    }

    /// Encode a signed integer as VLQ directly into buffer (zero allocation)
    /// This is 3-5x faster than `encode()` for source map generation
    #[inline]
    pub fn encode_to(value: i32, buf: &mut String) {
        // Convert to unsigned with sign in LSB
        let mut vlq = if value < 0 {
            ((-value) << 1) + 1
        } else {
            value << 1
        };

        loop {
            let mut digit = vlq & VLQ_BASE_MASK;
            vlq >>= VLQ_BASE_SHIFT;

            if vlq > 0 {
                digit |= VLQ_CONTINUATION_BIT;
            }

            // Direct push - no allocation per character
            let digit_idx = usize::try_from(digit).unwrap_or(0);
            buf.push(BASE64_CHARS[digit_idx].into());

            if vlq == 0 {
                break;
            }
        }
    }

    /// Decode a VLQ encoded string, returns (value, `bytes_consumed`)
    #[must_use]
    pub fn decode(s: &str) -> Option<(i32, usize)> {
        let bytes = s.as_bytes();
        let mut result: i32 = 0;
        let mut shift = 0;
        let mut consumed = 0;

        for &byte in bytes {
            let char_idx = BASE64_CHARS.iter().position(|&c| c == byte)?;
            let digit = i32::try_from(char_idx).unwrap_or(i32::MAX);

            result |= (digit & VLQ_BASE_MASK) << shift;
            consumed += 1;

            if (digit & VLQ_CONTINUATION_BIT) == 0 {
                // Check sign bit (LSB)
                let is_negative = (result & 1) == 1;
                result >>= 1;
                if is_negative {
                    result = -result;
                }
                return Some((result, consumed));
            }

            shift += VLQ_BASE_SHIFT;
        }

        None
    }
}

const BASE64_CHARS: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

/// Escape a string for JSON output
/// SIMD-optimized JSON string escaping
/// Uses memchr to find escape-worthy bytes in bulk, then copies safe chunks via memcpy.
/// 5-10x faster than char-by-char iteration for typical strings.
#[must_use]
pub fn escape_json(s: &str) -> String {
    let bytes = s.as_bytes();

    // Fast path: no special characters (common case)
    // memchr3 uses SIMD to scan 32 bytes at a time
    if memchr::memchr3(b'"', b'\\', b'\n', bytes).is_none()
        && memchr::memchr2(b'\r', b'\t', bytes).is_none()
    {
        return s.to_string();
    }

    // Slow path: has special chars, process with bulk copy optimization
    let mut result = String::with_capacity(s.len() + 16);
    let mut start = 0;

    for (i, &byte) in bytes.iter().enumerate() {
        let escape = match byte {
            b'"' => Some("\\\""),
            b'\\' => Some("\\\\"),
            b'\n' => Some("\\n"),
            b'\r' => Some("\\r"),
            b'\t' => Some("\\t"),
            // Control characters (0x00-0x1F except the ones above)
            0..=0x1f => {
                // Hex escape for other control chars
                if i > start {
                    result.push_str(&s[start..i]);
                }
                let _ = write!(result, "\\u{byte:04x}");
                start = i + 1;
                continue;
            }
            _ => None,
        };

        if let Some(escaped) = escape {
            // Bulk copy safe bytes before this escape char
            if i > start {
                result.push_str(&s[start..i]);
            }
            result.push_str(escaped);
            start = i + 1;
        }
    }

    // Copy remaining safe bytes
    if start < s.len() {
        result.push_str(&s[start..]);
    }

    result
}

/// Escape a JavaScript string literal (single or double quoted)
/// SIMD-optimized with memchr for bulk scanning
#[must_use]
pub fn escape_js_string(s: &str, quote: char) -> String {
    let bytes = s.as_bytes();
    let quote_byte = quote as u8;

    // Fast path check using SIMD
    let has_backslash = memchr::memchr(b'\\', bytes).is_some();
    let has_quote = memchr::memchr(quote_byte, bytes).is_some();
    let has_newline = memchr::memchr2(b'\n', b'\r', bytes).is_some();

    if !has_backslash && !has_quote && !has_newline {
        return s.to_string();
    }

    let mut result = String::with_capacity(s.len() + 16);
    let mut start = 0;

    for (i, &byte) in bytes.iter().enumerate() {
        let escape = match byte {
            b'\\' => Some("\\\\"),
            b'\n' => Some("\\n"),
            b'\r' => Some("\\r"),
            b'\t' => Some("\\t"),
            b'\0' => Some("\\0"),
            b if b == quote_byte => {
                if i > start {
                    result.push_str(&s[start..i]);
                }
                result.push('\\');
                result.push(quote);
                start = i + 1;
                continue;
            }
            _ => None,
        };

        if let Some(escaped) = escape {
            if i > start {
                result.push_str(&s[start..i]);
            }
            result.push_str(escaped);
            start = i + 1;
        }
    }

    if start < s.len() {
        result.push_str(&s[start..]);
    }

    result
}

/// Base64 encode a byte slice
#[must_use]
pub fn base64_encode(input: &[u8]) -> String {
    let bytes = input;
    let mut result = String::with_capacity(bytes.len().div_ceil(3) * 4);

    for chunk in bytes.chunks(3) {
        let b0 = u32::from(chunk[0]);
        let b1 = u32::from(chunk.get(1).copied().unwrap_or(0));
        let b2 = u32::from(chunk.get(2).copied().unwrap_or(0));

        let n = (b0 << 16) | (b1 << 8) | b2;

        result.push(BASE64_CHARS[((n >> 18) & 63) as usize] as char);
        result.push(BASE64_CHARS[((n >> 12) & 63) as usize] as char);

        if chunk.len() > 1 {
            result.push(BASE64_CHARS[((n >> 6) & 63) as usize] as char);
        } else {
            result.push('=');
        }

        if chunk.len() > 2 {
            result.push(BASE64_CHARS[(n & 63) as usize] as char);
        } else {
            result.push('=');
        }
    }

    result
}

#[cfg(test)]
#[path = "../tests/source_map.rs"]
mod tests;