webpack 5.99.6 → 5.99.7

package/lib/AutomaticPrefetchPlugin.js

@@ -11,6 +11,8 @@ const PrefetchDependency = require("./dependencies/PrefetchDependency");
 
 /** @typedef {import("./Compiler")} Compiler */
 
+const PLUGIN_NAME = "AutomaticPrefetchPlugin";
+
 class AutomaticPrefetchPlugin {
 	/**
 	 * Apply the plugin
@@ -19,7 +21,7 @@ class AutomaticPrefetchPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"AutomaticPrefetchPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					PrefetchDependency,
@@ -29,7 +31,7 @@ class AutomaticPrefetchPlugin {
 		);
 		/** @type {{context: string | null, request: string}[] | null} */
 		let lastModules = null;
-		compiler.hooks.afterCompile.tap("AutomaticPrefetchPlugin", compilation => {
+		compiler.hooks.afterCompile.tap(PLUGIN_NAME, compilation => {
 			lastModules = [];
 
 			for (const m of compilation.modules) {
@@ -41,26 +43,23 @@ class AutomaticPrefetchPlugin {
 				}
 			}
 		});
-		compiler.hooks.make.tapAsync(
-			"AutomaticPrefetchPlugin",
-			(compilation, callback) => {
-				if (!lastModules) return callback();
-				asyncLib.each(
-					lastModules,
-					(m, callback) => {
-						compilation.addModuleChain(
-							m.context || compiler.context,
-							new PrefetchDependency(`!!${m.request}`),
-							callback
-						);
-					},
-					err => {
-						lastModules = null;
-						callback(err);
-					}
-				);
-			}
-		);
+		compiler.hooks.make.tapAsync(PLUGIN_NAME, (compilation, callback) => {
+			if (!lastModules) return callback();
+			asyncLib.each(
+				lastModules,
+				(m, callback) => {
+					compilation.addModuleChain(
+						m.context || compiler.context,
+						new PrefetchDependency(`!!${m.request}`),
+						callback
+					);
+				},
+				err => {
+					lastModules = null;
+					callback(err);
+				}
+			);
+		});
 	}
 }
 module.exports = AutomaticPrefetchPlugin;

package/lib/BannerPlugin.js

@@ -44,6 +44,8 @@ const wrapComment = str => {
 		.trimEnd()}\n */`;
 };
 
+const PLUGIN_NAME = "BannerPlugin";
+
 class BannerPlugin {
 	/**
 	 * @param {BannerPluginArgument} options options object
@@ -91,47 +93,41 @@ class BannerPlugin {
 		const stage =
 			this.options.stage || Compilation.PROCESS_ASSETS_STAGE_ADDITIONS;
 
-		compiler.hooks.compilation.tap("BannerPlugin", compilation => {
-			compilation.hooks.processAssets.tap(
-				{
-					name: "BannerPlugin",
-					stage
-				},
-				() => {
-					for (const chunk of compilation.chunks) {
-						if (options.entryOnly && !chunk.canBeInitial()) {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+			compilation.hooks.processAssets.tap({ name: PLUGIN_NAME, stage }, () => {
+				for (const chunk of compilation.chunks) {
+					if (options.entryOnly && !chunk.canBeInitial()) {
+						continue;
+					}
+
+					for (const file of chunk.files) {
+						if (!matchObject(file)) {
 							continue;
 						}
 
-						for (const file of chunk.files) {
-							if (!matchObject(file)) {
-								continue;
+						/** @type {PathData} */
+						const data = { chunk, filename: file };
+
+						const comment = compilation.getPath(
+							/** @type {TemplatePath} */
+							(banner),
+							data
+						);
+
+						compilation.updateAsset(file, old => {
+							const cached = cache.get(old);
+							if (!cached || cached.comment !== comment) {
+								const source = options.footer
+									? new ConcatSource(old, "\n", comment)
+									: new ConcatSource(comment, "\n", old);
+								cache.set(old, { source, comment });
+								return source;
 							}
-
-							/** @type {PathData} */
-							const data = { chunk, filename: file };
-
-							const comment = compilation.getPath(
-								/** @type {TemplatePath} */
-								(banner),
-								data
-							);
-
-							compilation.updateAsset(file, old => {
-								const cached = cache.get(old);
-								if (!cached || cached.comment !== comment) {
-									const source = options.footer
-										? new ConcatSource(old, "\n", comment)
-										: new ConcatSource(comment, "\n", old);
-									cache.set(old, { source, comment });
-									return source;
-								}
-								return cached.source;
-							});
-						}
+							return cached.source;
+						});
 					}
 				}
-			);
+			});
 		});
 	}
 }

package/lib/CleanPlugin.js

@@ -296,6 +296,8 @@ const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
 /** @type {WeakMap<Compilation, CleanPluginCompilationHooks>} */
 const compilationHooksMap = new WeakMap();
 
+const PLUGIN_NAME = "CleanPlugin";
+
 class CleanPlugin {
 	/**
 	 * @param {Compilation} compilation the compilation
@@ -349,18 +351,18 @@ class CleanPlugin {
 
 		compiler.hooks.emit.tapAsync(
 			{
-				name: "CleanPlugin",
+				name: PLUGIN_NAME,
 				stage: 100
 			},
 			(compilation, callback) => {
 				const hooks = CleanPlugin.getCompilationHooks(compilation);
-				const logger = compilation.getLogger("webpack.CleanPlugin");
+				const logger = compilation.getLogger(`webpack.${PLUGIN_NAME}`);
 				const fs = /** @type {OutputFileSystem} */ (compiler.outputFileSystem);
 
 				if (!fs.readdir) {
 					return callback(
 						new Error(
-							"CleanPlugin: Output filesystem doesn't support listing directories (readdir)"
+							`${PLUGIN_NAME}: Output filesystem doesn't support listing directories (readdir)`
 						)
 					);
 				}

