webpack 5.59.0 → 5.94.0

package/lib/MultiCompiler.js

@@ -11,6 +11,7 @@ const { SyncHook, MultiHook } = require("tapable");
 const ConcurrentCompilationError = require("./ConcurrentCompilationError");
 const MultiStats = require("./MultiStats");
 const MultiWatching = require("./MultiWatching");
+const WebpackError = require("./WebpackError");
 const ArrayQueue = require("./util/ArrayQueue");
 
 /** @template T @typedef {import("tapable").AsyncSeriesHook<T>} AsyncSeriesHook<T> */
@@ -19,6 +20,7 @@ const ArrayQueue = require("./util/ArrayQueue");
 /** @typedef {import("./Compiler")} Compiler */
 /** @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 */
@@ -27,7 +29,7 @@ const ArrayQueue = require("./util/ArrayQueue");
 /**
  * @template T
  * @callback Callback
- * @param {Error=} err
+ * @param {Error | null} err
  * @param {T=} result
  */
 
@@ -38,7 +40,7 @@ const ArrayQueue = require("./util/ArrayQueue");
  */
 
 /**
- * @typedef {Object} MultiCompilerOptions
+ * @typedef {object} MultiCompilerOptions
  * @property {number=} parallelism how many Compilers are allows to run at the same time in parallel
  */
 
