@depup/webpack 5.109.2-depup.0 → 5.110.3-depup.0

package/lib/performance/UnusedReexportsPlugin.js

@@ -0,0 +1,159 @@
+/*
+	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");
+const UnusedReexportsWarning = require("../errors/UnusedReexportsWarning");
+const { compareStrings } = require("../util/comparators");
+const getModuleSize = require("./getModuleSize");
+const hasOnlyUnusedExports = require("./hasOnlyUnusedExports");
+
+/** @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";
+
+// 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.
+	 * @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 {UnusedReexportsWarning | undefined} */
+			let warning;
+
+			// Usage is final here, and concatenation has not merged the modules
+			// away yet, so each one can still be named and measured.
+			compilation.hooks.optimizeModules.tap(PLUGIN_NAME, (modules) => {
+				const { chunkGraph, moduleGraph, requestShortener } = compilation;
+				/** @type {UnusedReexportDetails[]} */
+				const unused = [];
+				let wasted = 0;
+
+				for (const module of modules) {
+					// One webpack already left out costs nothing.
+					if (chunkGraph.getNumberOfModuleChunks(module) === 0) continue;
+
+					if (!hasOnlyUnusedExports(module, moduleGraph, chunkGraph)) {
+						continue;
+					}
+
+					if (!isOnlyReexported(module, moduleGraph)) continue;
+
+					const size = getModuleSize(module);
+
+					wasted += size;
+					unused.push({
+						name: module.readableIdentifier(requestShortener),
+						size
+					});
+				}
+
+				if (unused.length === 0) return;
+
+				// Ties break by name: module order is not stable across runtimes.
+				unused.sort(
+					(a, b) => b.size - a.size || compareStrings(a.name, b.name)
+				);
+
+				warning = new UnusedReexportsWarning(
+					unused.slice(0, MAX_REPORTED_MODULES),
+					unused.length,
+					wasted
+				);
+			});
+
+			// 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 = UnusedReexportsPlugin;

package/lib/performance/UnusedRuleWarningPlugin.js

@@ -0,0 +1,105 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const UnusedRuleWarning = require("../errors/UnusedRuleWarning");
+
+/**
+ * @import {
+ * 	RuleSetRule,
+ * 	PerformanceOptions
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import Compiler from "../Compiler" */
+
+const PLUGIN_NAME = "UnusedRuleWarningPlugin";
+
+// `NormalModuleFactory` compiles `[{ rules: defaultRules }, { rules: rules }]`,
+// so only this subtree belongs to the configuration.
+const USER_RULES_PATH = "ruleSet[1].rules";
+
+/**
+ * Names the rule the way its author would recognize it. `module.rules[7]` alone
+ * is useless when a plugin injected the rule.
+ * @param {RuleSetRule} rule the raw rule
+ * @returns {string} a short descriptor, or an empty string when nothing identifies it
+ */
+const describeRule = (rule) => {
+	for (const key of ["test", "include", "exclude", "resource", "mimetype"]) {
+		const value = rule[/** @type {keyof RuleSetRule} */ (key)];
+		if (value instanceof RegExp) return ` (${key}: ${value})`;
+		if (typeof value === "string") return ` (${key}: ${value})`;
+	}
+	if (typeof rule.loader === "string") return ` (loader: ${rule.loader})`;
+	if (typeof rule.type === "string") return ` (type: ${rule.type})`;
+	return "";
+};
+
+class UnusedRuleWarningPlugin {
+	/**
+	 * Creates an instance of UnusedRuleWarningPlugin.
+	 * @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, { normalModuleFactory }) => {
+				compilation.hooks.afterSeal.tap(PLUGIN_NAME, () => {
+					// Nothing was factorized, so no rule could match — an empty build is
+					// not evidence that a rule is unused.
+					if (compilation.modules.size === 0) return;
+
+					/** @type {string[]} */
+					const descriptions = [];
+
+					for (const rule of normalModuleFactory.ruleSet.unusedRules()) {
+						if (!rule.path.startsWith(USER_RULES_PATH)) continue;
+						// A rule aimed at another compiler of a MultiCompiler is inactive
+						// here by design, not by mistake.
+						if (
+							rule.conditions.some(
+								(condition) => condition.property === "compiler"
+							)
+						) {
+							continue;
+						}
+						descriptions.push(
+							`${rule.path.replace(USER_RULES_PATH, "module.rules")}${describeRule(
+								rule.raw
+							)}`
+						);
+					}
+
+					if (descriptions.length === 0) return;
+
+					const warning = new UnusedRuleWarning(descriptions);
+
+					if (hints === "error") {
+						compilation.errors.push(warning);
+					} else if (hints === "stats") {
+						compilation.hints.push(warning);
+					} else {
+						compilation.warnings.push(warning);
+					}
+				});
+			}
+		);
+	}
+}
+
+module.exports = UnusedRuleWarningPlugin;

