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

package/lib/optimize/SplitChunksPlugin.js

@@ -21,21 +21,28 @@ const { makePathsRelative } = require("../util/identifier");
 const memoize = require("../util/memoize");
 const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 
-/** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksCacheGroup} OptimizationSplitChunksCacheGroup */
-/** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksOptions} OptimizationSplitChunksOptions */
-/** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksSizes} OptimizationSplitChunksSizes */
-/** @typedef {import("../config/defaults").OutputNormalizedWithDefaults} OutputOptions */
-/** @typedef {import("../Chunk").ChunkName} ChunkName */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../Module").SourceType} SourceType */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../Chunk").ChunkFilenameTemplate} ChunkFilenameTemplate */
+/**
+ * @import {
+ * 	OptimizationSplitChunksCacheGroup,
+ * 	OptimizationSplitChunksOptions,
+ * 	OptimizationSplitChunksSizes
+ * } from "../../declarations/WebpackOptions"
+ */
+/**
+ * @import {
+ * 	OutputNormalizedWithDefaults as OutputOptions
+ * } from "../config/defaults"
+ */
+/** @import { ChunkName, ChunkFilenameTemplate } from "../Chunk" */
+/** @import ChunkGraph from "../ChunkGraph" */
+/** @import ChunkGroup from "../ChunkGroup" */
+/** @import Compilation from "../Compilation" */
+/** @import Compiler from "../Compiler" */
+/** @import Module, { SourceType } from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
 /** @typedef {import("../util/deterministicGrouping").GroupedItems<Module>} DeterministicGroupingGroupedItemsForModule */
 /** @typedef {import("../util/deterministicGrouping").Options<Module>} DeterministicGroupingOptionsForModule */
-/** @typedef {import("../util/deterministicGrouping").Sizes} Sizes */
+/** @import { Sizes } from "../util/deterministicGrouping" */
 
 /**
  * Defines the chunk filter fn callback.
@@ -182,7 +189,6 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {string=} name
  * @property {SplitChunksSizes} sizes
  * @property {ChunkSet} chunks
- * @property {ChunkSet} reusableChunks
  * @property {Set<bigint | Chunk>} chunksKeys
  */
 
@@ -213,6 +219,27 @@ const hashFilename = (name, outputOptions) => {
 	return digest.slice(0, 8);
 };
 
+/**
+ * A split `maxInitialRequests`/`maxAsyncRequests` refused, recorded for
+ * `performance.splitChunksCapped`.
+ * @typedef {object} CappedSplit
+ * @property {string} cacheGroup the cache group whose split was refused
+ * @property {Chunk} chunk the chunk it would have been taken out of
+ * @property {"maxAsyncRequests" | "maxInitialRequests"} limit the option that refused it
+ * @property {number} maxRequests the value that option had
+ * @property {number} modules how many modules the split would have moved
+ */
+
+/** @type {WeakMap<Compilation, CappedSplit[]>} */
+const CAPPED_SPLITS = new WeakMap();
+
+/**
+ * Reads back the splits a request cap refused during this compilation.
+ * @param {Compilation} compilation the compilation
+ * @returns {CappedSplit[] | undefined} the refused splits, or `undefined` when nothing recorded them
+ */
+const getCappedSplits = (compilation) => CAPPED_SPLITS.get(compilation);
+
 /**
  * Returns the number of requests.
  * @param {Chunk} chunk the chunk
@@ -229,7 +256,6 @@ const getRequests = (chunk) => {
 /**
  * Returns result.
  * @template {object} T
- * @template {object} R
  * @param {T} obj obj an object
  * @param {(obj: T[keyof T], key: keyof T) => T[keyof T]} fn fn
  * @returns {T} result
@@ -314,6 +340,9 @@ const ASYNC_CHUNK_FILTER = (chunk) => !chunk.canBeInitial();
  */
 const ALL_CHUNK_FILTER = (_chunk) => true;
 
