pub mod generator;
use std::{
borrow::Cow,
sync::{Arc, LazyLock},
};
use once_cell::sync::OnceCell;
use regex::Regex;
use rspack_cacheable::{cacheable, cacheable_dyn};
use rspack_core::{
BoxDependencyTemplate, BoxModuleDependency, BuildMetaDefaultObject, BuildMetaExportsType,
ChunkGraph, Compilation, ConstDependency, CssExportsConvention, CssModuleGeneratorOptions,
CssModuleParserOptions, CssParserImport, CssParserImportContext, Dependency, DependencyRange,
DependencyType, ExportsInfoArtifact, GenerateContext, Module, ModuleGraph, ModuleIdentifier,
ModuleInitFragments, ModuleType, NormalModule, ParseContext, ParseResult, ParserAndGenerator,
RuntimeGlobals, RuntimeSpec, SourceType, TemplateContext, UsageState,
diagnostics::map_box_diagnostics_to_module_parse_diagnostics,
remove_bom,
rspack_sources::{BoxSource, ReplaceSource, Source, SourceExt},
};
pub use rspack_core::{CssExport, CssExports};
use rspack_error::{Diagnostic, IntoTWithDiagnosticArray, Result, Severity, TWithDiagnosticArray};
use rspack_hash::{RspackHash, RspackHashDigest};
use rspack_util::{
atom::Atom,
ext::DynHash,
fx_hash::{FxIndexMap, FxIndexSet},
};
use rustc_hash::{FxHashMap, FxHashSet};
use crate::{
dependency::{
CssComposeDependency, CssExportDependency, CssImportDependency, CssLayer,
CssLocalIdentDependency, CssMedia, CssSelfReferenceLocalIdentDependency,
CssSelfReferenceLocalIdentReplacement, CssSupports, CssUrlDependency,
},
parser_and_generator::generator::{CssModuleGenerator, update_css_exports},
utils::{
LocalIdentModuleHashOptions, LocalIdentOptions, PresentationalDependencyHashUpdate,
css_parsing_traceable_error, export_locals_convention, normalize_url,
replace_module_request_prefix, unescape,
},
};
static REGEX_IS_MODULES: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"\.module(s)?\.[^.]+$").expect("Invalid regex"));
static REGEX_IS_COMMENTS: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"/\*[\s\S]*?\*/").expect("Invalid regex"));
pub(crate) static CSS_MODULE_SOURCE_TYPE_LIST: &[SourceType; 1] = &[SourceType::Css];
pub(crate) static CSS_MODULE_AND_JS_SOURCE_TYPE_LIST: &[SourceType; 2] =
&[SourceType::Css, SourceType::JavaScript];
pub(crate) static CSS_MODULE_EXPORTS_ONLY_SOURCE_TYPE_LIST: &[SourceType; 1] =
&[SourceType::JavaScript];
pub type CssExportsRef<'a> = FxIndexMap<&'a str, &'a FxIndexSet<CssExport>>;
#[cacheable]
#[derive(Debug)]
pub struct CssParserAndGenerator {
pub generator_options: CssModuleGeneratorOptions,
pub parser_options: CssModuleParserOptions,
pub exports_only: bool,
pub hot: bool,
}
impl CssParserAndGenerator {
pub fn new(
generator_options: CssModuleGeneratorOptions,
parser_options: CssModuleParserOptions,
) -> Self {
let exports_only = generator_options
.exports_only
.expect("should have exports_only");
Self {
generator_options,
parser_options,
exports_only,
hot: false,
}
}
pub fn convention(&self) -> CssExportsConvention {
self
.generator_options
.exports_convention
.expect("should have convention for module_type css/auto, css/global or css/module")
}
pub fn named_exports(&self) -> bool {
self
.parser_options
.named_exports
.expect("should have named_exports")
}
pub fn es_module(&self) -> bool {
self
.generator_options
.es_module
.expect("should have es_module")
}
pub fn resolve_import(&self) -> &CssParserImport {
self
.parser_options
.resolve_import
.as_ref()
.unwrap_or(&CssParserImport::Bool(true))
}
pub fn url(&self) -> bool {
self.parser_options.url.expect("should have url")
}
async fn handle_local_ident_usage<'a>(
&self,
name: &'a str,
range: css_module_lexer::Range,
local_ident_options: &'a LocalIdentOptions<'a>,
css_exports: &'a mut Option<CssExports>,
dependencies: &'a mut Vec<Box<dyn Dependency>>,
module_hash_options: &LocalIdentModuleHashOptions<'_>,
) -> Result<()> {
let name = unescape(name);
let (local_ident, convention_names) = self
.resolve_local_ident_and_update_exports(
local_ident_options,
&name,
css_exports,
module_hash_options,
)
.await?;
dependencies.push(Box::new(CssSelfReferenceLocalIdentDependency::new(
convention_names,
vec![CssSelfReferenceLocalIdentReplacement {
local_ident,
range: (range.start, range.end).into(),
}],
)));
Ok(())
}
#[allow(clippy::too_many_arguments)]
async fn handle_local_ident_declaration<'a>(
&self,
name: &'a str,
range: css_module_lexer::Range,
local_ident_options: &'a LocalIdentOptions<'a>,
css_exports: &'a mut Option<CssExports>,
dependencies: &'a mut Vec<Box<dyn Dependency>>,
css_local_names: &mut Option<FxHashMap<String, String>>,
module_hash_options: &LocalIdentModuleHashOptions<'_>,
) -> rspack_error::Result<()> {
let name = unescape(name);
let (local_ident, convention_names) = self
.resolve_local_ident_and_update_exports(
local_ident_options,
&name,
css_exports,
module_hash_options,
)
.await?;
let local_names = css_local_names.get_or_insert_default();
local_names.insert(name.into_owned(), local_ident.clone());
dependencies.push(Box::new(CssLocalIdentDependency::new(
local_ident,
convention_names,
range.start,
range.end,
)));
Ok(())
}
pub async fn resolve_local_ident_and_update_exports(
&self,
local_ident_options: &LocalIdentOptions<'_>,
name: &str,
css_exports: &mut Option<CssExports>,
module_hash_options: &LocalIdentModuleHashOptions<'_>,
) -> Result<(String, Vec<String>)> {
let local_ident = local_ident_options
.get_local_ident(name, module_hash_options)
.await?;
let convention = self.convention();
let exports = css_exports.get_or_insert_default();
let convention_names = export_locals_convention(name, convention);
for convention_name in convention_names.iter() {
update_css_exports(
exports,
convention_name.to_owned(),
CssExport {
ident: local_ident.clone(),
orig_name: name.to_owned(),
from: None,
id: None,
},
);
}
Ok((local_ident, convention_names))
}
}
pub fn get_used_exports<'a>(
exports: &'a CssExports,
identifier: ModuleIdentifier,
runtime: Option<&RuntimeSpec>,
exports_info_artifact: &ExportsInfoArtifact,
) -> CssExportsRef<'a> {
let exports_info = exports_info_artifact
.get_exports_info_optional(&identifier)
.map(|info| info.as_data(exports_info_artifact));
exports
.iter()
.filter(|(name, _)| {
let export_info = exports_info
.as_ref()
.map(|info| info.get_read_only_export_info(&Atom::from(name.as_str())));
if let Some(export_info) = export_info {
export_info.get_used(runtime) != UsageState::Unused
} else {
true
}
})
.map(|(name, exports)| (name.as_str(), exports))
.collect()
}
#[derive(Debug, Clone)]
pub struct CodeGenerationDataUnusedLocalIdent {
pub(crate) idents: FxHashSet<String>,
}
pub fn get_unused_local_ident(
exports: &CssExports,
local_names: &FxHashMap<String, String>,
identifier: ModuleIdentifier,
runtime: Option<&RuntimeSpec>,
exports_info_artifact: &ExportsInfoArtifact,
) -> CodeGenerationDataUnusedLocalIdent {
let exports_names = exports.iter().fold(
FxHashMap::<&str, FxHashSet<Atom>>::default(),
|mut map, (name, css_exports)| {
css_exports.iter().for_each(|css_export| {
if let Some(set) = map.get_mut(css_export.orig_name.as_str()) {
set.insert(Atom::from(name.clone()));
} else {
map.insert(
&css_export.orig_name,
FxHashSet::from_iter([Atom::from(name.clone())]),
);
}
});
map
},
);
let exports_info = exports_info_artifact
.get_exports_info_optional(&identifier)
.map(|info| info.as_data(exports_info_artifact));
CodeGenerationDataUnusedLocalIdent {
idents: exports_names
.iter()
.filter(|(_, export_names)| {
export_names.iter().all(|export_name| {
let export_info = exports_info
.as_ref()
.map(|info| info.get_read_only_export_info(export_name));
if let Some(export_info) = export_info {
matches!(export_info.get_used(runtime), UsageState::Unused)
} else {
false
}
})
})
.filter_map(|(css_name, _)| local_names.get(*css_name).cloned())
.collect(),
}
}
static REGEX_CUSTOM_PROPERTY_IDENT: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"(^|[^-_a-zA-Z0-9])--([_a-zA-Z][-_a-zA-Z0-9]*)").expect("Invalid regex")
});
#[cacheable_dyn]
#[async_trait::async_trait]
impl ParserAndGenerator for CssParserAndGenerator {
fn source_types(&self, module: &dyn Module, module_graph: &ModuleGraph) -> &[SourceType] {
if self.exports_only {
return CSS_MODULE_EXPORTS_ONLY_SOURCE_TYPE_LIST;
}
let no_need_js = module_graph
.get_incoming_connections(&module.identifier())
.all(|conn| {
let dep = module_graph.dependency_by_id(&conn.dependency_id);
matches!(
dep.dependency_type(),
DependencyType::CssImport | DependencyType::EsmImport
)
});
if no_need_js {
CSS_MODULE_SOURCE_TYPE_LIST
} else {
CSS_MODULE_AND_JS_SOURCE_TYPE_LIST
}
}
fn size(&self, module: &dyn Module, source_type: Option<&SourceType>) -> f64 {
match source_type.unwrap_or(&SourceType::Css) {
SourceType::JavaScript => 42.0,
SourceType::Css => module.source().map_or(0, |source| source.size()) as f64,
_ => unreachable!(),
}
}
async fn parse<'a>(
&mut self,
parse_context: ParseContext<'a>,
) -> Result<TWithDiagnosticArray<ParseResult>> {
let ParseContext {
source,
module_type,
resource_data,
compiler_options,
build_info,
build_meta,
loaders,
module_match_resource,
..
} = parse_context;
build_info.strict = true;
build_meta.exports_type = if self.named_exports() {
BuildMetaExportsType::Namespace
} else {
BuildMetaExportsType::Default
};
build_meta.default_object = if self.named_exports() {
BuildMetaDefaultObject::False
} else {
BuildMetaDefaultObject::Redirect
};
let source = remove_bom(source);
let source_code = source.source().into_string_lossy();
let resource_data = module_match_resource.unwrap_or(resource_data);
let resource_path = resource_data.path();
let cached_source_code = OnceCell::new();
let get_source_code = || {
let s = cached_source_code.get_or_init(|| Arc::new(source_code.to_string()));
s.clone()
};
let mode = match module_type {
ModuleType::CssModule => css_module_lexer::Mode::Local,
ModuleType::CssGlobal => css_module_lexer::Mode::Global,
ModuleType::CssAuto
if resource_path.is_some()
&& REGEX_IS_MODULES.is_match(
resource_path
.as_ref()
.expect("should have resource_path for module_type css/auto")
.as_str(),
) =>
{
css_module_lexer::Mode::Local
}
_ => css_module_lexer::Mode::Css,
};
let mut diagnostics: Vec<Diagnostic> = vec![];
let mut dependencies: Vec<Box<dyn Dependency>> = vec![];
let mut presentational_dependencies: Vec<BoxDependencyTemplate> = vec![];
let mut code_generation_dependencies: Vec<BoxModuleDependency> = vec![];
let mut css_exports: Option<CssExports> = None;
let mut css_local_names: Option<FxHashMap<String, String>> = None;
let (deps, warnings) = css_module_lexer::collect_dependencies(&source_code, mode);
let mut export_dependency_names = Vec::new();
let mut graph_export_name_set = FxHashSet::default();
let mut presentational_dependency_hash_updates = Vec::new();
let convention = self.generator_options.exports_convention;
for dependency in deps.iter() {
match dependency {
css_module_lexer::Dependency::LocalClass { name, .. }
| css_module_lexer::Dependency::LocalId { name, .. } => {
if let Some(convention) = convention {
let (_prefix, name) = name.split_at(1);
let name = unescape(name).into_owned();
for convention_name in export_locals_convention(&name, convention) {
graph_export_name_set.insert(convention_name);
}
export_dependency_names.push(name);
}
}
css_module_lexer::Dependency::LocalKeyframes { name, .. }
| css_module_lexer::Dependency::LocalKeyframesDecl { name, .. } => {
if let Some(convention) = convention {
let name = unescape(name).into_owned();
for convention_name in export_locals_convention(&name, convention) {
graph_export_name_set.insert(convention_name);
}
export_dependency_names.push(name);
}
}
css_module_lexer::Dependency::ICSSExportValue { prop: name, .. } => {
if let Some(convention) = convention {
let name = unescape(name).into_owned();
for convention_name in export_locals_convention(&name, convention) {
graph_export_name_set.insert(convention_name);
}
export_dependency_names.push(name);
}
}
css_module_lexer::Dependency::Replace { content, range } => {
presentational_dependency_hash_updates.push(PresentationalDependencyHashUpdate {
start: range.start,
end: range.end + 1,
content,
});
}
_ => {}
}
}
if let Some(convention) = convention {
for captures in REGEX_CUSTOM_PROPERTY_IDENT.captures_iter(&source_code) {
if let Some(name) = captures.get(2) {
let name = name.as_str().to_string();
for convention_name in export_locals_convention(&name, convention) {
graph_export_name_set.insert(convention_name);
}
export_dependency_names.push(name);
}
}
}
let module_hash_options = LocalIdentModuleHashOptions {
export_dependency_names,
graph_export_names: graph_export_name_set,
presentational_dependency_hash_updates,
exports_only: self.exports_only,
es_module: self.es_module(),
named_exports: self.named_exports(),
exports_convention: self.generator_options.exports_convention,
};
let local_ident_options = OnceCell::new();
for dependency in deps {
match dependency {
css_module_lexer::Dependency::Url {
request,
range,
kind,
} => {
if request.trim().is_empty() {
continue;
}
if !self.url() {
continue;
}
let request = replace_module_request_prefix(
request,
&mut diagnostics,
get_source_code,
range.start,
range.end,
);
let request = normalize_url(request);
let dep = Box::new(CssUrlDependency::new(
request,
DependencyRange::new(range.start, range.end),
matches!(kind, css_module_lexer::UrlRangeKind::Function),
));
dependencies.push(dep.clone());
code_generation_dependencies.push(dep);
}
css_module_lexer::Dependency::Import {
request,
range,
media,
supports,
layer,
} => {
if request.is_empty() {
presentational_dependencies.push(Box::new(ConstDependency::new(
(range.start, range.end).into(),
"".into(),
)));
continue;
}
let should_import = match self.resolve_import() {
CssParserImport::Bool(b) => *b,
CssParserImport::Func(f) => {
let args = CssParserImportContext {
url: request.to_string(),
media: media.map(|s| s.to_string()),
resource_path: resource_path
.map(|p| p.as_str().to_string())
.unwrap_or_default(),
supports: supports.map(|s| s.to_string()),
layer: layer.map(|s| s.to_string()),
};
(f(args).await).unwrap_or(true)
}
};
if !should_import {
continue;
}
let request = replace_module_request_prefix(
request,
&mut diagnostics,
get_source_code,
range.start,
range.end,
);
dependencies.push(Box::new(CssImportDependency::new(
request.to_string(),
DependencyRange::new(range.start, range.end),
media.map(|s| s.to_string()),
supports.map(|s| s.to_string()),
layer.map(|s| {
if s.is_empty() {
CssLayer::Anonymous
} else {
CssLayer::Named(s.to_string())
}
}),
)));
}
css_module_lexer::Dependency::Replace { content, range } => presentational_dependencies
.push(Box::new(ConstDependency::new(
(range.start, range.end).into(),
content.into(),
))),
css_module_lexer::Dependency::LocalClass { name, range, .. }
| css_module_lexer::Dependency::LocalId { name, range, .. } => {
let (_prefix, name) = name.split_at(1);
let name = unescape(name);
let local_ident_options = local_ident_options.get_or_init(|| {
LocalIdentOptions::new(
resource_data,
module_type,
&source_code,
compiler_options,
&self.generator_options,
)
});
let (local_ident, convention_names) = self
.resolve_local_ident_and_update_exports(
local_ident_options,
&name,
&mut css_exports,
&module_hash_options,
)
.await?;
let local_names = css_local_names.get_or_insert_default();
local_names.insert(name.into_owned(), local_ident.clone());
dependencies.push(Box::new(CssLocalIdentDependency::new(
local_ident,
convention_names,
range.start + 1,
range.end,
)));
}
css_module_lexer::Dependency::LocalKeyframes { name, range, .. } => {
let local_ident_options = local_ident_options.get_or_init(|| {
LocalIdentOptions::new(
resource_data,
module_type,
&source_code,
compiler_options,
&self.generator_options,
)
});
self
.handle_local_ident_usage(
name,
range,
local_ident_options,
&mut css_exports,
&mut dependencies,
&module_hash_options,
)
.await?;
}
css_module_lexer::Dependency::LocalKeyframesDecl { name, range, .. } => {
let local_ident_options = local_ident_options.get_or_init(|| {
LocalIdentOptions::new(
resource_data,
module_type,
&source_code,
compiler_options,
&self.generator_options,
)
});
self
.handle_local_ident_declaration(
name,
range,
local_ident_options,
&mut css_exports,
&mut dependencies,
&mut css_local_names,
&module_hash_options,
)
.await?;
}
css_module_lexer::Dependency::Composes {
local_classes,
names,
from,
range,
} => {
let local_classes = local_classes
.into_iter()
.map(|s| unescape(s).to_string())
.collect::<Vec<_>>();
let names = names
.into_iter()
.map(|s| unescape(s).to_string())
.collect::<Vec<_>>();
let mut dep_id = None;
if let Some(from) = from
&& from != "global"
{
let from = from.trim_matches(|c| c == '\'' || c == '"');
let dep = CssComposeDependency::new(
from.to_string(),
names.iter().map(|s| s.to_owned().into()).collect(),
DependencyRange::new(range.start, range.end),
);
dep_id = Some(*dep.id());
dependencies.push(Box::new(dep));
} else if from.is_none() {
dependencies.push(Box::new(CssSelfReferenceLocalIdentDependency::new(
names.clone(),
vec![],
)));
}
let convention = self.convention();
let exports = css_exports.get_or_insert_default();
for name in names {
for local_class in local_classes.iter() {
let convention_names = export_locals_convention(&name, convention);
let convention_local_class = export_locals_convention(local_class, convention);
for (convention_name, local_class) in
convention_names.into_iter().zip(convention_local_class)
{
if let Some(existing) = exports.get(name.as_str())
&& from.is_none()
{
let existing = existing.clone();
exports
.get_mut(local_class.as_str())
.expect("composes local class must already added to exports")
.extend(existing);
} else {
exports
.get_mut(local_class.as_str())
.expect("composes local class must already added to exports")
.insert(CssExport {
ident: convention_name.clone(),
orig_name: name.clone(),
from: from
.filter(|f| *f != "global")
.map(|f| f.trim_matches(|c| c == '\'' || c == '"').to_string()),
id: dep_id,
});
}
}
}
}
}
css_module_lexer::Dependency::ICSSExportValue { prop, value } => {
let exports = css_exports.get_or_insert_default();
let convention = self.convention();
let convention_names = export_locals_convention(prop, convention);
let value = REGEX_IS_COMMENTS.replace_all(value, "");
for name in convention_names.iter() {
update_css_exports(
exports,
name.to_owned(),
CssExport {
ident: value.to_string(),
from: None,
id: None,
orig_name: prop.to_string(),
},
);
}
dependencies.push(Box::new(CssExportDependency::new(convention_names)));
}
_ => {}
}
}
for warning in warnings {
let range = warning.range();
let error = css_parsing_traceable_error(
get_source_code(),
range.start,
range.end,
warning.to_string(),
if matches!(
warning.kind(),
css_module_lexer::WarningKind::NotPrecededAtImport
) {
Severity::Error
} else {
Severity::Warning
},
);
diagnostics.push(error.into());
}
build_info.css_exports = css_exports;
build_info.css_local_names = css_local_names;
Ok(
ParseResult {
dependencies,
blocks: vec![],
presentational_dependencies,
code_generation_dependencies,
source,
side_effects_bailout: None,
}
.with_diagnostic(map_box_diagnostics_to_module_parse_diagnostics(
diagnostics,
loaders,
)),
)
}
#[allow(clippy::unwrap_in_result)]
async fn generate(
&self,
source: &BoxSource,
module: &dyn rspack_core::Module,
generate_context: &mut GenerateContext,
) -> Result<BoxSource> {
match generate_context.requested_source_type {
SourceType::Css => {
generate_context
.runtime_template
.runtime_requirements_mut()
.insert(RuntimeGlobals::HAS_CSS_MODULES);
let mut source = ReplaceSource::new(source.clone());
let compilation = generate_context.compilation;
let mut init_fragments = ModuleInitFragments::default();
let mut context = TemplateContext {
compilation,
module,
runtime: generate_context.runtime,
init_fragments: &mut init_fragments,
concatenation_scope: generate_context.concatenation_scope.take(),
data: generate_context.data,
runtime_template: generate_context.runtime_template,
};
let module_graph = compilation.get_module_graph();
module.get_dependencies().iter().for_each(|id| {
let dep = module_graph.dependency_by_id(id);
if let Some(dependency) = dep.as_dependency_code_generation() {
if let Some(template) = dependency
.dependency_template()
.and_then(|template_type| compilation.get_dependency_template(template_type))
{
template.render(dependency, &mut source, &mut context)
} else {
panic!(
"Can not find dependency template of {:?}",
dependency.dependency_template()
);
}
}
});
for conn in module_graph.get_incoming_connections(&module.identifier()) {
let dep = module_graph.dependency_by_id(&conn.dependency_id);
if matches!(dep.dependency_type(), DependencyType::CssImport) {
let Some(css_import_dep) = dep.downcast_ref::<CssImportDependency>() else {
panic!(
"dependency with type DependencyType::CssImport should only be CssImportDependency"
);
};
if let Some(media) = css_import_dep.media() {
let media = CssMedia(media.to_string());
context.data.insert(media);
}
if let Some(supports) = css_import_dep.supports() {
let supports = CssSupports(supports.to_string());
context.data.insert(supports);
}
if let Some(layer) = css_import_dep.layer() {
context.data.insert(layer.clone());
}
}
}
if let Some(dependencies) = module.get_presentational_dependencies() {
dependencies.iter().for_each(|dependency| {
if let Some(template) = dependency
.dependency_template()
.and_then(|dependency_type| compilation.get_dependency_template(dependency_type))
{
template.render(dependency.as_ref(), &mut source, &mut context)
} else {
panic!(
"Can not find dependency template of {:?}",
dependency.dependency_template()
);
}
});
};
generate_context.concatenation_scope = context.concatenation_scope.take();
Ok(source.boxed())
}
SourceType::JavaScript => {
CssModuleGenerator::new(module, generate_context, self.hot, self.es_module())
.generate_javascript_source()
}
_ => panic!(
"Unsupported source type: {:?}",
generate_context.requested_source_type
),
}
}
fn get_concatenation_bailout_reason(
&self,
_module: &dyn rspack_core::Module,
_mg: &ModuleGraph,
_cg: &ChunkGraph,
) -> Option<Cow<'static, str>> {
if self.exports_only {
None
} else {
Some("Module Concatenation is not implemented for CssParserAndGenerator".into())
}
}
async fn get_runtime_hash(
&self,
_module: &NormalModule,
compilation: &Compilation,
_runtime: Option<&RuntimeSpec>,
) -> Result<RspackHashDigest> {
let mut hasher = RspackHash::from(&compilation.options.output);
self.es_module().dyn_hash(&mut hasher);
Ok(hasher.digest(&compilation.options.output.hash_digest))
}
}