tailwind_rs_postcss/advanced_features/

advanced_source_maps.rs

//! Advanced Source Maps
//! 
//! This module provides comprehensive source map generation with
//! detailed mappings, transformation tracking, and source resolution.

use super::types::*;

/// Advanced source map generator
pub struct AdvancedSourceMapGenerator {
    mappings: Vec<SourceMapping>,
    sources: Vec<SourceFile>,
    names: Vec<String>,
    transformations: Vec<Transformation>,
}

impl AdvancedSourceMapGenerator {
    /// Create new advanced source map generator
    pub fn new() -> Self {
        Self {
            mappings: Vec::new(),
            sources: Vec::new(),
            names: Vec::new(),
            transformations: Vec::new(),
        }
    }
    
    /// Generate comprehensive source map
    pub fn generate_source_map(&mut self, css: &str, source_files: &[SourceFile]) -> Result<SourceMap, AdvancedFeatureError> {
        
        // Clear previous mappings
        self.mappings.clear();
        self.sources.clear();
        self.names.clear();
        
        // Add source files
        for source_file in source_files {
            self.sources.push(source_file.clone());
        }
        
        // Generate mappings for CSS
        self.generate_css_mappings(css)?;
        
        // Generate source map
        let source_map = SourceMap {
            version: 3,
            file: "output.css".to_string(),
            source_root: String::new(),
            sources: self.sources.iter().map(|s| s.path.clone()).collect(),
            names: self.names.clone(),
            mappings: self.encode_mappings(&self.mappings)?,
            sources_content: self.sources.iter().map(|s| s.content.clone()).collect(),
        };
        
        Ok(source_map)
    }
    
    /// Add transformation mapping
    pub fn add_transformation(&mut self, transformation: Transformation) -> Result<(), AdvancedFeatureError> {
        let transformation_clone = transformation.clone();
        self.transformations.push(transformation);
        
        // Generate mappings for transformation
        self.generate_transformation_mappings(transformation_clone)?;
        
        Ok(())
    }
    
    /// Resolve source location
    pub fn resolve_source_location(&self, line: usize, column: usize) -> Result<SourceLocation, AdvancedFeatureError> {
        // Find mapping for position
        for mapping in &self.mappings {
            if mapping.generated_line == line && mapping.generated_column == column {
                let source_file = if let Some(source_index) = mapping.source_file {
                    if source_index < self.sources.len() {
                        &self.sources[source_index]
                    } else {
                        return Err(AdvancedFeatureError::SourceMapFailed {
                            error: "Invalid source file index".to_string()
                        });
                    }
                } else {
                    return Err(AdvancedFeatureError::SourceMapFailed {
                        error: "No source file for mapping".to_string()
                    });
                };
                
                return Ok(SourceLocation {
                    file: source_file.path.clone(),
                    line: mapping.source_line,
                    column: mapping.source_column,
                    content: self.get_source_content(source_file, mapping.source_line)?,
                });
            }
        }
        
        Err(AdvancedFeatureError::SourceMapFailed {
            error: "No mapping found for position".to_string()
        })
    }
    
    /// Generate CSS mappings
    fn generate_css_mappings(&mut self, css: &str) -> Result<(), AdvancedFeatureError> {
        let lines: Vec<&str> = css.split('\n').collect();
        
        for (line_num, line) in lines.iter().enumerate() {
            for (col_num, _) in line.char_indices() {
                // Create 1:1 mapping for each character
                self.mappings.push(SourceMapping {
                    generated_line: line_num + 1,
                    generated_column: col_num,
                    source_line: line_num + 1,
                    source_column: col_num,
                    source_file: Some(0), // First source file
                    name: None,
                });
            }
        }
        
        Ok(())
    }
    
    /// Generate transformation mappings
    fn generate_transformation_mappings(&mut self, transformation: Transformation) -> Result<(), AdvancedFeatureError> {
        // Find source file index
        let source_index = self.sources.iter()
            .position(|s| s.path == transformation.source_file)
            .unwrap_or(0);
        
        // Generate mappings for transformation
        for line in transformation.input_range.start..transformation.output_range.end {
            self.mappings.push(SourceMapping {
                generated_line: line,
                generated_column: 0,
                source_line: line,
                source_column: 0,
                source_file: Some(source_index),
                name: Some(self.names.len()),
            });
            
            // Add transformation name
            self.names.push(transformation.name.clone());
        }
        
        Ok(())
    }
    
    /// Encode mappings using VLQ
    fn encode_mappings(&self, mappings: &[SourceMapping]) -> Result<String, AdvancedFeatureError> {
        let mut encoded = String::new();
        let mut previous_generated_line = 0;
        let mut previous_generated_column = 0;
        let mut previous_source_line = 0;
        let mut previous_source_column = 0;
        let mut previous_source_file = 0;
        let mut previous_name = 0;
        
        for mapping in mappings {
            // Calculate deltas
            let generated_line_delta = (mapping.generated_line - previous_generated_line) as isize;
            let generated_column_delta = (mapping.generated_column - previous_generated_column) as isize;
            let source_line_delta = (mapping.source_line - previous_source_line) as isize;
            let source_column_delta = (mapping.source_column - previous_source_column) as isize;
            let source_file_delta = (mapping.source_file.unwrap_or(0) - previous_source_file) as isize;
            let name_delta = (mapping.name.unwrap_or(0) - previous_name) as isize;
            
            // Encode deltas
            if !encoded.is_empty() {
                encoded.push(';');
            }
            
            encoded.push_str(&self.encode_vlq(generated_line_delta));
            encoded.push(',');
            encoded.push_str(&self.encode_vlq(generated_column_delta));
            encoded.push(',');
            encoded.push_str(&self.encode_vlq(source_file_delta));
            encoded.push(',');
            encoded.push_str(&self.encode_vlq(source_line_delta));
            encoded.push(',');
            encoded.push_str(&self.encode_vlq(source_column_delta));
            
            if mapping.name.is_some() {
                encoded.push(',');
                encoded.push_str(&self.encode_vlq(name_delta));
            }
            
            // Update previous values
            previous_generated_line = mapping.generated_line;
            previous_generated_column = mapping.generated_column;
            previous_source_line = mapping.source_line;
            previous_source_column = mapping.source_column;
            previous_source_file = mapping.source_file.unwrap_or(0);
            previous_name = mapping.name.unwrap_or(0);
        }
        
        Ok(encoded)
    }
    