package/lib/performance/getModuleSize.js

@@ -0,0 +1,22 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/** @import Module from "../Module" */
+
+/**
+ * Asks the module for its own source types rather than assuming javascript, so
+ * a css or asset module counts too.
+ * @param {Module} module a module
+ * @returns {number} its size over every source type it reports
+ */
+const getModuleSize = (module) => {
+	let size = 0;
+	for (const type of module.getSourceTypes()) size += module.size(type);
+	return size;
+};
+
+module.exports = getModuleSize;

package/lib/performance/getSourceModules.js

@@ -0,0 +1,22 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const ConcatenatedModule = require("../optimize/ConcatenatedModule");
+
+/** @import Module from "../Module" */
+
+/**
+ * Yields the modules a user wrote, looking through scope hoisting: a
+ * concatenation is one module in the chunk graph but several on disk, and a
+ * hint about bytes or duplication has to name the ones on disk.
+ * @param {Module} module a module from the chunk graph
+ * @returns {Iterable<Module>} the modules it was built from, or itself
+ */
+const getSourceModules = (module) =>
+	module instanceof ConcatenatedModule ? module.modules : [module];
+
+module.exports = getSourceModules;

package/lib/performance/hasOnlyUnusedExports.js

@@ -0,0 +1,40 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const { UsageState } = require("../ExportsInfo");
+
+/** @import ChunkGraph from "../ChunkGraph" */
+/** @import Module from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+
+/**
+ * Tells whether a module provides exports and no runtime uses any of them.
+ * One exporting nothing is there for its side effects, a different mistake.
+ * @param {Module} module the module to look up
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @returns {boolean} true when it provides exports and none are used
+ */
+const hasOnlyUnusedExports = (module, moduleGraph, chunkGraph) => {
+	const runtimes = [...chunkGraph.getModuleRuntimes(module)];
+	let provided = 0;
+
+	for (const exportInfo of moduleGraph.getExportsInfo(module).exports) {
+		if (!exportInfo.provided) continue;
+
+		provided++;
+
+		for (const runtime of runtimes) {
+			// `NoInfo` included: unknown usage is not unused.
+			if (exportInfo.getUsed(runtime) !== UsageState.Unused) return false;
+		}
+	}
+
+	return provided > 0;
+};
+
+module.exports = hasOnlyUnusedExports;

package/lib/prefetch/ChunkPrefetchFunctionRuntimeModule.js

