feat: support resolveImport for css parser

Author: JSerFeng

crates/node_binding/napi-binding.d.ts

@@ -2007,6 +2007,7 @@ export interface RawCssAutoGeneratorOptions {
 export interface RawCssAutoParserOptions {
   namedExports?: boolean
   url?: boolean
+  resolveImport?: boolean | ((args: [string, string | undefined, string, string | undefined, string | undefined]) => boolean)
 }
 
 export interface RawCssChunkingPluginOptions {
@@ -2043,11 +2044,13 @@ export interface RawCssModuleGeneratorOptions {
 export interface RawCssModuleParserOptions {
   namedExports?: boolean
   url?: boolean
+  resolveImport?: boolean | ((args: [string, string | undefined, string, string | undefined, string | undefined]) => boolean)
 }
 
 export interface RawCssParserOptions {
   namedExports?: boolean
   url?: boolean
+  resolveImport?: boolean | ((args: [string, string | undefined, string, string | undefined, string | undefined]) => boolean)
 }
 
 export interface RawDllEntryPluginOptions {

crates/rspack_binding_api/src/raw_options/raw_module/mod.rs

@@ -17,13 +17,14 @@ use rspack_core::{
   AssetGeneratorOptions, AssetInlineGeneratorOptions, AssetParserDataUrl,
   AssetParserDataUrlOptions, AssetParserOptions, AssetResourceGeneratorOptions,
   CssAutoGeneratorOptions, CssAutoParserOptions, CssGeneratorOptions, CssModuleGeneratorOptions,
-  CssModuleParserOptions, CssParserOptions, DescriptionData, DynamicImportFetchPriority,
-  DynamicImportMode, ExportPresenceMode, FuncUseCtx, GeneratorOptions, GeneratorOptionsMap,
-  JavascriptParserCommonjsExportsOption, JavascriptParserCommonjsOptions, JavascriptParserOptions,
-  JavascriptParserOrder, JavascriptParserUrl, JsonGeneratorOptions, JsonParserOptions,
-  ModuleNoParseRule, ModuleNoParseRules, ModuleNoParseTestFn, ModuleOptions, ModuleRule,
-  ModuleRuleEffect, ModuleRuleEnforce, ModuleRuleUse, ModuleRuleUseLoader, OverrideStrict,
-  ParseOption, ParserOptions, ParserOptionsMap, TypeReexportPresenceMode, UnsafeCachePredicate,
+  CssModuleParserOptions, CssParserImport, CssParserImportFnArgs, CssParserOptions,
+  DescriptionData, DynamicImportFetchPriority, DynamicImportMode, ExportPresenceMode, FuncUseCtx,
+  GeneratorOptions, GeneratorOptionsMap, JavascriptParserCommonjsExportsOption,
+  JavascriptParserCommonjsOptions, JavascriptParserOptions, JavascriptParserOrder,
+  JavascriptParserUrl, JsonGeneratorOptions, JsonParserOptions, ModuleNoParseRule,
+  ModuleNoParseRules, ModuleNoParseTestFn, ModuleOptions, ModuleRule, ModuleRuleEffect,
+  ModuleRuleEnforce, ModuleRuleUse, ModuleRuleUseLoader, OverrideStrict, ParseOption,
+  ParserOptions, ParserOptionsMap, TypeReexportPresenceMode, UnsafeCachePredicate,
 };
 use rspack_error::error;
 use rspack_napi::threadsafe_function::ThreadsafeFunction;
@@ -461,50 +462,96 @@ impl From<RawAssetParserDataUrlOptions> for AssetParserDataUrlOptions {
   }
 }
 
+// Use tuple to pass arguments separately to JS function
+type RawCssImportFn = ThreadsafeFunction<
+  (
+    String,
+    Option<String>,
+    String,
+    Option<String>,
+    Option<String>,
+  ),
+  bool,
+>;
+
+fn convert_import_option(import: Option<Either<bool, RawCssImportFn>>) -> Option<CssParserImport> {
+  import.map(|i| match i {
+    Either::A(b) => CssParserImport::Bool(b),
+    Either::B(f) => CssParserImport::Func(Arc::new(move |args: CssParserImportFnArgs| {
+      let f = f.clone();
+      Box::pin(async move {
+        f.call_with_sync((
+          args.url,
+          args.media,
+          args.resource_path,
+          args.supports,
+          args.layer,
+        ))
+        .await
+      })
+    })),
+  })
+}
+
 #[derive(Debug, Default)]
-#[napi(object)]
+#[napi(object, object_to_js = false)]
 pub struct RawCssParserOptions {
   pub named_exports: Option<bool>,
   pub url: Option<bool>,
+  #[napi(
+    ts_type = "boolean | ((args: [string, string | undefined, string, string | undefined, string | undefined]) => boolean)"
+  )]
+  pub resolve_import: Option<Either<bool, RawCssImportFn>>,
 }
 
 impl From<RawCssParserOptions> for CssParserOptions {
   fn from(value: RawCssParserOptions) -> Self {
     Self {
       named_exports: value.named_exports,
       url: value.url,
+      resolve_import: convert_import_option(value.resolve_import),
     }
   }
 }
 
 #[derive(Debug, Default)]
-#[napi(object)]
+#[napi(object, object_to_js = false)]
 pub struct RawCssAutoParserOptions {
   pub named_exports: Option<bool>,
   pub url: Option<bool>,
+  #[napi(
+    ts_type = "boolean | ((args: [string, string | undefined, string, string | undefined, string | undefined]) => boolean)"
+  )]
+  pub resolve_import: Option<Either<bool, RawCssImportFn>>,
 }
 
 impl From<RawCssAutoParserOptions> for CssAutoParserOptions {
   fn from(value: RawCssAutoParserOptions) -> Self {
     Self {
       named_exports: value.named_exports,
       url: value.url,
+      resolve_import: convert_import_option(value.resolve_import),
     }
   }
 }
 
 #[derive(Debug, Default)]
