webpack 5.110.2 → 5.111.0

package/lib/performance/UnusedModulesPlugin.js

@@ -0,0 +1,141 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const HarmonyImportBareSideEffectDependency = require("../dependencies/HarmonyImportBareSideEffectDependency");
+const UnusedModulesWarning = require("../errors/UnusedModulesWarning");
+const { compareStrings } = require("../util/comparators");
+const getModuleSize = require("./getModuleSize");
+const hasOnlyUnusedExports = require("./hasOnlyUnusedExports");
+const isOnlyReexported = require("./isOnlyReexported");
+
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/** @import Module, { BuildInfo } from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import { UnusedModuleDetails } from "../errors/UnusedModulesWarning" */
+
+const PLUGIN_NAME = "UnusedModulesPlugin";
+
+// Enough to name the offenders without listing every module kept this way.
+const MAX_REPORTED_MODULES = 5;
+
+/**
+ * Whether some importer bound a name from this module. A bare `import "..."`
+ * binds nothing, so it can only have been written for what importing does —
+ * that is deliberate, and not what this hint is about.
+ * @param {Module} module the module to look up
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @returns {boolean} true when every importer bound something
+ */
+const everyImportBinds = (module, moduleGraph) => {
+	for (const connection of moduleGraph.getIncomingConnections(module)) {
+		if (
+			connection.dependency instanceof HarmonyImportBareSideEffectDependency
+		) {
+			return false;
+		}
+	}
+
+	return true;
+};
+
+class UnusedModulesPlugin {
+	/**
+	 * Creates an instance of UnusedModulesPlugin.
+	 * @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) => {
+			/** @type {UnusedModulesWarning | undefined} */
+			let warning;
+
+			// Usage is final here, and concatenation has not merged the modules
+			// away yet, so each one can still be measured and attributed.
+			compilation.hooks.optimizeModules.tap(PLUGIN_NAME, (modules) => {
+				const { chunkGraph, moduleGraph, requestShortener } = compilation;
+				/** @type {UnusedModuleDetails[]} */
+				const found = [];
+				let size = 0;
+
+				for (const module of modules) {
+					// One webpack already left out costs nothing — and with no chunk it
+					// has no runtime, which is all `hasOnlyUnusedExports` reads usage in.
+					if (chunkGraph.getNumberOfModuleChunks(module) === 0) continue;
+					if (!hasOnlyUnusedExports(module, moduleGraph, chunkGraph)) continue;
+
+					// A barrel's leftover is the same finding with a different cause,
+					// and `UnusedReexportsPlugin` states it with the re-export named.
+					if (isOnlyReexported(module, moduleGraph)) continue;
+
+					if (!everyImportBinds(module, moduleGraph)) continue;
+
+					// Recorded while parsing, so a module restored from the cache still has it.
+					// Absent means the module is kept for a reason this hint cannot name.
+					const diagnostics =
+						/** @type {BuildInfo} */
+						(module.buildInfo).diagnostics;
+					const statement =
+						diagnostics === undefined
+							? undefined
+							: diagnostics.sideEffectStatement;
+
+					if (statement === undefined) continue;
+
+					const bytes = Math.round(getModuleSize(module));
+
+					size += bytes;
+					found.push({
+						name: module.readableIdentifier(requestShortener),
+						size: bytes,
+						statement
+					});
+				}
+
+				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));
+
+				warning = new UnusedModulesWarning(
+					found.slice(0, MAX_REPORTED_MODULES),
+					found.length,
+					size
+				);
+			});
+
+			// Reported past the hash: `createHash` folds every message into it, so
+			// a hint pushed earlier would change the build's identity.
+			compilation.hooks.afterSeal.tap(PLUGIN_NAME, () => {
+				if (warning === undefined) return;
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = UnusedModulesPlugin;

package/lib/performance/UnusedReexportsPlugin.js

@@ -5,17 +5,14 @@
 
 "use strict";
 
-const HarmonyExportImportedSpecifierDependency = require("../dependencies/HarmonyExportImportedSpecifierDependency");
-const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
 const UnusedReexportsWarning = require("../errors/UnusedReexportsWarning");
 const { compareStrings } = require("../util/comparators");
 const getModuleSize = require("./getModuleSize");
 const hasOnlyUnusedExports = require("./hasOnlyUnusedExports");
+const isOnlyReexported = require("./isOnlyReexported");
 
 /** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
 /** @import Compiler from "../Compiler" */
-/** @import Module from "../Module" */
-/** @import ModuleGraph from "../ModuleGraph" */
 /** @import { UnusedReexportDetails } from "../errors/UnusedReexportsWarning" */
 
 const PLUGIN_NAME = "UnusedReexportsPlugin";
@@ -23,57 +20,6 @@ const PLUGIN_NAME = "UnusedReexportsPlugin";
 // Enough to name the offenders without listing the barrel.
 const MAX_REPORTED_MODULES = 5;
 
-/**
- * Tells whether every module pulling this one in does so by re-exporting it.
- * One an importer wants for its side effects alone is deliberate, not a
- * barrel's leftover.
- * @param {Module} module the module to look up
- * @param {ModuleGraph} moduleGraph the module graph
- * @returns {boolean} true when only re-exports pull it in
- */
-const isOnlyReexported = (module, moduleGraph) => {
-	// A re-export emits a side-effect edge of its own, so edges are grouped by
-	// the statement they come from — `sourceOrder` — rather than by their type.
-	/** @type {Map<Module, Set<number | undefined>>} */
-	const reexportedStatements = new Map();
-	/** @type {[Module, number | undefined][]} */
-	const edges = [];
-
-	for (const connection of moduleGraph.getIncomingConnections(module)) {
-		const origin = connection.originModule;
-
-		// An entry has no origin: it is in the build because it was asked for.
-		if (!origin) return false;
-
-		const dependency = connection.dependency;
-
-		// Only an ESM import statement can carry a re-export.
-		if (!(dependency instanceof HarmonyImportDependency)) return false;
-
-		if (dependency instanceof HarmonyExportImportedSpecifierDependency) {
-			const statements = reexportedStatements.get(origin);
-
-			if (statements === undefined) {
-				reexportedStatements.set(origin, new Set([dependency.sourceOrder]));
-			} else {
-				statements.add(dependency.sourceOrder);
-			}
-		}
-
-		edges.push([origin, dependency.sourceOrder]);
-	}
-
-	if (edges.length === 0) return false;
-
-	for (const [origin, sourceOrder] of edges) {
-		const statements = reexportedStatements.get(origin);
-
-		if (statements === undefined || !statements.has(sourceOrder)) return false;
-	}
-
-	return true;
-};
-
 class UnusedReexportsPlugin {
 	/**
 	 * Creates an instance of UnusedReexportsPlugin.

package/lib/performance/isOnlyReexported.js

@@ -0,0 +1,65 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const HarmonyExportImportedSpecifierDependency = require("../dependencies/HarmonyExportImportedSpecifierDependency");
+const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
+
+/** @import Module from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+
+/**
+ * Tells whether every module pulling this one in does so by re-exporting it.
+ * One an importer wants for its side effects alone is deliberate, not a
+ * barrel's leftover.
+ * @param {Module} module the module to look up
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @returns {boolean} true when only re-exports pull it in
+ */
+const isOnlyReexported = (module, moduleGraph) => {
+	// A re-export emits a side-effect edge of its own, so edges are grouped by
+	// the statement they come from — `sourceOrder` — rather than by their type.
+	/** @type {Map<Module, Set<number | undefined>>} */
+	const reexportedStatements = new Map();
+	/** @type {[Module, number | undefined][]} */
+	const edges = [];
+
+	for (const connection of moduleGraph.getIncomingConnections(module)) {
+		const origin = connection.originModule;
+
+		// An entry has no origin: it is in the build because it was asked for.
+		if (!origin) return false;
+
+		const dependency = connection.dependency;
+
+		// Only an ESM import statement can carry a re-export.
+		if (!(dependency instanceof HarmonyImportDependency)) return false;
+
+		if (dependency instanceof HarmonyExportImportedSpecifierDependency) {
+			const statements = reexportedStatements.get(origin);
+
+			if (statements === undefined) {
+				reexportedStatements.set(origin, new Set([dependency.sourceOrder]));
+			} else {
+				statements.add(dependency.sourceOrder);
+			}
+		}
+
+		edges.push([origin, dependency.sourceOrder]);
+	}
+
+	if (edges.length === 0) return false;
+
+	for (const [origin, sourceOrder] of edges) {
+		const statements = reexportedStatements.get(origin);
+
+		if (statements === undefined || !statements.has(sourceOrder)) return false;
+	}
+
+	return true;
+};
+
+module.exports = isOnlyReexported;

package/lib/prefetch/ChunkPrefetchFunctionRuntimeModule.js

@@ -6,6 +6,8 @@
 
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
+const { getOnlyHandlerKey } = require("../util/handlerKeys");
+const { propertyAccess } = require("../util/property");
 
 /** @import Compilation from "../Compilation" */
 
@@ -33,6 +35,17 @@ class ChunkPrefetchFunctionRuntimeModule extends RuntimeModule {
 		this.runtimeHandlers = runtimeHandlers;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		// Reads a map rather than installing onto one, so reading its code back would
+		// render it in a cycle.
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
@@ -41,17 +54,24 @@ class ChunkPrefetchFunctionRuntimeModule extends RuntimeModule {
 		const { runtimeFunction, runtimeHandlers } = this;
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const { runtimeTemplate } = compilation;
+		const only =
+			runtimeFunction === null
+				? null
+				: getOnlyHandlerKey(this, runtimeHandlers);
 		return Template.asString([
 			`${runtimeHandlers} = {};`,
 			...(runtimeFunction === null
 				? []
 				: [
 						`${runtimeFunction} = ${runtimeTemplate.basicFunction("chunkId", [
-							// map is shorter than forEach
-							`Object.keys(${runtimeHandlers}).map(${runtimeTemplate.basicFunction(
-								"key",
-								`${runtimeHandlers}[key](chunkId);`
-							)});`
+							// One handler needs no walk over the others, and most chunks carry one.
+							only === null
+								? // map is shorter than forEach
+									`Object.keys(${runtimeHandlers}).map(${runtimeTemplate.basicFunction(
+										"key",
+										`${runtimeHandlers}[key](chunkId);`
+									)});`
+								: `${runtimeHandlers}${propertyAccess([only])}(chunkId);`
 						])};`
 					])
 		]);

package/lib/prefetch/ChunkPrefetchPreloadPlugin.js

@@ -50,6 +50,8 @@ class ChunkPrefetchPreloadPlugin {
 					if (startupChildChunks) {
 						set.add(RuntimeGlobals.prefetchChunk);
 						set.add(RuntimeGlobals.onChunksLoaded);
+						// This is the one startup callback that is queued behind a priority.
+						set.add(RuntimeGlobals.hasChunkPriority);
 						set.add(RuntimeGlobals.exports);
 						compilation.addLazyRuntimeModule(
 							chunk,

package/lib/prefetch/ChunkPrefetchStartupRuntimeModule.js

@@ -21,6 +21,15 @@ class ChunkPrefetchStartupRuntimeModule extends RuntimeModule {
 		this.startupChunks = startupChunks;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/prefetch/ChunkPrefetchTriggerRuntimeModule.js

@@ -21,6 +21,15 @@ class ChunkPrefetchTriggerRuntimeModule extends RuntimeModule {
 		this.chunkMap = chunkMap;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return [[RuntimeGlobals.ensureChunkHandlers, "prefetch"]];
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/prefetch/ChunkPreloadTriggerRuntimeModule.js

@@ -24,6 +24,15 @@ class ChunkPreloadTriggerRuntimeModule extends RuntimeModule {
 		this.handlerKey = handlerKey;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return [[RuntimeGlobals.ensureChunkHandlers, this.handlerKey]];
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/prefetch/ResourceHintPlugin.js

@@ -300,7 +300,12 @@ const collectEntrypointHints = (compilation, entryName, hints) => {
 	const out = [];
 	/** @type {Set<string>} */
 	const seenKeys = new Set();
-	const push = (/** @type {EntrypointHint} */ h) => {
+	/**
+	 * Appends a hint, dropping one already emitted for the same rel + href.
+	 * @param {EntrypointHint} h hint to append
+	 * @returns {void}
+	 */
+	const push = (h) => {
 		const key = `${h.rel}\0${h.href}`;
 		if (seenKeys.has(key)) return;
 		seenKeys.add(key);
@@ -485,8 +490,7 @@ const collectStartupAssetHintLines = (
 					dep.options.publicPath,
 					workerChunk,
 					module,
-					chunkGraph,
-					set
+					chunkGraph
 				);
 				// Without one the call site keeps the runtime form, where it wraps its own
 				// href — firing the `<link>` here too would emit the call twice.

package/lib/prefetch/ResourceHintRuntimeModule.js

@@ -50,6 +50,15 @@ class ResourceHintRuntimeModule extends RuntimeModule {
 		this._rel = rel;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/prefetch/StartupAssetHintRuntimeModule.js

@@ -30,6 +30,15 @@ class StartupAssetHintRuntimeModule extends RuntimeModule {
 		this._lines = lines;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code