package/lib/Compilation.js

@@ -973,9 +973,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			/** @type {SyncBailHook<[string, LogEntry], boolean | void>} */
 			log: new SyncBailHook(["origin", "logEntry"]),
 
-			/** @type {SyncWaterfallHook<[WebpackError[]]>} */
+			/** @type {SyncWaterfallHook<[Error[]]>} */
 			processWarnings: new SyncWaterfallHook(["warnings"]),
-			/** @type {SyncWaterfallHook<[WebpackError[]]>} */
+			/** @type {SyncWaterfallHook<[Error[]]>} */
 			processErrors: new SyncWaterfallHook(["errors"]),
 
 			/** @type {HookMap<SyncHook<[Partial<NormalizedStatsOptions>, CreateStatsOptionsContext]>>} */
@@ -1143,9 +1143,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.assetsInfo = new Map();
 		/** @type {Map<string, Map<string, Set<string>>>} */
 		this._assetsRelatedIn = new Map();
-		/** @type {WebpackError[]} */
+		/** @type {Error[]} */
 		this.errors = [];
-		/** @type {WebpackError[]} */
+		/** @type {Error[]} */
 		this.warnings = [];
 		/** @type {Compilation[]} */
 		this.children = [];
@@ -5486,9 +5486,9 @@ This prevents using hashes of each other and should be avoided.`);
 											if (strictModuleExceptionHandling) {
 												if (id) delete moduleCache[id];
 											} else if (strictModuleErrorHandling) {
-												moduleObject.error = /** @type {WebpackError} */ (
-													execErr
-												);
+												moduleObject.error =
+													/** @type {WebpackError} */
+													(execErr);
 											}
 											if (!(/** @type {WebpackError} */ (execErr).module)) {
 												/** @type {WebpackError} */
@@ -5515,7 +5515,8 @@ This prevents using hashes of each other and should be avoided.`);
 										`Execution of module code from module graph (${
 											/** @type {Module} */
 											(module).readableIdentifier(this.requestShortener)
-										}) failed: ${message}`
+										}) failed: ${message}`,
+										{ cause: execErr }
 									);
 									err.stack = stack;
 									err.module = module;

package/lib/Compiler.js

@@ -625,7 +625,8 @@ class Compiler {
 				callback(err, entries, compilation);
 			} catch (runAsChildErr) {
 				const err = new WebpackError(
-					`compiler.runAsChild callback error: ${runAsChildErr}`
+					`compiler.runAsChild callback error: ${runAsChildErr}`,
+					{ cause: runAsChildErr }
 				);
 				err.details = /** @type {Error} */ (runAsChildErr).stack;
 				/** @type {Compilation} */

package/lib/ContextExclusionPlugin.js

@@ -7,6 +7,8 @@
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./ContextModuleFactory")} ContextModuleFactory */
 
+const PLUGIN_NAME = "ContextExclusionPlugin";
+
 class ContextExclusionPlugin {
 	/**
 	 * @param {RegExp} negativeMatcher Matcher regular expression
@@ -21,8 +23,8 @@ class ContextExclusionPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.contextModuleFactory.tap("ContextExclusionPlugin", cmf => {
-			cmf.hooks.contextModuleFiles.tap("ContextExclusionPlugin", files =>
+		compiler.hooks.contextModuleFactory.tap(PLUGIN_NAME, cmf => {
+			cmf.hooks.contextModuleFiles.tap(PLUGIN_NAME, files =>
 				files.filter(filePath => !this.negativeMatcher.test(filePath))
 			);
 		});

package/lib/ContextReplacementPlugin.js

@@ -14,6 +14,8 @@ const { join } = require("./util/fs");
 
 /** @typedef {Record<string, string>} NewContentCreateContextMap */
 
+const PLUGIN_NAME = "ContextReplacementPlugin";
+
 class ContextReplacementPlugin {
 	/**
 	 * @param {RegExp} resourceRegExp A regular expression that determines which files will be selected
@@ -95,8 +97,8 @@ class ContextReplacementPlugin {
 		const newContentRegExp = this.newContentRegExp;
 		const newContentCreateContextMap = this.newContentCreateContextMap;
 
-		compiler.hooks.contextModuleFactory.tap("ContextReplacementPlugin", cmf => {
-			cmf.hooks.beforeResolve.tap("ContextReplacementPlugin", result => {
+		compiler.hooks.contextModuleFactory.tap(PLUGIN_NAME, cmf => {
+			cmf.hooks.beforeResolve.tap(PLUGIN_NAME, result => {
 				if (!result) return;
 				if (resourceRegExp.test(result.request)) {
 					if (newContentResource !== undefined) {
@@ -118,7 +120,7 @@ class ContextReplacementPlugin {
 				}
 				return result;
 			});
-			cmf.hooks.afterResolve.tap("ContextReplacementPlugin", result => {
+			cmf.hooks.afterResolve.tap(PLUGIN_NAME, result => {
 				if (!result) return;
 				if (resourceRegExp.test(result.resource)) {
 					if (newContentResource !== undefined) {

package/lib/DelegatedPlugin.js

@@ -11,6 +11,8 @@ const DelegatedSourceDependency = require("./dependencies/DelegatedSourceDepende
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./DelegatedModuleFactoryPlugin").Options} Options */
 
+const PLUGIN_NAME = "DelegatedPlugin";
+
 class DelegatedPlugin {
 	/**
 	 * @param {Options} options options
@@ -26,7 +28,7 @@ class DelegatedPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"DelegatedPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					DelegatedSourceDependency,
@@ -35,7 +37,7 @@ class DelegatedPlugin {
 			}
 		);
 
-		compiler.hooks.compile.tap("DelegatedPlugin", ({ normalModuleFactory }) => {
+		compiler.hooks.compile.tap(PLUGIN_NAME, ({ normalModuleFactory }) => {
 			new DelegatedModuleFactoryPlugin({
 				associatedObjectForCache: compiler.root,
 				...this.options

package/lib/DllEntryPlugin.js

@@ -13,6 +13,8 @@ const EntryDependency = require("./dependencies/EntryDependency");
 /** @typedef {string[]} Entries */
 /** @typedef {{ name: string, filename: TODO }} Options */
 
+const PLUGIN_NAME = "DllEntryPlugin";
+
 class DllEntryPlugin {
 	/**
 	 * @param {string} context context
@@ -32,7 +34,7 @@ class DllEntryPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"DllEntryPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				const dllModuleFactory = new DllModuleFactory();
 				compilation.dependencyFactories.set(
@@ -45,7 +47,7 @@ class DllEntryPlugin {
 				);
 			}
 		);
-		compiler.hooks.make.tapAsync("DllEntryPlugin", (compilation, callback) => {
+		compiler.hooks.make.tapAsync(PLUGIN_NAME, (compilation, callback) => {
 			compilation.addEntry(
 				this.context,
 				new DllEntryDependency(

package/lib/DllPlugin.js

@@ -24,6 +24,8 @@ const validate = createSchemaValidation(
 	}
 );
 
+const PLUGIN_NAME = "DllPlugin";
+
 class DllPlugin {
 	/**
 	 * @param {DllPluginOptions} options options object
@@ -42,7 +44,7 @@ class DllPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.entryOption.tap("DllPlugin", (context, entry) => {
+		compiler.hooks.entryOption.tap(PLUGIN_NAME, (context, entry) => {
 			if (typeof entry !== "function") {
 				for (const name of Object.keys(entry)) {
 					/** @type {Options} */
@@ -55,14 +57,14 @@ class DllPlugin {
 				}
 			} else {
 				throw new Error(
-					"DllPlugin doesn't support dynamic entry (function) yet"
+					`${PLUGIN_NAME} doesn't support dynamic entry (function) yet`
 				);
 			}
 			return true;
 		});
 		new LibManifestPlugin(this.options).apply(compiler);
 		if (!this.options.entryOnly) {
-			new FlagAllModulesAsUsedPlugin("DllPlugin").apply(compiler);
+			new FlagAllModulesAsUsedPlugin(PLUGIN_NAME).apply(compiler);
 		}
 	}
 }