@@ -7,17 +7,27 @@
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
-/** @typedef {import("../Compilation")} Compilation */
+/** @import Compilation from "../Compilation" */
 
 class ChunkPrefetchFunctionRuntimeModule extends RuntimeModule {
+	/**
+	 * Returns true, if the runtime module should get it's own scope.
+	 * When false, `generate()` must emit complete statements ending with `;`
+	 * so a following runtime IIFE is not parsed as a call (ASI).
+	 * @returns {boolean} true, if the runtime module should get it's own scope
+	 */
+	shouldIsolate() {
+		return false;
+	}
+
 	/**
 	 * @param {"prefetch" | "preload"} type "prefetch" or "preload" chunk type function
-	 * @param {string} runtimeFunction the runtime function name
+	 * @param {string | null} runtimeFunction the runtime function name, or `null` where nothing fans out over the handlers
 	 * @param {string} runtimeHandlers the runtime handlers
 	 */
 	constructor(type, runtimeFunction, runtimeHandlers) {
 		super(`chunk ${type} function`);
-		/** @type {string} */
+		/** @type {string | null} */
 		this.runtimeFunction = runtimeFunction;
 		/** @type {string} */
 		this.runtimeHandlers = runtimeHandlers;
@@ -33,13 +43,17 @@ class ChunkPrefetchFunctionRuntimeModule extends RuntimeModule {
 		const { runtimeTemplate } = compilation;
 		return Template.asString([
 			`${runtimeHandlers} = {};`,
-			`${runtimeFunction} = ${runtimeTemplate.basicFunction("chunkId", [
-				// map is shorter than forEach
-				`Object.keys(${runtimeHandlers}).map(${runtimeTemplate.basicFunction(
-					"key",
-					`${runtimeHandlers}[key](chunkId);`
-				)});`
-			])}`
+			...(runtimeFunction === null
+				? []
+				: [
+						`${runtimeFunction} = ${runtimeTemplate.basicFunction("chunkId", [
+							// map is shorter than forEach
+							`Object.keys(${runtimeHandlers}).map(${runtimeTemplate.basicFunction(
+								"key",
+								`${runtimeHandlers}[key](chunkId);`
+							)});`
+						])};`
+					])
 		]);
 	}
 }

package/lib/prefetch/ChunkPrefetchPreloadPlugin.js

@@ -6,12 +6,23 @@
 "use strict";
 
 const RuntimeGlobals = require("../RuntimeGlobals");
-const ChunkPrefetchFunctionRuntimeModule = require("./ChunkPrefetchFunctionRuntimeModule");
-const ChunkPrefetchStartupRuntimeModule = require("./ChunkPrefetchStartupRuntimeModule");
-const ChunkPrefetchTriggerRuntimeModule = require("./ChunkPrefetchTriggerRuntimeModule");
-const ChunkPreloadTriggerRuntimeModule = require("./ChunkPreloadTriggerRuntimeModule");
+const lazyModule = require("../util/lazyModule");
 
-/** @typedef {import("../Compiler")} Compiler */
+/** @import Compiler from "../Compiler" */
+
+// only a chunk graph carrying a prefetch/preload relation emits these
+const getChunkPrefetchFunctionRuntimeModule = lazyModule(() =>
+	require("./ChunkPrefetchFunctionRuntimeModule")
+);
+const getChunkPrefetchStartupRuntimeModule = lazyModule(() =>
+	require("./ChunkPrefetchStartupRuntimeModule")
+);
+const getChunkPrefetchTriggerRuntimeModule = lazyModule(() =>
+	require("./ChunkPrefetchTriggerRuntimeModule")
+);
+const getChunkPreloadTriggerRuntimeModule = lazyModule(() =>
+	require("./ChunkPreloadTriggerRuntimeModule")
+);
 
 const PLUGIN_NAME = "ChunkPrefetchPreloadPlugin";
 
@@ -40,9 +51,10 @@ class ChunkPrefetchPreloadPlugin {
 						set.add(RuntimeGlobals.prefetchChunk);
 						set.add(RuntimeGlobals.onChunksLoaded);
 						set.add(RuntimeGlobals.exports);
-						compilation.addRuntimeModule(
+						compilation.addLazyRuntimeModule(
 							chunk,
-							new ChunkPrefetchStartupRuntimeModule(startupChildChunks)
+							getChunkPrefetchStartupRuntimeModule,
+							(Ctor) => new Ctor(startupChildChunks)
 						);
 					}
 				}
@@ -54,61 +66,66 @@ class ChunkPrefetchPreloadPlugin {
 
 					if (chunkMap.prefetch) {
 						set.add(RuntimeGlobals.prefetchChunk);
-						compilation.addRuntimeModule(
+						compilation.addLazyRuntimeModule(
 							chunk,
-							new ChunkPrefetchTriggerRuntimeModule(chunkMap.prefetch)
+							getChunkPrefetchTriggerRuntimeModule,
+							(Ctor) => new Ctor(chunkMap.prefetch)
 						);
 					}
 					if (chunkMap.preload) {
 						set.add(RuntimeGlobals.preloadChunk);
-						compilation.addRuntimeModule(
+						compilation.addLazyRuntimeModule(
 							chunk,
-							new ChunkPreloadTriggerRuntimeModule(chunkMap.preload)
+							getChunkPreloadTriggerRuntimeModule,
+							(Ctor) => new Ctor(chunkMap.preload)
 						);
 					}
 					if (chunkMap.cssPreload) {
 						// CSS-only preload (`parser.javascript.dynamicImportCssPreload`):
-						// reuse `preloadChunk` — with no JS `preload` order the JS
-						// handler is never registered, so only the CSS `.s` handler
-						// fires (`<link rel="preload" as="style">`).
-						set.add(RuntimeGlobals.preloadChunk);
+						// the trigger reaches the CSS `.s` handler itself
+						// (`<link rel="preload" as="style">`), so it asks for the handlers
+						// alone — nothing here calls the one that fans out over them.
 						set.add(RuntimeGlobals.preloadChunkHandlers);
-						compilation.addRuntimeModule(
+						compilation.addLazyRuntimeModule(
 							chunk,
-							new ChunkPreloadTriggerRuntimeModule(
-								chunkMap.cssPreload,
-								"cssPreload"
-							)
+							getChunkPreloadTriggerRuntimeModule,
+							(Ctor) => new Ctor(chunkMap.cssPreload, "cssPreload")
 						);
 					}
 				}
 			);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.prefetchChunk)
-				.tap(PLUGIN_NAME, (chunk, set) => {
-					compilation.addRuntimeModule(
-						chunk,
-						new ChunkPrefetchFunctionRuntimeModule(
-							"prefetch",
-							RuntimeGlobals.prefetchChunk,
-							RuntimeGlobals.prefetchChunkHandlers
-						)
-					);
-					set.add(RuntimeGlobals.prefetchChunkHandlers);
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.preloadChunk)
-				.tap(PLUGIN_NAME, (chunk, set) => {
-					compilation.addRuntimeModule(
-						chunk,
-						new ChunkPrefetchFunctionRuntimeModule(
-							"preload",
-							RuntimeGlobals.preloadChunk,
-							RuntimeGlobals.preloadChunkHandlers
-						)
-					);
-					set.add(RuntimeGlobals.preloadChunkHandlers);
-				});
+			// The handlers object is what carries the runtime module, so a chunk asking
+			// only for it — a trigger that reaches one handler by name — ships no
+			// fan-out function. Whether one is wanted is read here rather than in
+			// `create`, which runs after the requirement pass is over.
+			for (const [type, fn, handlers] of /** @type {const} */ ([
+				[
+					"prefetch",
+					RuntimeGlobals.prefetchChunk,
+					RuntimeGlobals.prefetchChunkHandlers
+				],
+				[
+					"preload",
+					RuntimeGlobals.preloadChunk,
+					RuntimeGlobals.preloadChunkHandlers
+				]
+			])) {
+				compilation.hooks.runtimeRequirementInTree
+					.for(fn)
+					.tap(PLUGIN_NAME, (chunk, set) => {
+						set.add(handlers);
+					});
+				compilation.hooks.runtimeRequirementInTree
+					.for(handlers)
+					.tap(PLUGIN_NAME, (chunk, set) => {
+						const runtimeFunction = set.has(fn) ? fn : null;
+						compilation.addLazyRuntimeModule(
+							chunk,
+							getChunkPrefetchFunctionRuntimeModule,
+							(Ctor) => new Ctor(type, runtimeFunction, handlers)
+						);
+					});
+			}
 		});
 	}
 }

