webpack 5.109.2 → 5.110.0

package/lib/ModuleTemplate.js

@@ -6,18 +6,21 @@
 "use strict";
 
 const util = require("util");
-const memoize = require("./util/memoize");
+const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
 
-/** @typedef {import("tapable").Tap} Tap */
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
-/** @typedef {import("./javascript/JavascriptModulesPlugin").ModuleRenderContext}  ModuleRenderContext */
-/** @typedef {import("./util/Hash")} Hash */
+/** @import { Tap } from "tapable" */
+/** @import { Source } from "webpack-sources" */
+/** @import Compilation from "./Compilation" */
+/** @import DependencyTemplates from "./DependencyTemplates" */
+/** @import Module from "./Module" */
+/** @import RuntimeTemplate from "./RuntimeTemplate" */
+/**
+ * @import {
+ * 	ChunkRenderContext,
+ * 	ModuleRenderContext
+ * } from "./javascript/JavascriptModulesPlugin"
+ */
+/** @import Hash from "./util/Hash" */
 
 /**
  * Defines the if set type used by this module.
@@ -25,10 +28,6 @@ const memoize = require("./util/memoize");
  * @typedef {import("tapable").IfSet<T>} IfSet
  */
 
-const getJavascriptModulesPlugin = memoize(() =>
-	require("./javascript/JavascriptModulesPlugin")
-);
-
 // TODO webpack 6: remove this class
 class ModuleTemplate {
 	/**
@@ -51,18 +50,18 @@ class ModuleTemplate {
 					 * @param {(source: Source, module: Module, moduleRenderContext: ModuleRenderContext, dependencyTemplates: DependencyTemplates) => Source} fn fn
 					 */
 					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.renderModuleContent.tap(
-								options,
-								(source, module, renderContext) =>
-									fn(
-										source,
-										module,
-										renderContext,
-										renderContext.dependencyTemplates
-									)
-							);
+						JavascriptModulesPlugin.getCompilationHooks(
+							compilation
+						).renderModuleContent.tap(
+							options,
+							(source, module, renderContext) =>
+								fn(
+									source,
+									module,
+									renderContext,
+									renderContext.dependencyTemplates
+								)
+						);
 					},
 					"ModuleTemplate.hooks.content is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModuleContent instead)",
 					"DEP_MODULE_TEMPLATE_CONTENT"
@@ -77,18 +76,18 @@ class ModuleTemplate {
 					 * @param {(source: Source, module: Module, moduleRenderContext: ModuleRenderContext, dependencyTemplates: DependencyTemplates) => Source} fn fn
 					 */
 					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.renderModuleContent.tap(
-								options,
-								(source, module, renderContext) =>
-									fn(
-										source,
-										module,
-										renderContext,
-										renderContext.dependencyTemplates
-									)
-							);
+						JavascriptModulesPlugin.getCompilationHooks(
+							compilation
+						).renderModuleContent.tap(
+							options,
+							(source, module, renderContext) =>
+								fn(
+									source,
+									module,
+									renderContext,
+									renderContext.dependencyTemplates
+								)
+						);
 					},
 					"ModuleTemplate.hooks.module is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModuleContent instead)",
 					"DEP_MODULE_TEMPLATE_MODULE"
@@ -103,18 +102,18 @@ class ModuleTemplate {
 					 * @param {(source: Source, module: Module, chunkRenderContext: ChunkRenderContext, dependencyTemplates: DependencyTemplates) => Source} fn fn
 					 */
 					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.renderModuleContainer.tap(
-								options,
-								(source, module, renderContext) =>
-									fn(
-										source,
-										module,
-										renderContext,
-										renderContext.dependencyTemplates
-									)
-							);
+						JavascriptModulesPlugin.getCompilationHooks(
+							compilation
+						).renderModuleContainer.tap(
+							options,
+							(source, module, renderContext) =>
+								fn(
+									source,
+									module,
+									renderContext,
+									renderContext.dependencyTemplates
+								)
+						);
 					},
 					"ModuleTemplate.hooks.render is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModuleContainer instead)",
 					"DEP_MODULE_TEMPLATE_RENDER"
@@ -129,18 +128,18 @@ class ModuleTemplate {
 					 * @param {(source: Source, module: Module, chunkRenderContext: ChunkRenderContext, dependencyTemplates: DependencyTemplates) => Source} fn fn
 					 */
 					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.renderModulePackage.tap(
-								options,
-								(source, module, renderContext) =>
-									fn(
-										source,
-										module,
-										renderContext,
-										renderContext.dependencyTemplates
-									)
-							);
+						JavascriptModulesPlugin.getCompilationHooks(
+							compilation
+						).renderModulePackage.tap(
+							options,
+							(source, module, renderContext) =>
+								fn(
+									source,
+									module,
+									renderContext,
+									renderContext.dependencyTemplates
+								)
+						);
 					},
 					"ModuleTemplate.hooks.package is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModulePackage instead)",
 					"DEP_MODULE_TEMPLATE_PACKAGE"

