#![cfg(feature = "bundler")]
use rspack_lightningcss::{
bundler::{Bundler, ResolveResult, SourceProvider},
printer::{OriginalLocation, SourceMap},
rules::CssRule,
stylesheet::{ParserOptions, PrinterOptions},
};
use std::{
collections::HashMap,
path::{Path, PathBuf},
};
struct TestProvider(HashMap<PathBuf, String>);
impl SourceProvider for TestProvider {
type Error = std::io::Error;
fn read<'a>(&'a self, file: &Path) -> Result<&'a str, Self::Error> {
Ok(self.0.get(file).unwrap())
}
fn resolve(&self, specifier: &str, originating_file: &Path) -> Result<ResolveResult, Self::Error> {
Ok(originating_file.with_file_name(specifier).into())
}
}
const INPUT_MAP: &str = r#"data:application/json,{"version":3,"sources":["/original.scss"],"sourcesContent":[".original{color:red}"],"names":[],"mappings":"AAYG"}"#;
#[derive(Default)]
struct TestSourceMap {
sources: Vec<(u32, String, Option<String>)>,
mappings: Vec<OriginalLocation>,
input_mapping: Option<OriginalLocation>,
}
impl SourceMap for TestSourceMap {
fn add_source(&mut self, source: &str) -> u32 {
let source = if source == "/alias.css" {
"/dependency.css"
} else {
source
};
if let Some((index, _, _)) = self.sources.iter().find(|(_, path, _)| path == source) {
return *index;
}
let index = 100 + self.sources.len() as u32 * 10;
self.sources.push((index, source.into(), None));
index
}
fn add_name(&mut self, _: &str) -> u32 {
unreachable!()
}
fn set_source_content(&mut self, source_index: u32, source_content: &str) {
self.sources.iter_mut().find(|(index, _, _)| *index == source_index).unwrap().2 = Some(source_content.into());
}
fn add_mapping(&mut self, _: u32, _: u32, original: Option<OriginalLocation>) {
self.mappings.push(original.unwrap());
}
fn from_data_url(_: &str, data_url: &str) -> Option<Self> {
if data_url != INPUT_MAP {
return None;
}
let mut map = Self::default();
let source = map.add_source("/original.scss");
map.set_source_content(source, ".original{color:red}");
map.input_mapping = Some(OriginalLocation {
original_line: 12,
original_column: 3,
source,
name: None,
});
Some(map)
}
fn find_closest_mapping(&mut self, _: u32, _: u32) -> Option<OriginalLocation> {
self.input_mapping
}
fn get_source(&self, source_index: u32) -> Option<&str> {
self
.sources
.iter()
.find(|(index, _, _)| *index == source_index)
.map(|(_, source, _)| source.as_str())
}
fn get_name(&self, _: u32) -> Option<&str> {
None
}
fn get_source_content(&self, source_index: u32) -> Option<&str> {
self
.sources
.iter()
.find(|(index, _, _)| *index == source_index)
.and_then(|(_, _, content)| content.as_deref())
}
}
#[test]
fn translates_bundler_source_indices() {
let entry = "@import 'dependency.css';\n@import 'alias.css';\n.entry { color: red }";
let dependency = ".dependency { color: blue }";
let fs = TestProvider(HashMap::from([
(PathBuf::from("/entry.css"), entry.into()),
(PathBuf::from("/dependency.css"), dependency.into()),
(PathBuf::from("/alias.css"), dependency.into()),
]));
for prepopulated in [false, true] {
let mut map = TestSourceMap::default();
if prepopulated {
let existing = map.add_source("/existing.css");
map.set_source_content(existing, "existing content");
map.add_source("/dependency.css");
}
let mut bundler = Bundler::new(&fs, Some(&mut map), ParserOptions::default());
let stylesheet = bundler.bundle(Path::new("/entry.css")).unwrap();
let rules: Vec<_> = stylesheet
.rules
.0
.iter()
.filter_map(|rule| match rule {
CssRule::Style(rule) => Some(rule),
_ => None,
})
.collect();
assert_eq!(rules.len(), 3);
for (rule, source) in rules.iter().zip(["/dependency.css", "/alias.css", "/entry.css"]) {
assert_eq!(stylesheet.sources[rule.loc.source_index as usize], source);
}
stylesheet.to_css(PrinterOptions::default().with_source_map(&mut map)).unwrap();
assert_eq!(map.mappings.len(), 3);
for (mapping, (source, content)) in map.mappings.iter().zip([
("/dependency.css", dependency),
("/dependency.css", dependency),
("/entry.css", entry),
]) {
assert_eq!(map.get_source(mapping.source), Some(source));
assert_eq!(map.get_source_content(mapping.source), Some(content));
}
assert_eq!(map.mappings[0].source, map.mappings[1].source);
if prepopulated {
assert_eq!(map.get_source_content(100), Some("existing content"));
}
}
}
#[test]
fn translates_bundler_indices_alongside_inline_remapping() {
let dependency = ".dependency { color: blue }";
let fs = TestProvider(HashMap::from([
(
PathBuf::from("/entry.css"),
format!("@import 'dependency.css';\n.entry {{ color: red }}\n/*# sourceMappingURL={INPUT_MAP} */"),
),
(PathBuf::from("/dependency.css"), dependency.into()),
]));
let mut map = TestSourceMap::default();
map.add_source("/existing.css");
let mut bundler = Bundler::new(&fs, Some(&mut map), ParserOptions::default());
let stylesheet = bundler.bundle(Path::new("/entry.css")).unwrap();
stylesheet.to_css(PrinterOptions::default().with_source_map(&mut map)).unwrap();
assert_eq!(map.mappings.len(), 2);
let dependency_mapping = map.mappings[0];
assert_eq!(map.get_source(dependency_mapping.source), Some("/dependency.css"));
assert_eq!(map.get_source_content(dependency_mapping.source), Some(dependency));
let original = map.mappings[1];
assert_eq!(map.get_source(original.source), Some("/original.scss"));
assert_eq!(map.get_source_content(original.source), Some(".original{color:red}"));
assert_eq!((original.original_line, original.original_column), (12, 3));
assert!(!map.sources.iter().any(|(_, source, _)| source == "/entry.css"));
}
#[test]
fn registers_bundled_source_when_input_map_cannot_be_read() {
for source_map_url in ["data-bundle.map", "data:application/json,not-a-map"] {
let entry = format!(".entry {{ color: red }}\n/*# sourceMappingURL={source_map_url} */");
let fs = TestProvider(HashMap::from([(PathBuf::from("/entry.css"), entry.clone())]));
let mut map = TestSourceMap::default();
let mut bundler = Bundler::new(&fs, Some(&mut map), ParserOptions::default());
let stylesheet = bundler.bundle(Path::new("/entry.css")).unwrap();
stylesheet.to_css(PrinterOptions::default().with_source_map(&mut map)).unwrap();
assert_eq!(map.mappings.len(), 1);
let source = map.mappings[0].source;
assert_eq!(source, 100);
assert_eq!(map.get_source(source), Some("/entry.css"));
assert_eq!(map.get_source_content(source), Some(entry.as_str()));
}
}