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

package/lib/performance/SizeLimitsPlugin.js

@@ -5,24 +5,40 @@
 
 "use strict";
 
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
 const { find } = require("../util/SetHelpers");
+const { compareStrings } = require("../util/comparators");
 const AssetsOverSizeLimitWarning = require("./AssetsOverSizeLimitWarning");
 const EntrypointsOverSizeLimitWarning = require("./EntrypointsOverSizeLimitWarning");
 const NoAsyncChunksWarning = require("./NoAsyncChunksWarning");
+const RuntimeInLargeChunkWarning = require("./RuntimeInLargeChunkWarning");
+const getModuleSize = require("./getModuleSize");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").PerformanceOptions} PerformanceOptions */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../Compilation").Asset} Asset */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Entrypoint")} Entrypoint */
-/** @typedef {import("../errors/WebpackError")} WebpackError */
+/** @import { Source } from "webpack-sources" */
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Chunk from "../Chunk" */
+/** @import ChunkGraph from "../ChunkGraph" */
+/** @import ChunkGroup from "../ChunkGroup" */
+/** @import Compilation, { Asset } from "../Compilation" */
+/** @import Compiler from "../Compiler" */
+/** @import Module from "../Module" */
+/** @import Entrypoint from "../Entrypoint" */
+/** @import WebpackError from "../errors/WebpackError" */
+
+/**
+ * Defines the module details type used by this module.
+ * @typedef {object} ModuleDetails
+ * @property {string} name
+ * @property {number} size
+ */
 
 /**
  * Defines the asset details type used by this module.
  * @typedef {object} AssetDetails
  * @property {string} name
  * @property {number} size
+ * @property {ModuleDetails[]=} modules
  */
 
 /**
@@ -41,6 +57,108 @@ const isOverSizeLimitSet = new WeakSet();
 /** @type {AssetFilter} */
 const excludeSourceMap = (name, source, info) => !info.development;
 
+// Runtime globals whose generated code describes the other chunks, so the chunk
+// holding them is rewritten whenever anything else in the build changes.
+const BUILD_WIDE_RUNTIME_GLOBALS = [
+	RuntimeGlobals.getChunkScriptFilename,
+	RuntimeGlobals.getChunkCssFilename,
+	RuntimeGlobals.getChunkUpdateScriptFilename,
+	RuntimeGlobals.getFullHash,
+	RuntimeGlobals.getUpdateManifestFilename
+];
+
+/**
+ * Tells whether an entrypoint ships its runtime inside a chunk that also carries
+ * modules, and that runtime describes the rest of the build. Only then does
+ * `optimization.runtimeChunk` win anything.
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {Entrypoint} entrypoint an entrypoint
+ * @returns {boolean} true when splitting the runtime off would keep the chunk stable
+ */
+const hasEmbeddedRuntime = (chunkGraph, entrypoint) => {
+	const runtimeChunk = entrypoint.getRuntimeChunk();
+	if (!runtimeChunk) return false;
+	// A chunk of its own carries the runtime modules and nothing else. Asking each
+	// module beats counting, which depends on runtime modules being counted twice.
+	let carriesCode = false;
+	for (const module of chunkGraph.getChunkModulesIterable(runtimeChunk)) {
+		if (!(module instanceof RuntimeModule)) {
+			carriesCode = true;
+			break;
+		}
+	}
+	if (!carriesCode) return false;
+	// The tree requirements are the ones the emitted runtime modules answer to.
+	const runtimeRequirements =
+		chunkGraph.getTreeRuntimeRequirements(runtimeChunk);
+	// A global nothing here names stays silent, so a new one costs a hint, not a wrong one.
+	return BUILD_WIDE_RUNTIME_GLOBALS.some((runtimeGlobal) =>
+		runtimeRequirements.has(runtimeGlobal)
+	);
+};
+
+// Enough to point at the culprit without turning the hint into a report.
+const MAX_REPORTED_MODULES = 3;
+
+/**
+ * Names the largest modules inside each oversized asset. "This file is too big"
+ * is only actionable once you know what fills it.
+ * @param {Compilation} compilation the compilation
+ * @param {AssetDetails[]} assetsOverSizeLimit the oversized assets, annotated in place
+ * @returns {void}
+ */
+const addLargestModules = (compilation, assetsOverSizeLimit) => {
+	const { chunkGraph, requestShortener } = compilation;
+	/** @type {Map<string, Chunk[]>} */
+	const chunksByFile = new Map();
+
+	for (const chunk of compilation.chunks) {
+		// A chunk emitting several files (javascript plus extracted css, …) gives
+		// no way to tell which module ended up in which, so it names none.
+		if (chunk.files.size !== 1) continue;
+
+		for (const file of chunk.files) {
+			const chunks = chunksByFile.get(file);
+
+			if (chunks === undefined) {
+				chunksByFile.set(file, [chunk]);
+			} else {
+				chunks.push(chunk);
+			}
+		}
+	}
+
+	for (const asset of assetsOverSizeLimit) {
+		const chunks = chunksByFile.get(asset.name);
+
+		// An asset a loader or plugin emitted belongs to no chunk, so nothing
+		// describes its contents; likewise one whose chunk emits several files.
+		if (chunks === undefined) continue;
+
+		/** @type {Set<Module>} */
+		const seen = new Set();
+		/** @type {ModuleDetails[]} */
+		const modules = [];
+
+		for (const chunk of chunks) {
+			for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+				if (seen.has(module)) continue;
+				seen.add(module);
+				modules.push({
+					name: module.readableIdentifier(requestShortener),
+					size: getModuleSize(module)
+				});
+			}
+		}
+
+		if (modules.length === 0) continue;
+
+		// Ties break by name: which modules finish first is not stable.
+		modules.sort((a, b) => b.size - a.size || compareStrings(a.name, b.name));
+		asset.modules = modules.slice(0, MAX_REPORTED_MODULES);
+	}
+};
+
 const PLUGIN_NAME = "SizeLimitsPlugin";
 
 module.exports = class SizeLimitsPlugin {
@@ -132,6 +250,8 @@ module.exports = class SizeLimitsPlugin {
 
 			/** @type {EntrypointDetails[]} */
 			const entrypointsOverLimit = [];
+			/** @type {string[]} */
+			const entrypointsWithEmbeddedRuntime = [];
 			for (const [name, entry] of compilation.entrypoints) {
 				const size = getEntrypointSize(entry);
 
@@ -142,6 +262,9 @@ module.exports = class SizeLimitsPlugin {
 						files: entry.getFiles().filter(fileFilter)
 					});
 					isOverSizeLimitSet.add(entry);
+					if (hasEmbeddedRuntime(compilation.chunkGraph, entry)) {
+						entrypointsWithEmbeddedRuntime.push(name);
+					}
 				}
 			}
 
