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

package/lib/performance/BroadContextsPlugin.js

@@ -0,0 +1,142 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const ContextModule = require("../ContextModule");
+const BroadContextsWarning = require("../errors/BroadContextsWarning");
+const { compareStrings } = require("../util/comparators");
+const getModuleSize = require("./getModuleSize");
+
+/** @typedef {import("../../declarations/WebpackOptions").PerformanceOptions} PerformanceOptions */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../errors/BroadContextsWarning").BroadContextDetails} BroadContextDetails */
+
+const PLUGIN_NAME = "BroadContextsPlugin";
+
+// Enough to name the offenders without printing every context in the build.
+const MAX_REPORTED_CONTEXTS = 5;
+
+// A directory holding a handful of files costs little however it is matched,
+// and warning about it would bury the contexts that do carry weight.
+const MIN_REPORTED_MODULES = 20;
+
+// A bare leading wildcard takes every name in the directory, whether it is
+// `require.context`'s default or one webpack derived from an expression.
+const WILDCARD_PREFIX = "^\\.\\/.*";
+
+/**
+ * Whether a context takes whatever the directory holds. A pattern that narrows
+ * by anything other than a leading wildcard is left alone, as is one webpack
+ * cannot read — an unrecognized filter is never guessed at.
+ * @param {ContextModule} module a context module
+ * @returns {boolean} true when nothing narrows it
+ */
+const isBroad = (module) => {
+	const { regExp, include, exclude } = module.options;
+
+	if (include || exclude) return false;
+
+	return (
+		Boolean(regExp) &&
+		/** @type {RegExp} */ (regExp).source.startsWith(WILDCARD_PREFIX)
+	);
+};
+
+class BroadContextsPlugin {
+	/**
+	 * Creates an instance of BroadContextsPlugin.
+	 * @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 {BroadContextDetails[]} */
+				const broad = [];
+
+				for (const module of compilation.modules) {
+					if (!(module instanceof ContextModule)) continue;
+					if (!isBroad(module)) continue;
+
+					// One file is reached under several requests — with and without its
+					// extension — so the dependencies outnumber what is really matched.
+					/** @type {Set<Module>} */
+					const matched = new Set();
+
+					/**
+					 * @param {Dependency[]} dependencies the dependencies to walk
+					 * @returns {void}
+					 */
+					const collect = (dependencies) => {
+						for (const dependency of dependencies) {
+							const matchedModule = moduleGraph.getModule(dependency);
+
+							if (matchedModule) matched.add(matchedModule);
+						}
+					};
+
+					collect(module.dependencies);
+
+					// A lazy context keeps each match in a block of its own, so reading
+					// only `dependencies` would report it as matching nothing.
+					for (const block of module.blocks) collect(block.dependencies);
+
+					if (matched.size < MIN_REPORTED_MODULES) continue;
+
+					let size = 0;
+
+					for (const matchedModule of matched) {
+						size += getModuleSize(matchedModule);
+					}
+
+					broad.push({
+						name: module.readableIdentifier(requestShortener),
+						modules: matched.size,
+						size
+					});
+				}
+
+				if (broad.length === 0) return;
+
+				// Ties break by name: module order is not stable across runs.
+				broad.sort((a, b) => b.size - a.size || compareStrings(a.name, b.name));
+
+				const warning = new BroadContextsWarning(
+					broad.slice(0, MAX_REPORTED_CONTEXTS),
+					broad.length
+				);
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = BroadContextsPlugin;

package/lib/performance/CacheEffectivenessPlugin.js

@@ -0,0 +1,125 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const RuntimeModule = require("../RuntimeModule");
+const CacheEffectivenessWarning = require("../errors/CacheEffectivenessWarning");
+
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/** @import { BuildInfo } from "../Module" */
+
+const PLUGIN_NAME = "CacheEffectivenessPlugin";
+
+// A reason shared by many modules is the one worth fixing, so report the
+// frequent ones and count the rest.
+const MAX_REPORTED_REASONS = 3;
+
+const UNSPECIFIED_REASON = "reason not stated";
+
+class CacheEffectivenessPlugin {
+	/**
+	 * Creates an instance of CacheEffectivenessPlugin.
+	 * @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, () => {
+				let total = 0;
+				let rebuilt = 0;
+				let uncacheable = 0;
+				/** @type {Map<string, number>} */
+				const modulesByReason = new Map();
+
+				for (const module of compilation.modules) {
+					// Runtime modules are generated per compilation, never built and
+					// never cached, so counting them makes a cold build look warm.
+					if (module instanceof RuntimeModule) continue;
+
+					total++;
+
+					if (compilation.builtModules.has(module)) rebuilt++;
+
+					// Every built module carries one; `cacheable` being `undefined` is
+					// the module never reporting either way, not it opting out.
+					const buildInfo = /** @type {BuildInfo} */ (module.buildInfo);
+
+					if (buildInfo.cacheable !== false) continue;
+
+					uncacheable++;
+
+					const reasons =
+						buildInfo.notCacheableReasons &&
+						buildInfo.notCacheableReasons.length > 0
+							? buildInfo.notCacheableReasons
+							: [UNSPECIFIED_REASON];
+
+					for (const reason of reasons) {
+						modulesByReason.set(reason, (modulesByReason.get(reason) || 0) + 1);
+					}
+				}
+
+				// Work redone despite a warm cache needs both ends: everything rebuilt
+				// is a cold build, nothing rebuilt is the cache working.
+				const warmRebuild = rebuilt > 0 && rebuilt < total;
+
+				if (!warmRebuild && uncacheable === 0) return;
+
+				// Most frequent first, and by reason where two are as frequent: the
+				// map is keyed in the order the modules were walked, which is not the
+				// same twice, and only three reasons are reported — so an unbroken tie
+				// would vary which of them a build names at all.
+				const sorted = [...modulesByReason].sort(
+					(a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)
+				);
+				const reasons = sorted
+					.slice(0, MAX_REPORTED_REASONS)
+					.map(
+						([reason, modules]) =>
+							`${reason} (${modules} ${modules === 1 ? "module" : "modules"})`
+					);
+				const remaining = sorted.length - reasons.length;
+
+				if (remaining > 0) {
+					reasons.push(
+						`and ${remaining} other ${remaining === 1 ? "reason" : "reasons"}`
+					);
+				}
+
+				const warning = new CacheEffectivenessWarning({
+					total,
+					rebuilt,
+					uncacheable,
+					reasons
+				});
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = CacheEffectivenessPlugin;

package/lib/performance/ConflictingResourceHintsPlugin.js

@@ -0,0 +1,99 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const ConflictingResourceHintsWarning = require("../errors/ConflictingResourceHintsWarning");
+const { compareStrings } = require("../util/comparators");
+
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import ChunkGroup from "../ChunkGroup" */
+/** @import Compiler from "../Compiler" */
+/**
+ * @import {
+ * 	ConflictingResourceHintDetails
+ * } from "../errors/ConflictingResourceHintsWarning"
+ */
+
+const PLUGIN_NAME = "ConflictingResourceHintsPlugin";
+
+/**
+ * Names a chunk group for a message, falling back to its chunks: an `import()`
+ * without `webpackChunkName` produces a group with no name of its own.
+ * @param {ChunkGroup} chunkGroup a chunk group
+ * @returns {string} a name for it
+ */
+const getChunkGroupName = (chunkGroup) =>
+	chunkGroup.name ||
+	chunkGroup.chunks.map((chunk) => chunk.name || `${chunk.id}`).join(", ");
+
+class ConflictingResourceHintsPlugin {
+	/**
+	 * Creates an instance of ConflictingResourceHintsPlugin.
+	 * @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 { chunkGraph, moduleGraph } = compilation;
+				/** @type {ConflictingResourceHintDetails[]} */
+				const links = [];
+
+				for (const chunkGroup of compilation.chunkGroups) {
+					const children = chunkGroup.getChildrenByOrders(
+						moduleGraph,
+						chunkGraph
+					);
+
+					if (!children.prefetch || !children.preload) continue;
+
+					const preloaded = new Set(children.preload);
+
+					for (const child of children.prefetch) {
+						if (!preloaded.has(child)) continue;
+
+						links.push({
+							parent: getChunkGroupName(chunkGroup),
+							child: getChunkGroupName(child)
+						});
+					}
+				}
+
+				if (links.length === 0) return;
+
+				// Chunk group iteration order is not stable across runs.
+				links.sort(
+					(a, b) =>
+						compareStrings(a.parent, b.parent) ||
+						compareStrings(a.child, b.child)
+				);
+
+				const warning = new ConflictingResourceHintsWarning(links);
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = ConflictingResourceHintsPlugin;

package/lib/performance/DuplicateModulesPlugin.js

@@ -0,0 +1,93 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const DuplicateModulesWarning = require("../errors/DuplicateModulesWarning");
+const { compareStrings } = require("../util/comparators");
+const getModuleSize = require("./getModuleSize");
+
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/**
+ * @import {
+ * 	DuplicateModuleDetails
+ * } from "../errors/DuplicateModulesWarning"
+ */
+
+const PLUGIN_NAME = "DuplicateModulesPlugin";
+
+// Enough to name the offenders without printing the module graph.
+const MAX_REPORTED_MODULES = 5;
+
+class DuplicateModulesPlugin {
+	/**
+	 * Creates an instance of DuplicateModulesPlugin.
+	 * @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, requestShortener } = compilation;
+				/** @type {DuplicateModuleDetails[]} */
+				const duplicated = [];
+				let wasted = 0;
+
+				for (const module of compilation.modules) {
+					const chunks = chunkGraph.getNumberOfModuleChunks(module);
+
+					if (chunks < 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);
+
+					wasted += extra;
+					duplicated.push({
+						name: module.readableIdentifier(requestShortener),
+						chunks,
+						wasted: extra
+					});
+				}
+
+				if (duplicated.length === 0) return;
+
+				// Ties break by name: which modules finish first is not stable.
+				duplicated.sort(
+					(a, b) => b.wasted - a.wasted || compareStrings(a.name, b.name)
+				);
+
+				const warning = new DuplicateModulesWarning(
+					duplicated.slice(0, MAX_REPORTED_MODULES),
+					wasted
+				);
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = DuplicateModulesPlugin;

package/lib/performance/DuplicatePackagesPlugin.js

@@ -0,0 +1,119 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const DuplicatePackagesWarning = require("./DuplicatePackagesWarning");
+
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/** @import Module from "../Module" */
+/** @import NormalModule from "../NormalModule" */
+
+/**
+ * One copy of a package, identified by the directory its description file
+ * (usually `package.json`) lives in.
+ * @typedef {object} PackageCopy
+ * @property {string} version version of this copy
+ * @property {string} path directory of this copy
+ * @property {Module[]} modules modules included from this copy
+ */
+
+const PLUGIN_NAME = "DuplicatePackagesPlugin";
+
+class DuplicatePackagesPlugin {
+	/**
+	 * Creates an instance of DuplicatePackagesPlugin.
+	 * @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;
+
+		// `thisCompilation` keeps the hint to the root build, as child
+		// compilations report the copies of their parent a second time
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+			/** @type {DuplicatePackagesWarning[]} */
+			const warnings = [];
+
+			compilation.hooks.seal.tap(PLUGIN_NAME, () => {
+				/** @type {Map<string, Map<string, PackageCopy>>} */
+				const packages = new Map();
+				for (const module of compilation.modules) {
+					const resolveData =
+						/** @type {NormalModule} */
+						(module).resourceResolveData;
+					if (resolveData === undefined) continue;
+					const { descriptionFileData, descriptionFileRoot } = resolveData;
+					if (descriptionFileData === undefined) continue;
+					const { name, version } = descriptionFileData;
+					// Only a named and versioned package can be compared with another copy
+					if (
+						typeof name !== "string" ||
+						typeof version !== "string" ||
+						descriptionFileRoot === undefined
+					) {
+						continue;
+					}
+					let copies = packages.get(name);
+					if (copies === undefined) {
+						copies = new Map();
+						packages.set(name, copies);
+					}
+					const copy = copies.get(descriptionFileRoot);
+					if (copy === undefined) {
+						copies.set(descriptionFileRoot, {
+							version,
+							path: descriptionFileRoot,
+							modules: [module]
+						});
+					} else {
+						copy.modules.push(module);
+					}
+				}
+				for (const name of [...packages.keys()].sort()) {
+					const copies = /** @type {Map<string, PackageCopy>} */ (
+						packages.get(name)
+					);
+					if (copies.size < 2) continue;
+					const warning = new DuplicatePackagesWarning(
+						name,
+						[...copies.values()].sort((a, b) => (a.path < b.path ? -1 : 1)),
+						compilation.moduleGraph,
+						compilation.requestShortener
+					);
+					warnings.push(warning);
+				}
+			});
+
+			// 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, () => {
+				for (const warning of warnings) {
+					if (hints === "error") {
+						compilation.errors.push(warning);
+					} else if (hints === "stats") {
+						compilation.hints.push(warning);
+					} else {
+						compilation.warnings.push(warning);
+					}
+				}
+			});
+		});
+	}
+}
+
+module.exports = DuplicatePackagesPlugin;

