refactor: render __webpack_require__ in static code by runtime template (#12284)

* refactor: render __webpack_require__ by runtime template in dead code

* refactor: render __webpack_require__ by runtime template in dead code

Author: LingyuCoder

crates/rspack_plugin_esm_library/src/render.rs

@@ -204,7 +204,7 @@ impl EsmLibraryPlugin {
         // __webpack_require__.add({ "./src/main.js"(require, exports) { ... } })
         decl_source.add(RawStringSource::from(format!(
           "{}({{\n",
-          RegisterModuleRuntime::runtime_id()
+          RegisterModuleRuntime::runtime_id(&compilation.runtime_template)
         )));
         decl_source.add(decl_inner);
         decl_source.add(RawStringSource::from_static("});\n"));

crates/rspack_plugin_esm_library/src/runtime.rs

@@ -1,14 +1,18 @@
 use rspack_core::{
-  Compilation, ModuleIdentifier, RuntimeGlobals, RuntimeModule, impl_runtime_module,
+  Compilation, ModuleIdentifier, RuntimeGlobals, RuntimeModule, RuntimeTemplate,
+  impl_runtime_module,
 };
 
 #[impl_runtime_module]
 #[derive(Default, Debug)]
 pub(crate) struct RegisterModuleRuntime {}
 
 impl RegisterModuleRuntime {
-  pub(crate) fn runtime_id() -> &'static str {
-    "__webpack_require__.add"
+  pub(crate) fn runtime_id(runtime_template: &RuntimeTemplate) -> String {
+    format!(
+      "{}.add",
+      runtime_template.render_runtime_globals(&RuntimeGlobals::REQUIRE)
+    )
   }
 }
 
@@ -21,7 +25,7 @@ impl RuntimeModule for RegisterModuleRuntime {
   async fn generate(&self, compilation: &Compilation) -> rspack_error::Result<String> {
     Ok(format!(
       "{} = function registerModules(modules) {{ Object.assign({}, modules) }}\n",
-      Self::runtime_id(),
+      Self::runtime_id(&compilation.runtime_template),
       compilation
         .runtime_template
         .render_runtime_globals(&RuntimeGlobals::MODULE_FACTORIES),

crates/rspack_plugin_extract_css/src/plugin.rs

@@ -538,7 +538,12 @@ async fn runtime_requirement_in_tree(
         "css",
         "mini-css",
         SOURCE_TYPE[0],
-        "__webpack_require__.miniCssF".into(),
+        format!(
+          "{}.miniCssF",
+          compilation
+            .runtime_template
+            .render_runtime_globals(&RuntimeGlobals::REQUIRE)
+        ),
         move |runtime_requirements| {
           runtime_requirements.contains(RuntimeGlobals::HMR_DOWNLOAD_UPDATE_HANDLERS)
         },

crates/rspack_plugin_javascript/src/parser_plugin/define_plugin/utils.rs

@@ -1,4 +1,4 @@
-use std::{borrow::Cow, sync::LazyLock};
+use std::borrow::Cow;
 
 use itertools::Itertools as _;
 use regex::Regex;
@@ -7,11 +7,6 @@ use serde_json::{Value, json};
 
 use crate::visitors::{DestructuringAssignmentProperties, JavascriptParser};
 
-static REQUIRE_FUNCTION_REGEX: LazyLock<Regex> = LazyLock::new(|| {
-  Regex::new("__webpack_require__\\s*(!?\\.)").expect("should init `REQUIRE_FUNCTION_REGEX`")
-});
-static REQUIRE_IDENTIFIER: &str = "__webpack_require__";
-
 pub fn gen_const_dep(
   parser: &JavascriptParser,
   code: Cow<str>,
@@ -33,9 +28,14 @@ pub fn gen_const_dep(
     )
   };
 
-  if REQUIRE_FUNCTION_REGEX.is_match(&code) {
+  let require_name = parser
+    .runtime_template
+    .render_runtime_globals(&RuntimeGlobals::REQUIRE);
+  let require_function_regex = Regex::new(&format!("{}\\s*(!?\\.)", &require_name))
+    .expect("should init `REQUIRE_FUNCTION_REGEX`");
+  if require_function_regex.is_match(&code) {
     to_const_dep(Some(RuntimeGlobals::REQUIRE))
-  } else if code.contains(REQUIRE_IDENTIFIER) {
+  } else if code.contains(&require_name) {
     to_const_dep(Some(RuntimeGlobals::REQUIRE_SCOPE))
   } else {
     to_const_dep(None)

crates/rspack_plugin_javascript/src/plugin/mod.rs

@@ -183,20 +183,35 @@ impl JsPlugin {
     let module_execution = if runtime_requirements
       .contains(RuntimeGlobals::INTERCEPT_MODULE_EXECUTION)
     {
-      indoc!{r#"
-        var execOptions = { id: moduleId, module: module, factory: __webpack_modules__[moduleId], require: __webpack_require__ };
-        __webpack_require__.i.forEach(function(handler) { handler(execOptions); });
+      format!(r#"
+        var execOptions = {{ id: moduleId, module: module, factory: __webpack_modules__[moduleId], require: {} }};
+        {}.forEach(function(handler) {{ handler(execOptions); }});
         module = execOptions.module;
-        if (!execOptions.factory) {
+        if (!execOptions.factory) {{
           console.error("undefined factory", moduleId);
           throw Error("RuntimeError: factory is undefined (" + moduleId + ")");
-        }
+        }}
         execOptions.factory.call(module.exports, module, module.exports, execOptions.require);
-      "#}.into()
+      "#,
+        compilation.runtime_template.render_runtime_globals(&RuntimeGlobals::REQUIRE),
+        compilation.runtime_template.render_runtime_globals(&RuntimeGlobals::INTERCEPT_MODULE_EXECUTION)
+      ).into()
     } else if runtime_requirements.contains(RuntimeGlobals::THIS_AS_EXPORTS) {
-      "__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n".into()
+      format!(
+        "__webpack_modules__[moduleId].call(module.exports, module, module.exports, {});\n",
+        compilation
+          .runtime_template
+          .render_runtime_globals(&RuntimeGlobals::REQUIRE)
+      )
+      .into()
     } else {
-      "__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n".into()
+      format!(
+        "__webpack_modules__[moduleId](module, module.exports, {});\n",
+        compilation
+          .runtime_template
+          .render_runtime_globals(&RuntimeGlobals::REQUIRE)
+      )
+      .into()
     };
 
     if strict_module_error_handling {

crates/rspack_plugin_javascript/src/visitors/dependency/parser/mod.rs

@@ -325,7 +325,7 @@ pub struct JavascriptParser<'parser> {
   pub resource_data: &'parser ResourceData,
   pub(crate) compiler_options: &'parser CompilerOptions,
   pub(crate) javascript_options: &'parser JavascriptParserOptions,
-  pub(crate) runtime_template: &'parser RuntimeTemplate,
+  pub runtime_template: &'parser RuntimeTemplate,
   pub module_type: &'parser ModuleType,
   pub(crate) module_layer: Option<&'parser ModuleLayer>,
   pub module_identifier: &'parser ModuleIdentifier,

crates/rspack_plugin_lazy_compilation/src/module.rs

@@ -221,7 +221,10 @@ impl Module for LazyCompilationProxyModule {
     let block = self.blocks.first();
 
     let client = format!(
-      "var client = __webpack_require__(\"{}\");\nvar data = {};",
+      "var client = {}(\"{}\");\nvar data = {};",
+      compilation
+        .runtime_template
+        .render_runtime_globals(&RuntimeGlobals::REQUIRE),
       ChunkGraph::get_module_id(&compilation.module_ids_artifact, *client_module)
         .expect("should have module id"),
       serde_json::to_string(&self.identifier).expect("should serialize identifier")

crates/rspack_plugin_mf/src/container/container_entry_module.rs

@@ -211,12 +211,24 @@ impl Module for ContainerEntryModule {
         compilation
           .runtime_template
           .render_runtime_globals(&RuntimeGlobals::DEFINE_PROPERTY_GETTERS),
-        compilation
-          .runtime_template
-          .returning_function("__webpack_require__.getContainer", ""),
-        compilation
-          .runtime_template
-          .returning_function("__webpack_require__.initContainer", ""),
+        compilation.runtime_template.returning_function(
+          &format!(
+            "{}.getContainer",
+            compilation
+              .runtime_template
+              .render_runtime_globals(&RuntimeGlobals::REQUIRE)
+          ),
+          ""
+        ),
+        compilation.runtime_template.returning_function(
+          &format!(
+            "{}.initContainer",
+            compilation
+              .runtime_template
+              .render_runtime_globals(&RuntimeGlobals::REQUIRE)
+          ),
+          ""
+        ),
       )
     } else {
       format!(

crates/rspack_plugin_mf/src/container/expose_runtime_module.rs

@@ -1,6 +1,7 @@
 use rspack_collections::Identifier;
 use rspack_core::{
-  ChunkUkey, Compilation, RuntimeModule, RuntimeModuleStage, SourceType, impl_runtime_module,
+  ChunkUkey, Compilation, RuntimeGlobals, RuntimeModule, RuntimeModuleStage, SourceType,
+  impl_runtime_module,
 };
 
 use super::container_entry_module::CodeGenerationDataExpose;
@@ -64,18 +65,27 @@ impl RuntimeModule for ExposeRuntimeModule {
       return Ok("".to_string());
     };
     let module_map = data.module_map.render(compilation);
+    let require_name = compilation
+      .runtime_template
+      .render_runtime_globals(&RuntimeGlobals::REQUIRE);
     let mut source = format!(
       r#"
-__webpack_require__.initializeExposesData = {{
+    {require_name}.initializeExposesData = {{
   moduleMap: {},
   shareScope: {},
 }};
 "#,
       module_map,
       json_stringify(&data.share_scope)
     );
-    source += "__webpack_require__.getContainer = __webpack_require__.getContainer || function() { throw new Error(\"should have __webpack_require__.getContainer\") };";
-    source += "__webpack_require__.initContainer = __webpack_require__.initContainer || function() { throw new Error(\"should have __webpack_require__.initContainer\") };";
+    source += &format!(
+      "{require_name}.getContainer = {require_name}.getContainer || function() {{ throw new Error(\"should have {require_name}.getContainer\") }};",
+      require_name = require_name,
+    );
+    source += &format!(
+      "{require_name}.initContainer = {require_name}.initContainer || function() {{ throw new Error(\"should have {require_name}.initContainer\") }};",
+      require_name = require_name,
+    );
     Ok(source)
   }
 

crates/rspack_plugin_mf/src/container/remote_runtime_module.rs

@@ -1,6 +1,6 @@
 use rspack_collections::{Identifiable, Identifier};
 use rspack_core::{
-  ChunkGraph, ChunkUkey, Compilation, DependenciesBlock, ModuleId, RuntimeModule,
+  ChunkGraph, ChunkUkey, Compilation, DependenciesBlock, ModuleId, RuntimeGlobals, RuntimeModule,
   RuntimeModuleStage, SourceType, impl_runtime_module,
 };
 use rustc_hash::FxHashMap;
@@ -91,16 +91,25 @@ impl RuntimeModule for RemoteRuntimeModule {
         remotes,
       );
     }
+
     let remotes_loading_impl = if self.enhanced {
-      "__webpack_require__.f.remotes = __webpack_require__.f.remotes || function() { throw new Error(\"should have __webpack_require__.f.remotes\"); }"
+      format!(
+        "{ensure_chunk_handlers}.remotes = {ensure_chunk_handlers}.remotes || function() {{ throw new Error(\"should have {ensure_chunk_handlers}.remotes\"); }}",
+        ensure_chunk_handlers = compilation
+          .runtime_template
+          .render_runtime_globals(&RuntimeGlobals::ENSURE_CHUNK_HANDLERS),
+      )
     } else {
-      include_str!("./remotesLoading.js")
+      include_str!("./remotesLoading.js").to_string()
     };
     Ok(format!(
       r#"
-__webpack_require__.remotesLoadingData = {{ chunkMapping: {chunk_mapping}, moduleIdToRemoteDataMapping: {id_to_remote_data_mapping} }};
+{require_name}.remotesLoadingData = {{ chunkMapping: {chunk_mapping}, moduleIdToRemoteDataMapping: {id_to_remote_data_mapping} }};
 {remotes_loading_impl}
 "#,
+      require_name = compilation
+        .runtime_template
+        .render_runtime_globals(&RuntimeGlobals::REQUIRE),
       chunk_mapping = json_stringify(&chunk_to_remotes_mapping),
       id_to_remote_data_mapping = json_stringify(&id_to_remote_data_mapping),
       remotes_loading_impl = remotes_loading_impl,