package/lib/DllReferencePlugin.js

@@ -32,6 +32,8 @@ const validate = createSchemaValidation(
 
 /** @typedef {{ path: string, data: DllReferencePluginOptionsManifest | undefined, error: Error | undefined }} CompilationDataItem */
 
+const PLUGIN_NAME = "DllReferencePlugin";
+
 class DllReferencePlugin {
 	/**
 	 * @param {DllReferencePluginOptions} options options object
@@ -50,7 +52,7 @@ class DllReferencePlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"DllReferencePlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					DelegatedSourceDependency,
@@ -59,51 +61,48 @@ class DllReferencePlugin {
 			}
 		);
 
-		compiler.hooks.beforeCompile.tapAsync(
-			"DllReferencePlugin",
-			(params, callback) => {
-				if ("manifest" in this.options) {
-					const manifest = this.options.manifest;
-					if (typeof manifest === "string") {
-						/** @type {InputFileSystem} */
-						(compiler.inputFileSystem).readFile(manifest, (err, result) => {
-							if (err) return callback(err);
-							/** @type {CompilationDataItem} */
-							const data = {
-								path: manifest,
-								data: undefined,
-								error: undefined
-							};
-							// Catch errors parsing the manifest so that blank
-							// or malformed manifest files don't kill the process.
-							try {
-								data.data = parseJson(
-									/** @type {Buffer} */ (result).toString("utf-8")
-								);
-							} catch (parseErr) {
-								// Store the error in the params so that it can
-								// be added as a compilation error later on.
-								const manifestPath = makePathsRelative(
-									/** @type {string} */ (compiler.options.context),
-									manifest,
-									compiler.root
-								);
-								data.error = new DllManifestError(
-									manifestPath,
-									/** @type {Error} */ (parseErr).message
-								);
-							}
-							this._compilationData.set(params, data);
-							return callback();
-						});
-						return;
-					}
+		compiler.hooks.beforeCompile.tapAsync(PLUGIN_NAME, (params, callback) => {
+			if ("manifest" in this.options) {
+				const manifest = this.options.manifest;
+				if (typeof manifest === "string") {
+					/** @type {InputFileSystem} */
+					(compiler.inputFileSystem).readFile(manifest, (err, result) => {
+						if (err) return callback(err);
+						/** @type {CompilationDataItem} */
+						const data = {
+							path: manifest,
+							data: undefined,
+							error: undefined
+						};
+						// Catch errors parsing the manifest so that blank
+						// or malformed manifest files don't kill the process.
+						try {
+							data.data = parseJson(
+								/** @type {Buffer} */ (result).toString("utf-8")
+							);
+						} catch (parseErr) {
+							// Store the error in the params so that it can
+							// be added as a compilation error later on.
+							const manifestPath = makePathsRelative(
+								/** @type {string} */ (compiler.options.context),
+								manifest,
+								compiler.root
+							);
+							data.error = new DllManifestError(
+								manifestPath,
+								/** @type {Error} */ (parseErr).message
+							);
+						}
+						this._compilationData.set(params, data);
+						return callback();
+					});
+					return;
 				}
-				return callback();
 			}
-		);
+			return callback();
+		});
 
