webpack 5.97.1 → 5.104.1

package/lib/MultiCompiler.js

@@ -6,7 +6,7 @@
 "use strict";
 
 const asyncLib = require("neo-async");
-const { SyncHook, MultiHook } = require("tapable");
+const { MultiHook, SyncHook } = require("tapable");
 
 const ConcurrentCompilationError = require("./ConcurrentCompilationError");
 const MultiStats = require("./MultiStats");
@@ -14,29 +14,36 @@ const MultiWatching = require("./MultiWatching");
 const WebpackError = require("./WebpackError");
 const ArrayQueue = require("./util/ArrayQueue");
 
-/** @template T @typedef {import("tapable").AsyncSeriesHook<T>} AsyncSeriesHook<T> */
-/** @template T @template R @typedef {import("tapable").SyncBailHook<T, R>} SyncBailHook<T, R> */
+/**
+ * @template T
+ * @typedef {import("tapable").AsyncSeriesHook<T>} AsyncSeriesHook<T>
+ */
+/**
+ * @template T
+ * @template R
+ * @typedef {import("tapable").SyncBailHook<T, R>} SyncBailHook<T, R>
+ */
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
 /** @typedef {import("../declarations/WebpackOptions").WatchOptions} WatchOptions */
 /** @typedef {import("./Compiler")} Compiler */
+/**
+ * @template T
+ * @template [R=void]
+ * @typedef {import("./webpack").Callback<T, R>} Callback
+ */
+/** @typedef {import("./webpack").ErrorCallback} ErrorCallback */
 /** @typedef {import("./Stats")} Stats */
-/** @typedef {import("./Watching")} Watching */
 /** @typedef {import("./logging/Logger").Logger} Logger */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./util/fs").IntermediateFileSystem} IntermediateFileSystem */
 /** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
 /** @typedef {import("./util/fs").WatchFileSystem} WatchFileSystem */
 
-/**
- * @template T
- * @callback Callback
- * @param {Error | null} err
- * @param {T=} result
- */
-
 /**
  * @callback RunWithDependenciesHandler
  * @param {Compiler} compiler
  * @param {Callback<MultiStats>} callback
+ * @returns {void}
  */
 
 /**
@@ -44,6 +51,10 @@ const ArrayQueue = require("./util/ArrayQueue");
  * @property {number=} parallelism how many Compilers are allows to run at the same time in parallel
  */
 