@@ -49,9 +51,11 @@ module.exports = class MultiCompiler {
 	 */
 	constructor(compilers, options) {
 		if (!Array.isArray(compilers)) {
+			/** @type {Compiler[]} */
 			compilers = Object.keys(compilers).map(name => {
-				compilers[name].name = name;
-				return compilers[name];
+				/** @type {Record<string, Compiler>} */
+				(compilers)[name].name = name;
+				return /** @type {Record<string, Compiler>} */ (compilers)[name];
 			});
 		}
 
@@ -80,13 +84,14 @@ module.exports = class MultiCompiler {
 		this.dependencies = new WeakMap();
 		this.running = false;
 
-		/** @type {Stats[]} */
+		/** @type {(Stats | null)[]} */
 		const compilerStats = this.compilers.map(() => null);
 		let doneCompilers = 0;
 		for (let index = 0; index < this.compilers.length; index++) {
 			const compiler = this.compilers[index];
 			const compilerIndex = index;
 			let compilerDone = false;
+			// eslint-disable-next-line no-loop-func
 			compiler.hooks.done.tap("MultiCompiler", stats => {
 				if (!compilerDone) {
 					compilerDone = true;
@@ -94,9 +99,12 @@ module.exports = class MultiCompiler {
 				}
 				compilerStats[compilerIndex] = stats;
 				if (doneCompilers === this.compilers.length) {
-					this.hooks.done.call(new MultiStats(compilerStats));
+					this.hooks.done.call(
+						new MultiStats(/** @type {Stats[]} */ (compilerStats))
+					);
 				}
 			});
+			// eslint-disable-next-line no-loop-func
 			compiler.hooks.invalid.tap("MultiCompiler", () => {
 				if (compilerDone) {
 					compilerDone = false;
@@ -104,6 +112,40 @@ module.exports = class MultiCompiler {
 				}
 			});
 		}
+		this._validateCompilersOptions();
+	}
+
+	_validateCompilersOptions() {
+		if (this.compilers.length < 2) return;
+		/**
+		 * @param {Compiler} compiler compiler
+		 * @param {WebpackError} warning warning
+		 */
+		const addWarning = (compiler, warning) => {
+			compiler.hooks.thisCompilation.tap("MultiCompiler", compilation => {
+				compilation.warnings.push(warning);
+			});
+		};
+		const cacheNames = new Set();
+		for (const compiler of this.compilers) {
+			if (compiler.options.cache && "name" in compiler.options.cache) {
+				const name = compiler.options.cache.name;
+				if (cacheNames.has(name)) {
+					addWarning(
+						compiler,
+						new WebpackError(
+							`${
+								compiler.name
+									? `Compiler with name "${compiler.name}" doesn't use unique cache name. `
+									: ""
+							}Please set unique "cache.name" option. Name "${name}" already used.`
+						)
+					);
+				} else {
+					cacheNames.add(name);
+				}
+			}
+		}
 	}
 
 	get options() {
@@ -132,18 +174,6 @@ module.exports = class MultiCompiler {
 		throw new Error("Cannot read inputFileSystem of a MultiCompiler");
 	}
 
-	get outputFileSystem() {
-		throw new Error("Cannot read outputFileSystem of a MultiCompiler");
-	}
-
-	get watchFileSystem() {
-		throw new Error("Cannot read watchFileSystem of a MultiCompiler");
-	}
-
-	get intermediateFileSystem() {
-		throw new Error("Cannot read outputFileSystem of a MultiCompiler");
-	}
-
 	/**
 	 * @param {InputFileSystem} value the new input file system
 	 */
@@ -153,6 +183,10 @@ module.exports = class MultiCompiler {
 		}
 	}
 
+	get outputFileSystem() {
+		throw new Error("Cannot read outputFileSystem of a MultiCompiler");
+	}
+
 	/**
 	 * @param {OutputFileSystem} value the new output file system
 	 */
@@ -162,6 +196,10 @@ module.exports = class MultiCompiler {
 		}
 	}
 
+	get watchFileSystem() {
+		throw new Error("Cannot read watchFileSystem of a MultiCompiler");
+	}
+
 	/**
 	 * @param {WatchFileSystem} value the new watch file system
 	 */
@@ -180,6 +218,14 @@ module.exports = class MultiCompiler {
 		}
 	}
 
+	get intermediateFileSystem() {
+		throw new Error("Cannot read outputFileSystem of a MultiCompiler");
+	}
+
+	/**
+	 * @param {string | (function(): string)} name name of the logger, or function called once to get the logger name
+	 * @returns {Logger} a logger with that name
+	 */
 	getInfrastructureLogger(name) {
 		return this.compilers[0].getInfrastructureLogger(name);
 	}
@@ -202,6 +248,10 @@ module.exports = class MultiCompiler {
 		const edges = new Set();
 		/** @type {string[]} */
 		const missing = [];
+		/**
+		 * @param {Compiler} compiler compiler
+		 * @returns {boolean} target was found
+		 */
 		const targetFound = compiler => {
 			for (const edge of edges) {
 				if (edge.target === compiler) {
@@ -210,12 +260,16 @@ module.exports = class MultiCompiler {
 			}
 			return false;
 		};
-		const sortEdges = (e1, e2) => {
-			return (
-				e1.source.name.localeCompare(e2.source.name) ||
-				e1.target.name.localeCompare(e2.target.name)
-			);
-		};
+		/**
+		 * @param {{source: Compiler, target: Compiler}} e1 edge 1
+		 * @param {{source: Compiler, target: Compiler}} e2 edge 2
+		 * @returns {number} result
+		 */
+		const sortEdges = (e1, e2) =>
+			/** @type {string} */
+			(e1.source.name).localeCompare(/** @type {string} */ (e2.source.name)) ||
+			/** @type {string} */
+			(e1.target.name).localeCompare(/** @type {string} */ (e2.target.name));
 		for (const source of this.compilers) {
 			const dependencies = this.dependencies.get(source);
 			if (dependencies) {
@@ -274,10 +328,17 @@ module.exports = class MultiCompiler {
 	runWithDependencies(compilers, fn, callback) {
 		const fulfilledNames = new Set();
 		let remainingCompilers = compilers;
+		/**
+		 * @param {string} d dependency
+		 * @returns {boolean} when dependency was fulfilled
+		 */
 		const isDependencyFulfilled = d => fulfilledNames.has(d);
+		/**
+		 * @returns {Compiler[]} compilers
+		 */
 		const getReadyCompilers = () => {
-			let readyCompilers = [];
-			let list = remainingCompilers;
+			const readyCompilers = [];
+			const list = remainingCompilers;
 			remainingCompilers = [];
 			for (const c of list) {
 				const dependencies = this.dependencies.get(c);
@@ -291,8 +352,12 @@ module.exports = class MultiCompiler {
 			}
 			return readyCompilers;
 		};
+		/**
+		 * @param {Callback<MultiStats>} callback callback
+		 * @returns {void}
+		 */
 		const runCompilers = callback => {
-			if (remainingCompilers.length === 0) return callback();
+			if (remainingCompilers.length === 0) return callback(null);
 			asyncLib.map(
 				getReadyCompilers(),
 				(compiler, callback) => {
@@ -302,7 +367,9 @@ module.exports = class MultiCompiler {
 						runCompilers(callback);
 					});
 				},
-				callback
+				(err, results) => {
+					callback(err, /** @type {TODO} */ (results));
+				}
 			);
 		};
 		runCompilers(callback);
@@ -316,7 +383,7 @@ module.exports = class MultiCompiler {
 	 * @returns {SetupResult[]} result of setup
 	 */
 	_runGraph(setup, run, callback) {
-		/** @typedef {{ compiler: Compiler, setupResult: SetupResult, result: Stats, state: "pending" | "blocked" | "queued" | "starting" | "running" | "running-outdated" | "done", children: Node[], parents: Node[] }} Node */
+		/** @typedef {{ compiler: Compiler, setupResult: undefined | SetupResult, result: undefined | Stats, state: "pending" | "blocked" | "queued" | "starting" | "running" | "running-outdated" | "done", children: Node[], parents: Node[] }} Node */
 
 		// State transitions for nodes:
 		// -> blocked (initial)
@@ -341,12 +408,14 @@ module.exports = class MultiCompiler {
 		}));
 		/** @type {Map<string, Node>} */
 		const compilerToNode = new Map();
-		for (const node of nodes) compilerToNode.set(node.compiler.name, node);
+		for (const node of nodes) {
+			compilerToNode.set(/** @type {string} */ (node.compiler.name), node);
+		}
 		for (const node of nodes) {
 			const dependencies = this.dependencies.get(node.compiler);
 			if (!dependencies) continue;
 			for (const dep of dependencies) {
-				const parent = compilerToNode.get(dep);
+				const parent = /** @type {Node} */ (compilerToNode.get(dep));
 				node.parents.push(parent);
 				parent.children.push(node);
 			}
@@ -361,10 +430,10 @@ module.exports = class MultiCompiler {
 		}
 		let errored = false;
 		let running = 0;
-		const parallelism = this._options.parallelism;
+		const parallelism = /** @type {number} */ (this._options.parallelism);
 		/**
 		 * @param {Node} node node
-		 * @param {Error=} err error
+		 * @param {(Error | null)=} err error
 		 * @param {Stats=} stats result
 		 * @returns {void}
 		 */
@@ -440,8 +509,9 @@ module.exports = class MultiCompiler {
 			}
 		};
 
+		/** @type {SetupResult[]} */
 		const setupResults = [];
-		nodes.forEach((node, i) => {
+		for (const [i, node] of nodes.entries()) {
 			setupResults.push(
 				(node.setupResult = setup(
 					node.compiler,
@@ -452,7 +522,7 @@ module.exports = class MultiCompiler {
 					() => nodeInvalid(node)
 				))
 			);
-		});
+		}
 		let processing = true;
 		const processQueue = () => {
 			if (processing) return;
@@ -460,8 +530,9 @@ module.exports = class MultiCompiler {
 			process.nextTick(processQueueWorker);
 		};
 		const processQueueWorker = () => {
+			// eslint-disable-next-line no-unmodified-loop-condition
 			while (running < parallelism && queue.length > 0 && !errored) {
-				const node = queue.dequeue();
+				const node = /** @type {Node} */ (queue.dequeue());
 				if (
 					node.state === "queued" ||
 					(node.state === "blocked" &&
@@ -469,7 +540,11 @@ module.exports = class MultiCompiler {
 				) {
 					running++;
 					node.state = "starting";
-					run(node.compiler, node.setupResult, nodeDone.bind(null, node));
+					run(
+						node.compiler,
+						/** @type {SetupResult} */ (node.setupResult),
+						nodeDone.bind(null, node)
+					);
 					node.state = "running";
 				}
 			}
@@ -576,7 +651,9 @@ module.exports = class MultiCompiler {
 			(compiler, callback) => {
 				compiler.close(callback);
 			},
-			callback
+			error => {
+				callback(error);
+			}
 		);
 	}
 };

package/lib/MultiStats.js

@@ -8,15 +8,25 @@
 const identifierUtils = require("./util/identifier");
 
 /** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
+/** @typedef {import("./Compilation").CreateStatsOptionsContext} CreateStatsOptionsContext */
+/** @typedef {import("./Compilation").NormalizedStatsOptions} NormalizedStatsOptions */
 /** @typedef {import("./Stats")} Stats */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").KnownStatsCompilation} KnownStatsCompilation */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsError} StatsError */
 
+/**
+ * @param {string} str string
+ * @param {string} prefix pref
+ * @returns {string} indent
+ */
 const indent = (str, prefix) => {
-	const rem = str.replace(/\n([^\n])/g, "\n" + prefix + "$1");
+	const rem = str.replace(/\n([^\n])/g, `\n${prefix}$1`);
 	return prefix + rem;
 };
 
+/** @typedef {{ version: boolean, hash: boolean, errorsCount: boolean, warningsCount: boolean, errors: boolean, warnings: boolean, children: NormalizedStatsOptions[] }} ChildOptions */
+
 class MultiStats {
 	/**
 	 * @param {Stats[]} stats the child stats
@@ -43,13 +53,30 @@ class MultiStats {
 		return this.stats.some(stat => stat.hasWarnings());
 	}
 
+	/**
+	 * @param {string | boolean | StatsOptions | undefined} options stats options
+	 * @param {CreateStatsOptionsContext} context context
+	 * @returns {ChildOptions} context context
+	 */
 	_createChildOptions(options, context) {
-		if (!options) {
-			options = {};
-		}
-		const { children: childrenOptions = undefined, ...baseOptions } =
-			typeof options === "string" ? { preset: options } : options;
+		const getCreateStatsOptions = () => {
+			if (!options) {
+				options = {};
+			}
+
+			const { children: childrenOptions = undefined, ...baseOptions } =
+				typeof options === "string"
+					? { preset: options }
+					: /** @type {StatsOptions} */ (options);
+
+			return { childrenOptions, baseOptions };
+		};
+
 		const children = this.stats.map((stat, idx) => {
+			if (typeof options === "boolean") {
+				return stat.compilation.createStatsOptions(options, context);
+			}
+			const { childrenOptions, baseOptions } = getCreateStatsOptions();
 			const childOptions = Array.isArray(childrenOptions)
 				? childrenOptions[idx]
 				: childrenOptions;
@@ -59,8 +86,8 @@ class MultiStats {
 					...(typeof childOptions === "string"
 						? { preset: childOptions }
 						: childOptions && typeof childOptions === "object"
-						? childOptions
-						: undefined)
+							? childOptions
+							: undefined)
 				},
 				context
 			);
@@ -77,81 +104,96 @@ class MultiStats {
 	}
 
 	/**
-	 * @param {any} options stats options
+	 * @param {(string | boolean | StatsOptions)=} options stats options
 	 * @returns {StatsCompilation} json output
 	 */
 	toJson(options) {
-		options = this._createChildOptions(options, { forToString: false });
+		const childOptions = this._createChildOptions(options, {
+			forToString: false
+		});
 		/** @type {KnownStatsCompilation} */
 		const obj = {};
 		obj.children = this.stats.map((stat, idx) => {
-			const obj = stat.toJson(options.children[idx]);
+			const obj = stat.toJson(childOptions.children[idx]);
 			const compilationName = stat.compilation.name;
 			const name =
 				compilationName &&
 				identifierUtils.makePathsRelative(
-					options.context,
+					stat.compilation.compiler.context,
 					compilationName,
 					stat.compilation.compiler.root
 				);
 			obj.name = name;
 			return obj;
 		});
-		if (options.version) {
+		if (childOptions.version) {
 			obj.version = obj.children[0].version;
 		}
-		if (options.hash) {
+		if (childOptions.hash) {
 			obj.hash = obj.children.map(j => j.hash).join("");
 		}
-		const mapError = (j, obj) => {
-			return {
-				...obj,
-				compilerPath: obj.compilerPath
-					? `${j.name}.${obj.compilerPath}`
-					: j.name
-			};
-		};
-		if (options.errors) {
+		/**
+		 * @param {StatsCompilation} j stats error
+		 * @param {StatsError} obj Stats error
+		 * @returns {TODO} result
+		 */
+		const mapError = (j, obj) => ({
+			...obj,
+			compilerPath: obj.compilerPath ? `${j.name}.${obj.compilerPath}` : j.name
+		});
+		if (childOptions.errors) {
 			obj.errors = [];
 			for (const j of obj.children) {
-				for (const i of j.errors) {
+				const errors =
+					/** @type {NonNullable<KnownStatsCompilation["errors"]>} */
+					(j.errors);
+				for (const i of errors) {
 					obj.errors.push(mapError(j, i));
 				}
 			}
 		}
-		if (options.warnings) {
+		if (childOptions.warnings) {
 			obj.warnings = [];
 			for (const j of obj.children) {
-				for (const i of j.warnings) {
+				const warnings =
+					/** @type {NonNullable<KnownStatsCompilation["warnings"]>} */
+					(j.warnings);
+				for (const i of warnings) {
 					obj.warnings.push(mapError(j, i));
 				}
 			}
 		}
-		if (options.errorsCount) {
+		if (childOptions.errorsCount) {
 			obj.errorsCount = 0;
 			for (const j of obj.children) {
-				obj.errorsCount += j.errorsCount;
+				obj.errorsCount += /** @type {number} */ (j.errorsCount);
 			}
 		}
-		if (options.warningsCount) {
+		if (childOptions.warningsCount) {
 			obj.warningsCount = 0;
 			for (const j of obj.children) {
-				obj.warningsCount += j.warningsCount;
+				obj.warningsCount += /** @type {number} */ (j.warningsCount);
 			}
 		}
 		return obj;
 	}
 
+	/**
+	 * @param {(string | boolean | StatsOptions)=} options stats options
+	 * @returns {string} string output
+	 */
 	toString(options) {
-		options = this._createChildOptions(options, { forToString: true });
+		const childOptions = this._createChildOptions(options, {
+			forToString: true
+		});
 		const results = this.stats.map((stat, idx) => {
-			const str = stat.toString(options.children[idx]);
+			const str = stat.toString(childOptions.children[idx]);
 			const compilationName = stat.compilation.name;
 			const name =
 				compilationName &&
 				identifierUtils
 					.makePathsRelative(
-						options.context,
+						stat.compilation.compiler.context,
 						compilationName,
 						stat.compilation.compiler.root
 					)

package/lib/MultiWatching.js

@@ -13,7 +13,7 @@ const asyncLib = require("neo-async");
 /**
  * @template T
  * @callback Callback
- * @param {Error=} err
+ * @param {(Error | null)=} err
  * @param {T=} result
  */
 
@@ -27,6 +27,10 @@ class MultiWatching {
 		this.compiler = compiler;
 	}
 
+	/**
+	 * @param {Callback<void>=} callback signals when the build has completed again
+	 * @returns {void}
+	 */
 	invalidate(callback) {
 		if (callback) {
 			asyncLib.each(
@@ -58,7 +62,7 @@ class MultiWatching {
 	 * @returns {void}
 	 */
 	close(callback) {
-		asyncLib.forEach(
+		asyncLib.each(
 			this.watchings,
 			(watching, finishedCallback) => {
 				watching.close(finishedCallback);