feat: lazy compilation middleware supports multiCompiler

Author: JSerFeng

packages/rspack-cli/src/commands/serve.ts

@@ -105,16 +105,15 @@ export class ServeCommand implements RspackCommand {
 
 				const result = (compilerForDevServer.options.devServer ??= {});
 
-				if (compilerForDevServer.options.experiments.lazyCompilation) {
-					const options =
-						compilerForDevServer.options.experiments.lazyCompilation;
-
+				// if one of compilers enable lazy compilation
+				if (
+					compilers.some(
+						compiler => compiler.options.experiments.lazyCompilation
+					)
+				) {
 					const setupMiddlewares = result.setupMiddlewares;
 					const lazyCompileMiddleware =
-						rspack.experiments.lazyCompilationMiddleware(
-							compilerForDevServer,
-							options
-						);
+						rspack.experiments.lazyCompilationMiddleware(compiler);
 					result.setupMiddlewares = (middlewares, server) => {
 						let finalMiddlewares = middlewares;
 						if (setupMiddlewares) {

packages/rspack-test-tools/etc/test-tools.api.md

@@ -11,6 +11,7 @@ import type EventEmitter from 'node:events';
 import { IBasicGlobalContext as IBasicGlobalContext_2 } from '../../type';
 import { IBasicModuleScope as IBasicModuleScope_2 } from '../../type';
 import { ITestCompilerManager as ITestCompilerManager_2 } from '../type';
+import type { MultiCompiler } from '@rspack/core';
 import type { MultiStats } from '@rspack/core';
 import type { MultiStats as MultiStats_2 } from 'webpack';
 import type { RspackOptions } from '@rspack/core';
@@ -1212,7 +1213,7 @@ export class JSDOMWebRunner<T extends ECompilerType = ECompilerType.Rspack> exte
 // @public (undocumented)
 export class LazyCompilationTestPlugin {
     // (undocumented)
-    apply(compiler: Compiler): void;
+    apply(compiler: Compiler | MultiCompiler): void;
 }
 
 // @public (undocumented)

packages/rspack-test-tools/src/plugin/lazy-compilation-test-plugin.ts

@@ -1,16 +1,11 @@
 import { createServer } from "node:http";
 import type { Socket } from "node:net";
 import type { AddressInfo } from "node:net";
-import type { Compiler } from "@rspack/core";
+import type { Compiler, MultiCompiler } from "@rspack/core";
 import { experiments } from "@rspack/core";
 
 export class LazyCompilationTestPlugin {
-	apply(compiler: Compiler) {
-		const options = compiler.options.experiments.lazyCompilation!;
-		if (!options) {
-			return;
-		}
-
+	apply(compiler: Compiler | MultiCompiler) {
 		let middleware: any;
 		const server = createServer();
 		const sockets = new Set<Socket>();
@@ -31,8 +26,7 @@ export class LazyCompilationTestPlugin {
 				middleware = experiments.lazyCompilationMiddleware(compiler, {
 					// @ts-expect-error cacheable is hidden config only for tests
 					cacheable: false,
-					serverUrl: urlBase,
-					...options
+					serverUrl: urlBase
 				});
 
 				resolve(null);

packages/rspack-test-tools/tests/fixtures/esm/d-dynamic.js

@@ -0,0 +1 @@
+export default 4;

packages/rspack-test-tools/tests/fixtures/esm/d.js

@@ -0,0 +1 @@
+export default import('./d-dynamic');

packages/rspack-test-tools/tests/legacy-test/MultiCompiler.test.js

@@ -3,6 +3,7 @@
 require("../../dist/helper/legacy/warmup-webpack");
 const path = require("path");
 const webpack = require("@rspack/core");
+const { LazyCompilationTestPlugin } = require("@rspack/test-tools");
 
 describe("MultiCompiler", function () {
 	jest.setTimeout(20000);
@@ -39,6 +40,82 @@ describe("MultiCompiler", function () {
 	}, 20000);
 });
 
+describe("with lazy compilation", function () {
+	it("compiler has unique lazy compilation config", done => {
+		const context = path.join(__dirname, "../fixtures");
+		const configs = [
+			{
+				entry: "./esm/a.js",
+				context
+			},
+			{
+				entry: "./esm/b.js",
+				experiments: {
+					lazyCompilation: {
+						entries: true
+					}
+				},
+				context
+			},
+			{
+				entry: "./esm/d.js",
+				experiments: {
+					lazyCompilation: {
+						entries: false,
+						imports: true
+					}
+				},
+				context
+			}
+		];
+		const compiler = webpack(configs);
+
+		new LazyCompilationTestPlugin().apply(compiler);
+
+		compiler.watch({}, (err, multiStats) => {
+			if (err) {
+				compiler.close(() => {
+					done(err);
+				});
+				return;
+			}
+
+			const [statsA, statsB, statsC] = multiStats.stats;
+
+			expect(
+				statsA.toJson().modules.every(module => {
+					return !module.identifier.includes("lazy-compilation-proxy");
+				})
+			).toBeTruthy();
+
+			// second compiler lazy compile entry
+			expect(
+				statsB.toJson().modules.find(module => {
+					return (
+						module.identifier.includes("lazy-compilation-proxy") &&
+						module.identifier.includes("/esm/b.js")
+					);
+				})
+			).toBeDefined();
+
+			// third compiler lazy compile dyn imports
+			expect(
+				statsC.toJson().modules.find(module => {
+					return (
+						module.identifier.includes("lazy-compilation-proxy") &&
+						module.identifier.includes("/esm/d-dynamic.js")
+					);
+				})
+			).toBeDefined();
+
+			compiler.close(err => {
+				if (err) return done(err);
+				done();
+			});
+		});
+	});
+});
+
 describe.skip("Pressure test", function () {
 	it("should work well in multiCompilers", done => {
 		const configs = Array(100).fill({

packages/rspack/etc/core.api.md

@@ -3141,7 +3141,7 @@ type KnownStatsProfile = {
 export type Layer = string | null;
 
 // @public (undocumented)
-const lazyCompilationMiddleware: (compiler: Compiler, userOptions?: LazyCompilationOptions | boolean) => Middleware;
+const lazyCompilationMiddleware: (compiler: Compiler | MultiCompiler, userOptions?: LazyCompilationOptions | boolean) => Middleware;
 
 // @public
 export type LazyCompilationOptions = {
@@ -3750,6 +3750,8 @@ export class MultiCompiler {
     hooks: {
         done: liteTapable.SyncHook<MultiStats>;
         invalid: liteTapable.MultiHook<liteTapable.SyncHook<[string | null, number]>>;
+        beforeCompile: liteTapable.MultiHook<liteTapable.AsyncSeriesHook<[CompilationParams]>>;
+        shutdown: liteTapable.MultiHook<liteTapable.AsyncSeriesHook<[]>>;
         run: liteTapable.MultiHook<liteTapable.AsyncSeriesHook<[Compiler]>>;
         watchClose: liteTapable.SyncHook<[]>;
         watchRun: liteTapable.MultiHook<liteTapable.AsyncSeriesHook<[Compiler]>>;
@@ -3788,6 +3790,8 @@ export class MultiCompiler {
     // (undocumented)
     get watchFileSystem(): WatchFileSystem;
     set watchFileSystem(value: WatchFileSystem);
+    // (undocumented)
+    watching?: MultiWatching;
 }
 
 // @public (undocumented)
@@ -3825,6 +3829,8 @@ class MultiWatching {
     // (undocumented)
     invalidate(callback: Callback<Error, void>): void;
     // (undocumented)
+    invalidateWithChangesAndRemovals(changedFiles?: Set<string>, removedFiles?: Set<string>, callback?: Callback<Error, void>): void;
+    // (undocumented)
     resume(): void;
     // (undocumented)
     suspend(): void;

packages/rspack/src/MultiCompiler.ts

@@ -9,7 +9,7 @@
  */
 
 import * as liteTapable from "@rspack/lite-tapable";
-import type { Compiler, RspackOptions, Stats } from ".";
+import type { CompilationParams, Compiler, RspackOptions, Stats } from ".";
 import MultiStats from "./MultiStats";
 import MultiWatching from "./MultiWatching";
 import type { WatchOptions } from "./config";
@@ -56,6 +56,10 @@ export class MultiCompiler {
 		invalid: liteTapable.MultiHook<
 			liteTapable.SyncHook<[string | null, number]>
 		>;
+		beforeCompile: liteTapable.MultiHook<
+			liteTapable.AsyncSeriesHook<[CompilationParams]>
+		>;
+		shutdown: liteTapable.MultiHook<liteTapable.AsyncSeriesHook<[]>>;
 		run: liteTapable.MultiHook<liteTapable.AsyncSeriesHook<[Compiler]>>;
 		watchClose: liteTapable.SyncHook<[]>;
 		watchRun: liteTapable.MultiHook<liteTapable.AsyncSeriesHook<[Compiler]>>;
@@ -65,6 +69,7 @@ export class MultiCompiler {
 	};
 	_options: MultiCompilerOptions;
 	running: boolean;
+	watching?: MultiWatching;
 
 	constructor(
 		compilers: Compiler[] | Record<string, Compiler>,
@@ -92,6 +97,12 @@ export class MultiCompiler {
 			watchRun: new liteTapable.MultiHook(
 				normalizedCompilers.map(c => c.hooks.watchRun)
 			),
+			beforeCompile: new liteTapable.MultiHook(
+				normalizedCompilers.map(c => c.hooks.beforeCompile)
+			),
+			shutdown: new liteTapable.MultiHook(
+				normalizedCompilers.map(c => c.hooks.shutdown)
+			),
 			infrastructureLog: new liteTapable.MultiHook(
 				normalizedCompilers.map(c => c.hooks.infrastructureLog)
 			)
@@ -509,10 +520,14 @@ export class MultiCompiler {
 				},
 				handler
 			);
-			return new MultiWatching(watchings, this);
+			const watching = new MultiWatching(watchings, this);
+			this.watching = watching;
+			return watching;
 		}
 
-		return new MultiWatching([], this);
+		const watching = new MultiWatching([], this);
+		this.watching = watching;
+		return watching;
 	}
 
 	/**

packages/rspack/src/MultiWatching.ts

@@ -42,6 +42,31 @@ class MultiWatching {
 		}
 	}
 
+	invalidateWithChangesAndRemovals(
+		changedFiles?: Set<string>,
+		removedFiles?: Set<string>,
+		callback?: Callback<Error, void>
+	) {
+		if (callback) {
+			asyncLib.each(
+				this.watchings,
+				(watching, callback) =>
+					watching.invalidateWithChangesAndRemovals(
+						changedFiles,
+						removedFiles,
+						callback
+					),
+				// cannot be resolved without assertion
+				// Type 'Error | null | undefined' is not assignable to type 'Error | null'
+				callback as (err: Error | null | undefined) => void
+			);
+		} else {
+			for (const watching of this.watchings) {
+				watching.invalidateWithChangesAndRemovals(changedFiles, removedFiles);
+			}
+		}
+	}
+
 	close(callback: Callback<Error, void>) {
 		asyncLib.each(
 			this.watchings,