package/lib/MultiCompiler.js

@@ -10,9 +10,13 @@ const { MultiHook, SyncHook } = require("tapable");
 
 const MultiStats = require("./MultiStats");
 const MultiWatching = require("./MultiWatching");
-const ConcurrentCompilationError = require("./errors/ConcurrentCompilationError");
 const WebpackError = require("./errors/WebpackError");
 const ArrayQueue = require("./util/ArrayQueue");
+const memoize = require("./util/memoize");
+
+const getConcurrentCompilationError = memoize(() =>
+	require("./errors/ConcurrentCompilationError")
+);
 
 /**
  * Defines the shared type used by this module.
@@ -25,22 +29,31 @@ const ArrayQueue = require("./util/ArrayQueue");
  * @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 */
+
+/**
+ * @import {
+ * 	WebpackOptions,
+ * 	WatchOptions
+ * } from "../declarations/WebpackOptions"
+ */
+/** @import Compiler from "./Compiler" */
 /**
  * Defines the callback type used by this module.
  * @template T
  * @template [R=void]
  * @typedef {import("./webpack").Callback<T, R>} Callback
  */
-/** @typedef {import("./webpack").ErrorCallback} ErrorCallback */
-/** @typedef {import("./Stats")} Stats */
-/** @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 */
+/** @import { ErrorCallback } from "./webpack" */
+/** @import Stats from "./Stats" */
+/** @import { Logger } from "./logging/Logger" */
+/**
+ * @import {
+ * 	InputFileSystem,
+ * 	IntermediateFileSystem,
+ * 	OutputFileSystem,
+ * 	WatchFileSystem
+ * } from "./util/fs"
+ */
 
 /**
  * Defines the run with dependencies handler callback.
@@ -77,14 +90,16 @@ module.exports = class MultiCompiler {
 		}
 
 		this.hooks = Object.freeze({
-			/** @type {SyncHook<[MultiStats]>} */
-			done: new SyncHook(["stats"]),
+			/** @type {SyncHook<[MultiStats, Compiler[]]>} */
+			done: new SyncHook(["stats", "changedCompilers"]),
 			/** @type {MultiHook<SyncHook<[string | null, number]>>} */
 			invalid: new MultiHook(compilers.map((c) => c.hooks.invalid)),
 			/** @type {MultiHook<AsyncSeriesHook<[Compiler]>>} */
 			run: new MultiHook(compilers.map((c) => c.hooks.run)),
 			/** @type {SyncHook<[]>} */
 			watchClose: new SyncHook([]),
+			/** @type {MultiHook<AsyncSeriesHook<[]>>} */
+			shutdown: new MultiHook(compilers.map((c) => c.hooks.shutdown)),
 			/** @type {MultiHook<AsyncSeriesHook<[Compiler]>>} */
 			watchRun: new MultiHook(compilers.map((c) => c.hooks.watchRun)),
 			/** @type {MultiHook<SyncBailHook<[string, string, EXPECTED_ANY[] | undefined], true | void>>} */
