webpack 5.90.2 → 5.91.0

package/lib/MultiCompiler.js

@@ -19,6 +19,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 +28,7 @@ const ArrayQueue = require("./util/ArrayQueue");
 /**
  * @template T
  * @callback Callback
- * @param {(Error | null)=} err
+ * @param {Error | null} err
  * @param {T=} result
  */
 
@@ -49,9 +50,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,7 +83,7 @@ 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++) {
@@ -94,7 +97,9 @@ 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))
+					);
 				}
 			});
 			compiler.hooks.invalid.tap("MultiCompiler", () => {
@@ -180,6 +185,10 @@ module.exports = class 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 +211,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,10 +223,19 @@ module.exports = class MultiCompiler {
 			}
 			return false;
 		};
+		/**
+		 * @param {{source: Compiler, target: Compiler}} e1 edge 1
+		 * @param {{source: Compiler, target: Compiler}} e2 edge 2
+		 * @returns {number} result
+		 */
 		const sortEdges = (e1, e2) => {
 			return (
-				e1.source.name.localeCompare(e2.source.name) ||
-				e1.target.name.localeCompare(e2.target.name)
+				/** @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) {
@@ -274,7 +296,14 @@ 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;
@@ -291,8 +320,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 +335,9 @@ module.exports = class MultiCompiler {
 						runCompilers(callback);
 					});
 				},
-				callback
+				(err, results) => {
+					callback(err, /** @type {TODO} */ (results));
+				}
 			);
 		};
 		runCompilers(callback);
@@ -316,7 +351,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 +376,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 +398,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,6 +477,7 @@ module.exports = class MultiCompiler {
 			}
 		};
 
+		/** @type {SetupResult[]} */
 		const setupResults = [];
 		nodes.forEach((node, i) => {
 			setupResults.push(
@@ -461,7 +499,7 @@ module.exports = class MultiCompiler {
 		};
 		const processQueueWorker = () => {
 			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 +507,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 +618,9 @@ module.exports = class MultiCompiler {
 			(compiler, callback) => {
 				compiler.close(callback);
 			},
-			callback
+			error => {
+				callback(error);
+			}
 		);
 	}
 };

package/lib/NodeStuffPlugin.js

@@ -32,6 +32,7 @@ const { parseResource } = require("./util/identifier");
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("./javascript/JavascriptParser").Range} Range */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
 const PLUGIN_NAME = "NodeStuffPlugin";
 
@@ -193,7 +194,11 @@ class NodeStuffPlugin {
 								break;
 							case true:
 								setModuleConstant("__filename", module =>
-									relative(compiler.inputFileSystem, context, module.resource)
+									relative(
+										/** @type {InputFileSystem} */ (compiler.inputFileSystem),
+										context,
+										module.resource
+									)
 								);
 								break;
 						}
@@ -227,7 +232,11 @@ class NodeStuffPlugin {
 								break;
 							case true:
 								setModuleConstant("__dirname", module =>
-									relative(compiler.inputFileSystem, context, module.context)
+									relative(
+										/** @type {InputFileSystem} */ (compiler.inputFileSystem),
+										context,
+										/** @type {string} */ (module.context)
+									)
 								);
 								break;
 						}
@@ -236,7 +245,9 @@ class NodeStuffPlugin {
 							.for("__dirname")
 							.tap(PLUGIN_NAME, expr => {
 								if (!parser.state.module) return;
-								return evaluateToString(parser.state.module.context)(expr);
+								return evaluateToString(
+									/** @type {string} */ (parser.state.module.context)
+								)(expr);
 							});
 					}
 					parser.hooks.expression