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

package/lib/performance/EvalUsagePlugin.js

@@ -0,0 +1,115 @@
+/*
+	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 EvalUsageWarning = require("../errors/EvalUsageWarning");
+const { compareStrings } = require("../util/comparators");
+
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/** @import { BuildInfo } from "../Module" */
+/** @import JavascriptParser from "../javascript/JavascriptParser" */
+
+const PLUGIN_NAME = "EvalUsagePlugin";
+
+// Enough to name the offenders without listing the graph.
+const MAX_REPORTED_MODULES = 5;
+
+class EvalUsagePlugin {
+	/**
+	 * Creates an instance of EvalUsagePlugin.
+	 * @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
+				 */
+				const handler = (parser) => {
+					// Only a call of the name itself is a direct eval; `(0, eval)()` and
+					// `globalThis.eval()` run in global scope and reach no local name.
+					parser.hooks.call.for("eval").tap(PLUGIN_NAME, () => {
+						// 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.usesEval = true;
+					});
+				};
+
+				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, () => {
+					const { requestShortener } = compilation;
+					/** @type {string[]} */
+					const callers = [];
+
+					for (const module of compilation.modules) {
+						// Every built module carries one, so only the field is in question.
+						const buildInfo = /** @type {BuildInfo} */ (module.buildInfo);
+
+						if (!buildInfo.usesEval) continue;
+
+						callers.push(module.readableIdentifier(requestShortener));
+					}
+
+					if (callers.length === 0) return;
+
+					// Sorted by name: module order is not stable across runs.
+					callers.sort(compareStrings);
+
+					const warning = new EvalUsageWarning(
+						callers.slice(0, MAX_REPORTED_MODULES),
+						callers.length
+					);
+
+					if (hints === "error") {
+						compilation.errors.push(warning);
+					} else if (hints === "stats") {
+						compilation.hints.push(warning);
+					} else {
+						compilation.warnings.push(warning);
+					}
+				});
+			}
+		);
+	}
+}
+
+module.exports = EvalUsagePlugin;

package/lib/performance/HotspotsPlugin.js