+/** @typedef {ReadonlyArray<WebpackOptions> & MultiCompilerOptions} MultiWebpackOptions */
+
+const CLASS_NAME = "MultiCompiler";
+
 module.exports = class MultiCompiler {
 	/**
 	 * @param {Compiler[] | Record<string, Compiler>} compilers child compilers
@@ -52,7 +63,7 @@ module.exports = class MultiCompiler {
 	constructor(compilers, options) {
 		if (!Array.isArray(compilers)) {
 			/** @type {Compiler[]} */
-			compilers = Object.keys(compilers).map(name => {
+			compilers = Object.keys(compilers).map((name) => {
 				/** @type {Record<string, Compiler>} */
 				(compilers)[name].name = name;
 				return /** @type {Record<string, Compiler>} */ (compilers)[name];
@@ -63,16 +74,16 @@ module.exports = class MultiCompiler {
 			/** @type {SyncHook<[MultiStats]>} */
 			done: new SyncHook(["stats"]),
 			/** @type {MultiHook<SyncHook<[string | null, number]>>} */
-			invalid: new MultiHook(compilers.map(c => c.hooks.invalid)),
+			invalid: new MultiHook(compilers.map((c) => c.hooks.invalid)),
 			/** @type {MultiHook<AsyncSeriesHook<[Compiler]>>} */
-			run: new MultiHook(compilers.map(c => c.hooks.run)),
+			run: new MultiHook(compilers.map((c) => c.hooks.run)),
 			/** @type {SyncHook<[]>} */
 			watchClose: new SyncHook([]),
 			/** @type {MultiHook<AsyncSeriesHook<[Compiler]>>} */
-			watchRun: new MultiHook(compilers.map(c => c.hooks.watchRun)),
-			/** @type {MultiHook<SyncBailHook<[string, string, any[]], true>>} */
+			watchRun: new MultiHook(compilers.map((c) => c.hooks.watchRun)),
+			/** @type {MultiHook<SyncBailHook<[string, string, EXPECTED_ANY[] | undefined], true | void>>} */
 			infrastructureLog: new MultiHook(
-				compilers.map(c => c.hooks.infrastructureLog)
+				compilers.map((c) => c.hooks.infrastructureLog)
 			)
 		});
 		this.compilers = compilers;
@@ -92,7 +103,7 @@ module.exports = class MultiCompiler {
 			const compilerIndex = index;
 			let compilerDone = false;
 			// eslint-disable-next-line no-loop-func
-			compiler.hooks.done.tap("MultiCompiler", stats => {
+			compiler.hooks.done.tap(CLASS_NAME, (stats) => {
 				if (!compilerDone) {
 					compilerDone = true;
 					doneCompilers++;
@@ -105,7 +116,7 @@ module.exports = class MultiCompiler {
 				}
 			});
 			// eslint-disable-next-line no-loop-func
-			compiler.hooks.invalid.tap("MultiCompiler", () => {
+			compiler.hooks.invalid.tap(CLASS_NAME, () => {
 				if (compilerDone) {
 					compilerDone = false;
 					doneCompilers--;
@@ -122,7 +133,7 @@ module.exports = class MultiCompiler {
 		 * @param {WebpackError} warning warning
 		 */
 		const addWarning = (compiler, warning) => {
-			compiler.hooks.thisCompilation.tap("MultiCompiler", compilation => {
+			compiler.hooks.thisCompilation.tap(CLASS_NAME, (compilation) => {
 				compilation.warnings.push(warning);
 			});
 		};
@@ -150,7 +161,7 @@ module.exports = class MultiCompiler {
 
 	get options() {
 		return Object.assign(
-			this.compilers.map(c => c.options),
+			this.compilers.map((c) => c.options),
 			this._options
 		);
 	}
@@ -223,7 +234,7 @@ module.exports = class MultiCompiler {
 	}
 
 	/**
-	 * @param {string | (function(): string)} name name of the logger, or function called once to get the logger name
+	 * @param {string | (() => string)} name name of the logger, or function called once to get the logger name
 	 * @returns {Logger} a logger with that name
 	 */
 	getInfrastructureLogger(name) {
@@ -252,7 +263,7 @@ module.exports = class MultiCompiler {
 		 * @param {Compiler} compiler compiler
 		 * @returns {boolean} target was found
 		 */
-		const targetFound = compiler => {
+		const targetFound = (compiler) => {
 			for (const edge of edges) {
 				if (edge.target === compiler) {
 					return true;
@@ -274,7 +285,7 @@ module.exports = class MultiCompiler {
 			const dependencies = this.dependencies.get(source);
 			if (dependencies) {
 				for (const dep of dependencies) {
-					const target = this.compilers.find(c => c.name === dep);
+					const target = this.compilers.find((c) => c.name === dep);
 					if (!target) {
 						missing.push(dep);
 					} else {
@@ -287,8 +298,10 @@ module.exports = class MultiCompiler {
 			}
 		}
 		/** @type {string[]} */
-		const errors = missing.map(m => `Compiler dependency \`${m}\` not found.`);
-		const stack = this.compilers.filter(c => !targetFound(c));
+		const errors = missing.map(
+			(m) => `Compiler dependency \`${m}\` not found.`
+		);
+		const stack = this.compilers.filter((c) => !targetFound(c));
 		while (stack.length > 0) {
 			const current = stack.pop();
 			for (const edge of edges) {
@@ -303,9 +316,9 @@ module.exports = class MultiCompiler {
 		}
 		if (edges.size > 0) {
 			/** @type {string[]} */
-			const lines = Array.from(edges)
+			const lines = [...edges]
 				.sort(sortEdges)
-				.map(edge => `${edge.source.name} -> ${edge.target.name}`);
+				.map((edge) => `${edge.source.name} -> ${edge.target.name}`);
 			lines.unshift("Circular dependency found in compiler dependencies.");
 			errors.unshift(lines.join("\n"));
 		}
@@ -322,7 +335,7 @@ module.exports = class MultiCompiler {
 	 * @deprecated This method should have been private
 	 * @param {Compiler[]} compilers the child compilers
 	 * @param {RunWithDependenciesHandler} fn a handler to run for each compiler
-	 * @param {Callback<MultiStats>} callback the compiler's handler
+	 * @param {Callback<Stats[]>} callback the compiler's handler
 	 * @returns {void}
 	 */
 	runWithDependencies(compilers, fn, callback) {
@@ -332,7 +345,7 @@ module.exports = class MultiCompiler {
 		 * @param {string} d dependency
 		 * @returns {boolean} when dependency was fulfilled
 		 */
-		const isDependencyFulfilled = d => fulfilledNames.has(d);
+		const isDependencyFulfilled = (d) => fulfilledNames.has(d);
 		/**
 		 * @returns {Compiler[]} compilers
 		 */
@@ -353,22 +366,22 @@ module.exports = class MultiCompiler {
 			return readyCompilers;
 		};
 		/**
-		 * @param {Callback<MultiStats>} callback callback
+		 * @param {Callback<Stats[]>} callback callback
 		 * @returns {void}
 		 */
-		const runCompilers = callback => {
+		const runCompilers = (callback) => {
 			if (remainingCompilers.length === 0) return callback(null);
 			asyncLib.map(
 				getReadyCompilers(),
 				(compiler, callback) => {
-					fn(compiler, err => {
+					fn(compiler, (err) => {
 						if (err) return callback(err);
 						fulfilledNames.add(compiler.name);
 						runCompilers(callback);
 					});
 				},
 				(err, results) => {
-					callback(err, /** @type {TODO} */ (results));
+					callback(err, results);
 				}
 			);
 		};
@@ -377,8 +390,8 @@ module.exports = class MultiCompiler {
 
 	/**
 	 * @template SetupResult
-	 * @param {function(Compiler, number, Callback<Stats>, function(): boolean, function(): void, function(): void): SetupResult} setup setup a single compiler
-	 * @param {function(Compiler, SetupResult, Callback<Stats>): void} run run/continue a single compiler
+	 * @param {(compiler: Compiler, index: number, doneCallback: Callback<Stats>, isBlocked: () => boolean, setChanged: () => void, setInvalid: () => void) => SetupResult} setup setup a single compiler
+	 * @param {(compiler: Compiler, setupResult: SetupResult, callback: Callback<Stats>) => void} run run/continue a single compiler
 	 * @param {Callback<MultiStats>} callback callback when all compilers are done, result includes Stats of all changed compilers
 	 * @returns {SetupResult[]} result of setup
 	 */
@@ -398,7 +411,7 @@ module.exports = class MultiCompiler {
 		// running-outdated -> blocked [running--] (when compilation is done)
 
 		/** @type {Node[]} */
-		const nodes = this.compilers.map(compiler => ({
+		const nodes = this.compilers.map((compiler) => ({
 			compiler,
 			setupResult: undefined,
 			result: undefined,
@@ -470,7 +483,7 @@ module.exports = class MultiCompiler {
 		 * @param {Node} node node
 		 * @returns {void}
 		 */
-		const nodeInvalidFromParent = node => {
+		const nodeInvalidFromParent = (node) => {
 			if (node.state === "done") {
 				node.state = "blocked";
 			} else if (node.state === "running") {
@@ -484,7 +497,7 @@ module.exports = class MultiCompiler {
 		 * @param {Node} node node
 		 * @returns {void}
 		 */
-		const nodeInvalid = node => {
+		const nodeInvalid = (node) => {
 			if (node.state === "done") {
 				node.state = "pending";
 			} else if (node.state === "running") {
@@ -498,7 +511,7 @@ module.exports = class MultiCompiler {
 		 * @param {Node} node node
 		 * @returns {void}
 		 */
-		const nodeChange = node => {
+		const nodeChange = (node) => {
 			nodeInvalid(node);
 			if (node.state === "pending") {
 				node.state = "blocked";
@@ -536,7 +549,7 @@ module.exports = class MultiCompiler {
 				if (
 					node.state === "queued" ||
 					(node.state === "blocked" &&
-						node.parents.every(p => p.state === "done"))
+						node.parents.every((p) => p.state === "done"))
 				) {
 					running++;
 					node.state = "starting";
@@ -552,7 +565,7 @@ module.exports = class MultiCompiler {
 			if (
 				!errored &&
 				running === 0 &&
-				nodes.every(node => node.state === "done")
+				nodes.every((node) => node.state === "done")
 			) {
 				const stats = [];
 				for (const node of nodes) {
@@ -572,13 +585,14 @@ module.exports = class MultiCompiler {
 	}
 
 	/**
-	 * @param {WatchOptions|WatchOptions[]} watchOptions the watcher's options
+	 * @param {WatchOptions | WatchOptions[]} watchOptions the watcher's options
 	 * @param {Callback<MultiStats>} handler signals when the call finishes
-	 * @returns {MultiWatching} a compiler watcher
+	 * @returns {MultiWatching | undefined} a compiler watcher
 	 */
 	watch(watchOptions, handler) {
 		if (this.running) {
-			return handler(new ConcurrentCompilationError());
+			handler(new ConcurrentCompilationError());
+			return;
 		}
 		this.running = true;
 
@@ -596,7 +610,7 @@ module.exports = class MultiCompiler {
 					}
 					return watching;
 				},
-				(compiler, watching, callback) => {
+				(compiler, watching, _callback) => {
 					if (compiler.watching !== watching) return;
 					if (!watching.running) watching.invalidate();
 				},
@@ -614,7 +628,8 @@ module.exports = class MultiCompiler {
 	 */
 	run(callback) {
 		if (this.running) {
-			return callback(new ConcurrentCompilationError());
+			callback(new ConcurrentCompilationError());
+			return;
 		}
 		this.running = true;
 
@@ -642,7 +657,7 @@ module.exports = class MultiCompiler {
 	}
 
 	/**
-	 * @param {Callback<void>} callback signals when the compiler closes
+	 * @param {ErrorCallback} callback signals when the compiler closes
 	 * @returns {void}
 	 */
 	close(callback) {
@@ -651,7 +666,7 @@ module.exports = class MultiCompiler {
 			(compiler, callback) => {
 				compiler.close(callback);
 			},
-			error => {
+			(error) => {
 				callback(error);
 			}
 		);

package/lib/MultiStats.js

@@ -25,6 +25,8 @@ const indent = (str, prefix) => {
 	return prefix + rem;
 };
 
+/** @typedef {undefined | string | boolean | StatsOptions} ChildrenStatsOptions */
+/** @typedef {Omit<StatsOptions, "children"> & { children?: ChildrenStatsOptions | ChildrenStatsOptions[] }} MultiStatsOptions */
 /** @typedef {{ version: boolean, hash: boolean, errorsCount: boolean, warningsCount: boolean, errors: boolean, warnings: boolean, children: NormalizedStatsOptions[] }} ChildOptions */
 
 class MultiStats {
@@ -36,25 +38,25 @@ class MultiStats {
 	}
 
 	get hash() {
-		return this.stats.map(stat => stat.hash).join("");
+		return this.stats.map((stat) => stat.hash).join("");
 	}
 
 	/**
 	 * @returns {boolean} true if a child compilation encountered an error
 	 */
 	hasErrors() {
-		return this.stats.some(stat => stat.hasErrors());
+		return this.stats.some((stat) => stat.hasErrors());
 	}
 
 	/**
 	 * @returns {boolean} true if a child compilation had a warning
 	 */
 	hasWarnings() {
-		return this.stats.some(stat => stat.hasWarnings());
+		return this.stats.some((stat) => stat.hasWarnings());
 	}
 
 	/**
-	 * @param {string | boolean | StatsOptions | undefined} options stats options
+	 * @param {undefined | string | boolean | MultiStatsOptions} options stats options
 	 * @param {CreateStatsOptionsContext} context context
 	 * @returns {ChildOptions} context context
 	 */
@@ -80,6 +82,9 @@ class MultiStats {
 			const childOptions = Array.isArray(childrenOptions)
 				? childrenOptions[idx]
 				: childrenOptions;
+			if (typeof childOptions === "boolean") {
+				return stat.compilation.createStatsOptions(childOptions, context);
+			}
 			return stat.compilation.createStatsOptions(
 				{
 					...baseOptions,
@@ -93,18 +98,18 @@ class MultiStats {
 			);
 		});
 		return {
-			version: children.every(o => o.version),
-			hash: children.every(o => o.hash),
-			errorsCount: children.every(o => o.errorsCount),
-			warningsCount: children.every(o => o.warningsCount),
-			errors: children.every(o => o.errors),
-			warnings: children.every(o => o.warnings),
+			version: children.every((o) => o.version),
+			hash: children.every((o) => o.hash),
+			errorsCount: children.every((o) => o.errorsCount),
+			warningsCount: children.every((o) => o.warningsCount),
+			errors: children.every((o) => o.errors),
+			warnings: children.every((o) => o.warnings),
 			children
 		};
 	}
 
 	/**
-	 * @param {(string | boolean | StatsOptions)=} options stats options
+	 * @param {(string | boolean | MultiStatsOptions)=} options stats options
 	 * @returns {StatsCompilation} json output
 	 */
 	toJson(options) {
@@ -130,12 +135,12 @@ class MultiStats {
 			obj.version = obj.children[0].version;
 		}
 		if (childOptions.hash) {
-			obj.hash = obj.children.map(j => j.hash).join("");
+			obj.hash = obj.children.map((j) => j.hash).join("");
 		}
 		/**
 		 * @param {StatsCompilation} j stats error
 		 * @param {StatsError} obj Stats error
-		 * @returns {TODO} result
+		 * @returns {StatsError} result
 		 */
 		const mapError = (j, obj) => ({
 			...obj,
@@ -179,7 +184,7 @@ class MultiStats {
 	}
 
 	/**
-	 * @param {(string | boolean | StatsOptions)=} options stats options
+	 * @param {(string | boolean | MultiStatsOptions)=} options stats options
 	 * @returns {string} string output
 	 */
 	toString(options) {

package/lib/MultiWatching.js

@@ -9,13 +9,7 @@ const asyncLib = require("neo-async");
 
 /** @typedef {import("./MultiCompiler")} MultiCompiler */
 /** @typedef {import("./Watching")} Watching */
-
-/**
- * @template T
- * @callback Callback
- * @param {(Error | null)=} err
- * @param {T=} result
- */
+/** @typedef {import("./webpack").ErrorCallback} ErrorCallback */
 
 class MultiWatching {
 	/**
@@ -28,7 +22,7 @@ class MultiWatching {
 	}
 
 	/**
-	 * @param {Callback<void>=} callback signals when the build has completed again
+	 * @param {ErrorCallback=} callback signals when the build has completed again
 	 * @returns {void}
 	 */
 	invalidate(callback) {
@@ -36,7 +30,9 @@ class MultiWatching {
 			asyncLib.each(
 				this.watchings,
 				(watching, callback) => watching.invalidate(callback),
-				callback
+				(err) => {
+					callback(err);
+				}
 			);
 		} else {
 			for (const watching of this.watchings) {
@@ -58,7 +54,7 @@ class MultiWatching {
 	}
 
 	/**
-	 * @param {Callback<void>} callback signals when the watcher is closed
+	 * @param {ErrorCallback} callback signals when the watcher is closed
 	 * @returns {void}
 	 */
 	close(callback) {
@@ -67,7 +63,7 @@ class MultiWatching {
 			(watching, finishedCallback) => {
 				watching.close(finishedCallback);
 			},
-			err => {
+			(err) => {
 				this.compiler.hooks.watchClose.call();
 				if (typeof callback === "function") {
 					this.compiler.running = false;

package/lib/NoEmitOnErrorsPlugin.js

@@ -7,6 +7,8 @@
 
 /** @typedef {import("./Compiler")} Compiler */
 
+const PLUGIN_NAME = "NoEmitOnErrorsPlugin";
+
 class NoEmitOnErrorsPlugin {
 	/**
 	 * Apply the plugin
@@ -14,11 +16,11 @@ class NoEmitOnErrorsPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.shouldEmit.tap("NoEmitOnErrorsPlugin", compilation => {
+		compiler.hooks.shouldEmit.tap(PLUGIN_NAME, (compilation) => {
 			if (compilation.getStats().hasErrors()) return false;
 		});
-		compiler.hooks.compilation.tap("NoEmitOnErrorsPlugin", compilation => {
-			compilation.hooks.shouldRecord.tap("NoEmitOnErrorsPlugin", () => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			compilation.hooks.shouldRecord.tap(PLUGIN_NAME, () => {
 				if (compilation.getStats().hasErrors()) return false;
 			});
 		});