+/** Placeholder until a chunk set group is filled and its signatures are written. */
+const EMPTY_SIGNATURES = new Uint32Array(0);
+
 /**
  * Returns normalized representation.
  * @param {OptimizationSplitChunksSizes | undefined} value the sizes
@@ -689,7 +718,7 @@ const createCacheGroupSource = (options, key, defaultSizeTypes) => {
 
 const PLUGIN_NAME = "SplitChunksPlugin";
 
-module.exports = class SplitChunksPlugin {
+class SplitChunksPlugin {
 	/**
 	 * Creates an instance of SplitChunksPlugin.
 	 * @param {OptimizationSplitChunksOptions=} options plugin options
@@ -896,21 +925,40 @@ module.exports = class SplitChunksPlugin {
 				(chunks) => {
 					if (alreadyOptimized) return;
 					alreadyOptimized = true;
+					const { performance } = compilation.options;
+					// Mirrors both of `SplitChunksCappedPlugin`'s gates: a build that
+					// would not report records nothing and allocates nothing.
+					/** @type {CappedSplit[] | undefined} */
+					let cappedSplits;
+					if (
+						performance !== false &&
+						performance.splitChunksCapped === true &&
+						Boolean(performance.hints)
+					) {
+						cappedSplits = [];
+						CAPPED_SPLITS.set(compilation, cappedSplits);
+					}
 					logger.time("prepare");
 					const chunkGraph = compilation.chunkGraph;
 					const moduleGraph = compilation.moduleGraph;
 					// Give each selected chunk an index (to create strings from chunks)
 					/** @type {Map<Chunk, bigint>} */
 					const chunkIndexMap = new Map();
+					// Dense per-chunk index, folded into the 64 bit membership
+					// signatures that reject non-subsets in getCombinations
+					/** @type {Map<Chunk, number>} */
+					const chunkSignatureBitMap = new Map();
 					const ZERO = BigInt("0");
 					const ONE = BigInt("1");
 					const START = ONE << BigInt("31");
 					let index = START;
+					let denseIndex = 0;
 					for (const chunk of chunks) {
 						chunkIndexMap.set(
 							chunk,
 							index | BigInt((Math.random() * 0x7fffffff) | 0)
 						);
+						chunkSignatureBitMap.set(chunk, denseIndex++ & 63);
 						index <<= ONE;
 					}
 					/**
@@ -1011,7 +1059,36 @@ module.exports = class SplitChunksPlugin {
 						return { chunkSetsInGraph, singleChunkSets };
 					});
 
-					/** @typedef {Map<CountOfChunk, ChunkSet[]>} ChunkSetsByCount */
+					/**
+					 * Chunk sets of equal size, with a 64 bit membership signature
+					 * per set stored as two words at `2 * i` in `signatures`.
+					 * @typedef {object} ChunkSetGroup
+					 * @property {ChunkSet[]} sets the chunk sets
+					 * @property {Uint32Array} signatures two signature words per set
+					 */
+
+					/** @typedef {Map<CountOfChunk, ChunkSetGroup>} ChunkSetsByCount */
+
+					// holds the signature of the set currently being combined; transient
+					const signatureScratch = new Uint32Array(2);
+
+					/**
+					 * Folds a chunk set into a 64 bit membership signature.
+					 * @param {ChunkSet} chunksSet set of chunks
+					 * @param {Uint32Array} out target array
+					 * @param {number} offset index of the first of the two words
+					 * @returns {void}
+					 */
+					const writeSignature = (chunksSet, out, offset) => {
+						out[offset] = 0;
+						out[offset + 1] = 0;
+						for (const chunk of chunksSet) {
+							const bit = /** @type {number} */ (
+								chunkSignatureBitMap.get(chunk)
+							);
+							out[offset + (bit >> 5)] |= 1 << (bit & 31);
+						}
+					};
 
 					// group these set of chunks by count
 					// to allow to check less sets via isSubset
