feat: add EnableChunkLoadingPlugin.{setEnabled,checkEnabled} (#9092)

Author: colinaaa

crates/rspack/src/builder/mod.rs

@@ -2730,23 +2730,23 @@ impl OutputOptionsBuilder {
 
     let enabled_chunk_loading_types = f!(self.enabled_chunk_loading_types.take(), || {
       let mut enabled_chunk_loading_types = vec![];
-      if let ChunkLoading::Enable(ty) = chunk_loading {
-        enabled_chunk_loading_types.push(ty);
+      if let ChunkLoading::Enable(ty) = &chunk_loading {
+        enabled_chunk_loading_types.push(ty.clone());
       }
-      if let ChunkLoading::Enable(ty) = worker_chunk_loading {
-        enabled_chunk_loading_types.push(ty);
+      if let ChunkLoading::Enable(ty) = &worker_chunk_loading {
+        enabled_chunk_loading_types.push(ty.clone());
       }
       for (_, desc) in entry.iter() {
         if let Some(ChunkLoading::Enable(ty)) = &desc.chunk_loading {
-          enabled_chunk_loading_types.push(*ty);
+          enabled_chunk_loading_types.push(ty.clone());
         }
       }
       enabled_chunk_loading_types
     });
     for ty in enabled_chunk_loading_types.iter() {
       builder_context
         .plugins
-        .push(BuiltinPluginOptions::EnableChunkLoadingPlugin(*ty));
+        .push(BuiltinPluginOptions::EnableChunkLoadingPlugin(ty.clone()));
     }
 
     let enabled_wasm_loading_types = f!(self.enabled_wasm_loading_types.take(), || {

crates/rspack_binding_values/src/compilation/entries.rs

@@ -54,7 +54,7 @@ impl EntryOptionsDTO {
   #[napi(getter)]
   pub fn chunk_loading(&self) -> Either<&str, ()> {
     match &self.0.chunk_loading {
-      Some(c) => Either::A(c.into()),
+      Some(c) => Either::A(c.as_str()),
       None => Either::B(()),
     }
   }

crates/rspack_core/src/options/output.rs

@@ -110,24 +110,24 @@ impl From<ChunkLoading> for String {
   }
 }
 
-impl From<&ChunkLoading> for &str {
-  fn from(value: &ChunkLoading) -> Self {
-    match value {
-      ChunkLoading::Enable(ty) => ty.into(),
+impl ChunkLoading {
+  pub fn as_str(&self) -> &str {
+    match self {
+      ChunkLoading::Enable(ty) => ty.as_str(),
       ChunkLoading::Disable => "false",
     }
   }
 }
 
 #[cacheable]
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub enum ChunkLoadingType {
   Jsonp,
   ImportScripts,
   Require,
   AsyncNode,
   Import,
-  // TODO: Custom
+  Custom(String),
 }
 
 impl From<&str> for ChunkLoadingType {
@@ -138,25 +138,26 @@ impl From<&str> for ChunkLoadingType {
       "require" => Self::Require,
       "async-node" => Self::AsyncNode,
       "import" => Self::Import,
-      _ => unimplemented!("custom chunkLoading in not supported yet"),
+      _ => Self::Custom(value.to_string()),
     }
   }
 }
 
 impl From<ChunkLoadingType> for String {
   fn from(value: ChunkLoadingType) -> Self {
-    Into::<&str>::into(&value).to_string()
+    value.as_str().to_string()
   }
 }
 
-impl From<&ChunkLoadingType> for &str {
-  fn from(value: &ChunkLoadingType) -> Self {
-    match value {
+impl ChunkLoadingType {
+  pub fn as_str(&self) -> &str {
+    match self {
       ChunkLoadingType::Jsonp => "jsonp",
       ChunkLoadingType::ImportScripts => "import-scripts",
       ChunkLoadingType::Require => "require",
       ChunkLoadingType::AsyncNode => "async-node",
       ChunkLoadingType::Import => "import",
+      ChunkLoadingType::Custom(value) => value.as_str(),
     }
   }
 }

crates/rspack_plugin_runtime/src/lib.rs

@@ -67,5 +67,6 @@ pub fn enable_chunk_loading_plugin(loading_type: ChunkLoadingType, plugins: &mut
       plugins.push(ImportScriptsChunkLoadingPlugin::default().boxed());
     }
     ChunkLoadingType::Import => plugins.push(ModuleChunkLoadingPlugin::default().boxed()),
+    ChunkLoadingType::Custom(_) => (),
   }
 }

packages/rspack-test-tools/tests/__snapshots__/Config.test.js.snap

@@ -209,6 +209,8 @@ Object {
 }
 `;
 
+exports[`config config/builtins/enable-chunk-loading step  should pass 1`] = `Chunk loading type "non-existing" is not enabled. EnableChunkLoadingPlugin need to be used to enable this type of chunk loading. This usually happens through the "output.enabledChunkLoadingTypes" option. If you are using a function as entry which sets "chunkLoading", you need to add all potential chunk loading types to "output.enabledChunkLoadingTypes". These types are enabled: custom, import, async-node`;
+
 exports[`config config/chunk-index/available-modules-order-index exported tests should compile 1`] = `
 .m {
   color: red;

packages/rspack-test-tools/tests/__snapshots__/NewCodeSplitting-config.test.js.snap

@@ -209,6 +209,8 @@ Object {
 }
 `;
 
+exports[`new-code-splitting config cases new-code-splitting config cases/builtins/enable-chunk-loading step  should pass 1`] = `Chunk loading type "non-existing" is not enabled. EnableChunkLoadingPlugin need to be used to enable this type of chunk loading. This usually happens through the "output.enabledChunkLoadingTypes" option. If you are using a function as entry which sets "chunkLoading", you need to add all potential chunk loading types to "output.enabledChunkLoadingTypes". These types are enabled: custom, import, async-node`;
+
 exports[`new-code-splitting config cases new-code-splitting config cases/chunk-index/available-modules-order-index exported tests should compile 1`] = `
 .m {
   color: red;

packages/rspack-test-tools/tests/configCases/builtins/enable-chunk-loading/index.js

@@ -0,0 +1 @@
+const foo = 42;

packages/rspack-test-tools/tests/configCases/builtins/enable-chunk-loading/rspack.config.js

@@ -0,0 +1,38 @@
+const { rspack } = require("@rspack/core");
+
+/** @type {import("@rspack/core").Configuration} */
+module.exports = {
+	entry: {
+		main: ["./index.js"]
+	},
+	output: {
+		enabledChunkLoadingTypes: ["import", "async-node"]
+	},
+	plugins: [
+		/** @param {import('@rspack/core').Compiler} compiler  */
+		compiler => {
+			rspack.javascript.EnableChunkLoadingPlugin.setEnabled(compiler, "custom");
+
+			compiler.hooks.initialize.tap("test", () => {
+				rspack.javascript.EnableChunkLoadingPlugin.checkEnabled(
+					compiler,
+					"custom"
+				);
+				rspack.javascript.EnableChunkLoadingPlugin.checkEnabled(
+					compiler,
+					"import"
+				);
+				rspack.javascript.EnableChunkLoadingPlugin.checkEnabled(
+					compiler,
+					"async-node"
+				);
+				expect(() =>
+					rspack.javascript.EnableChunkLoadingPlugin.checkEnabled(
+						compiler,
+						"non-existing"
+					)
+				).toThrowErrorMatchingSnapshot();
+			});
+		}
+	]
+};

packages/rspack/etc/core.api.md

@@ -1594,13 +1594,23 @@ const ElectronTargetPlugin: {
 };
 
 // @public (undocumented)
-const EnableChunkLoadingPlugin: {
+class EnableChunkLoadingPlugin extends EnableChunkLoadingPluginInner {
+    // (undocumented)
+    apply(compiler: Compiler): void;
+    // (undocumented)
+    static checkEnabled(compiler: Compiler, type: ChunkLoadingType): void;
+    // (undocumented)
+    static setEnabled(compiler: Compiler, type: ChunkLoadingType): void;
+}
+
+// @public (undocumented)
+const EnableChunkLoadingPluginInner: {
     new (type: string): {
         name: BuiltinPluginName;
         _args: [type: string];
         affectedHooks: "done" | "environment" | "make" | "compile" | "emit" | "afterEmit" | "invalid" | "thisCompilation" | "afterDone" | "compilation" | "normalModuleFactory" | "contextModuleFactory" | "initialize" | "shouldEmit" | "infrastructureLog" | "beforeRun" | "run" | "assetEmitted" | "failed" | "shutdown" | "watchRun" | "watchClose" | "afterEnvironment" | "afterPlugins" | "afterResolvers" | "beforeCompile" | "afterCompile" | "finishMake" | "entryOption" | "additionalPass" | undefined;
-        raw(compiler: Compiler_2): BuiltinPlugin;
-        apply(compiler: Compiler_2): void;
+        raw(compiler: Compiler): BuiltinPlugin;
+        apply(compiler: Compiler): void;
     };
 };
 

packages/rspack/src/builtin-plugin/EnableChunkLoadingPlugin.ts

@@ -1,8 +1,75 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/3919c84/lib/javascript/EnableChunkLoadingPlugin.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+
 import { BuiltinPluginName } from "@rspack/binding";
 
+import type { ChunkLoadingType, Compiler } from "../exports";
 import { create } from "./base";
 
-export const EnableChunkLoadingPlugin = create(
+const EnableChunkLoadingPluginInner = create(
 	BuiltinPluginName.EnableChunkLoadingPlugin,
 	(type: string): string => type
 );
+
+const enabledTypes: WeakMap<Compiler, Set<ChunkLoadingType>> = new WeakMap();
+
+const getEnabledTypes = (compiler: Compiler): Set<ChunkLoadingType> => {
+	let set = enabledTypes.get(compiler);
+	if (set === undefined) {
+		set = new Set();
+		enabledTypes.set(compiler, set);
+	}
+	return set;
+};
+
+export class EnableChunkLoadingPlugin extends EnableChunkLoadingPluginInner {
+	static setEnabled(compiler: Compiler, type: ChunkLoadingType) {
+		getEnabledTypes(compiler).add(type);
+	}
+
+	static checkEnabled(compiler: Compiler, type: ChunkLoadingType) {
+		if (!getEnabledTypes(compiler).has(type)) {
+			throw new Error(
+				[
+					`Chunk loading type "${type}" is not enabled.`,
+					"EnableChunkLoadingPlugin need to be used to enable this type of chunk loading.",
+					'This usually happens through the "output.enabledChunkLoadingTypes" option.',
+					'If you are using a function as entry which sets "chunkLoading", you need to add all potential chunk loading types to "output.enabledChunkLoadingTypes".',
+					`These types are enabled: ${Array.from(
+						getEnabledTypes(compiler)
+					).join(", ")}`
+				].join(" ")
+			);
+		}
+	}
+
+	override apply(compiler: Compiler): void {
+		const [type] = this._args;
+		// Only enable once
+		const enabled = getEnabledTypes(compiler);
+		if (enabled.has(type)) return;
+		enabled.add(type);
+
+		switch (type) {
+			// builtin chunk loading types
+			case "jsonp":
+			case "import-scripts":
+			case "require":
+			case "async-node":
+			case "import": {
+				super.apply(compiler);
+				return;
+			}
+			default:
+				throw new Error(`Unsupported chunk loading type ${type}.
+Plugins which provide custom chunk loading types must call EnableChunkLoadingPlugin.setEnabled(compiler, type) to disable this error.`);
+		}
+	}
+}