webpack 5.108.4 → 5.109.1

package/lib/optimize/SplitChunksPlugin.js

@@ -182,7 +182,6 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {string=} name
  * @property {SplitChunksSizes} sizes
  * @property {ChunkSet} chunks
- * @property {ChunkSet} reusableChunks
  * @property {Set<bigint | Chunk>} chunksKeys
  */
 
@@ -229,7 +228,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 +312,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
@@ -902,15 +903,21 @@ module.exports = class SplitChunksPlugin {
 					// 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 +1018,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 +1062,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 +1121,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 +1245,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 +1353,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 +1371,6 @@ module.exports = class SplitChunksPlugin {
 									name,
 									sizes: {},
 									chunks: new Set(),
-									reusableChunks: new Set(),
 									chunksKeys: new Set()
 								})
 							);
@@ -1316,6 +1396,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 +1437,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
@@ -1577,12 +1677,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
 									);
 								}

package/lib/prefetch/ChunkPrefetchPreloadPlugin.js

@@ -66,6 +66,21 @@ class ChunkPrefetchPreloadPlugin {
 							new ChunkPreloadTriggerRuntimeModule(chunkMap.preload)
 						);
 					}
+					if (chunkMap.cssPreload) {
+						// CSS-only preload (`parser.javascript.dynamicImportCssPreload`):
+						// reuse `preloadChunk` — with no JS `preload` order the JS
+						// handler is never registered, so only the CSS `.s` handler
+						// fires (`<link rel="preload" as="style">`).
+						set.add(RuntimeGlobals.preloadChunk);
+						set.add(RuntimeGlobals.preloadChunkHandlers);
+						compilation.addRuntimeModule(
+							chunk,
+							new ChunkPreloadTriggerRuntimeModule(
+								chunkMap.cssPreload,
+								"cssPreload"
+							)
+						);
+					}
 				}
 			);
 			compilation.hooks.runtimeRequirementInTree

package/lib/prefetch/ChunkPreloadTriggerRuntimeModule.js

@@ -14,11 +14,14 @@ const Template = require("../Template");
 class ChunkPreloadTriggerRuntimeModule extends RuntimeModule {
 	/**
 	 * @param {ChunkChildIdsByOrdersMap} chunkMap map from chunk to chunks
+	 * @param {string=} handlerKey the `ensureChunkHandlers` key to install under (default `"preload"`); `"cssPreload"` preloads only the CSS handler so it stays CSS-only even when the build also registers a JS preload handler
 	 */
-	constructor(chunkMap) {
-		super("chunk preload trigger", RuntimeModule.STAGE_TRIGGER);
+	constructor(chunkMap, handlerKey = "preload") {
+		super(`chunk ${handlerKey} trigger`, RuntimeModule.STAGE_TRIGGER);
 		/** @type {ChunkChildIdsByOrdersMap} */
 		this.chunkMap = chunkMap;
+		/** @type {string} */
+		this.handlerKey = handlerKey;
 	}
 
 	/**
@@ -26,20 +29,28 @@ class ChunkPreloadTriggerRuntimeModule extends RuntimeModule {
 	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { chunkMap } = this;
+		const { chunkMap, handlerKey } = this;
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const { runtimeTemplate } = compilation;
-		const body = [
-			"var chunks = chunkToChildrenMap[chunkId];",
-			`Array.isArray(chunks) && chunks.map(${RuntimeGlobals.preloadChunk});`
-		];
+		// `cssPreload` calls only the CSS preload handler (`preloadChunkHandlers.s`)
+		// so it stays CSS-only regardless of a JS preload handler registered
+		// elsewhere; plain `preload` fans out to every handler via `preloadChunk`.
+		const body =
+			handlerKey === "cssPreload"
+				? [
+						`var handler = ${RuntimeGlobals.preloadChunkHandlers}.s;`,
+						"var chunks = chunkToChildrenMap[chunkId];",
+						"if (handler && Array.isArray(chunks)) chunks.forEach(handler);"
+					]
+				: [
+						"var chunks = chunkToChildrenMap[chunkId];",
+						`Array.isArray(chunks) && chunks.map(${RuntimeGlobals.preloadChunk});`
+					];
 		return Template.asString([
-			Template.asString([
-				`var chunkToChildrenMap = ${JSON.stringify(chunkMap, null, "\t")};`,
-				`${
-					RuntimeGlobals.ensureChunkHandlers
-				}.preload = ${runtimeTemplate.basicFunction("chunkId", body)};`
-			])
+			`var chunkToChildrenMap = ${JSON.stringify(chunkMap, null, "\t")};`,
+			`${
+				RuntimeGlobals.ensureChunkHandlers
+			}.${handlerKey} = ${runtimeTemplate.basicFunction("chunkId", body)};`
 		]);
 	}
 }