-		compiler.hooks.compile.tap("DllReferencePlugin", params => {
+		compiler.hooks.compile.tap(PLUGIN_NAME, params => {
 			let name = this.options.name;
 			let sourceType = this.options.sourceType;
 			let resolvedContent =
@@ -154,27 +153,24 @@ class DllReferencePlugin {
 			}).apply(normalModuleFactory);
 		});
 
-		compiler.hooks.compilation.tap(
-			"DllReferencePlugin",
-			(compilation, params) => {
-				if ("manifest" in this.options) {
-					const manifest = this.options.manifest;
-					if (typeof manifest === "string") {
-						const data = /** @type {CompilationDataItem} */ (
-							this._compilationData.get(params)
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation, params) => {
+			if ("manifest" in this.options) {
+				const manifest = this.options.manifest;
+				if (typeof manifest === "string") {
+					const data = /** @type {CompilationDataItem} */ (
+						this._compilationData.get(params)
+					);
+					// If there was an error parsing the manifest file, add the
+					// error as a compilation error to make the compilation fail.
+					if (data.error) {
+						compilation.errors.push(
+							/** @type {DllManifestError} */ (data.error)
 						);
-						// If there was an error parsing the manifest file, add the
-						// error as a compilation error to make the compilation fail.
-						if (data.error) {
-							compilation.errors.push(
-								/** @type {DllManifestError} */ (data.error)
-							);
-						}
-						compilation.fileDependencies.add(manifest);
 					}
+					compilation.fileDependencies.add(manifest);
 				}
 			}
-		);
+		});
 	}
 }
 

package/lib/DynamicEntryPlugin.js

@@ -15,6 +15,8 @@ const EntryDependency = require("./dependencies/EntryDependency");
 /** @typedef {import("../declarations/WebpackOptions").EntryStaticNormalized} EntryStatic */
 /** @typedef {import("./Compiler")} Compiler */
 
+const PLUGIN_NAME = "DynamicEntryPlugin";
+
 class DynamicEntryPlugin {
 	/**
 	 * @param {string} context the context path
@@ -32,7 +34,7 @@ class DynamicEntryPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"DynamicEntryPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					EntryDependency,
@@ -41,7 +43,7 @@ class DynamicEntryPlugin {
 			}
 		);
 
-		compiler.hooks.make.tapPromise("DynamicEntryPlugin", compilation =>
+		compiler.hooks.make.tapPromise(PLUGIN_NAME, compilation =>
 			Promise.resolve(this.entry())
 				.then(entry => {
 					const promises = [];

package/lib/EntryOptionPlugin.js

@@ -10,13 +10,15 @@
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
 
+const PLUGIN_NAME = "EntryOptionPlugin";
+
 class EntryOptionPlugin {
 	/**
 	 * @param {Compiler} compiler the compiler instance one is tapping into
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.entryOption.tap("EntryOptionPlugin", (context, entry) => {
+		compiler.hooks.entryOption.tap(PLUGIN_NAME, (context, entry) => {
 			EntryOptionPlugin.applyEntryOption(compiler, context, entry);
 			return true;
 		});

package/lib/EntryPlugin.js

@@ -10,6 +10,8 @@ const EntryDependency = require("./dependencies/EntryDependency");
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
 
+const PLUGIN_NAME = "EntryPlugin";
+
 class EntryPlugin {
 	/**
 	 * An entry plugin which will handle creation of the EntryDependency
@@ -30,7 +32,7 @@ class EntryPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"EntryPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					EntryDependency,
@@ -42,7 +44,7 @@ class EntryPlugin {
 		const { entry, options, context } = this;
 		const dep = EntryPlugin.createDependency(entry, options);
 
-		compiler.hooks.make.tapAsync("EntryPlugin", (compilation, callback) => {
+		compiler.hooks.make.tapAsync(PLUGIN_NAME, (compilation, callback) => {
 			compilation.addEntry(context, dep, options, err => {
 				callback(err);
 			});

package/lib/EnvironmentPlugin.js

@@ -11,6 +11,8 @@ const WebpackError = require("./WebpackError");
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./DefinePlugin").CodeValue} CodeValue */
 
+const PLUGIN_NAME = "EnvironmentPlugin";
+
 class EnvironmentPlugin {
 	/**
 	 * @param {(string | string[] | Record<string, EXPECTED_ANY>)[]} keys keys
@@ -46,9 +48,9 @@ class EnvironmentPlugin {
 					: this.defaultValues[key];
 
 			if (value === undefined) {
-				compiler.hooks.thisCompilation.tap("EnvironmentPlugin", compilation => {
+				compiler.hooks.thisCompilation.tap(PLUGIN_NAME, compilation => {
 					const error = new WebpackError(
-						`EnvironmentPlugin - ${key} environment variable is undefined.\n\n` +
+						`${PLUGIN_NAME} - ${key} environment variable is undefined.\n\n` +
 							"You can pass an object with default values to suppress this warning.\n" +
 							"See https://webpack.js.org/plugins/environment-plugin for example."
 					);