feat: Support import.meta.filename/dirname/resolve

Author: magic-akari

crates/node_binding/napi-binding.d.ts

@@ -2100,6 +2100,7 @@ export interface RawEnvironment {
   optionalChaining?: boolean
   templateLiteral?: boolean
   dynamicImportInWorker?: boolean
+  importMetaDirnameAndFilename?: boolean
 }
 
 export interface RawEsmLibraryPlugin {

crates/rspack/tests/snapshots/defaults__default_options.snap

@@ -140,6 +140,7 @@ CompilerOptions {
             dynamic_import_in_worker: Some(
                 false,
             ),
+            import_meta_dirname_and_filename: None,
         },
         compare_before_emit: true,
     },

crates/rspack_binding_api/src/raw_options/raw_output.rs

@@ -58,6 +58,7 @@ pub struct RawEnvironment {
   pub optional_chaining: Option<bool>,
   pub template_literal: Option<bool>,
   pub dynamic_import_in_worker: Option<bool>,
+  pub import_meta_dirname_and_filename: Option<bool>,
 }
 
 impl From<RawEnvironment> for Environment {
@@ -78,6 +79,7 @@ impl From<RawEnvironment> for Environment {
       optional_chaining: value.optional_chaining,
       template_literal: value.template_literal,
       dynamic_import_in_worker: value.dynamic_import_in_worker,
+      import_meta_dirname_and_filename: value.import_meta_dirname_and_filename,
     }
   }
 }

crates/rspack_core/src/dependency/dependency_type.rs