package/lib/performance/DuplicatePackagesWarning.js

@@ -0,0 +1,84 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("../errors/WebpackError");
+
+/** @import Module from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import NormalModule from "../NormalModule" */
+/** @import RequestShortener from "../RequestShortener" */
+/** @import { PackageCopy } from "./DuplicatePackagesPlugin" */
+
+/**
+ * @param {Module} module the module
+ * @returns {string | undefined} directory of the package the module belongs to
+ */
+const getPackagePath = (module) => {
+	const resolveData =
+		/** @type {NormalModule} */
+		(module).resourceResolveData;
+	return resolveData && resolveData.descriptionFileRoot;
+};
+
+/**
+ * Finds a module outside of the copy that pulled it into the build, so the
+ * warning can name the dependency responsible for this copy.
+ * @param {PackageCopy} copy the copy
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @returns {Module | undefined} a module importing this copy, when there is one
+ */
+const findImporter = (copy, moduleGraph) => {
+	for (const module of copy.modules) {
+		for (const origin of moduleGraph
+			.getIncomingConnectionsByOriginModule(module)
+			.keys()) {
+			if (origin && getPackagePath(origin) !== copy.path) return origin;
+		}
+	}
+};
+
+/**
+ * Warning emitted when one package is included more than once in a build,
+ * either in different versions or as several copies of the same version.
+ */
+class DuplicatePackagesWarning extends WebpackError {
+	/**
+	 * @param {string} name name of the package
+	 * @param {PackageCopy[]} copies copies of the package, sorted by path
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {RequestShortener} requestShortener the request shortener
+	 */
+	constructor(name, copies, moduleGraph, requestShortener) {
+		const versions = new Set(copies.map((copy) => copy.version));
+		const headline =
+			versions.size > 1
+				? `Multiple versions of the package "${name}" (${[...versions].join(", ")}) are included in this build:`
+				: `The package "${name}" (${copies[0].version}) is included ${copies.length} times in this build:`;
+		const copiesList = copies
+			.map((copy) => {
+				const importer = findImporter(copy, moduleGraph);
+				let message = `* ${copy.version} from ${requestShortener.shorten(copy.path)}, ${copy.modules.length} module(s)`;
+				if (importer !== undefined) {
+					message += `\n    Included by ${importer.readableIdentifier(requestShortener)}`;
+				}
+				return message;
+			})
+			.join("\n");
+		super(`webpack performance recommendations:
+${headline}
+${copiesList}
+Every copy is bundled separately and has its own module state, which increases the output size and can break \`instanceof\` checks and configuration shared through the package.
+Align the version ranges requiring this package, or force a single version with "resolutions"/"overrides" in your package.json.`);
+
+		/** @type {string} */
+		this.name = "DuplicatePackagesWarning";
+		/** @type {Module} */
+		this.module = copies[0].modules[0];
+	}
+}
+
+module.exports = DuplicatePackagesWarning;