    /// Encode number using VLQ
    fn encode_vlq(&self, mut num: isize) -> String {
        let mut result = String::new();
        
        if num < 0 {
            num = (-num << 1) | 1;
        } else {
            num <<= 1;
        }
        
        loop {
            let mut digit = (num & 0x1f) as u8;
            num >>= 5;
            
            if num > 0 {
                digit |= 0x20;
            }
            
            result.push(self.vlq_to_char(digit));
            
            if num == 0 {
                break;
            }
        }
        
        result
    }
    
    /// Convert VLQ digit to character
    fn vlq_to_char(&self, digit: u8) -> char {
        const VLQ_CHARS: &str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
        VLQ_CHARS.chars().nth(digit as usize).unwrap_or('A')
    }
    
    /// Get source content for line
    fn get_source_content(&self, source_file: &SourceFile, line: usize) -> Result<String, AdvancedFeatureError> {
        let lines: Vec<&str> = source_file.content.split('\n').collect();
        
        if line > 0 && line <= lines.len() {
            Ok(lines[line - 1].to_string())
        } else {
            Ok(String::new())
        }
    }
}

/// Source map structure
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct SourceMap {
    pub version: u32,
    pub file: String,
    pub source_root: String,
    pub sources: Vec<String>,
    pub names: Vec<String>,
    pub mappings: String,
    pub sources_content: Vec<String>,
}

impl SourceMap {
    /// Create new source map
    pub fn new() -> Self {
        Self {
            version: 3,
            file: String::new(),
            source_root: String::new(),
            sources: Vec::new(),
            names: Vec::new(),
            mappings: String::new(),
            sources_content: Vec::new(),
        }
    }
    
    /// Get source map as JSON
    pub fn to_json(&self) -> Result<String, AdvancedFeatureError> {
        serde_json::to_string_pretty(self)
            .map_err(|e| AdvancedFeatureError::SourceMapFailed {
                error: format!("Failed to serialize source map: {}", e)
            })
    }
    
    /// Load source map from JSON
    pub fn from_json(json: &str) -> Result<Self, AdvancedFeatureError> {
        serde_json::from_str(json)
            .map_err(|e| AdvancedFeatureError::SourceMapFailed {
                error: format!("Failed to parse source map: {}", e)
            })
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_source_map_generation() {
        let mut generator = AdvancedSourceMapGenerator::new();
        let css = ".test { color: red; }";
        let source_files = vec![
            SourceFile {
                path: "input.css".to_string(),
                content: css.to_string(),
                mtime: std::time::SystemTime::now(),
                size: css.len(),
            }
        ];
        
        let result = generator.generate_source_map(css, &source_files);
        assert!(result.is_ok());
        
        let source_map = result.unwrap();
        assert_eq!(source_map.version, 3);
        assert!(!source_map.sources.is_empty());
        assert!(!source_map.mappings.is_empty());
    }
    
    #[test]
    fn test_transformation_mapping() {
        let mut generator = AdvancedSourceMapGenerator::new();
        let transformation = Transformation {
            name: "autoprefixer".to_string(),
            input_range: TextRange::new(0, 10),
            output_range: TextRange::new(0, 15),
            source_file: "input.css".to_string(),
        };
        
        let result = generator.add_transformation(transformation);
        assert!(result.is_ok());
    }
    
    #[test]
    fn test_source_location_resolution() {
        let mut generator = AdvancedSourceMapGenerator::new();
        let css = ".test { color: red; }";
        let source_files = vec![
            SourceFile {
                path: "input.css".to_string(),
                content: css.to_string(),
                mtime: std::time::SystemTime::now(),
                size: css.len(),
            }
        ];
        
        generator.generate_source_map(css, &source_files).unwrap();
        
        let result = generator.resolve_source_location(1, 0);
        assert!(result.is_ok());
        
        let location = result.unwrap();
        assert_eq!(location.file, "input.css");
        assert_eq!(location.line, 1);
    }
    
    #[test]
    fn test_vlq_encoding() {
        let generator = AdvancedSourceMapGenerator::new();
        let encoded = generator.encode_vlq(123);
        assert!(!encoded.is_empty());
    }
    
    #[test]
    fn test_source_map_json() {
        let source_map = SourceMap::new();
        let json = source_map.to_json();
        assert!(json.is_ok());
        
        let json_str = json.unwrap();
        let parsed = SourceMap::from_json(&json_str);
        assert!(parsed.is_ok());
    }
}