@@ -107,6 +122,8 @@ module.exports = class MultiCompiler {
 
 		/** @type {(Stats | null)[]} */
 		const compilerStats = this.compilers.map(() => null);
+		/** @type {Set<Compiler>} */
+		const changedCompilers = new Set();
 		let doneCompilers = 0;
 		for (let index = 0; index < this.compilers.length; index++) {
 			const compiler = this.compilers[index];
@@ -114,17 +131,26 @@ module.exports = class MultiCompiler {
 			let compilerDone = false;
 			// eslint-disable-next-line no-loop-func
 			compiler.hooks.done.tap(CLASS_NAME, (stats) => {
+				changedCompilers.add(compiler);
 				if (!compilerDone) {
 					compilerDone = true;
 					doneCompilers++;
 				}
 				compilerStats[compilerIndex] = stats;
 				if (doneCompilers === this.compilers.length) {
+					const changed = this.compilers.filter((c) => changedCompilers.has(c));
+					changedCompilers.clear();
 					this.hooks.done.call(
-						new MultiStats(/** @type {Stats[]} */ (compilerStats))
+						// Copy: the live array is cleared per child on shutdown.
+						new MultiStats(/** @type {Stats[]} */ ([...compilerStats])),
+						changed
 					);
 				}
 			});
+			// Each entry holds a Stats -> Compilation; don't outlive the child's close().
+			compiler.hooks.shutdown.tap(CLASS_NAME, () => {
+				compilerStats[compilerIndex] = null;
+			});
 			// eslint-disable-next-line no-loop-func
 			compiler.hooks.invalid.tap(CLASS_NAME, () => {
 				if (compilerDone) {
@@ -193,10 +219,22 @@ module.exports = class MultiCompiler {
 	}
 
 	get outputPath() {
+		// Match whole path segments: "/dist-app" must not count as inside "/dist"
+		/**
+		 * @param {string} parent candidate ancestor path
+		 * @param {string} path path to test
+		 * @returns {boolean} true when path is parent or inside it
+		 */
+		const isSubPath = (parent, path) => {
+			if (path === parent) return true;
+			if (!path.startsWith(parent)) return false;
+			const next = path.charCodeAt(parent.length);
+			return next === 47 || next === 92 || /[/\\]$/.test(parent);
+		};
 		let commonPath = this.compilers[0].outputPath;
 		for (const compiler of this.compilers) {
 			while (
-				compiler.outputPath.indexOf(commonPath) !== 0 &&
+				!isSubPath(commonPath, compiler.outputPath) &&
 				/[/\\]/.test(commonPath)
 			) {
 				commonPath = commonPath.replace(/[/\\][^/\\]*$/, "");
@@ -485,7 +523,28 @@ module.exports = class MultiCompiler {
 		}
 		let errored = false;
 		let running = 0;
+		let duringSetup = true;
+		/** @type {Error | null} */
+		let setupError = null;
 		const parallelism = /** @type {number} */ (this._options.parallelism);
+		/**
+		 * Closes all node watchings.
+		 * @param {() => void} onClosed called when every watching is closed
+		 * @returns {void}
+		 */
+		const closeWatchings = (onClosed) => {
+			asyncLib.each(
+				nodes,
+				(node, callback) => {
+					if (node.compiler.watching) {
+						node.compiler.watching.close(callback);
+					} else {
+						callback();
+					}
+				},
+				onClosed
+			);
+		};
 		/**
 		 * Processes the provided node.
 		 * @param {Node} node node
@@ -497,17 +556,13 @@ module.exports = class MultiCompiler {
 			if (errored) return;
 			if (err) {
 				errored = true;
-				return asyncLib.each(
-					nodes,
-					(node, callback) => {
-						if (node.compiler.watching) {
-							node.compiler.watching.close(callback);
-						} else {
-							callback();
-						}
-					},
-					() => callback(err)
-				);
+				// During setup later watchings do not exist yet — defer the close
+				// sweep until the setup loop created them all, or they would leak
+				if (duringSetup) {
+					setupError = err;
+					return;
+				}
+				return closeWatchings(() => callback(err));
 			}
 			node.result = stats;
 			running--;
@@ -627,7 +682,14 @@ module.exports = class MultiCompiler {
 				}
 			}
 		};
-		processQueueWorker();
+		duringSetup = false;
+		if (setupError) {
+			// The setup loop finished, every watching exists now — safe to sweep
+			const err = setupError;
+			closeWatchings(() => callback(err));
+		} else {
+			processQueueWorker();
+		}
 		return setupResults;
 	}
 
@@ -639,36 +701,40 @@ module.exports = class MultiCompiler {
 	 */
 	watch(watchOptions, handler) {
 		if (this.running) {
-			handler(new ConcurrentCompilationError());
+			handler(new (getConcurrentCompilationError())());
 			return;
 		}
-		this.running = true;
-
-		if (this.validateDependencies(handler)) {
-			const watchings = this._runGraph(
-				(compiler, idx, callback, isBlocked, setChanged, setInvalid) => {
-					const watching = compiler.watch(
-						Array.isArray(watchOptions) ? watchOptions[idx] : watchOptions,
-						callback
-					);
-					if (watching) {
-						watching._onInvalid = setInvalid;
-						watching._onChange = setChanged;
-						watching._isBlocked = isBlocked;
-					}
-					return watching;
-				},
-				(compiler, watching, _callback) => {
-					if (compiler.watching !== watching) return;
-					if (!watching.running) watching.invalidate();
-				},
-				handler
-			);
-			this.watching = new MultiWatching(watchings, this);
+		// Only mark as running after validation, so a retry reports the real error
+		if (!this.validateDependencies(handler)) {
+			this.watching = new MultiWatching([], this);
 			return this.watching;
 		}
+		this.running = true;
 
-		this.watching = new MultiWatching([], this);
+		const watchings = this._runGraph(
+			(compiler, idx, callback, isBlocked, setChanged, setInvalid) => {
+				const watching = compiler.watch(
+					Array.isArray(watchOptions) ? watchOptions[idx] : watchOptions,
+					callback
+				);
+				if (watching) {
+					watching._onInvalid = setInvalid;
+					watching._onChange = setChanged;
+					watching._isBlocked = isBlocked;
+				}
+				return watching;
+			},
+			(compiler, watching, _callback) => {
+				if (compiler.watching !== watching) return;
+				if (!watching.running) watching.invalidate();
+			},
+			(err, stats) => {
+				// A fatal error tears the whole graph down — allow watching again
+				if (err) this.running = false;
+				handler(err, stats);
+			}
+		);
+		this.watching = new MultiWatching(watchings, this);
 		return this.watching;
 	}
 
@@ -679,24 +745,24 @@ module.exports = class MultiCompiler {
 	 */
 	run(callback) {
 		if (this.running) {
-			callback(new ConcurrentCompilationError());
+			callback(new (getConcurrentCompilationError())());
 			return;
 		}
+		// Only mark as running after validation, so a retry reports the real error
+		if (!this.validateDependencies(callback)) return;
 		this.running = true;
 
-		if (this.validateDependencies(callback)) {
-			this._runGraph(
-				() => {},
-				(compiler, setupResult, callback) => compiler.run(callback),
-				(err, stats) => {
-					this.running = false;
+		this._runGraph(
+			() => {},
+			(compiler, setupResult, callback) => compiler.run(callback),
+			(err, stats) => {
+				this.running = false;
 
-					if (callback !== undefined) {
-						return callback(err, stats);
-					}
+				if (callback !== undefined) {
+					return callback(err, stats);
 				}
-			);
-		}
+			}
+		);
 	}
 
 	purgeInputFileSystem() {

package/lib/MultiStats.js

@@ -7,14 +7,26 @@
 
 const identifierUtils = require("./util/identifier");
 
-/** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
-/** @typedef {import("../declarations/WebpackOptions").StatsValue} StatsValue */
-/** @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 */
+/**
+ * @import {
+ * 	StatsOptions,
+ * 	StatsValue
+ * } from "../declarations/WebpackOptions"
+ */
+/**
+ * @import {
+ * 	CreateStatsOptionsContext,
+ * 	NormalizedStatsOptions
+ * } from "./Compilation"
+ */
+/** @import Stats from "./Stats" */
+/**
+ * @import {
+ * 	KnownStatsCompilation,
+ * 	StatsCompilation,
+ * 	StatsError
+ * } from "./stats/DefaultStatsFactoryPlugin"
+ */
 
 /**
  * Returns indent.
@@ -28,7 +40,7 @@ const indent = (str, prefix) => {
 };
 
 /** @typedef {StatsOptions} MultiStatsOptions */
-/** @typedef {{ version: boolean, hash: boolean, errorsCount: boolean, warningsCount: boolean, errors: boolean, warnings: boolean, children: NormalizedStatsOptions[] }} ChildOptions */
+/** @typedef {{ version: boolean, hash: boolean, errorsCount: boolean, warningsCount: boolean, errors: boolean, warnings: boolean, hints: boolean, hintsCount: boolean, children: NormalizedStatsOptions[] }} ChildOptions */
 
 class MultiStats {
 	/**
@@ -110,6 +122,8 @@ class MultiStats {
 			warningsCount: children.every((o) => o.warningsCount),
 			errors: children.every((o) => o.errors),
 			warnings: children.every((o) => o.warnings),
+			hints: children.every((o) => o.hints),
+			hintsCount: children.every((o) => o.hintsCount),
 			children
 		};
 	}
@@ -176,6 +190,17 @@ class MultiStats {
 				}
 			}
 		}
+		if (childOptions.hints) {
+			obj.hints = [];
+			for (const j of obj.children) {
+				const hints =
+					/** @type {NonNullable<KnownStatsCompilation["hints"]>} */
+					(j.hints);
+				for (const i of hints) {
+					obj.hints.push(mapError(j, i));
+				}
+			}
+		}
 		if (childOptions.errorsCount) {
 			obj.errorsCount = 0;
 			for (const j of obj.children) {
@@ -188,6 +213,12 @@ class MultiStats {
 				obj.warningsCount += /** @type {number} */ (j.warningsCount);
 			}
 		}
+		if (childOptions.hintsCount) {
+			obj.hintsCount = 0;
+			for (const j of obj.children) {
+				obj.hintsCount += /** @type {number} */ (j.hintsCount);
+			}
+		}
 		return obj;
 	}
 

package/lib/MultiWatching.js

@@ -7,9 +7,9 @@
 
 const asyncLib = require("neo-async");
 
-/** @typedef {import("./MultiCompiler")} MultiCompiler */
-/** @typedef {import("./Watching")} Watching */
-/** @typedef {import("./webpack").ErrorCallback} ErrorCallback */
+/** @import MultiCompiler from "./MultiCompiler" */
+/** @import Watching from "./Watching" */
+/** @import { ErrorCallback } from "./webpack" */
 
 class MultiWatching {
 	/**

package/lib/NoEmitOnErrorsPlugin.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-/** @typedef {import("./Compiler")} Compiler */
+/** @import Compiler from "./Compiler" */
 
 const PLUGIN_NAME = "NoEmitOnErrorsPlugin";