feat: port normal module replacement plugin to builtin plugin (#11362)

Author: ahabhgk

Cargo.lock

@@ -176,7 +176,6 @@ rspack_paths                           = { version = "=0.4.11", path = "crates/r
 rspack_plugin_asset                    = { version = "=0.4.11", path = "crates/rspack_plugin_asset", default-features = false }
 rspack_plugin_banner                   = { version = "=0.4.11", path = "crates/rspack_plugin_banner", default-features = false }
 rspack_plugin_circular_dependencies    = { version = "=0.4.11", path = "crates/rspack_plugin_circular_dependencies", default-features = false }
-rspack_plugin_context_replacement      = { version = "=0.4.11", path = "crates/rspack_plugin_context_replacement", default-features = false }
 rspack_plugin_copy                     = { version = "=0.4.11", path = "crates/rspack_plugin_copy", default-features = false }
 rspack_plugin_css                      = { version = "=0.4.11", path = "crates/rspack_plugin_css", default-features = false }
 rspack_plugin_css_chunking             = { version = "=0.4.11", path = "crates/rspack_plugin_css_chunking", default-features = false }
@@ -199,6 +198,7 @@ rspack_plugin_limit_chunk_count        = { version = "=0.4.11", path = "crates/r
 rspack_plugin_merge_duplicate_chunks   = { version = "=0.4.11", path = "crates/rspack_plugin_merge_duplicate_chunks", default-features = false }
 rspack_plugin_mf                       = { version = "=0.4.11", path = "crates/rspack_plugin_mf", default-features = false }
 rspack_plugin_module_info_header       = { version = "=0.4.11", path = "crates/rspack_plugin_module_info_header", default-features = false }
+rspack_plugin_module_replacement       = { version = "=0.4.11", path = "crates/rspack_plugin_module_replacement", default-features = false }
 rspack_plugin_no_emit_on_errors        = { version = "=0.4.11", path = "crates/rspack_plugin_no_emit_on_errors", default-features = false }
 rspack_plugin_progress                 = { version = "=0.4.11", path = "crates/rspack_plugin_progress", default-features = false }
 rspack_plugin_real_content_hash        = { version = "=0.4.11", path = "crates/rspack_plugin_real_content_hash", default-features = false }

Cargo.toml

@@ -567,6 +567,7 @@ export declare enum BuiltinPluginName {
   RuntimeChunkPlugin = 'RuntimeChunkPlugin',
   SizeLimitsPlugin = 'SizeLimitsPlugin',
   NoEmitOnErrorsPlugin = 'NoEmitOnErrorsPlugin',
+  NormalModuleReplacementPlugin = 'NormalModuleReplacementPlugin',
   ContextReplacementPlugin = 'ContextReplacementPlugin',
   DllEntryPlugin = 'DllEntryPlugin',
   DllReferenceAgencyPlugin = 'DllReferenceAgencyPlugin',
@@ -598,13 +599,6 @@ export interface ContextInfo {
   issuerLayer?: string
 }
 
-export interface CssChunkingPluginOptions {
-  strict?: boolean
-  minSize?: number
-  maxSize?: number
-  exclude?: RegExp
-}
-
 export declare enum EnforceExtension {
   Auto = 0,
   Enabled = 1,
@@ -704,13 +698,6 @@ export interface JsBeforeEmitData {
   uid?: number
 }
 
-export interface JsBeforeResolveArgs {
-  request: string
-  context: string
-  issuer: string
-  issuerLayer?: string
-}
-
 export interface JsBuildMeta {
   strictEsmModule: boolean
   hasTopLevelAwait: boolean
@@ -864,13 +851,6 @@ export interface JsExecuteModuleResult {
   error?: string
 }
 
-export interface JsFactorizeArgs {
-  request: string
-  context: string
-  issuer: string
-  issuerLayer?: string
-}
-
 export interface JsFactoryMeta {
   sideEffectFree?: boolean
 }
@@ -1022,11 +1002,14 @@ export interface JsPathDataChunkLike {
   id?: string
 }
 
-export interface JsResolveArgs {
+export interface JsResolveData {
   request: string
   context: string
-  issuer: string
-  issuerLayer?: string
+  contextInfo: ContextInfo
+  fileDependencies: Array<string>
+  contextDependencies: Array<string>
+  missingDependencies: Array<string>
+  createData?: JsCreateData
 }
 
 export interface JsResolveForSchemeArgs {
@@ -2006,6 +1989,13 @@ export interface RawCssAutoParserOptions {
   url?: boolean
 }
 
+export interface RawCssChunkingPluginOptions {
+  strict?: boolean
+  minSize?: number
+  maxSize?: number
+  exclude?: RegExp
+}
+
 export interface RawCssExtractPluginOption {
   filename: JsFilename
   chunkFilename: JsFilename
@@ -2516,6 +2506,11 @@ export interface RawNonStandard {
   deepSelectorCombinator: boolean
 }
 
+export interface RawNormalModuleReplacementPluginOptions {
+  resourceRegExp: RegExp
+  newResource: string | ((data: JsResolveData) => JsResolveData)
+}
+
 export interface RawOccurrenceChunkIdsPluginOptions {
   prioritiseInitial?: boolean
 }
@@ -2946,11 +2941,11 @@ export interface RegisterJsTaps {
   registerCompilationAfterProcessAssetsTaps: (stages: Array<number>) => Array<{ function: ((arg: JsCompilation) => void); stage: number; }>
   registerCompilationSealTaps: (stages: Array<number>) => Array<{ function: (() => void); stage: number; }>
   registerCompilationAfterSealTaps: (stages: Array<number>) => Array<{ function: (() => Promise<void>); stage: number; }>
-  registerNormalModuleFactoryBeforeResolveTaps: (stages: Array<number>) => Array<{ function: ((arg: JsBeforeResolveArgs) => Promise<[boolean | undefined, JsBeforeResolveArgs]>); stage: number; }>
-  registerNormalModuleFactoryFactorizeTaps: (stages: Array<number>) => Array<{ function: ((arg: JsFactorizeArgs) => Promise<JsFactorizeArgs>); stage: number; }>
-  registerNormalModuleFactoryResolveTaps: (stages: Array<number>) => Array<{ function: ((arg: JsResolveArgs) => Promise<JsResolveArgs>); stage: number; }>
+  registerNormalModuleFactoryBeforeResolveTaps: (stages: Array<number>) => Array<{ function: ((arg: JsResolveData) => Promise<[boolean | undefined, JsResolveData]>); stage: number; }>
+  registerNormalModuleFactoryFactorizeTaps: (stages: Array<number>) => Array<{ function: ((arg: JsResolveData) => Promise<JsResolveData>); stage: number; }>
+  registerNormalModuleFactoryResolveTaps: (stages: Array<number>) => Array<{ function: ((arg: JsResolveData) => Promise<JsResolveData>); stage: number; }>
   registerNormalModuleFactoryResolveForSchemeTaps: (stages: Array<number>) => Array<{ function: ((arg: JsResolveForSchemeArgs) => Promise<[boolean | undefined, JsResolveForSchemeArgs]>); stage: number; }>
-  registerNormalModuleFactoryAfterResolveTaps: (stages: Array<number>) => Array<{ function: ((arg: string) => Promise<[boolean | undefined, JsCreateData | undefined]>); stage: number; }>
+  registerNormalModuleFactoryAfterResolveTaps: (stages: Array<number>) => Array<{ function: ((arg: JsResolveData) => Promise<[boolean | undefined, JsResolveData]>); stage: number; }>
   registerNormalModuleFactoryCreateModuleTaps: (stages: Array<number>) => Array<{ function: ((arg: JsNormalModuleFactoryCreateModuleArgs) => Promise<void>); stage: number; }>
   registerContextModuleFactoryBeforeResolveTaps: (stages: Array<number>) => Array<{ function: ((arg: false | JsContextModuleFactoryBeforeResolveData) => Promise<false | JsContextModuleFactoryBeforeResolveData>); stage: number; }>
   registerContextModuleFactoryAfterResolveTaps: (stages: Array<number>) => Array<{ function: ((arg: false | JsContextModuleFactoryAfterResolveData) => Promise<false | JsContextModuleFactoryAfterResolveData>); stage: number; }>

crates/node_binding/napi-binding.d.ts

@@ -73,7 +73,6 @@ rspack_napi_macros                     = { workspace = true }
 rspack_plugin_asset                    = { workspace = true }
 rspack_plugin_banner                   = { workspace = true }
 rspack_plugin_circular_dependencies    = { workspace = true }
-rspack_plugin_context_replacement      = { workspace = true }
 rspack_plugin_copy                     = { workspace = true }
 rspack_plugin_css                      = { workspace = true }
 rspack_plugin_css_chunking             = { workspace = true }
@@ -94,6 +93,7 @@ rspack_plugin_limit_chunk_count        = { workspace = true }
 rspack_plugin_merge_duplicate_chunks   = { workspace = true }
 rspack_plugin_mf                       = { workspace = true }
 rspack_plugin_module_info_header       = { workspace = true }
+rspack_plugin_module_replacement       = { workspace = true }
 rspack_plugin_no_emit_on_errors        = { workspace = true }
 rspack_plugin_progress                 = { workspace = true }
 rspack_plugin_real_content_hash        = { workspace = true }

crates/rspack_binding_api/Cargo.toml

@@ -1,5 +1,9 @@
+use napi::{
+  Env,
+  bindgen_prelude::{Object, ToNapiValue},
+};
 use napi_derive::napi;
-use rspack_core::NormalModuleCreateData;
+use rspack_core::{ModuleFactoryCreateData, NormalModuleCreateData, ResourceData, parse_resource};
 use serde::Serialize;
 
 use crate::resource_data::JsResourceData;
@@ -12,37 +16,32 @@ pub struct JsResolveForSchemeArgs {
 
 pub type JsResolveForSchemeOutput = (Option<bool>, JsResourceData);
 
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
 #[napi(object)]
-pub struct JsBeforeResolveArgs {
-  pub request: String,
-  pub context: String,
-  pub issuer: String,
-  pub issuer_layer: Option<String>,
-}
-
-pub type JsBeforeResolveOutput = (Option<bool>, JsBeforeResolveArgs);
-
-#[napi(object)]
-pub struct JsFactorizeArgs {
-  pub request: String,
-  pub context: String,
+pub struct ContextInfo {
   pub issuer: String,
   pub issuer_layer: Option<String>,
 }
 
-pub type JsFactorizeOutput = JsFactorizeArgs;
-
-#[napi(object)]
-pub struct JsResolveArgs {
-  pub request: String,
-  pub context: String,
-  pub issuer: String,
-  pub issuer_layer: Option<String>,
+impl ToNapiValue for &ContextInfo {
+  unsafe fn to_napi_value(
+    env: napi::sys::napi_env,
+    val: Self,
+  ) -> napi::Result<napi::sys::napi_value> {
+    unsafe {
+      let env_wrapper = Env::from(env);
+      let mut obj = Object::new(&env_wrapper)?;
+      obj.set("issuer", &val.issuer)?;
+      if let Some(issuer_layer) = &val.issuer_layer {
+        obj.set("issuerLayer", issuer_layer)?;
+      }
+      ToNapiValue::to_napi_value(env, obj)
+    }
+  }
 }
 
-pub type JsResolveOutput = JsResolveArgs;
-
-#[derive(Serialize)]
+#[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 #[napi(object)]
 pub struct JsCreateData {
@@ -51,20 +50,104 @@ pub struct JsCreateData {
   pub resource: String,
 }
 
-#[derive(Serialize)]
+impl From<&NormalModuleCreateData> for JsCreateData {
+  fn from(value: &NormalModuleCreateData) -> Self {
+    Self {
+      request: value.request.to_owned(),
+      user_request: value.user_request.to_owned(),
+      resource: value.resource_resolve_data.resource.to_owned(),
+    }
+  }
+}
+
+impl JsCreateData {
+  pub fn update_nmf_data(self, create_data: &mut NormalModuleCreateData) {
+    fn update_resource_data(old_resource_data: &mut ResourceData, new_resource: String) {
+      if old_resource_data.resource_path.is_some()
+        && let Some(parsed) = parse_resource(&new_resource)
+      {
+        old_resource_data.set_path(parsed.path);
+        old_resource_data.set_query_optional(parsed.query);
+        old_resource_data.set_fragment_optional(parsed.fragment);
+      }
+      old_resource_data.set_resource(new_resource);
+    }
+
+    create_data.request = self.request;
+    create_data.user_request = self.user_request;
+    if create_data.resource_resolve_data.resource != self.resource {
+      update_resource_data(&mut create_data.resource_resolve_data, self.resource);
+    }
+  }
+}
+
+#[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct JsAfterResolveData {
+#[napi(object)]
+pub struct JsResolveData {
   pub request: String,
   pub context: String,
-  pub issuer: String,
-  pub issuer_layer: Option<String>,
+  pub context_info: ContextInfo,
   pub file_dependencies: Vec<String>,
   pub context_dependencies: Vec<String>,
   pub missing_dependencies: Vec<String>,
   pub create_data: Option<JsCreateData>,
 }
 
-pub type JsAfterResolveOutput = (Option<bool>, Option<JsCreateData>);
+impl JsResolveData {
+  pub fn from_nmf_data(
+    data: &ModuleFactoryCreateData,
+    create_data: Option<&NormalModuleCreateData>,
+  ) -> Self {
+    JsResolveData {
+      request: data.request.to_string(),
+      context: data.context.to_string(),
+      context_info: ContextInfo {
+        issuer: data
+          .issuer
+          .as_ref()
+          .map(|issuer| issuer.to_string())
+          .unwrap_or_default(),
+        issuer_layer: data.issuer_layer.clone(),
+      },
+      file_dependencies: data
+        .file_dependencies
+        .iter()
+        .map(|item| item.to_string_lossy().into_owned())
+        .collect::<Vec<_>>(),
+      context_dependencies: data
+        .context_dependencies
+        .iter()
+        .map(|item| item.to_string_lossy().into_owned())
+        .collect::<Vec<_>>(),
+      missing_dependencies: data
+        .missing_dependencies
+        .iter()
+        .map(|item| item.to_string_lossy().into_owned())
+        .collect::<Vec<_>>(),
+      create_data: create_data.map(|create_data| JsCreateData {
+        request: create_data.request.to_owned(),
+        user_request: create_data.user_request.to_owned(),
+        resource: create_data.resource_resolve_data.resource.to_owned(),
+      }),
+    }
+  }
+
+  pub fn update_nmf_data(
+    self,
+    data: &mut ModuleFactoryCreateData,
+    create_data: Option<&mut NormalModuleCreateData>,
+  ) {
+    // only supports update request for now
+    data.request = self.request;
+    data.context = self.context.into();
+    if let Some(new_data) = self.create_data
+      && let Some(create_data) = create_data
+    {
+      new_data.update_nmf_data(create_data);
+    }
+  }
+}
 
 #[napi(object)]
 pub struct JsNormalModuleFactoryCreateModuleArgs {
@@ -74,13 +157,3 @@ pub struct JsNormalModuleFactoryCreateModuleArgs {
   pub context: String,
   pub match_resource: Option<String>,
 }
-
-impl From<&NormalModuleCreateData> for JsCreateData {
-  fn from(value: &NormalModuleCreateData) -> Self {
-    Self {
-      request: value.request.to_owned(),
-      user_request: value.user_request.to_owned(),
-      resource: value.resource_resolve_data.resource.to_owned(),
-    }
-  }
-}