package/lib/prefetch/ChunkPrefetchStartupRuntimeModule.js

@@ -8,9 +8,8 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Chunk").ChunkChildOfTypeInOrder} ChunkChildOfTypeInOrder */
-/** @typedef {import("../Compilation")} Compilation */
+/** @import Chunk, { ChunkChildOfTypeInOrder } from "../Chunk" */
+/** @import Compilation from "../Compilation" */
 
 class ChunkPrefetchStartupRuntimeModule extends RuntimeModule {
 	/**

package/lib/prefetch/ChunkPrefetchTriggerRuntimeModule.js

@@ -8,8 +8,8 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Chunk").ChunkChildIdsByOrdersMap} ChunkChildIdsByOrdersMap */
+/** @import Compilation from "../Compilation" */
+/** @import { ChunkChildIdsByOrdersMap } from "../Chunk" */
 
 class ChunkPrefetchTriggerRuntimeModule extends RuntimeModule {
 	/**

package/lib/prefetch/ChunkPreloadTriggerRuntimeModule.js

@@ -8,8 +8,8 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Chunk").ChunkChildIdsByOrdersMap} ChunkChildIdsByOrdersMap */
+/** @import Compilation from "../Compilation" */
+/** @import { ChunkChildIdsByOrdersMap } from "../Chunk" */
 
 class ChunkPreloadTriggerRuntimeModule extends RuntimeModule {
 	/**