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

package/lib/performance/UnsplitVendorsPlugin.js

@@ -0,0 +1,112 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const UnsplitVendorsWarning = require("../errors/UnsplitVendorsWarning");
+const { compareStrings } = require("../util/comparators");
+const { NODE_MODULES_REGEXP } = require("../util/identifier");
+const getModuleSize = require("./getModuleSize");
+const getSourceModules = require("./getSourceModules");
+
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/**
+ * @import {
+ * 	UnsplitVendorChunkDetails
+ * } from "../errors/UnsplitVendorsWarning"
+ */
+
+const PLUGIN_NAME = "UnsplitVendorsPlugin";
+
+// Enough to name the offenders without printing the chunk graph.
+const MAX_REPORTED_CHUNKS = 5;
+
+class UnsplitVendorsPlugin {
+	/**
+	 * Creates an instance of UnsplitVendorsPlugin.
+	 * @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) => {
+			compilation.hooks.afterSeal.tap(PLUGIN_NAME, () => {
+				const { chunkGraph } = compilation;
+				/** @type {UnsplitVendorChunkDetails[]} */
+				const mixed = [];
+
+				for (const chunk of compilation.chunks) {
+					// Only an initial chunk is downloaded on every visit, so only there
+					// does mixing cost a returning visitor anything.
+					if (!chunk.canBeInitial()) continue;
+
+					let vendorModules = 0;
+					let vendorSize = 0;
+					let applicationModules = 0;
+
+					for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+						for (const inner of getSourceModules(module)) {
+							const resource = inner.nameForCondition();
+
+							// A module with no resource is webpack's own (a runtime module),
+							// which belongs to neither side and must not force a report.
+							if (!resource) continue;
+
+							if (NODE_MODULES_REGEXP.test(resource)) {
+								vendorModules++;
+								vendorSize += getModuleSize(inner);
+							} else {
+								applicationModules++;
+							}
+						}
+					}
+
+					if (vendorModules === 0 || applicationModules === 0) continue;
+
+					mixed.push({
+						name: chunk.name || `${chunk.id}`,
+						vendorModules,
+						vendorSize
+					});
+				}
+
+				if (mixed.length === 0) return;
+
+				// Ties break by name: chunk iteration order is not stable.
+				mixed.sort(
+					(a, b) =>
+						b.vendorSize - a.vendorSize || compareStrings(a.name, b.name)
+				);
+
+				const warning = new UnsplitVendorsWarning(
+					mixed.slice(0, MAX_REPORTED_CHUNKS)
+				);
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = UnsplitVendorsPlugin;

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;