@@ -73,6 +73,8 @@ pub enum DependencyType {
   ImportContext,
   // import.meta.webpackContext
   ImportMetaContext,
+  // import.meta.resolve
+  ImportMetaResolve,
   // commonjs require context
   CommonJSRequireContext,
   // require.context
@@ -177,6 +179,7 @@ impl DependencyType {
       DependencyType::ExportInfoApi => "export info api",
       // TODO: mode
       DependencyType::ImportMetaContext => "import.meta context",
+      DependencyType::ImportMetaResolve => "import.meta.resolve",
       DependencyType::ContainerExposed => "container exposed",
       DependencyType::ContainerEntry => "container entry",
       DependencyType::DllEntry => "dll entry",

crates/rspack_core/src/options/output.rs

@@ -533,6 +533,7 @@ pub struct Environment {
   pub optional_chaining: Option<bool>,
   pub template_literal: Option<bool>,
   pub dynamic_import_in_worker: Option<bool>,
+  pub import_meta_dirname_and_filename: Option<bool>,
 }
 
 impl Environment {

crates/rspack_plugin_circular_dependencies/src/lib.rs

@@ -108,6 +108,7 @@ impl AggregatedDependency {
           | DependencyType::LazyImport
           | DependencyType::ImportMetaHotAccept
           | DependencyType::ImportMetaHotDecline
+          | DependencyType::ImportMetaResolve
           | DependencyType::ModuleHotAccept
           | DependencyType::ModuleHotDecline
           | DependencyType::RequireResolve

crates/rspack_plugin_javascript/src/dependency/esm/import_meta_resolve_dependency.rs

@@ -0,0 +1,135 @@
+use rspack_cacheable::{cacheable, cacheable_dyn};
+use rspack_core::{
+  AsContextDependency, Dependency, DependencyCategory, DependencyCodeGeneration, DependencyId,
+  DependencyRange, DependencyTemplate, DependencyTemplateType, DependencyType,
+  ExtendedReferencedExport, FactorizeInfo, ModuleDependency, ModuleGraph, ModuleGraphCacheArtifact,
+  RuntimeSpec, TemplateContext, TemplateReplaceSource,
+};
+
+#[cacheable]
+#[derive(Debug, Clone)]
+pub struct ImportMetaResolveDependency {
+  pub id: DependencyId,
+  pub request: String,
+  range: DependencyRange,
+  optional: bool,
+  factorize_info: FactorizeInfo,
+}
+
+impl ImportMetaResolveDependency {
+  pub fn new(request: String, range: DependencyRange, optional: bool) -> Self {
+    Self {
+      range,
+      request,
+      optional,
+      id: DependencyId::new(),
+      factorize_info: Default::default(),
+    }
+  }
+}
+
+#[cacheable_dyn]
+impl Dependency for ImportMetaResolveDependency {
+  fn id(&self) -> &DependencyId {
+    &self.id
+  }
+
+  fn category(&self) -> &DependencyCategory {
+    &DependencyCategory::Esm
+  }
+
+  fn dependency_type(&self) -> &DependencyType {
+    &DependencyType::ImportMetaResolve
+  }
+
+  fn range(&self) -> Option<DependencyRange> {
+    Some(self.range)
+  }
+
+  fn get_referenced_exports(
+    &self,
+    _module_graph: &ModuleGraph,
+    _module_graph_cache: &ModuleGraphCacheArtifact,
+    _runtime: Option<&RuntimeSpec>,
+  ) -> Vec<ExtendedReferencedExport> {
+    vec![]
+  }
+
+  fn could_affect_referencing_module(&self) -> rspack_core::AffectType {
+    rspack_core::AffectType::True
+  }
+}
+
+#[cacheable_dyn]
+impl ModuleDependency for ImportMetaResolveDependency {
+  fn request(&self) -> &str {
+    &self.request
+  }
+
+  fn user_request(&self) -> &str {
+    &self.request
+  }
+
+  fn get_optional(&self) -> bool {
+    self.optional
+  }
+
+  fn factorize_info(&self) -> &FactorizeInfo {
+    &self.factorize_info
+  }
+
+  fn factorize_info_mut(&mut self) -> &mut FactorizeInfo {
+    &mut self.factorize_info
+  }
+}
+
+#[cacheable_dyn]
+impl DependencyCodeGeneration for ImportMetaResolveDependency {
+  fn dependency_template(&self) -> Option<DependencyTemplateType> {
+    Some(ImportMetaResolveDependencyTemplate::template_type())
+  }
+}
+
+impl AsContextDependency for ImportMetaResolveDependency {}
+
+#[cacheable]
+#[derive(Debug, Clone, Default)]
+pub struct ImportMetaResolveDependencyTemplate;
+
+impl ImportMetaResolveDependencyTemplate {
+  pub fn template_type() -> DependencyTemplateType {
+    DependencyTemplateType::Dependency(DependencyType::ImportMetaResolve)
+  }
+}
+
+impl DependencyTemplate for ImportMetaResolveDependencyTemplate {
+  fn render(
+    &self,
+    dep: &dyn DependencyCodeGeneration,
+    source: &mut TemplateReplaceSource,
+    code_generatable_context: &mut TemplateContext,
+  ) {
+    let dep = dep
+      .as_any()
+      .downcast_ref::<ImportMetaResolveDependency>()
+      .expect(
+        "ImportMetaResolveDependencyTemplate should only be used for ImportMetaResolveDependency",
+      );
+
+    source.replace(
+      dep.range.start,
+      dep.range.end,
+      code_generatable_context
+        .compilation
+        .runtime_template
+        .module_id(
+          code_generatable_context.compilation,
+          &dep.id,
+          &dep.request,
+          false,
+        )
+        .as_str(),
+      None,
+    );
+  }
+}

crates/rspack_plugin_javascript/src/dependency/esm/import_meta_resolve_header_dependency.rs

@@ -0,0 +1,81 @@
+use rspack_cacheable::{cacheable, cacheable_dyn, with::Skip};
+use rspack_core::{
+  AffectType, AsContextDependency, AsModuleDependency, Dependency, DependencyCodeGeneration,
+  DependencyId, DependencyLocation, DependencyRange, DependencyTemplate, DependencyTemplateType,
+  SharedSourceMap, TemplateContext, TemplateReplaceSource,
+};
+
+#[cacheable]
+#[derive(Debug, Clone)]
+pub struct ImportMetaResolveHeaderDependency {
+  id: DependencyId,
+  range: DependencyRange,
+  #[cacheable(with=Skip)]
+  source_map: Option<SharedSourceMap>,
+}
+
+impl ImportMetaResolveHeaderDependency {
+  pub fn new(range: DependencyRange, source_map: Option<SharedSourceMap>) -> Self {
+    Self {
+      id: DependencyId::new(),
+      range,
+      source_map,
+    }
+  }
+}
+
+#[cacheable_dyn]
+impl Dependency for ImportMetaResolveHeaderDependency {
+  fn id(&self) -> &DependencyId {
+    &self.id
+  }
+
+  fn loc(&self) -> Option<DependencyLocation> {
+    self.range.to_loc(self.source_map.as_ref())
+  }
+
+  fn could_affect_referencing_module(&self) -> AffectType {
+    AffectType::False
+  }
+}
+
+impl AsModuleDependency for ImportMetaResolveHeaderDependency {}
+impl AsContextDependency for ImportMetaResolveHeaderDependency {}
+
+#[cacheable_dyn]
+impl DependencyCodeGeneration for ImportMetaResolveHeaderDependency {
+  fn dependency_template(&self) -> Option<DependencyTemplateType> {
+    Some(ImportMetaResolveHeaderDependencyTemplate::template_type())
+  }
+}
+
+#[cacheable]
+#[derive(Debug, Clone, Default)]
+pub struct ImportMetaResolveHeaderDependencyTemplate;
+
+impl ImportMetaResolveHeaderDependencyTemplate {
+  pub fn template_type() -> DependencyTemplateType {
+    DependencyTemplateType::Custom("ImportMetaResolveHeaderDependency")
+  }
+}
+
+impl DependencyTemplate for ImportMetaResolveHeaderDependencyTemplate {
+  fn render(
+    &self,
+    dep: &dyn DependencyCodeGeneration,
+    source: &mut TemplateReplaceSource,
+    _code_generatable_context: &mut TemplateContext,
+  ) {
+    let dep = dep
+      .as_any()
+      .downcast_ref::<ImportMetaResolveHeaderDependency>()
+      .expect("ImportMetaResolveHeaderDependencyTemplate should only be used for ImportMetaResolveHeaderDependency");
+
+    source.replace(
+      dep.range.start,
+      dep.range.end,
+      "/*import.meta.resolve*/",
+      None,
+    );
+  }
+}

crates/rspack_plugin_javascript/src/dependency/esm/mod.rs

@@ -8,6 +8,8 @@ mod esm_import_specifier_dependency;
 mod external_module_dependency;
 mod import_dependency;
 mod import_eager_dependency;
+mod import_meta_resolve_dependency;
+mod import_meta_resolve_header_dependency;
 mod provide_dependency;
 
 use rspack_core::{DependencyCategory, ImportAttributes, ResourceIdentifier};
@@ -36,6 +38,12 @@ pub use self::{
   external_module_dependency::{ExternalModuleDependency, ExternalModuleDependencyTemplate},
   import_dependency::{ImportDependency, ImportDependencyTemplate},
   import_eager_dependency::{ImportEagerDependency, ImportEagerDependencyTemplate},
+  import_meta_resolve_dependency::{
+    ImportMetaResolveDependency, ImportMetaResolveDependencyTemplate,
+  },
+  import_meta_resolve_header_dependency::{
+    ImportMetaResolveHeaderDependency, ImportMetaResolveHeaderDependencyTemplate,
+  },
   provide_dependency::{ProvideDependency, ProvideDependencyTemplate},
 };