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

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;

package/lib/performance/DynamicExportsPlugin.js

@@ -0,0 +1,120 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const DynamicExportsWarning = require("../errors/DynamicExportsWarning");
+const { compareStrings } = require("../util/comparators");
+const getModuleSize = require("./getModuleSize");
+
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/** @import Module from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import { DynamicExportsDetails } from "../errors/DynamicExportsWarning" */
+
+/**
+ * Tells whether another module imports this one.
+ * @param {Module} module the module to look up
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @returns {boolean} true when at least one module imports it
+ */
+const hasImporter = (module, moduleGraph) => {
+	for (const connection of moduleGraph.getIncomingConnections(module)) {
+		if (connection.originModule) return true;
+	}
+
+	return false;
+};
+
+const PLUGIN_NAME = "DynamicExportsPlugin";
+
+// Enough to name the offenders without listing every CommonJS dependency.
+const MAX_REPORTED_MODULES = 5;
+
+class DynamicExportsPlugin {
+	/**
+	 * Creates an instance of DynamicExportsPlugin.
+	 * @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 {DynamicExportsWarning | undefined} */
+			let warning;
+
+			// Exports are settled 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 {DynamicExportsDetails[]} */
+				const unknown = [];
+
+				for (const module of modules) {
+					// One webpack already left out costs nothing.
+					if (chunkGraph.getNumberOfModuleChunks(module) === 0) continue;
+
+					// `null` is the third state: not "no other exports" but "there
+					// may be more, and they cannot be read from the source".
+					if (
+						moduleGraph.getExportsInfo(module).otherExportsInfo.provided !==
+						null
+					) {
+						continue;
+					}
+
+					// The cost lands on whoever imports it, so an entry pays nothing.
+					if (!hasImporter(module, moduleGraph)) continue;
+
+					unknown.push({
+						name: module.readableIdentifier(requestShortener),
+						size: getModuleSize(module)
+					});
+				}
+
+				if (unknown.length === 0) return;
+
+				// Ties break by name: module order is not stable across runtimes.
+				unknown.sort(
+					(a, b) => b.size - a.size || compareStrings(a.name, b.name)
+				);
+
+				warning = new DynamicExportsWarning(
+					unknown.slice(0, MAX_REPORTED_MODULES),
+					unknown.length
+				);
+			});
+
+			// 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 = DynamicExportsPlugin;

package/lib/performance/EmbeddedSourceMapsPlugin.js

@@ -0,0 +1,71 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const EmbeddedSourceMapsWarning = require("../errors/EmbeddedSourceMapsWarning");
+
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+
+const PLUGIN_NAME = "EmbeddedSourceMapsPlugin";
+
+// The two families that put the map inside the bundle rather than beside it:
+// `eval` carries one per module, `inline` appends the whole map as a data url.
+const EMBEDS_MAP_REGEXP = /^eval|inline/;
+
+class EmbeddedSourceMapsPlugin {
+	/**
+	 * Creates an instance of EmbeddedSourceMapsPlugin.
+	 * @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;
+
+		const { devtool, mode } = compiler.options;
+
+		// Only production: embedding is what these devtools are for everywhere
+		// else, and the cost is only paid by the people loading the site.
+		if (mode !== "production" || !devtool) return;
+
+		// One devtool, or one per source type — either way it is the setting
+		// that embeds which the report has to name.
+		const embedding = (
+			typeof devtool === "string" ? [devtool] : devtool.map((it) => it.use)
+		).find((it) => typeof it === "string" && EMBEDS_MAP_REGEXP.test(it));
+
+		if (!embedding) 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 warning = new EmbeddedSourceMapsWarning(embedding);
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = EmbeddedSourceMapsPlugin;

package/lib/performance/EntrypointOverlapPlugin.js

@@ -0,0 +1,122 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const EntrypointOverlapWarning = require("../errors/EntrypointOverlapWarning");
+const { compareStrings } = require("../util/comparators");
+const getModuleSize = require("./getModuleSize");
+const getSourceModules = require("./getSourceModules");
+
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Chunk from "../Chunk" */
+/** @import Compiler from "../Compiler" */
+/** @import Module from "../Module" */
+/**
+ * @import {
+ * 	EntrypointOverlapDetails
+ * } from "../errors/EntrypointOverlapWarning"
+ */
+
+const PLUGIN_NAME = "EntrypointOverlapPlugin";
+
+// Enough to name the offenders without printing the module graph.
+const MAX_REPORTED_MODULES = 5;
+
+class EntrypointOverlapPlugin {
+	/**
+	 * Creates an instance of EntrypointOverlapPlugin.
+	 * @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, entrypoints, requestShortener } = compilation;
+
+				if (entrypoints.size < 2) return;
+
+				/** @type {Map<Module, { chunks: Set<Chunk>, entrypoints: Set<string> }>} */
+				const reach = new Map();
+
+				for (const [name, entrypoint] of entrypoints) {
+					for (const chunk of entrypoint.chunks) {
+						for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+							// Through scope hoisting: two entrypoints concatenating the same
+							// file produce two modules, so the chunk graph alone shows none.
+							for (const inner of getSourceModules(module)) {
+								let entry = reach.get(inner);
+
+								if (entry === undefined) {
+									reach.set(
+										inner,
+										(entry = { chunks: new Set(), entrypoints: new Set() })
+									);
+								}
+
+								entry.chunks.add(chunk);
+								entry.entrypoints.add(name);
+							}
+						}
+					}
+				}
+
+				/** @type {EntrypointOverlapDetails[]} */
+				const overlapping = [];
+				let wasted = 0;
+
+				for (const [module, { chunks, entrypoints: names }] of reach) {
+					// One chunk reached from several entrypoints is downloaded once, so
+					// only separate copies cost anything.
+					if (chunks.size < 2 || names.size < 2) continue;
+
+					const extra = getModuleSize(module) * (chunks.size - 1);
+
+					wasted += extra;
+					overlapping.push({
+						name: module.readableIdentifier(requestShortener),
+						entrypoints: [...names].sort(compareStrings),
+						wasted: extra
+					});
+				}
+
+				if (overlapping.length === 0) return;
+
+				// Ties break by name: which modules finish first is not stable.
+				overlapping.sort(
+					(a, b) => b.wasted - a.wasted || compareStrings(a.name, b.name)
+				);
+
+				const warning = new EntrypointOverlapWarning(
+					overlapping.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 = EntrypointOverlapPlugin;

package/lib/performance/EntrypointsOverSizeLimitWarning.js

@@ -8,7 +8,7 @@
 const WebpackError = require("../errors/WebpackError");
 const formatSize = require("../util/formatSize");
 
-/** @typedef {import("./SizeLimitsPlugin").EntrypointDetails} EntrypointDetails */
+/** @import { EntrypointDetails } from "./SizeLimitsPlugin" */
 
 class EntrypointsOverSizeLimitWarning extends WebpackError {
 	/**