@depup/webpack 5.109.0-depup.0 → 5.110.1-depup.0

package/lib/performance/UnusedAliasesPlugin.js

@@ -0,0 +1,253 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const UnusedAliasesWarning = require("../errors/UnusedAliasesWarning");
+const { join } = require("../util/fs");
+const {
+	ABSOLUTE_PATH_REGEXP,
+	WINDOWS_PATH_SEPARATOR_REGEXP
+} = require("../util/identifier");
+const matchAlias = require("../util/matchAlias");
+const getSourceModules = require("./getSourceModules");
+
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/** @import Dependency from "../Dependency" */
+/** @import DependenciesBlock from "../DependenciesBlock" */
+/** @import { ContextDependencyOptions } from "../dependencies/ContextDependency" */
+/** @import Module from "../Module" */
+
+/**
+ * One `resolve.alias` entry, prepared for repeated matching.
+ * @typedef {object} PendingAlias
+ * @property {string} name the alias name as written, for the report
+ * @property {string} matchName the name to compare with, separators normalized when absolute
+ * @property {boolean} onlyModule whether the alias only matches the whole request
+ * @property {boolean} absolute whether the name is an absolute path
+ * @property {string | undefined} wildcardPrefix the part of `matchName` before its single "*", when it has one
+ * @property {string} wildcardSuffix the part of `matchName` after that "*"
+ * @property {boolean} used whether some request reached this alias
+ */
+
+const PLUGIN_NAME = "UnusedAliasesPlugin";
+
+const SLASH = "/";
+
+/**
+ * Whether an alias applies to a request. `AliasPlugin` accepts a single "*" in
+ * a name, matching by prefix and suffix instead of by segment.
+ * @param {string} request the request, separators normalized when the alias is absolute
+ * @param {PendingAlias} alias the alias to test
+ * @returns {boolean} true when the alias applies
+ */
+const aliasApplies = (request, alias) =>
+	alias.wildcardPrefix !== undefined
+		? request.startsWith(alias.wildcardPrefix) &&
+			request.endsWith(alias.wildcardSuffix)
+		: matchAlias(request, alias.matchName, alias.onlyModule);
+
+class UnusedAliasesPlugin {
+	/**
+	 * Creates an instance of UnusedAliasesPlugin.
+	 * @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 alias could match — an empty build
+					// is not evidence that an alias is unused.
+					if (compilation.modules.size === 0) return;
+
+					const configured =
+						normalModuleFactory.getResolver("normal").options.alias;
+
+					if (configured.length === 0) return;
+
+					/** @type {PendingAlias[]} */
+					const entries = [];
+					let hasAbsoluteName = false;
+					let unused = configured.length;
+
+					for (const { name, onlyModule } of configured) {
+						const absolute = ABSOLUTE_PATH_REGEXP.test(name);
+						// An absolute name is compared with paths, whose separator differs
+						// per platform
+						const matchName = absolute
+							? name.replace(WINDOWS_PATH_SEPARATOR_REGEXP, SLASH)
+							: name;
+						const starIndex = matchName.indexOf("*");
+						// `onlyModule` turns the wildcard off, so only the whole name matches
+						const wildcardPrefix =
+							!onlyModule &&
+							starIndex !== -1 &&
+							!matchName.includes("*", starIndex + 1)
+								? matchName.slice(0, starIndex)
+								: undefined;
+
+						if (absolute) hasAbsoluteName = true;
+
+						entries.push({
+							name,
+							matchName,
+							onlyModule: Boolean(onlyModule),
+							absolute,
+							wildcardPrefix,
+							wildcardSuffix:
+								wildcardPrefix === undefined
+									? ""
+									: matchName.slice(starIndex + 1),
+							used: false
+						});
+					}
+
+					/**
+					 * Marks the one alias a request reaches: `AliasPlugin` stops at the
+					 * first match, and a resolved path is only seen by an absolute name.
+					 * @param {string} request the request to test
+					 * @param {boolean=} absoluteOnly whether to test absolute names only
+					 * @returns {void}
+					 */
+					const consume = (request, absoluteOnly) => {
+						/** @type {string | undefined} */
+						let normalized;
+
+						for (let i = 0; i < entries.length; i++) {
+							const alias = entries[i];
+							let candidate = request;
+
+							if (alias.absolute) {
+								if (normalized === undefined) {
+									normalized = request.replace(
+										WINDOWS_PATH_SEPARATOR_REGEXP,
+										SLASH
+									);
+								}
+								candidate = normalized;
+							} else if (absoluteOnly) {
+								continue;
+							}
+
+							if (aliasApplies(candidate, alias)) {
+								if (!alias.used) {
+									alias.used = true;
+									unused--;
+								}
+
+								return;
+							}
+						}
+					};
+
+					for (const module of compilation.modules) {
+						if (unused === 0) break;
+
+						for (const sourceModule of getSourceModules(module)) {
+							const rawRequest =
+								/** @type {Module & { rawRequest?: string }} */
+								(sourceModule).rawRequest;
+
+							if (typeof rawRequest === "string") consume(rawRequest);
+						}
+					}
+
+					// Only what is left unaccounted for is worth the walk: a request the
+					// graph keeps nowhere else is on the dependency that asked for it.
+					if (unused > 0) {
+						const fs = compiler.inputFileSystem || undefined;
+						// One import states its request on several dependencies, and a
+						// request every module makes states it once per module.
+						/** @type {Set<string>} */
+						const seen = new Set();
+
+						for (const module of compilation.modules) {
+							if (unused === 0) break;
+
+							const context = module.context;
+
+							/** @type {DependenciesBlock[]} */
+							const blocks = [module];
+
+							while (blocks.length > 0) {
+								const block =
+									/** @type {DependenciesBlock} */
+									(blocks.pop());
+
+								for (const dependency of block.dependencies) {
+									const typed =
+										/** @type {Dependency & { request?: string, options?: ContextDependencyOptions }} */
+										(dependency);
+									// A `ContextModule` keeps the request in its options, and one
+									// an alias sent to `false` reaches no `rawRequest` at all.
+									const request =
+										typeof typed.request === "string"
+											? typed.request
+											: typed.options &&
+												  typeof typed.options.request === "string"
+												? typed.options.request
+												: undefined;
+
+									if (request === undefined) continue;
+
+									if (!seen.has(request)) {
+										seen.add(request);
+										consume(request);
+									}
+
+									// An absolute name matches the path the resolver saw, which for
+									// a relative request is the issuer's context joined with it, so
+									// the same request answers differently per module.
+									if (
+										hasAbsoluteName &&
+										context !== null &&
+										request.startsWith(".")
+									) {
+										consume(join(fs, context, request), true);
+									}
+								}
+
+								for (const child of block.blocks) blocks.push(child);
+							}
+						}
+					}
+
+					if (unused === 0) return;
+
+					const warning = new UnusedAliasesWarning(
+						entries
+							.filter((alias) => !alias.used)
+							.map((alias) => `'${alias.name}'`)
+							.sort()
+					);
+
+					if (hints === "error") {
+						compilation.errors.push(warning);
+					} else if (hints === "stats") {
+						compilation.hints.push(warning);
+					} else {
+						compilation.warnings.push(warning);
+					}
+				});
+			}
+		);
+	}
+}
+
+module.exports = UnusedAliasesPlugin;