@@ -151,6 +274,7 @@ module.exports = class SizeLimitsPlugin {
 				// 3. No Async Chunks
 				// if !1, then 2, if !2 return
 				if (assetsOverSizeLimit.length > 0) {
+					addLargestModules(compilation, assetsOverSizeLimit);
 					warnings.push(
 						new AssetsOverSizeLimitWarning(
 							assetsOverSizeLimit,
@@ -177,8 +301,16 @@ module.exports = class SizeLimitsPlugin {
 						warnings.push(new NoAsyncChunksWarning());
 					}
 
+					if (entrypointsWithEmbeddedRuntime.length > 0) {
+						warnings.push(
+							new RuntimeInLargeChunkWarning(entrypointsWithEmbeddedRuntime)
+						);
+					}
+
 					if (hints === "error") {
 						compilation.errors.push(...warnings);
+					} else if (hints === "stats") {
+						compilation.hints.push(...warnings);
 					} else {
 						compilation.warnings.push(...warnings);
 					}

package/lib/performance/SplitChunksCappedPlugin.js

@@ -0,0 +1,99 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const SplitChunksCappedWarning = require("../errors/SplitChunksCappedWarning");
+const { getCappedSplits } = require("../optimize/SplitChunksPlugin");
+const { compareStrings } = require("../util/comparators");
+
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/** @import { CappedSplitDetails } from "../errors/SplitChunksCappedWarning" */
+
+const PLUGIN_NAME = "SplitChunksCappedPlugin";
+
+// Enough to name the offenders without printing the chunk graph.
+const MAX_REPORTED_SPLITS = 5;
+
+class SplitChunksCappedPlugin {
+	/**
+	 * Creates an instance of SplitChunksCappedPlugin.
+	 * @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 recorded = getCappedSplits(compilation);
+
+				if (recorded === undefined || recorded.length === 0) return;
+
+				/** @type {Map<string, CappedSplitDetails>} */
+				const splits = new Map();
+
+				for (const split of recorded) {
+					// Chunk ids only exist after seal, and the queue reconsiders a
+					// refused split, so the same one is recorded several times.
+					const chunk = split.chunk.name || `${split.chunk.id}`;
+					const key = `${split.cacheGroup} ${chunk} ${split.limit}`;
+					const previous = splits.get(key);
+
+					if (previous !== undefined && previous.modules >= split.modules) {
+						continue;
+					}
+
+					splits.set(key, {
+						cacheGroup: split.cacheGroup,
+						chunk,
+						limit: split.limit,
+						maxRequests: split.maxRequests,
+						modules: split.modules
+					});
+				}
+
+				// Held only to be reported: nothing needs the chunks after this.
+				recorded.length = 0;
+
+				const details = [...splits.values()];
+
+				// Ties break by name: the order splits are refused in is not stable.
+				details.sort(
+					(a, b) =>
+						b.modules - a.modules ||
+						compareStrings(a.cacheGroup, b.cacheGroup) ||
+						compareStrings(a.chunk, b.chunk)
+				);
+
+				const warning = new SplitChunksCappedWarning(
+					details.slice(0, MAX_REPORTED_SPLITS)
+				);
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = SplitChunksCappedPlugin;

package/lib/performance/TinyChunksPlugin.js

@@ -0,0 +1,128 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const TinyChunksWarning = require("../errors/TinyChunksWarning");
+const { compareStrings } = require("../util/comparators");
+
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/** @import { TinyChunkDetails } from "../errors/TinyChunksWarning" */
+
+const PLUGIN_NAME = "TinyChunksPlugin";
+
+// Enough to name the offenders without printing the chunk graph.
+const MAX_REPORTED_CHUNKS = 5;
+
+// One small chunk is a lazy route; a crowd of them is a request pattern, and
+// only then does grouping them save more than it costs.
+const MIN_REPORTED_CHUNKS = 10;
+
+// What `splitChunks.minSize` falls back to when it is absent or given per
+// source type rather than as one number.
+const DEFAULT_MIN_SIZE = 20000;
+
+class TinyChunksPlugin {
+	/**
+	 * Creates an instance of TinyChunksPlugin.
+	 * @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 { splitChunks } = compiler.options.optimization;
+		const configured = splitChunks && splitChunks.minSize;
+
+		/**
+		 * Read from `splitChunks.minSize`, so raising the size worth splitting
+		 * raises what counts as too small. Either one number or one per type.
+		 * @param {string} sourceType the type in question
+		 * @returns {number} the floor below which a chunk of it is too small
+		 */
+		const minSizeFor = (sourceType) => {
+			if (typeof configured === "number") return configured;
+
+			if (configured) {
+				const forType = configured[sourceType];
+
+				if (typeof forType === "number") return forType;
+			}
+
+			return DEFAULT_MIN_SIZE;
+		};
+
+		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 { chunkGraph } = compilation;
+				/** @type {TinyChunkDetails[]} */
+				const tiny = [];
+				let totalSize = 0;
+
+				for (const chunk of compilation.chunks) {
+					// An initial chunk is downloaded whatever its size; only one fetched
+					// on demand costs a request of its own.
+					if (chunk.canBeInitial()) continue;
+
+					const sizes = chunkGraph.getChunkModulesSizes(chunk);
+					const types = Object.keys(sizes);
+
+					if (types.length === 0) continue;
+
+					// Under its own floor for every type it carries: a chunk holding
+					// enough of any one of them is worth the request it costs.
+					let size = 0;
+					let small = true;
+
+					for (const type of types) {
+						size += sizes[type];
+
+						if (sizes[type] >= minSizeFor(type)) small = false;
+					}
+
+					if (!small) continue;
+
+					totalSize += size;
+					tiny.push({ name: chunk.name || `${chunk.id}`, size });
+				}
+
+				if (tiny.length < MIN_REPORTED_CHUNKS) return;
+
+				// Smallest first, and ties break by name: chunk order is not stable.
+				tiny.sort((a, b) => a.size - b.size || compareStrings(a.name, b.name));
+
+				const warning = new TinyChunksWarning(
+					tiny.slice(0, MAX_REPORTED_CHUNKS),
+					tiny.length,
+					totalSize
+				);
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = TinyChunksPlugin;

package/lib/performance/TopLevelThisPlugin.js

@@ -0,0 +1,208 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../ModuleTypeConstants");
+const TopLevelThisWarning = require("../errors/TopLevelThisWarning");
+const { compareStrings } = require("../util/comparators");
+const getSourceModules = require("./getSourceModules");
+
+/** @import { Program } from "estree" */
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/** @import Module from "../Module" */
+/** @import { BuildInfo } from "../Module" */
+/** @import JavascriptParser from "../javascript/JavascriptParser" */
+/** @import { TopLevelThisDetails } from "../errors/TopLevelThisWarning" */
+
+const PLUGIN_NAME = "TopLevelThisPlugin";
+
+// Enough to name the offenders without listing every module.
+const MAX_REPORTED_MODULES = 5;
+
+// Bodies that rebind `this`; everything else keeps the enclosing one, so an
+// arrow function at the top level still reads the module's `this`.
+const REBINDS_THIS = new Set(["FunctionDeclaration", "FunctionExpression"]);
+
+// A class rebinds `this` in its body, but its heritage clause and computed
+// keys are evaluated where the class is written.
+const CLASS_TYPES = new Set(["ClassDeclaration", "ClassExpression"]);
+
+/**
+ * Counts the reads of `this` that reach the top level of a program.
+ * @param {Program} ast the program
+ * @returns {number} how many there are
+ */
+const countTopLevelThis = (ast) => {
+	let count = 0;
+	/** @type {unknown[]} */
+	const queue = [ast];
+
+	while (queue.length > 0) {
+		const node = queue.pop();
+
+		if (!node || typeof node !== "object") continue;
+
+		if (Array.isArray(node)) {
+			for (const item of /** @type {unknown[]} */ (node)) queue.push(item);
+			continue;
+		}
+
+		// Walked structurally rather than per node type, so a node the estree
+		// types do not name is still reached.
+		const fields = /** @type {Record<string, unknown>} */ (node);
+		const { type } = fields;
+
+		if (typeof type !== "string") continue;
+		if (REBINDS_THIS.has(type)) continue;
+
+		if (type === "ThisExpression") {
+			count++;
+			continue;
+		}
+
+		if (CLASS_TYPES.has(type)) {
+			queue.push(fields.superClass);
+
+			const body = /** @type {EXPECTED_ANY} */ (fields.body);
+
+			for (const element of (body && body.body) || []) {
+				if (element.computed) queue.push(element.key);
+			}
+
+			continue;
+		}
+
+		for (const key of Object.keys(fields)) {
+			if (key !== "range" && key !== "loc") queue.push(fields[key]);
+		}
+	}
+
+	return count;
+};
+
+class TopLevelThisPlugin {
+	/**
+	 * Creates an instance of TopLevelThisPlugin.
+	 * @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, { normalModuleFactory }) => {
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @returns {void}
+				 */
+				const handler = (parser) => {
+					parser.hooks.program.tap(PLUGIN_NAME, (ast) => {
+						// Only ES modules: in CommonJS `this` is `module.exports`, which
+						// is what the code reading it means.
+						const buildMeta = parser.state.module.buildMeta;
+
+						if (!buildMeta || buildMeta.exportsType !== "namespace") return;
+
+						const count = countTopLevelThis(ast);
+
+						if (count === 0) return;
+
+						// Kept on the module rather than in a map here, so a module the
+						// filesystem cache restores rather than parses still reports.
+						const buildInfo =
+							/** @type {BuildInfo} */
+							(parser.state.module.buildInfo);
+
+						buildInfo.topLevelThis = count;
+					});
+				};
+
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, handler);
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, handler);
+
+				// `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, () => {
+					/** @type {TopLevelThisDetails[]} */
+					const modules = [];
+					let total = 0;
+
+					// A module can be reached both on its own and inside a
+					// concatenation, so it is only counted the first time.
+					/** @type {Set<Module>} */
+					const seen = new Set();
+
+					for (const parent of compilation.modules) {
+						// Scope hoisting makes several modules into one, and the evidence
+						// sits on the ones that were parsed.
+						for (const module of getSourceModules(parent)) {
+							if (seen.has(module)) continue;
+
+							seen.add(module);
+
+							const buildInfo = /** @type {BuildInfo} */ (module.buildInfo);
+							const count = buildInfo.topLevelThis;
+
+							if (!count) continue;
+
+							total += count;
+							modules.push({
+								name: module.readableIdentifier(compilation.requestShortener),
+								count
+							});
+						}
+					}
+
+					if (modules.length === 0) return;
+
+					// Most first; ties break by name, module order is not stable.
+					modules.sort(
+						(a, b) => b.count - a.count || compareStrings(a.name, b.name)
+					);
+
+					const warning = new TopLevelThisWarning(
+						modules.slice(0, MAX_REPORTED_MODULES),
+						total
+					);
+
+					if (hints === "error") {
+						compilation.errors.push(warning);
+					} else if (hints === "stats") {
+						compilation.hints.push(warning);
+					} else {
+						compilation.warnings.push(warning);
+					}
+				});
+			}
+		);
+	}
+}
+
+module.exports = TopLevelThisPlugin;