-#[napi(object)]
+#[napi(object, object_to_js = false)]
 pub struct RawCssModuleParserOptions {
   pub named_exports: Option<bool>,
   pub url: Option<bool>,
+  #[napi(
+    ts_type = "boolean | ((args: [string, string | undefined, string, string | undefined, string | undefined]) => boolean)"
+  )]
+  pub resolve_import: Option<Either<bool, RawCssImportFn>>,
 }
 
 impl From<RawCssModuleParserOptions> for CssModuleParserOptions {
   fn from(value: RawCssModuleParserOptions) -> Self {
     Self {
       named_exports: value.named_exports,
       url: value.url,
+      resolve_import: convert_import_option(value.resolve_import),
     }
   }
 }

crates/rspack_core/src/options/module.rs

@@ -330,25 +330,76 @@ pub struct AssetParserDataUrlOptions {
   pub max_size: Option<f64>,
 }
 
+/// Arguments passed to the CSS parser import filter function
+pub struct CssParserImportFnArgs {
+  pub url: String,
+  pub media: Option<String>,
+  pub resource_path: String,
+  pub supports: Option<String>,
+  pub layer: Option<String>,
+}
+
+pub type CssParserImportFn =
+  Arc<dyn Fn(CssParserImportFnArgs) -> BoxFuture<'static, Result<bool>> + Sync + Send>;
+
+#[cacheable]
+pub enum CssParserImport {
+  Bool(bool),
+  Func(#[cacheable(with=Unsupported)] CssParserImportFn),
+}
+
+impl Default for CssParserImport {
+  fn default() -> Self {
+    Self::Bool(true)
+  }
+}
+
+impl fmt::Debug for CssParserImport {
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    match self {
+      Self::Bool(b) => write!(f, "CssParserImport::Bool({b})"),
+      Self::Func(_) => write!(f, "CssParserImport::Func(...)"),
+    }
+  }
+}
+
+impl Clone for CssParserImport {
+  fn clone(&self) -> Self {
+    match self {
+      Self::Bool(b) => Self::Bool(*b),
+      Self::Func(f) => Self::Func(f.clone()),
+    }
+  }
+}
+
+impl MergeFrom for CssParserImport {
+  fn merge_from(self, other: &Self) -> Self {
+    other.clone()
+  }
+}
+
 #[cacheable]
 #[derive(Debug, Clone, MergeFrom)]
 pub struct CssParserOptions {
   pub named_exports: Option<bool>,
   pub url: Option<bool>,
+  pub resolve_import: Option<CssParserImport>,
 }
 
 #[cacheable]
 #[derive(Debug, Clone, MergeFrom)]
 pub struct CssAutoParserOptions {
   pub named_exports: Option<bool>,
   pub url: Option<bool>,
+  pub resolve_import: Option<CssParserImport>,
 }
 
 impl From<CssParserOptions> for CssAutoParserOptions {
   fn from(value: CssParserOptions) -> Self {
     Self {
       named_exports: value.named_exports,
       url: value.url,
+      resolve_import: value.resolve_import,
     }
   }
 }
