chore: update webpack 5.97.1 (#9340)

* chore: bump webpack 5.97.1

* fix: use rspack ignore plugin

* chore: ⬆️ update pnpm-lock

* feat: align async node with webpack

* fix: walkaround tsc error

* fix: option builder error

* feat:  align webpack module chunk loader

* chore: ⬆️ update pnpm-lock

* feat: add wrong wasm loading type error message

* test: update plugin-test snapshot

* fix: style unstable

* refactor: remove dead code

* refactor: todo -> unreachable

Co-authored-by: JSerFeng

crates/rspack/src/builder/mod.rs

@@ -2926,11 +2926,7 @@ impl OutputOptionsBuilder {
         if tp.fetch_wasm() {
           WasmLoading::Enable(WasmLoadingType::Fetch)
         } else if tp.node_builtins() {
-          if output_module {
-            WasmLoading::Enable(WasmLoadingType::AsyncNodeModule)
-          } else {
-            WasmLoading::Enable(WasmLoadingType::AsyncNode)
-          }
+          WasmLoading::Enable(WasmLoadingType::AsyncNode)
         } else {
           WasmLoading::Disable
         }

crates/rspack_core/src/build_chunk_graph/code_splitter.rs

@@ -869,16 +869,16 @@ Or do you want to use the entrypoints '{name}' and '{runtime}' independently on
 
       let mut visited = IdentifierIndexSet::default();
 
+      let mut ctx = (0, 0, Default::default());
       for root in roots {
-        let mut ctx = (0, 0, Default::default());
         self.calculate_order_index(root, &runtime, &mut visited, &mut ctx, compilation);
 
         let chunk_group = compilation
           .chunk_group_by_ukey
           .expect_get_mut(&chunk_group_ukey);
-        for (id, (pre, post)) in ctx.2 {
-          chunk_group.module_pre_order_indices.insert(id, pre);
-          chunk_group.module_post_order_indices.insert(id, post);
+        for (id, (pre, post)) in &ctx.2 {
+          chunk_group.module_pre_order_indices.insert(*id, *pre);
+          chunk_group.module_post_order_indices.insert(*id, *post);
         }
       }
     }

crates/rspack_core/src/options/output.rs

@@ -180,16 +180,14 @@ impl From<&str> for WasmLoading {
 pub enum WasmLoadingType {
   Fetch,
   AsyncNode,
-  AsyncNodeModule,
 }
 
 impl From<&str> for WasmLoadingType {
   fn from(value: &str) -> Self {
     match value {
       "fetch" => Self::Fetch,
       "async-node" => Self::AsyncNode,
-      "async-node-module" => Self::AsyncNodeModule,
-      _ => todo!(),
+      _ => unreachable!("invalid wasm loading type: {value}, expect one of [fetch, async-node]",),
     }
   }
 }

crates/rspack_plugin_runtime/src/module_chunk_format.rs

@@ -108,18 +108,22 @@ fn render_chunk(
 
   let mut sources = ConcatSource::default();
   sources.add(RawStringSource::from(format!(
-    "export const ids = ['{}'];\n",
+    "export const __webpack_ids__ = ['{}'];\n",
     &chunk.expect_id(&compilation.chunk_ids_artifact)
   )));
-  sources.add(RawStringSource::from_static("export const modules = "));
+  sources.add(RawStringSource::from_static(
+    "export const __webpack_modules__ = ",
+  ));
   sources.add(render_source.source.clone());
   sources.add(RawStringSource::from_static(";\n"));
 
   if compilation
     .chunk_graph
     .has_chunk_runtime_modules(chunk_ukey)
   {
-    sources.add(RawStringSource::from_static("export const runtime = "));
+    sources.add(RawStringSource::from_static(
+      "export const __webpack_runtime__ = ",
+    ));
     sources.add(render_chunk_runtime_modules(compilation, chunk_ukey)?);
     sources.add(RawStringSource::from_static(";\n"));
   }

crates/rspack_plugin_runtime/src/runtime_module/runtime/module_chunk_loading.js

@@ -1,22 +1,22 @@
 var installChunk = function (data) {
-    var ids = data.ids;
-    var modules = data.modules;
-    var runtime = data.runtime;
+    var __webpack_ids__ = data.__webpack_ids__;
+    var __webpack_modules__ = data.__webpack_modules__;
+    var __webpack_runtime__ = data.__webpack_runtime__;
     // add "modules" to the modules object,
     // then flag all "ids" as loaded and fire callback
     var moduleId, chunkId, i = 0;
-    for (moduleId in modules) {
-        if (__webpack_require__.o(modules, moduleId)) {
-            __webpack_require__.m[moduleId] = modules[moduleId];
+    for (moduleId in __webpack_modules__) {
+        if (__webpack_require__.o(__webpack_modules__, moduleId)) {
+            __webpack_require__.m[moduleId] = __webpack_modules__[moduleId];
         }
     }
-    if (runtime) runtime(__webpack_require__);
-    for (; i < ids.length; i++) {
-        chunkId = ids[i];
+    if (__webpack_runtime__) __webpack_runtime__(__webpack_require__);
+    for (; i < __webpack_ids__.length; i++) {
+        chunkId = __webpack_ids__[i];
         if (__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {
             installedChunks[chunkId][0]();
         }
-        installedChunks[ids[i]] = 0;
+        installedChunks[__webpack_ids__[i]] = 0;
     }
     $WITH_ON_CHUNK_LOAD$
 };

crates/rspack_plugin_wasm/src/loading_plugin.rs

@@ -10,8 +10,7 @@ use crate::AsyncWasmLoadingRuntimeModule;
 pub fn enable_wasm_loading_plugin(wasm_loading_type: WasmLoadingType) -> BoxPlugin {
   match wasm_loading_type {
     WasmLoadingType::Fetch => FetchCompileAsyncWasmPlugin::default().boxed(),
-    WasmLoadingType::AsyncNode => ReadFileCompileAsyncWasmPlugin::new(false).boxed(),
-    WasmLoadingType::AsyncNodeModule => ReadFileCompileAsyncWasmPlugin::new(true).boxed(),
+    WasmLoadingType::AsyncNode => ReadFileCompileAsyncWasmPlugin::new().boxed(),
   }
 }
 
@@ -65,13 +64,11 @@ impl Plugin for FetchCompileAsyncWasmPlugin {
 
 #[plugin]
 #[derive(Debug)]
-pub struct ReadFileCompileAsyncWasmPlugin {
-  import: bool,
-}
+pub struct ReadFileCompileAsyncWasmPlugin {}
 
 impl ReadFileCompileAsyncWasmPlugin {
-  fn new(import: bool) -> Self {
-    Self::new_inner(import)
+  fn new() -> Self {
+    Self::new_inner()
   }
 }
 
@@ -86,10 +83,19 @@ fn read_file_compile_async_wasm_plugin_runtime_requirements_in_tree(
 ) -> Result<Option<()>> {
   if runtime_requirements.contains(RuntimeGlobals::INSTANTIATE_WASM) {
     runtime_requirements_mut.insert(RuntimeGlobals::PUBLIC_PATH);
+
+    let import_enabled = compilation.options.output.module
+      && compilation
+        .options
+        .output
+        .environment
+        .dynamic_import
+        .unwrap_or_default();
+
     compilation.add_runtime_module(
       chunk_ukey,
       AsyncWasmLoadingRuntimeModule::new(
-        if self.import {
+        if import_enabled {
           include_str!("runtime/read_file_compile_async_wasm_with_import.js").to_string()
         } else {
           include_str!("runtime/read_file_compile_async_wasm.js").to_string()

package.json

@@ -77,7 +77,7 @@
     "rimraf": "^5.0.10",
     "ts-jest": "29.2.5",
     "typescript": "^5.7.3",
-    "webpack": "^5.95.0",
+    "webpack": "5.97.1",
     "webpack-cli": "5.1.4",
     "zx": "8.3.0"
   },
@@ -88,4 +88,4 @@
       "rollup-plugin-dts": "patches/rollup-plugin-dts.patch"
     }
   }
-}
+}

packages/rspack-test-tools/package.json

@@ -67,7 +67,7 @@
     "rimraf": "^5.0.10",
     "source-map": "^0.7.4",
     "terser-webpack-plugin": "^5.3.10",
-    "webpack": "^5.95.0",
+    "webpack": "5.97.1",
     "webpack-merge": "5.9.0",
     "webpack-sources": "3.2.3"
   },
@@ -126,4 +126,4 @@
   "peerDependencies": {
     "@rspack/core": ">=1.0.0"
   }
-}
+}

packages/rspack-test-tools/src/plugin/webpack-diff-config-plugin.ts

@@ -24,7 +24,7 @@ export class WebpackDiffConfigPlugin {
 		options.optimization.mangleExports ??= false;
 		options.optimization.concatenateModules ??= false;
 
-		options.output ??= {};
+		options.output ??= {} as any;
 		options.output.pathinfo ??= false;
 
 		options.output.environment ??= {};

packages/rspack-test-tools/tests/runtimeDiffCases/chunk-loading/async-wasm-loading#async-node-module/rspack.config.js

@@ -1,7 +1,12 @@
 /** @type {import("@rspack/core").Configuration} */
 module.exports = {
 	output: {
-		wasmLoading: "async-node-module"
+		wasmLoading: "async-node",
+		module: true,
+		environment: {
+			dynamicImport: true,
+			module: true
+		}
 	},
 	module: {
 		rules: [

packages/rspack-test-tools/tests/runtimeDiffCases/chunk-loading/async-wasm-loading#async-node-module/webpack.config.js

@@ -1,7 +1,12 @@
 /** @type {import("webpack").Configuration} */
 module.exports = {
 	output: {
-		wasmLoading: "async-node-module"
+		wasmLoading: "async-node",
+		module: true,
+		environment: {
+			dynamicImport: true,
+			module: true
+		}
 	},
 	module: {
 		rules: [
@@ -13,6 +18,7 @@ module.exports = {
 		]
 	},
 	experiments: {
-		asyncWebAssembly: true
+		asyncWebAssembly: true,
+		outputModule: true
 	}
 };

packages/rspack-test-tools/tests/statsOutputCases/ignore-plugin/rspack.config.js

@@ -1,4 +1,4 @@
-const webpack = require("webpack");
+const rspack = require("@rspack/core");
 
 /** @type {import('@rspack/core').Configuration} */
 module.exports = {
@@ -8,7 +8,7 @@ module.exports = {
 		modules: true
 	},
 	plugins: [
-		new webpack.IgnorePlugin({
+		new rspack.IgnorePlugin({
 			checkResource: (resource, request) => {
 				if (resource.includes("zh") || resource.includes("globalIndex")) {
 					return true;

packages/rspack/src/config/defaults.ts

@@ -708,8 +708,7 @@ const applyOutputDefaults = (
 	F(output, "wasmLoading", () => {
 		if (tp) {
 			if (tp.fetchWasm) return "fetch";
-			if (tp.nodeBuiltins)
-				return output.module ? "async-node-module" : "async-node";
+			if (tp.nodeBuiltins) return "async-node";
 			if (tp.nodeBuiltins === null || tp.fetchWasm === null) {
 				return "universal";
 			}