webpack 5.110.2 → 5.111.0

package/lib/performance/DuplicateModulesPlugin.js

@@ -8,18 +8,17 @@
 const DuplicateModulesWarning = require("../errors/DuplicateModulesWarning");
 const { compareStrings } = require("../util/comparators");
 const getModuleSize = require("./getModuleSize");
+const getSourceModules = require("./getSourceModules");
 
 /** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Chunk from "../Chunk" */
 /** @import Compiler from "../Compiler" */
-/**
- * @import {
- * 	DuplicateModuleDetails
- * } from "../errors/DuplicateModulesWarning"
- */
+/** @import Module from "../Module" */
+/** @import { DuplicateModuleDetails } from "../errors/DuplicateModulesWarning" */
 
 const PLUGIN_NAME = "DuplicateModulesPlugin";
 
-// Enough to name the offenders without printing the module graph.
+// Enough to name the costliest without listing every shared module.
 const MAX_REPORTED_MODULES = 5;
 
 class DuplicateModulesPlugin {
@@ -44,24 +43,69 @@ class DuplicateModulesPlugin {
 
 		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			compilation.hooks.afterSeal.tap(PLUGIN_NAME, () => {
-				const { chunkGraph, requestShortener } = compilation;
+				const { chunkGraph, entrypoints, requestShortener } = compilation;
+
+				// The entrypoints a chunk is reached from, so a copy can be blamed on
+				// the pages that pay for it.
+				/** @type {Map<Chunk, Set<string>>} */
+				const chunkEntrypoints = new Map();
+
+				for (const [name, entrypoint] of entrypoints) {
+					for (const chunk of entrypoint.chunks) {
+						const names = chunkEntrypoints.get(chunk);
+
+						if (names === undefined) {
+							chunkEntrypoints.set(chunk, new Set([name]));
+						} else {
+							names.add(name);
+						}
+					}
+				}
+
+				/** @type {Map<Module, { chunks: Set<Chunk>, entrypoints: Set<string> }>} */
+				const copies = new Map();
+
+				for (const chunk of compilation.chunks) {
+					const names = chunkEntrypoints.get(chunk);
+
+					for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+						// Scope hoisting makes several modules into one, so a module
+						// concatenated into two chunks is in neither on its own.
+						for (const inner of getSourceModules(module)) {
+							let entry = copies.get(inner);
+
+							if (entry === undefined) {
+								copies.set(
+									inner,
+									(entry = { chunks: new Set(), entrypoints: new Set() })
+								);
+							}
+
+							entry.chunks.add(chunk);
+
+							if (names !== undefined) {
+								for (const name of names) entry.entrypoints.add(name);
+							}
+						}
+					}
+				}
+
 				/** @type {DuplicateModuleDetails[]} */
 				const duplicated = [];
 				let wasted = 0;
 
-				for (const module of compilation.modules) {
-					const chunks = chunkGraph.getNumberOfModuleChunks(module);
-
-					if (chunks < 2) continue;
+				for (const [module, { chunks, entrypoints: names }] of copies) {
+					if (chunks.size < 2) continue;
 
 					// The first copy is the one that had to be emitted; the rest are
 					// what a shared chunk would save.
-					const extra = getModuleSize(module) * (chunks - 1);
+					const extra = getModuleSize(module) * (chunks.size - 1);
 
 					wasted += extra;
 					duplicated.push({
 						name: module.readableIdentifier(requestShortener),
-						chunks,
+						chunks: chunks.size,
+						entrypoints: [...names].sort(compareStrings),
 						wasted: extra
 					});
 				}

package/lib/performance/EvalUsagePlugin.js

@@ -11,6 +11,7 @@ const {
 	JAVASCRIPT_MODULE_TYPE_ESM
 } = require("../ModuleTypeConstants");
 const EvalUsageWarning = require("../errors/EvalUsageWarning");
+const { getBuildDiagnostics } = require("../util/buildDiagnostics");
 const { compareStrings } = require("../util/comparators");
 
 /** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
@@ -59,7 +60,7 @@ class EvalUsagePlugin {
 							parser.state.module.buildInfo
 						);
 
-						buildInfo.usesEval = true;
+						getBuildDiagnostics(buildInfo).usesEval = true;
 					});
 				};
 
@@ -84,7 +85,9 @@ class EvalUsagePlugin {
 						// Every built module carries one, so only the field is in question.
 						const buildInfo = /** @type {BuildInfo} */ (module.buildInfo);
 
-						if (!buildInfo.usesEval) continue;
+						if (!buildInfo.diagnostics || !buildInfo.diagnostics.usesEval) {
+							continue;
+						}
 
 						callers.push(module.readableIdentifier(requestShortener));
 					}

package/lib/performance/MissingSourceMapsPlugin.js

@@ -0,0 +1,115 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const { SourceMapSource } = require("webpack-sources");
+const NormalModule = require("../NormalModule");
+const MissingSourceMapsWarning = require("../errors/MissingSourceMapsWarning");
+const { compareStrings } = require("../util/comparators");
+const getSourceModules = require("./getSourceModules");
+
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/** @import Module from "../Module" */
+/** @import RequestShortener from "../RequestShortener" */
+/** @import { MissingSourceMapDetails } from "../errors/MissingSourceMapsWarning" */
+
+const PLUGIN_NAME = "MissingSourceMapsPlugin";
+
+// Enough to name the offenders without listing every module a loader touched.
+const MAX_REPORTED_MODULES = 5;
+
+/**
+ * The loaders that ran on a module, shortened for reading.
+ * @param {NormalModule} module the module
+ * @param {RequestShortener} requestShortener the request shortener
+ * @returns {string[]} what to call them
+ */
+const loaderNames = (module, requestShortener) =>
+	module.loaders.map((it) => requestShortener.shorten(it.loader) || it.loader);
+
+class MissingSourceMapsPlugin {
+	/**
+	 * Creates an instance of MissingSourceMapsPlugin.
+	 * @param {PerformanceOptions} options the plugin options
+	 */
+	constructor(options) {
+		/** @type {PerformanceOptions["hints"]} */
+		this.hints = options.hints;
+	}
+
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const hints = this.hints;
+
+		if (!hints) return;
+
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			// `afterSeal` is past the hash, which folds every message into it — a
+			// hint reported earlier would change the build's identity.
+			compilation.hooks.afterSeal.tap(PLUGIN_NAME, () => {
+				const { requestShortener } = compilation;
+				/** @type {MissingSourceMapDetails[]} */
+				const found = [];
+
+				// A module can be reached both on its own and inside a
+				// concatenation, so it is only counted the first time.
+				/** @type {Set<Module>} */
+				const seen = new Set();
+
+				for (const parent of compilation.modules) {
+					// Scope hoisting makes several modules into one, and each of them
+					// kept the source its own loaders produced.
+					for (const module of getSourceModules(parent)) {
+						if (seen.has(module)) continue;
+
+						seen.add(module);
+
+						if (!(module instanceof NormalModule)) continue;
+
+						// Only where a real map was asked for: the cheap devtools map to
+						// the loader output by design, so nothing is lost there.
+						if (!module.useSourceMap) continue;
+						if (module.loaders.length === 0) continue;
+
+						// A loader that returned a map produces a `SourceMapSource`;
+						// falling back to any other source is the map being dropped.
+						if (module.originalSource() instanceof SourceMapSource) continue;
+
+						found.push({
+							name: module.readableIdentifier(requestShortener),
+							loaders: loaderNames(module, requestShortener)
+						});
+					}
+				}
+
+				if (found.length === 0) return;
+
+				// By name: module order is not stable across runs.
+				found.sort((a, b) => compareStrings(a.name, b.name));
+
+				const warning = new MissingSourceMapsWarning(
+					found.slice(0, MAX_REPORTED_MODULES),
+					found.length
+				);
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = MissingSourceMapsPlugin;

package/lib/performance/PureAnnotationsPlugin.js

@@ -11,6 +11,7 @@ const {
 	JAVASCRIPT_MODULE_TYPE_ESM
 } = require("../ModuleTypeConstants");
 const PureAnnotationsWarning = require("../errors/PureAnnotationsWarning");
+const { getBuildDiagnostics } = require("../util/buildDiagnostics");
 const { compareStrings } = require("../util/comparators");
 const { CompilerHintNotationRegExp } = require("../util/magicComment");
 
@@ -154,7 +155,7 @@ class PureAnnotationsPlugin {
 							parser.state.module.buildInfo
 						);
 
-						buildInfo.ineffectivePureAnnotations = wasted;
+						getBuildDiagnostics(buildInfo).ineffectivePureAnnotations = wasted;
 					});
 				};
 
@@ -180,9 +181,11 @@ class PureAnnotationsPlugin {
 						// Every built module carries one, so only the field is in question.
 						const buildInfo = /** @type {BuildInfo} */ (module.buildInfo);
 
-						if (!buildInfo.ineffectivePureAnnotations) continue;
+						const count =
+							buildInfo.diagnostics &&
+							buildInfo.diagnostics.ineffectivePureAnnotations;
 
-						const count = buildInfo.ineffectivePureAnnotations;
+						if (!count) continue;
 
 						total += count;
 						wasteful.push({

package/lib/performance/TopLevelThisPlugin.js

@@ -11,14 +11,14 @@ const {
 	JAVASCRIPT_MODULE_TYPE_ESM
 } = require("../ModuleTypeConstants");
 const TopLevelThisWarning = require("../errors/TopLevelThisWarning");
+const { getBuildDiagnostics } = require("../util/buildDiagnostics");
 const { compareStrings } = require("../util/comparators");
 const getSourceModules = require("./getSourceModules");
 
 /** @import { Program } from "estree" */
 /** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
 /** @import Compiler from "../Compiler" */
-/** @import Module from "../Module" */
-/** @import { BuildInfo } from "../Module" */
+/** @import Module, { BuildInfo } from "../Module" */
 /** @import JavascriptParser from "../javascript/JavascriptParser" */
 /** @import { TopLevelThisDetails } from "../errors/TopLevelThisWarning" */
 
@@ -133,7 +133,7 @@ class TopLevelThisPlugin {
 							/** @type {BuildInfo} */
 							(parser.state.module.buildInfo);
 
-						buildInfo.topLevelThis = count;
+						getBuildDiagnostics(buildInfo).topLevelThis = count;
 					});
 				};
 
@@ -168,7 +168,8 @@ class TopLevelThisPlugin {
 							seen.add(module);
 
 							const buildInfo = /** @type {BuildInfo} */ (module.buildInfo);
-							const count = buildInfo.topLevelThis;
+							const count =
+								buildInfo.diagnostics && buildInfo.diagnostics.topLevelThis;
 
 							if (!count) continue;
 

package/lib/performance/UnusedAssetsPlugin.js

@@ -0,0 +1,109 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const { ASSET_TYPE } = require("../ModuleSourceTypeConstants");
+const HarmonyImportBareSideEffectDependency = require("../dependencies/HarmonyImportBareSideEffectDependency");
+const HarmonyImportSideEffectDependency = require("../dependencies/HarmonyImportSideEffectDependency");
+const UnusedAssetsWarning = require("../errors/UnusedAssetsWarning");
+const { compareStrings } = require("../util/comparators");
+const getModuleSize = require("./getModuleSize");
+
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/** @import { UnusedAssetDetails } from "../errors/UnusedAssetsWarning" */
+
+const PLUGIN_NAME = "UnusedAssetsPlugin";
+
+// Enough to name the offenders without listing every asset in the build.
+const MAX_REPORTED_ASSETS = 5;
+
+class UnusedAssetsPlugin {
+	/**
+	 * Creates an instance of UnusedAssetsPlugin.
+	 * @param {PerformanceOptions} options the plugin options
+	 */
+	constructor(options) {
+		/** @type {PerformanceOptions["hints"]} */
+		this.hints = options.hints;
+	}
+
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const hints = this.hints;
+
+		if (!hints) return;
+
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			// `afterSeal` is past the hash, which folds every message into it — a
+			// hint reported earlier would change the build's identity.
+			compilation.hooks.afterSeal.tap(PLUGIN_NAME, () => {
+				const { moduleGraph, requestShortener } = compilation;
+				/** @type {UnusedAssetDetails[]} */
+				const found = [];
+				let total = 0;
+
+				for (const module of compilation.modules) {
+					// An inlined one carries no asset type: it is a data url in the
+					// importer, whose bytes `inlinedAssets` is the check for.
+					if (!module.getSourceTypes().has(ASSET_TYPE)) continue;
+
+					let onlyUnread = false;
+
+					for (const connection of moduleGraph.getIncomingConnections(module)) {
+						const dependency = connection.dependency;
+
+						// Anything else — a `url()`, a `new URL()`, an html `src` — reads
+						// the file, and a bare import asks for it on purpose.
+						if (
+							!(dependency instanceof HarmonyImportSideEffectDependency) ||
+							dependency instanceof HarmonyImportBareSideEffectDependency
+						) {
+							onlyUnread = false;
+							break;
+						}
+
+						onlyUnread = true;
+					}
+
+					if (!onlyUnread) continue;
+
+					const size = Math.round(getModuleSize(module));
+
+					total += size;
+					found.push({
+						name: module.readableIdentifier(requestShortener),
+						size
+					});
+				}
+
+				if (found.length === 0) return;
+
+				// Largest first; ties break by name, module order is not stable.
+				found.sort((a, b) => b.size - a.size || compareStrings(a.name, b.name));
+
+				const warning = new UnusedAssetsWarning(
+					found.slice(0, MAX_REPORTED_ASSETS),
+					total
+				);
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = UnusedAssetsPlugin;

package/lib/performance/UnusedFederationPlugin.js

@@ -0,0 +1,147 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const RemoteModule = require("../container/RemoteModule");
+const { getDeclaredRemotes } = require("../container/declaredRemotes");
+const UnusedFederationWarning = require("../errors/UnusedFederationWarning");
+const ConsumeSharedModule = require("../sharing/ConsumeSharedModule");
+const { getDeclaredShared } = require("../sharing/declaredShared");
+const { compareStrings } = require("../util/comparators");
+
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/** @import { UnusedFederationDetails } from "../errors/UnusedFederationWarning" */
+
+const PLUGIN_NAME = "UnusedFederationPlugin";
+
+/**
+ * @param {Set<string>} used the share keys modules were created for
+ * @param {string} shareKey the declared share key
+ * @returns {boolean} whether anything under the share key was used
+ */
+const someUsedStartsWith = (used, shareKey) => {
+	for (const usedKey of used) {
+		if (usedKey.startsWith(shareKey)) return true;
+	}
+
+	return false;
+};
+
+/**
+ * Applies the rule `ContainerReferencePlugin` factorizes by, so that a remote
+ * name holding slashes is told apart from an exposed path holding them too.
+ * @param {string} request the request a remote module was created for
+ * @param {string} name the declared remote name
+ * @returns {boolean} whether the request names this remote
+ */
+const isRequestFor = (request, name) =>
+	request.startsWith(name) &&
+	(request.length === name.length || request[name.length] === "/");
+
+class UnusedFederationPlugin {
+	/**
+	 * Creates an instance of UnusedFederationPlugin.
+	 * @param {PerformanceOptions} options the plugin options
+	 */
+	constructor(options) {
+		/** @type {PerformanceOptions["hints"]} */
+		this.hints = options.hints;
+	}
+
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const hints = this.hints;
+
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			// Reported past the hash, which folds every message into it, so a hint
+			// pushed earlier would change the build's identity.
+			compilation.hooks.afterSeal.tap(PLUGIN_NAME, () => {
+				const declaredShared = getDeclaredShared(compilation);
+				const declaredRemotes = getDeclaredRemotes(compilation);
+
+				if (declaredShared === undefined && declaredRemotes === undefined) {
+					return;
+				}
+
+				// Nothing was factorized, so no shared or remote module could exist.
+				if (compilation.modules.size === 0) return;
+
+				/** @type {Set<string>} */
+				const usedShared = new Set();
+				/** @type {Set<string>} */
+				const remoteRequests = new Set();
+
+				for (const module of compilation.modules) {
+					if (module instanceof ConsumeSharedModule) {
+						usedShared.add(module.options.shareKey);
+					} else if (module instanceof RemoteModule) {
+						remoteRequests.add(module.request);
+					}
+				}
+
+				/** @type {UnusedFederationDetails[]} */
+				const unused = [];
+
+				if (declaredShared !== undefined) {
+					// Matched on the share key, since that is what the module carries,
+					// but reported by the config key, which is what the config spells.
+					for (const { name, shareKey, prefix } of declaredShared) {
+						const used = prefix
+							? someUsedStartsWith(usedShared, shareKey)
+							: usedShared.has(shareKey);
+
+						if (!used) unused.push({ name, kind: "shared" });
+					}
+				}
+
+				if (declaredRemotes !== undefined) {
+					/** @type {Set<string>} */
+					const usedRemotes = new Set();
+
+					// Declaration order is precedence: `factorize` takes the first
+					// name a request matches, so a later one it also matches is dead.
+					for (const request of remoteRequests) {
+						for (const name of declaredRemotes) {
+							if (isRequestFor(request, name)) {
+								usedRemotes.add(name);
+								break;
+							}
+						}
+					}
+
+					for (const name of declaredRemotes) {
+						if (!usedRemotes.has(name)) unused.push({ name, kind: "remote" });
+					}
+				}
+
+				if (unused.length === 0) return;
+
+				// Ties break by name: declaration order is not worth preserving here.
+				unused.sort(
+					(a, b) =>
+						compareStrings(a.kind, b.kind) || compareStrings(a.name, b.name)
+				);
+
+				const warning = new UnusedFederationWarning(unused);
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = UnusedFederationPlugin;