@@ -358,13 +409,15 @@ impl From<CssParserOptions> for CssAutoParserOptions {
 pub struct CssModuleParserOptions {
   pub named_exports: Option<bool>,
   pub url: Option<bool>,
+  pub resolve_import: Option<CssParserImport>,
 }
 
 impl From<CssParserOptions> for CssModuleParserOptions {
   fn from(value: CssParserOptions) -> Self {
     Self {
       named_exports: value.named_exports,
       url: value.url,
+      resolve_import: value.resolve_import,
     }
   }
 }

crates/rspack_plugin_css/src/parser_and_generator/mod.rs

@@ -12,11 +12,11 @@ use rspack_cacheable::{
 };
 use rspack_core::{
   BoxDependencyTemplate, BoxModuleDependency, BuildMetaDefaultObject, BuildMetaExportsType,
-  ChunkGraph, Compilation, ConstDependency, CssExportsConvention, Dependency, DependencyId,
-  DependencyRange, DependencyType, GenerateContext, LocalIdentName, Module, ModuleGraph,
-  ModuleIdentifier, ModuleInitFragments, ModuleType, NormalModule, ParseContext, ParseResult,
-  ParserAndGenerator, PrefetchExportsInfoMode, RuntimeGlobals, RuntimeSpec, SourceType,
-  TemplateContext, UsageState,
+  ChunkGraph, Compilation, ConstDependency, CssExportsConvention, CssParserImport,
+  CssParserImportFnArgs, Dependency, DependencyId, DependencyRange, DependencyType,
+  GenerateContext, LocalIdentName, Module, ModuleGraph, ModuleIdentifier, ModuleInitFragments,
+  ModuleType, NormalModule, ParseContext, ParseResult, ParserAndGenerator, PrefetchExportsInfoMode,
+  RuntimeGlobals, RuntimeSpec, SourceType, TemplateContext, UsageState,
   diagnostics::map_box_diagnostics_to_module_parse_diagnostics,
   remove_bom,
   rspack_sources::{BoxSource, ConcatSource, RawStringSource, ReplaceSource, Source, SourceExt},
@@ -83,6 +83,7 @@ pub struct CssParserAndGenerator {
   pub named_exports: bool,
   pub es_module: bool,
   pub url: bool,
+  pub resolve_import: CssParserImport,
   #[cacheable(with=AsOption<AsMap<AsCacheable, AsVec>>)]
   pub exports: Option<CssExports>,
   pub local_names: Option<FxHashMap<String, String>>,
@@ -227,6 +228,29 @@ impl ParserAndGenerator for CssParserAndGenerator {
             )));
             continue;
           }
+          // Check the import option
+          let should_import = match &self.resolve_import {
+            CssParserImport::Bool(b) => *b,
+            CssParserImport::Func(f) => {
+              // Call the filter function with the import arguments
+              let args = CssParserImportFnArgs {
+                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()),
+              };
+              match f(args).await {
+                Ok(result) => result,
+                Err(_) => true, // Default to include if function call fails
+              }
+            }
+          };
+          if !should_import {
+            continue;
+          }
           let request = replace_module_request_prefix(
             request,
             &mut diagnostics,

crates/rspack_plugin_css/src/plugin/impl_plugin_for_css_plugin.rs

@@ -519,6 +519,7 @@ impl Plugin for CssPlugin {
           es_module: g.es_module.expect("should have es_module"),
           hot: false,
           url: p.url.expect("should have url"),
+          resolve_import: p.resolve_import.clone().unwrap_or_default(),
         }) as Box<dyn ParserAndGenerator>
       }),
     );
@@ -548,6 +549,7 @@ impl Plugin for CssPlugin {
           es_module: g.es_module.expect("should have es_module"),
           hot: false,
           url: p.url.expect("should have url"),
+          resolve_import: p.resolve_import.clone().unwrap_or_default(),
         }) as Box<dyn ParserAndGenerator>
       }),
     );
@@ -577,6 +579,7 @@ impl Plugin for CssPlugin {
           es_module: g.es_module.expect("should have es_module"),
           hot: false,
           url: p.url.expect("should have url"),
+          resolve_import: p.resolve_import.clone().unwrap_or_default(),
         }) as Box<dyn ParserAndGenerator>
       }),
     );

packages/rspack/etc/core.api.md

@@ -1612,6 +1612,7 @@ export type CssAutoGeneratorOptions = {
 export type CssAutoParserOptions = {
     namedExports?: CssParserNamedExports;
     url?: CssParserUrl;
+    resolveImport?: CssParserResolveImport;
 };
 
 // @public
@@ -1718,6 +1719,7 @@ export type CssModuleGeneratorOptions = CssAutoGeneratorOptions;
 export type CssModuleParserOptions = {
     namedExports?: CssParserNamedExports;
     url?: CssParserUrl;
+    resolveImport?: CssParserResolveImport;
 };
 
 // @public (undocumented)
@@ -1727,8 +1729,12 @@ export type CssParserNamedExports = boolean;
 export type CssParserOptions = {
     namedExports?: CssParserNamedExports;
     url?: CssParserUrl;
+    resolveImport?: CssParserResolveImport;
 };
 
+// @public (undocumented)
+export type CssParserResolveImport = boolean | ((url: string, media: string | undefined, resourcePath: string, supports: string | undefined, layer: string | undefined) => boolean);
+
 // @public (undocumented)
 export type CssParserUrl = boolean;
 
@@ -6835,6 +6841,7 @@ declare namespace rspackExports {
         AssetParserOptions,
         CssParserNamedExports,
         CssParserUrl,
+        CssParserResolveImport,
         CssParserOptions,
         CssAutoParserOptions,
         CssModuleParserOptions,

packages/rspack/src/config/adapter.ts

@@ -628,6 +628,21 @@ function getRawCssParserOptions(
   return {
     namedExports: parser.namedExports,
     url: parser.url,
+    resolveImport:
+      parser.resolveImport === undefined
+        ? undefined
+        : typeof parser.resolveImport === 'function'
+          ? (args) =>
+              (
+                parser.resolveImport as (
+                  url: string,
+                  media: string | undefined,
+                  resourcePath: string,
+                  supports: string | undefined,
+                  layer: string | undefined,
+                ) => boolean
+              )(...args)
+          : parser.resolveImport,
   };
 }