package/lib/performance/UnusedDefinesPlugin.js

@@ -0,0 +1,87 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const { VALUE_DEP_PREFIX, getDeclaredKeys } = require("../DefinePlugin");
+const UnusedDefinesWarning = require("../errors/UnusedDefinesWarning");
+
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/** @import { NormalModuleBuildInfo } from "../NormalModule" */
+
+const PLUGIN_NAME = "UnusedDefinesPlugin";
+
+class UnusedDefinesPlugin {
+	/**
+	 * Creates an instance of UnusedDefinesPlugin.
+	 * @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) => {
+			compilation.hooks.afterSeal.tap(PLUGIN_NAME, () => {
+				const declared = getDeclaredKeys(compilation);
+
+				if (declared === undefined || declared.size === 0) return;
+				// Nothing was parsed, so no key could be substituted — an empty build is
+				// not evidence that a key is unused.
+				if (compilation.modules.size === 0) return;
+
+				/** @type {Set<string>} */
+				const used = new Set();
+
+				for (const module of compilation.modules) {
+					const buildInfo =
+						/** @type {NormalModuleBuildInfo} */
+						(module.buildInfo);
+
+					if (!buildInfo || !buildInfo.valueDependencies) continue;
+
+					// Survives the persistent cache: `valueDependencies` is serialized
+					// with the module, so a restored module answers without rebuilding.
+					for (const name of buildInfo.valueDependencies.keys()) {
+						if (name.startsWith(VALUE_DEP_PREFIX)) {
+							used.add(name.slice(VALUE_DEP_PREFIX.length));
+						}
+					}
+				}
+
+				const unused = [];
+
+				for (const key of declared) {
+					if (!used.has(key)) unused.push(key);
+				}
+
+				if (unused.length === 0) return;
+
+				unused.sort();
+
+				const warning = new UnusedDefinesWarning(unused);
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = UnusedDefinesPlugin;

package/lib/performance/UnusedExternalsPlugin.js

@@ -0,0 +1,110 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const ExternalModule = require("../ExternalModule");
+const {
+	getAlternateCoreModuleRequest
+} = require("../ExternalModuleFactoryPlugin");
+const UnusedExternalsWarning = require("../errors/UnusedExternalsWarning");
+
+/**
+ * @import {
+ * 	Externals,
+ * 	PerformanceOptions
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import Compiler from "../Compiler" */
+
+const PLUGIN_NAME = "UnusedExternalsPlugin";
+
+/**
+ * Collects the requests the configuration names outright. A RegExp or a function
+ * decides per request, so there is no entry that could be called unused.
+ * @param {Externals} externals the configured externals
+ * @param {Set<string>} requests collected requests
+ * @returns {void}
+ */
+const collectRequests = (externals, requests) => {
+	if (typeof externals === "string") {
+		requests.add(externals);
+	} else if (Array.isArray(externals)) {
+		for (const entry of externals) collectRequests(entry, requests);
+	} else if (externals instanceof RegExp || typeof externals === "function") {
+		// Decides per request, so it names nothing that could be called unused.
+	} else if (externals) {
+		for (const request of Object.keys(externals)) requests.add(request);
+	}
+};
+
+class UnusedExternalsPlugin {
+	/**
+	 * Creates an instance of UnusedExternalsPlugin.
+	 * @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) => {
+			compilation.hooks.afterSeal.tap(PLUGIN_NAME, () => {
+				const { externals } = compilation.options;
+
+				if (externals === undefined) return;
+
+				/** @type {Set<string>} */
+				const declared = new Set();
+
+				collectRequests(externals, declared);
+
+				if (declared.size === 0) return;
+				// Nothing was factorized, so nothing could be made external.
+				if (compilation.modules.size === 0) return;
+
+				for (const module of compilation.modules) {
+					if (module instanceof ExternalModule) {
+						// The request as written, not what it was rewritten to.
+						declared.delete(module.userRequest);
+
+						// A core module is external under either spelling, so the entry
+						// that matched may be the one the request does not use.
+						const alternateRequest = getAlternateCoreModuleRequest(
+							module.userRequest
+						);
+
+						if (alternateRequest !== undefined) {
+							declared.delete(alternateRequest);
+						}
+					}
+				}
+
+				if (declared.size === 0) return;
+
+				const unused = [...declared].sort();
+				const warning = new UnusedExternalsWarning(unused);
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = UnusedExternalsPlugin;

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;