@@ -0,0 +1,296 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const NormalModule = require("../NormalModule");
+const HotspotsWarning = require("../errors/HotspotsWarning");
+const { LOADER_TIMING } = require("../loaders/LoaderRunner");
+const { compareStrings } = require("../util/comparators");
+const { contextify } = require("../util/identifier");
+
+/** @typedef {import("tapable").FullTap} FullTap */
+/** @typedef {import("../../declarations/WebpackOptions").PerformanceOptions} PerformanceOptions */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../errors/HotspotsWarning").HookDetails} HookDetails */
+/** @typedef {import("../errors/HotspotsWarning").HotspotDetails} HotspotDetails */
+
+const PLUGIN_NAME = "HotspotsPlugin";
+
+// Enough to name the offenders without listing the whole build.
+const MAX_REPORTED_HOTSPOTS = 5;
+const MAX_REPORTED_HOOKS = 3;
+
+// Below this nothing is waiting on it, and naming it would bury what is.
+const MIN_REPORTED_MS = 100;
+
+// Ahead of every other `compilation` tap: the counters are reset there, and
+// anything measured before that reset would be thrown away by it.
+const INTERCEPT_STAGE = -10000;
+
+const NS_PER_MS = 1e6;
+const MS_PER_SECOND = 1000;
+
+/**
+ * @param {[number, number]} start what `process.hrtime()` returned
+ * @returns {number} milliseconds since then
+ */
+const msSince = (start) => {
+	const [seconds, nanoseconds] = process.hrtime(start);
+
+	return seconds * MS_PER_SECOND + nanoseconds / NS_PER_MS;
+};
+
+/**
+ * @param {Map<string, { ms: number, runs: number }>} map where the time is kept
+ * @param {string} key what ran
+ * @param {number} ms how long its own code took
+ * @returns {void}
+ */
+const charge = (map, key, ms) => {
+	const spent = map.get(key);
+
+	if (spent === undefined) {
+		map.set(key, { ms, runs: 1 });
+		return;
+	}
+
+	spent.ms += ms;
+	spent.runs++;
+};
+
+class HotspotsPlugin {
+	/**
+	 * Creates an instance of HotspotsPlugin.
+	 * @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;
+
+		/** @typedef {{ ms: number, runs: number }} Spent */
+		// Kept per kind: a loader and a plugin could otherwise share a name and
+		// have their runs counted together.
+		/** @type {Map<string, Spent>} */
+		const pluginTime = new Map();
+		/** @type {Map<string, Spent>} */
+		const loaderTime = new Map();
+		/** @type {Map<string, number>} */
+		const hookTime = new Map();
+		// One frame per thing currently running, innermost last. Only the innermost
+		// is charged, so whatever calls out to something else is not billed for it.
+		/** @type {{ child: number }[]} */
+		const running = [];
+
+		/**
+		 * Runs one loader or tap, charging it its own work alone.
+		 * @template T
+		 * @param {Map<string, { ms: number, runs: number }>} map where its time is kept
+		 * @param {string} name what is running
+		 * @param {string | undefined} hookName the hook it runs under, if any
+		 * @param {() => T} run the work, already bound to its arguments
+		 * @returns {T} whatever it returned
+		 */
+		const measure = (map, name, hookName, run) => {
+			const frame = { child: 0 };
+
+			running.push(frame);
+
+			const start = process.hrtime();
+
+			try {
+				return run();
+			} finally {
+				const elapsed = msSince(start);
+				const own = elapsed - frame.child;
+
+				running.pop();
+				charge(map, name, own);
+
+				if (hookName !== undefined) {
+					hookTime.set(hookName, (hookTime.get(hookName) || 0) + own);
+				}
+
+				if (running.length > 0) {
+					running[running.length - 1].child += elapsed;
+				}
+			}
+		};
+
+		/**
+		 * @param {string} hookName the hook being tapped
+		 * @returns {(tapInfo: FullTap) => FullTap} an interceptor for it
+		 */
+		const registerFor = (hookName) => (tapInfo) => {
+			const { name, type, fn } = tapInfo;
+
+			if (name === PLUGIN_NAME) return tapInfo;
+
+			if (type === "async") {
+				return {
+					...tapInfo,
+					/**
+					 * @param {EXPECTED_ANY[]} args the tap's arguments, callback last
+					 * @returns {EXPECTED_ANY} whatever the tap returned
+					 */
+					fn: (...args) => {
+						const callback = args.pop();
+
+						/**
+						 * @param {EXPECTED_ANY[]} result what the tap reported
+						 * @returns {EXPECTED_ANY} whatever the callback returned
+						 */
+						const finish = (...result) =>
+							measure(pluginTime, name, hookName, () => callback(...result));
+
+						// The completion callback is the plugin's own code as well, so it
+						// is charged to the plugin rather than to whoever resumed it.
+						return measure(pluginTime, name, hookName, () =>
+							/** @type {EXPECTED_FUNCTION} */ (fn)(...args, finish)
+						);
+					}
+				};
+			}
+
+			return {
+				...tapInfo,
+				/**
+				 * @param {EXPECTED_ANY[]} args the tap's arguments
+				 * @returns {EXPECTED_ANY} whatever the tap returned
+				 */
+				fn: (...args) =>
+					measure(pluginTime, name, hookName, () =>
+						/** @type {EXPECTED_FUNCTION} */ (fn)(...args)
+					)
+			};
+		};
+
+		/**
+		 * @param {EXPECTED_ANY} instance anything carrying tapable hooks
+		 * @returns {void}
+		 */
+		const interceptAll = (instance) => {
+			for (const hookName of Object.keys(instance.hooks)) {
+				const descriptor = Object.getOwnPropertyDescriptor(
+					instance.hooks,
+					hookName
+				);
+
+				// A hook kept only as an alias for one that moved is an accessor, and
+				// reading it is what prints the deprecation — so it is never read.
+				if (!descriptor || descriptor.get) continue;
+
+				const hook = descriptor.value;
+
+				// A deprecated hook kept as a stand-in throws when intercepted.
+				if (hook && !hook._fakeHook && typeof hook.intercept === "function") {
+					hook.intercept({ register: registerFor(hookName) });
+				}
+			}
+		};
+
+		interceptAll(compiler);
+
+		compiler.hooks.compilation.tap(
+			{ name: PLUGIN_NAME, stage: INTERCEPT_STAGE },
+			(compilation, { normalModuleFactory, contextModuleFactory }) => {
+				// Each build reports its own time. Watching keeps the compiler, so
+				// without this every rebuild would add to the one before it.
+				pluginTime.clear();
+				loaderTime.clear();
+				hookTime.clear();
+				running.length = 0;
+
+				interceptAll(compilation);
+				interceptAll(normalModuleFactory);
+				interceptAll(contextModuleFactory);
+
+				const context = compiler.context;
+
+				// Loaders are not taps, so they are measured where they run instead.
+				NormalModule.getCompilationHooks(compilation).loader.tap(
+					PLUGIN_NAME,
+					(loaderContext) => {
+						/** @type {EXPECTED_ANY} */
+						(loaderContext)[LOADER_TIMING] =
+							/**
+							 * @param {{ path: string }} loader the loader about to run
+							 * @param {() => EXPECTED_ANY} run its own execution
+							 * @returns {EXPECTED_ANY} whatever it returned
+							 */
+							(loader, run) =>
+								measure(
+									loaderTime,
+									contextify(context, loader.path, compiler.root),
+									undefined,
+									run
+								);
+					}
+				);
+			}
+		);
+
+		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, () => {
+				/** @type {HotspotDetails[]} */
+				const hotspots = [];
+
+				// Loaders and plugins never name the same thing, so one ranking over
+				// both double counts nothing.
+				for (const [kind, map] of /** @type {const} */ ([
+					["loader", loaderTime],
+					["plugin", pluginTime]
+				])) {
+					for (const [name, spent] of map) {
+						if (spent.ms < MIN_REPORTED_MS) continue;
+
+						hotspots.push({ kind, name, ms: spent.ms, runs: spent.runs });
+					}
+				}
+
+				if (hotspots.length === 0) return;
+
+				// Ties break by name, though two rarely take the same time.
+				hotspots.sort((a, b) => b.ms - a.ms || compareStrings(a.name, b.name));
+
+				/** @type {HookDetails[]} */
+				const hooks = [...hookTime]
+					.filter(([, ms]) => ms >= MIN_REPORTED_MS)
+					.map(([name, ms]) => ({ name, ms }))
+					.sort((a, b) => b.ms - a.ms || compareStrings(a.name, b.name))
+					.slice(0, MAX_REPORTED_HOOKS);
+
+				const warning = new HotspotsWarning(
+					hotspots.slice(0, MAX_REPORTED_HOTSPOTS),
+					hotspots.length,
+					hooks
+				);
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = HotspotsPlugin;

package/lib/performance/InlinedAssetsPlugin.js

@@ -0,0 +1,99 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const InlinedAssetsWarning = require("../errors/InlinedAssetsWarning");
+const { compareStrings } = require("../util/comparators");
+const getModuleSize = require("./getModuleSize");
+
+/** @import { AssetModuleBuildInfo } from "../asset/AssetModule" */
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/** @import { InlinedAssetDetails } from "../errors/InlinedAssetsWarning" */
+
+const PLUGIN_NAME = "InlinedAssetsPlugin";
+
+// Enough to name the offenders without listing every icon.
+const MAX_REPORTED_ASSETS = 5;
+
+// What the asset modules default `dataUrlCondition.maxSize` is: below it,
+// inlining saves a request for less than it costs in bytes.
+const DEFAULT_MAX_SIZE = 8096;
+
+class InlinedAssetsPlugin {
+	/**
+	 * Creates an instance of InlinedAssetsPlugin.
+	 * @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, () => {
+				/** @type {InlinedAssetDetails[]} */
+				const assets = [];
+				let total = 0;
+
+				for (const module of compilation.modules) {
+					// The parser records whether it inlined, so this asks rather than
+					// deciding from the module's type what it must have done.
+					const buildInfo =
+						/** @type {AssetModuleBuildInfo} */
+						(module.buildInfo);
+
+					if (!buildInfo.dataUrl) continue;
+
+					// Module sizes are estimates and come back fractional.
+					const size = Math.round(getModuleSize(module));
+
+					if (size <= DEFAULT_MAX_SIZE) continue;
+
+					total += size;
+					assets.push({
+						name: module.readableIdentifier(compilation.requestShortener),
+						size
+					});
+				}
+
+				if (assets.length === 0) return;
+
+				// Largest first; ties break by name, module order is not stable.
+				assets.sort(
+					(a, b) => b.size - a.size || compareStrings(a.name, b.name)
+				);
+
+				const warning = new InlinedAssetsWarning(
+					assets.slice(0, MAX_REPORTED_ASSETS),
+					total
+				);
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = InlinedAssetsPlugin;

package/lib/performance/LargeModulesPlugin.js

@@ -0,0 +1,126 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const LargeModulesWarning = require("../errors/LargeModulesWarning");
+const { compareStrings } = require("../util/comparators");
+const getModuleSize = require("./getModuleSize");
+const getSourceModules = require("./getSourceModules");
+
+/** @typedef {import("../../declarations/WebpackOptions").PerformanceOptions} PerformanceOptions */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../errors/LargeModulesWarning").LargeModuleDetails} LargeModuleDetails */
+
+const PLUGIN_NAME = "LargeModulesPlugin";
+
+// Enough to name the offenders without listing the module graph.
+const MAX_REPORTED_MODULES = 5;
+
+// Half of a chunk in a single module is where the chunk really is that module.
+// Below it the weight is spread around and there is nothing single to act on.
+const DOMINANT_SHARE = 0.5;
+
+// Scaled to the asset budget rather than fixed, so raising `maxAssetSize`
+// raises what counts as big enough to be worth naming.
+const MIN_SHARE_OF_ASSET_LIMIT = 0.2;
+
+class LargeModulesPlugin {
+	/**
+	 * Creates an instance of LargeModulesPlugin.
+	 * @param {PerformanceOptions} options the plugin options
+	 */
+	constructor(options) {
+		/** @type {PerformanceOptions["hints"]} */
+		this.hints = options.hints;
+		/** @type {PerformanceOptions["maxAssetSize"]} */
+		this.maxAssetSize = options.maxAssetSize;
+	}
+
+	/**
+	 * 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 minSize =
+			/** @type {number} */ (this.maxAssetSize) * MIN_SHARE_OF_ASSET_LIMIT;
+
+		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, requestShortener } = compilation;
+				/** @type {Map<Module, LargeModuleDetails>} */
+				const worst = new Map();
+
+				for (const chunk of compilation.chunks) {
+					const chunkName = chunk.name || `${chunk.id}`;
+					/** @type {Map<Module, number>} */
+					const sizes = new Map();
+					let chunkSize = 0;
+
+					for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+						// Through scope hoisting one module stands for the several it
+						// absorbed, and it is those the report has to name.
+						for (const inner of getSourceModules(module)) {
+							const size = getModuleSize(inner);
+
+							sizes.set(inner, (sizes.get(inner) || 0) + size);
+							chunkSize += size;
+						}
+					}
+
+					for (const [module, size] of sizes) {
+						if (size < minSize) continue;
+						if (size < chunkSize * DOMINANT_SHARE) continue;
+
+						const previous = worst.get(module);
+
+						// A module weighs the same in every chunk holding it, so the one
+						// named is the first by name — chunk order is not stable.
+						if (previous && compareStrings(previous.chunk, chunkName) <= 0) {
+							continue;
+						}
+
+						worst.set(module, {
+							name: module.readableIdentifier(requestShortener),
+							chunk: chunkName,
+							size,
+							chunkSize
+						});
+					}
+				}
+
+				if (worst.size === 0) return;
+
+				const large = [...worst.values()];
+
+				// Ties break by name: chunk iteration order is not stable.
+				large.sort((a, b) => b.size - a.size || compareStrings(a.name, b.name));
+
+				const warning = new LargeModulesWarning(
+					large.slice(0, MAX_REPORTED_MODULES),
+					large.length
+				);
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = LargeModulesPlugin;