@@ -1026,12 +1103,20 @@ module.exports = class SplitChunksPlugin {
 						const chunkSetsByCount = new Map();
 						for (const chunksSet of chunkSets) {
 							const count = chunksSet.size;
-							let array = chunkSetsByCount.get(count);
-							if (array === undefined) {
-								array = [];
-								chunkSetsByCount.set(count, array);
+							let group = chunkSetsByCount.get(count);
+							if (group === undefined) {
+								group = { sets: [], signatures: EMPTY_SIGNATURES };
+								chunkSetsByCount.set(count, group);
 							}
-							array.push(chunksSet);
+							group.sets.push(chunksSet);
+						}
+						for (const group of chunkSetsByCount.values()) {
+							const { sets } = group;
+							const signatures = new Uint32Array(sets.length * 2);
+							for (let i = 0; i < sets.length; i++) {
+								writeSignature(sets[i], signatures, i * 2);
+							}
+							group.signatures = signatures;
 						}
 						return chunkSetsByCount;
 					};
@@ -1077,10 +1162,24 @@ module.exports = class SplitChunksPlugin {
 								(chunkSets.get(key));
 							/** @type {Combinations} */
 							const array = [chunksSet];
-							for (const [count, setArray] of chunkSetsByCount) {
+							writeSignature(chunksSet, signatureScratch, 0);
+							const selfLow = signatureScratch[0];
+							const selfHigh = signatureScratch[1];
+							for (const [count, group] of chunkSetsByCount) {
 								// "equal" is not needed because they would have been merge in the first step
 								if (count < chunksSet.size) {
-									for (const set of setArray) {
+									const { sets, signatures } = group;
+									for (let i = 0; i < sets.length; i++) {
+										// a subset cannot hold a signature bit the superset lacks,
+										// so this rejects nearly every candidate without touching the Set
+										const offset = i * 2;
+										if (
+											(signatures[offset] & ~selfLow) !== 0 ||
+											(signatures[offset + 1] & ~selfHigh) !== 0
+										) {
+											continue;
+										}
+										const set = sets[i];
 										if (isSubset(chunksSet, set)) {
 											array.push(set);
 										}
@@ -1187,6 +1286,31 @@ module.exports = class SplitChunksPlugin {
 					/** @type {Map<string, ChunksInfoItem>} */
 					const chunksInfoMap = new Map();
 
+					// The unnamed key is derived only from cache group and chunk set, so it
+					// repeats for every module sharing that pair — build the string once
+					/** @type {Map<CacheGroup, Map<bigint | Chunk, string>>} */
+					const unnamedKeyCache = new Map();
+
+					/**
+					 * Returns the chunksInfoMap key for a cache group and chunk set.
+					 * @param {CacheGroup} cacheGroup the current cache group
+					 * @param {bigint | Chunk} selectedChunksKey a key of selectedChunks
+					 * @returns {string} key into chunksInfoMap
+					 */
+					const getUnnamedKey = (cacheGroup, selectedChunksKey) => {
+						let byChunksKey = unnamedKeyCache.get(cacheGroup);
+						if (byChunksKey === undefined) {
+							byChunksKey = new Map();
+							unnamedKeyCache.set(cacheGroup, byChunksKey);
+						}
+						let key = byChunksKey.get(selectedChunksKey);
+						if (key === undefined) {
+							key = `${cacheGroup.key} chunks:${keyToString(selectedChunksKey)}`;
+							byChunksKey.set(selectedChunksKey, key);
+						}
+						return key;
+					};
+
 					/**
 					 * Adds module to chunks info map.
 					 * @param {CacheGroup} cacheGroup the current cache group
@@ -1270,11 +1394,9 @@ module.exports = class SplitChunksPlugin {
 						// When it has a name we use the name as key
 						// Otherwise we create the key from chunks and cache group key
 						// This automatically merges equal names
-						const key =
-							cacheGroup.key +
-							(name
-								? ` name:${name}`
-								: ` chunks:${keyToString(selectedChunksKey)}`);
+						const key = name
+							? `${cacheGroup.key} name:${name}`
+							: getUnnamedKey(cacheGroup, selectedChunksKey);
 						// Add module to maps
 						let info = chunksInfoMap.get(key);
 						if (info === undefined) {
@@ -1290,7 +1412,6 @@ module.exports = class SplitChunksPlugin {
 									name,
 									sizes: {},
 									chunks: new Set(),
-									reusableChunks: new Set(),
 									chunksKeys: new Set()
 								})
 							);
@@ -1316,6 +1437,35 @@ module.exports = class SplitChunksPlugin {
 						chunkGraph
 					};
 
+					/**
+					 * Returns combinations of the chunks the module is in.
+					 * @param {Module} module the module
+					 * @returns {Combinations} chunk combinations
+					 */
+					const computeCombinations = (module) =>
+						getCombinations(getKey(chunkGraph.getModuleChunksIterable(module)));
+
+					/**
+					 * Returns combinations of the module's chunks grouped by used exports.
+					 * @param {Module} module the module
+					 * @returns {Set<ChunkSet | Chunk>} chunk combinations
+					 */
+					const computeCombinationsByUsedExports = (module) => {
+						// fill the groupedByExportsMap
+						getExportsChunkSetsInGraph();
+						/** @type {Set<ChunkSet | Chunk>} */
+						const set = new Set();
+						const groupedByUsedExports =
+							/** @type {Iterable<Chunk[]>} */
+							(groupedByExportsMap.get(module));
+						for (const chunks of groupedByUsedExports) {
+							for (const comb of getExportsCombinations(getKey(chunks))) {
+								set.add(comb);
+							}
+						}
+						return set;
+					};
+
 					logger.timeEnd("prepare");
 
 					logger.time("modules");
@@ -1328,38 +1478,29 @@ module.exports = class SplitChunksPlugin {
 							continue;
 						}
 
-						// Prepare some values (usedExports = false)
-						const getCombs = memoize(() => {
-							const chunks = chunkGraph.getModuleChunksIterable(module);
-							const chunksKey = getKey(chunks);
-							return getCombinations(chunksKey);
-						});
-
-						// Prepare some values (usedExports = true)
-						const getCombsByUsedExports = memoize(() => {
-							// fill the groupedByExportsMap
-							getExportsChunkSetsInGraph();
-							/** @type {Set<ChunkSet | Chunk>} */
-							const set = new Set();
-							const groupedByUsedExports =
-								/** @type {Iterable<Chunk[]>} */
-								(groupedByExportsMap.get(module));
-							for (const chunks of groupedByUsedExports) {
-								const chunksKey = getKey(chunks);
-								for (const comb of getExportsCombinations(chunksKey)) {
-									set.add(comb);
-								}
-							}
-							return set;
-						});
+						// Computed at most once per module, on first use by a cache group
+						/** @type {Combinations | undefined} */
+						let combsCache;
+						/** @type {Set<ChunkSet | Chunk> | undefined} */
+						let combsByUsedExportsCache;
 
 						let cacheGroupIndex = 0;
 						for (const cacheGroupSource of cacheGroups) {
 							const cacheGroup = this._getCacheGroup(cacheGroupSource);
 
-							const combs = cacheGroup.usedExports
-								? getCombsByUsedExports()
-								: getCombs();
+							let combs;
+							if (cacheGroup.usedExports) {
+								if (combsByUsedExportsCache === undefined) {
+									combsByUsedExportsCache =
+										computeCombinationsByUsedExports(module);
+								}
+								combs = combsByUsedExportsCache;
+							} else {
+								if (combsCache === undefined) {
+									combsCache = computeCombinations(module);
+								}
+								combs = combsCache;
+							}
 							// For all combination of chunk selection
 							for (const chunkCombination of combs) {
 								// Break if minimum number of chunks is not reached
@@ -1544,19 +1685,36 @@ module.exports = class SplitChunksPlugin {
 								Number.isFinite(item.cacheGroup.maxAsyncRequests))
 						) {
 							for (const chunk of usedChunks) {
-								// respect max requests
-								const maxRequests = chunk.isOnlyInitial()
-									? item.cacheGroup.maxInitialRequests
-									: chunk.canBeInitial()
-										? Math.min(
-												item.cacheGroup.maxInitialRequests,
-												item.cacheGroup.maxAsyncRequests
-											)
-										: item.cacheGroup.maxAsyncRequests;
+								// respect max requests: a chunk that is both initial and
+								// async answers to the stricter of the two caps
+								const isOnlyInitial = chunk.isOnlyInitial();
+								const byAsyncRequests =
+									!isOnlyInitial &&
+									(!chunk.canBeInitial() ||
+										item.cacheGroup.maxAsyncRequests <
+											item.cacheGroup.maxInitialRequests);
+								const maxRequests = byAsyncRequests
+									? item.cacheGroup.maxAsyncRequests
+									: item.cacheGroup.maxInitialRequests;
 								if (
 									Number.isFinite(maxRequests) &&
 									getRequests(chunk) >= maxRequests
 								) {
+									if (cappedSplits !== undefined) {
+										cappedSplits.push({
+											cacheGroup: item.cacheGroup.key,
+											chunk,
+											// which cap it was cannot be read back off the value:
+											// the two are equal by default in production
+											limit: byAsyncRequests
+												? "maxAsyncRequests"
+												: "maxInitialRequests",
+											maxRequests:
+												/** @type {number} */
+												(maxRequests),
+											modules: item.modules.size
+										});
+									}
 									usedChunks.delete(chunk);
 								}
 							}
@@ -1577,12 +1735,14 @@ module.exports = class SplitChunksPlugin {
 							}
 							if (usedChunks.size >= item.cacheGroup.minChunks) {
 								const chunksArr = [...usedChunks];
+								// invariant across the module loop below
+								const usedChunksKey = getKey(usedChunks);
 								for (const module of item.modules) {
 									addModuleToChunksInfoMap(
 										item.cacheGroup,
 										item.cacheGroupIndex,
 										chunksArr,
-										getKey(usedChunks),
+										usedChunksKey,
 										module
 									);
 								}
@@ -1881,4 +2041,8 @@ module.exports = class SplitChunksPlugin {
 			);
 		});
 	}
-};
+}
+
+SplitChunksPlugin.getCappedSplits = getCappedSplits;
+
+module.exports = SplitChunksPlugin;

package/lib/performance/AssetsOverSizeLimitWarning.js

@@ -8,7 +8,7 @@
 const WebpackError = require("../errors/WebpackError");
 const formatSize = require("../util/formatSize");
 
-/** @typedef {import("./SizeLimitsPlugin").AssetDetails} AssetDetails */
+/** @import { AssetDetails } from "./SizeLimitsPlugin" */
 
 class AssetsOverSizeLimitWarning extends WebpackError {
 	/**
@@ -18,7 +18,15 @@ class AssetsOverSizeLimitWarning extends WebpackError {
 	 */
 	constructor(assetsOverSizeLimit, assetLimit) {
 		const assetLists = assetsOverSizeLimit
-			.map((asset) => `\n  ${asset.name} (${formatSize(asset.size)})`)
+			.map((asset) => {
+				const largest = asset.modules
+					? `\n    Largest modules: ${asset.modules
+							.map((module) => `${module.name} (${formatSize(module.size)})`)
+							.join(", ")}`
+					: "";
+
+				return `\n  ${asset.name} (${formatSize(asset.size)})${largest}`;
+			})
 			.join("");
 
 		super(`asset size limit: The following asset(s) exceed the recommended size limit (${formatSize(

package/lib/performance/AsyncChunkWaterfallsPlugin.js

@@ -0,0 +1,136 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const AsyncChunkWaterfallWarning = require("../errors/AsyncChunkWaterfallWarning");
+
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import ChunkGroup from "../ChunkGroup" */
+/** @import Compiler from "../Compiler" */
+/** @import { WaterfallDetails } from "../errors/AsyncChunkWaterfallWarning" */
+
+const PLUGIN_NAME = "AsyncChunkWaterfallsPlugin";
+
+// Enough to name the offenders without printing the whole chunk graph.
+const MAX_REPORTED_WATERFALLS = 5;
+
+// Two levels is the shape `import()` is for — a route that loads its own data.
+// Three is where the round trips start outweighing what splitting saved.
+const MIN_REPORTED_DEPTH = 3;
+
+class AsyncChunkWaterfallsPlugin {
+	/**
+	 * Creates an instance of AsyncChunkWaterfallsPlugin.
+	 * @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 { chunkGraph } = compilation;
+
+				/**
+				 * The name to print for a group; ids exist by `afterSeal`.
+				 * @param {ChunkGroup} group the group
+				 * @returns {string} what to call it
+				 */
+				const nameOf = (group) => {
+					if (group.name) return group.name;
+
+					const [chunk] = group.chunks;
+
+					return chunk && chunk.id !== null ? `${chunk.id}` : "(unnamed)";
+				};
+
+				// Breadth-first from the initial groups, so the depth recorded for a
+				// group is the fewest requests a client makes to reach it.
+				/** @type {Map<ChunkGroup, ChunkGroup[]>} */
+				const pathTo = new Map();
+				/** @type {ChunkGroup[]} */
+				const queue = [];
+
+				for (const group of compilation.chunkGroups) {
+					if (!group.isInitial()) continue;
+
+					pathTo.set(group, []);
+					queue.push(group);
+				}
+
+				/** @type {WaterfallDetails[]} */
+				const waterfalls = [];
+				let deepest = 0;
+
+				for (let i = 0; i < queue.length; i++) {
+					const group = queue[i];
+					const path = /** @type {ChunkGroup[]} */ (pathTo.get(group));
+
+					for (const child of group.getChildren()) {
+						if (pathTo.has(child)) continue;
+
+						const childPath = [...path, child];
+
+						pathTo.set(child, childPath);
+						queue.push(child);
+
+						if (childPath.length < MIN_REPORTED_DEPTH) continue;
+
+						// Only the end of a chain is reported: every prefix of it is a
+						// waterfall too, and naming them all says the same thing N times.
+						if (child.getNumberOfChildren() > 0) continue;
+
+						let size = 0;
+
+						for (const step of childPath) {
+							for (const chunk of step.chunks) {
+								size += chunkGraph.getChunkSize(chunk);
+							}
+						}
+
+						deepest = Math.max(deepest, childPath.length);
+						waterfalls.push({ chain: childPath.map(nameOf), size });
+					}
+				}
+
+				if (waterfalls.length === 0) return;
+
+				// Deepest first, then largest: the worst round-trip cost leads.
+				waterfalls.sort(
+					(a, b) => b.chain.length - a.chain.length || b.size - a.size
+				);
+
+				const warning = new AsyncChunkWaterfallWarning(
+					waterfalls.slice(0, MAX_REPORTED_WATERFALLS),
+					deepest
+				);
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = AsyncChunkWaterfallsPlugin;