webpack 4.8.2 → 4.9.2

package/lib/optimize/SplitChunksPlugin.js

@@ -10,6 +10,7 @@ const GraphHelpers = require("../GraphHelpers");
 const { isSubset } = require("../util/SetHelpers");
 
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Module")} Module */
 
 const hashFilename = name => {
 	return crypto
@@ -310,7 +311,6 @@ module.exports = class SplitChunksPlugin {
 
 					// Create a list of possible combinations
 					const combinationsCache = new Map(); // Map<string, Set<Chunk>[]>
-					const selectedChunksCacheByChunksSet = new WeakMap(); // WeakMap<Set<Chunk>, WeakMap<Function, {chunks: Chunk[], key: string}>>
 
 					const getCombinations = key => {
 						const chunksSet = chunkSetsInGraph.get(key);
@@ -330,14 +330,36 @@ module.exports = class SplitChunksPlugin {
 						return array;
 					};
 
+					/**
+					 * @typedef {Object} SelectedChunksResult
+					 * @property {Chunk[]} chunks the list of chunks
+					 * @property {string} key a key of the list
+					 */
+
+					/**
+					 * @typedef {function(Chunk): boolean} ChunkFilterFunction
+					 */
+
+					/** @type {WeakMap<Set<Chunk>, WeakMap<ChunkFilterFunction, SelectedChunksResult>>} */
+					const selectedChunksCacheByChunksSet = new WeakMap();
+
+					/**
+					 * get list and key by applying the filter function to the list
+					 * It is cached for performance reasons
+					 * @param {Set<Chunk>} chunks list of chunks
+					 * @param {ChunkFilterFunction} chunkFilter filter function for chunks
+					 * @returns {SelectedChunksResult} list and key
+					 */
 					const getSelectedChunks = (chunks, chunkFilter) => {
 						let entry = selectedChunksCacheByChunksSet.get(chunks);
 						if (entry === undefined) {
-							entry = new Map();
+							entry = new WeakMap();
 							selectedChunksCacheByChunksSet.set(chunks, entry);
 						}
+						/** @type {SelectedChunksResult} */
 						let entry2 = entry.get(chunkFilter);
 						if (entry2 === undefined) {
+							/** @type {Chunk[]} */
 							const selectedChunks = [];
 							for (const chunk of chunks) {
 								if (chunkFilter(chunk)) selectedChunks.push(chunk);
@@ -351,10 +373,76 @@ module.exports = class SplitChunksPlugin {
 						return entry2;
 					};
 
+					/**
+					 * @typedef {Object} ChunksInfoItem
+					 * @property {SortableSet} modules
+					 * @property {TODO} cacheGroup
+					 * @property {string} name
+					 * @property {number} size
+					 * @property {Map<Chunk, number>} chunks
+					 * @property {Set<Chunk>} reuseableChunks
+					 * @property {Set<string>} chunksKeys
+					 */
+
 					// Map a list of chunks to a list of modules
 					// For the key the chunk "index" is used, the value is a SortableSet of modules
+					/** @type {Map<string, ChunksInfoItem>} */
 					const chunksInfoMap = new Map();
 
+					/**
+					 * @param {TODO} cacheGroup the current cache group
+					 * @param {Chunk[]} selectedChunks chunks selected for this module
+					 * @param {string} selectedChunksKey a key of selectedChunks
+					 * @param {Module} module the current module
+					 * @returns {void}
+					 */
+					const addModuleToChunksInfoMap = (
+						cacheGroup,
+						selectedChunks,
+						selectedChunksKey,
+						module
+					) => {
+						// Break if minimum number of chunks is not reached
+						if (selectedChunks.length < cacheGroup.minChunks) return;
+						// Determine name for split chunk
+						const name = cacheGroup.getName(
+							module,
+							selectedChunks,
+							cacheGroup.key
+						);
+						// Create key for maps
+						// When it has a name we use the name as key
+						// Elsewise we create the key from chunks and cache group key
+						// This automatically merges equal names
+						const key =
+							(name && `name:${name}`) ||
+							`chunks:${selectedChunksKey} key:${cacheGroup.key}`;
+						// Add module to maps
+						let info = chunksInfoMap.get(key);
+						if (info === undefined) {
+							chunksInfoMap.set(
+								key,
+								(info = {
+									modules: new SortableSet(undefined, sortByIdentifier),
+									cacheGroup,
+									name,
+									size: 0,
+									chunks: new Map(),
+									reuseableChunks: new Set(),
+									chunksKeys: new Set()
+								})
+							);
+						}
+						info.modules.add(module);
+						info.size += module.size();
+						if (!info.chunksKeys.has(selectedChunksKey)) {
+							info.chunksKeys.add(selectedChunksKey);
+							for (const chunk of selectedChunks) {
+								info.chunks.set(chunk, chunk.getNumberOfModules());
+							}
+						}
+					};
+
 					// Walk through all modules
 					for (const module of compilation.modules) {
 						// Get cache group
@@ -422,55 +510,17 @@ module.exports = class SplitChunksPlugin {
 									chunkCombination,
 									cacheGroup.chunksFilter
 								);
-								// Break if minimum number of chunks is not reached
-								if (selectedChunks.length < cacheGroup.minChunks) continue;
-								// Determine name for split chunk
-								const name = cacheGroup.getName(
-									module,
+
+								addModuleToChunksInfoMap(
+									cacheGroup,
 									selectedChunks,
-									cacheGroup.key
+									selectedChunksKey,
+									module
 								);
-								// Create key for maps
-								// When it has a name we use the name as key
-								// Elsewise we create the key from chunks and cache group key
-								// This automatically merges equal names
-								const key =
-									(name && `name:${name}`) ||
-									`chunks:${selectedChunksKey} key:${cacheGroup.key}`;
-								// Add module to maps
-								let info = chunksInfoMap.get(key);
-								if (info === undefined) {
-									chunksInfoMap.set(
-										key,
-										(info = {
-											modules: new SortableSet(undefined, sortByIdentifier),
-											cacheGroup,
-											name,
-											size: 0,
-											chunks: new Map(),
-											reusedableChunks: new Set(),
-											chunksKeys: new Set()
-										})
-									);
-								}
-								info.modules.add(module);
-								info.size += module.size();
-								if (!info.chunksKeys.has(selectedChunksKey)) {
-									info.chunksKeys.add(selectedChunksKey);
-									for (const chunk of selectedChunks) {
-										info.chunks.set(chunk, chunk.getNumberOfModules());
-									}
-								}
 							}
 						}
 					}
 
-					for (const [key, info] of chunksInfoMap) {
-						// Get size of module lists
-						if (info.size < info.cacheGroup.minSize) {
-							chunksInfoMap.delete(key);
-						}
-					}
 					while (chunksInfoMap.size > 0) {
 						// Find best matching entry
 						let bestEntryKey;
@@ -478,15 +528,20 @@ module.exports = class SplitChunksPlugin {
 						for (const pair of chunksInfoMap) {
 							const key = pair[0];
 							const info = pair[1];
-							if (bestEntry === undefined) {
-								bestEntry = info;
-								bestEntryKey = key;
-							} else if (compareEntries(bestEntry, info) < 0) {
-								bestEntry = info;
-								bestEntryKey = key;
+							if (info.size >= info.cacheGroup.minSize) {
+								if (bestEntry === undefined) {
+									bestEntry = info;
+									bestEntryKey = key;
+								} else if (compareEntries(bestEntry, info) < 0) {
+									bestEntry = info;
+									bestEntryKey = key;
+								}
 							}
 						}
 
+						// No suitable item left
+						if (bestEntry === undefined) break;
+
 						const item = bestEntry;
 						chunksInfoMap.delete(bestEntryKey);
 
@@ -517,12 +572,19 @@ module.exports = class SplitChunksPlugin {
 								}
 							}
 						}
-						const usedChunks = [];
-						// Walk through all chunks
-						for (const chunk of item.chunks.keys()) {
+						// Check if maxRequests condition can be fullfilled
+
+						const usedChunks = Array.from(item.chunks.keys()).filter(chunk => {
 							// skip if we address ourself
-							if ((chunkName && chunk.name === chunkName) || chunk === newChunk)
-								continue;
+							return (
+								(!chunkName || chunk.name !== chunkName) && chunk !== newChunk
+							);
+						});
+
+						// Skip when no chunk selected
+						if (usedChunks.length === 0) continue;
+
+						const chunkInLimit = usedChunks.filter(chunk => {
 							// respect max requests when not enforced
 							const maxRequests = chunk.isOnlyInitial()
 								? item.cacheGroup.maxInitialRequests
@@ -532,88 +594,97 @@ module.exports = class SplitChunksPlugin {
 											item.cacheGroup.maxAsyncRequests
 									  )
 									: item.cacheGroup.maxAsyncRequests;
-							if (isFinite(maxRequests) && getRequests(chunk) >= maxRequests)
-								continue;
-							if (newChunk === undefined) {
-								// Create the new chunk
-								newChunk = compilation.addChunk(chunkName);
+							return !isFinite(maxRequests) || getRequests(chunk) < maxRequests;
+						});
+
+						if (chunkInLimit.length < usedChunks.length) {
+							for (const module of item.modules) {
+								addModuleToChunksInfoMap(
+									item.cacheGroup,
+									chunkInLimit,
+									getKey(chunkInLimit),
+									module
+								);
 							}
+							continue;
+						}
+
+						// Create the new chunk if not reusing one
+						if (!isReused) {
+							newChunk = compilation.addChunk(chunkName);
+						}
+						// Walk through all chunks
+						for (const chunk of usedChunks) {
 							// Add graph connections for splitted chunk
 							chunk.split(newChunk);
-							usedChunks.push(chunk);
 						}
 
-						// If we successfully created a new chunk or reused one
-						if (newChunk) {
-							// Add a note to the chunk
-							newChunk.chunkReason = isReused
-								? "reused as split chunk"
-								: "split chunk";
-							if (item.cacheGroup.key) {
-								newChunk.chunkReason += ` (cache group: ${
-									item.cacheGroup.key
-								})`;
+						// Add a note to the chunk
+						newChunk.chunkReason = isReused
+							? "reused as split chunk"
+							: "split chunk";
+						if (item.cacheGroup.key) {
+							newChunk.chunkReason += ` (cache group: ${item.cacheGroup.key})`;
+						}
+						if (chunkName) {
+							newChunk.chunkReason += ` (name: ${chunkName})`;
+							// If the chosen name is already an entry point we remove the entry point
+							const entrypoint = compilation.entrypoints.get(chunkName);
+							if (entrypoint) {
+								compilation.entrypoints.delete(chunkName);
+								entrypoint.remove();
+								newChunk.entryModule = undefined;
+							}
+						}
+						if (item.cacheGroup.filename) {
+							if (!newChunk.isOnlyInitial()) {
+								throw new Error(
+									"SplitChunksPlugin: You are trying to set a filename for a chunk which is (also) loaded on demand. " +
+										"The runtime can only handle loading of chunks which match the chunkFilename schema. " +
+										"Using a custom filename would fail at runtime. " +
+										`(cache group: ${item.cacheGroup.key})`
+								);
 							}
-							if (chunkName) {
-								newChunk.chunkReason += ` (name: ${chunkName})`;
-								// If the chosen name is already an entry point we remove the entry point
-								const entrypoint = compilation.entrypoints.get(chunkName);
-								if (entrypoint) {
-									compilation.entrypoints.delete(chunkName);
-									entrypoint.remove();
-									newChunk.entryModule = undefined;
+							newChunk.filenameTemplate = item.cacheGroup.filename;
+						}
+						if (!isReused) {
+							// Add all modules to the new chunk
+							for (const module of item.modules) {
+								if (typeof module.chunkCondition === "function") {
+									if (!module.chunkCondition(newChunk)) continue;
+								}
+								// Add module to new chunk
+								GraphHelpers.connectChunkAndModule(newChunk, module);
+								// Remove module from used chunks
+								for (const chunk of usedChunks) {
+									chunk.removeModule(module);
+									module.rewriteChunkInReasons(chunk, [newChunk]);
 								}
 							}
-							if (item.cacheGroup.filename) {
-								if (!newChunk.isOnlyInitial()) {
-									throw new Error(
-										"SplitChunksPlugin: You are trying to set a filename for a chunk which is (also) loaded on demand. " +
-											"The runtime can only handle loading of chunks which match the chunkFilename schema. " +
-											"Using a custom filename would fail at runtime. " +
-											`(cache group: ${item.cacheGroup.key})`
-									);
+						} else {
+							// Remove all modules from used chunks
+							for (const module of item.modules) {
+								for (const chunk of usedChunks) {
+									chunk.removeModule(module);
+									module.rewriteChunkInReasons(chunk, [newChunk]);
 								}
-								newChunk.filenameTemplate = item.cacheGroup.filename;
 							}
-							if (!isReused) {
-								// Add all modules to the new chunk
+						}
+						// remove all modules from other entries and update size
+						for (const [key, info] of chunksInfoMap) {
+							if (isOverlap(info.chunks, item.chunks)) {
+								const oldSize = info.modules.size;
 								for (const module of item.modules) {
-									if (typeof module.chunkCondition === "function") {
-										if (!module.chunkCondition(newChunk)) continue;
-									}
-									// Add module to new chunk
-									GraphHelpers.connectChunkAndModule(newChunk, module);
-									// Remove module from used chunks
-									for (const chunk of usedChunks) {
-										chunk.removeModule(module);
-										module.rewriteChunkInReasons(chunk, [newChunk]);
-									}
+									info.modules.delete(module);
 								}
-							} else {
-								// Remove all modules from used chunks
-								for (const module of item.modules) {
-									for (const chunk of usedChunks) {
-										chunk.removeModule(module);
-										module.rewriteChunkInReasons(chunk, [newChunk]);
-									}
+								if (info.modules.size === 0) {
+									chunksInfoMap.delete(key);
+									continue;
 								}
-							}
-							// remove all modules from other entries and update size
-							for (const [key, info] of chunksInfoMap) {
-								if (isOverlap(info.chunks, item.chunks)) {
-									const oldSize = info.modules.size;
-									for (const module of item.modules) {
-										info.modules.delete(module);
-									}
-									if (info.modules.size === 0) {
+								if (info.modules.size !== oldSize) {
+									info.size = getModulesSize(info.modules);
+									if (info.size < info.cacheGroup.minSize)
 										chunksInfoMap.delete(key);
-										continue;
-									}
-									if (info.modules.size !== oldSize) {
-										info.size = getModulesSize(info.modules);
-										if (info.size < info.cacheGroup.minSize)
-											chunksInfoMap.delete(key);
-									}
 								}
 							}
 						}

package/lib/util/Queue.js

@@ -1,46 +1,46 @@
-"use strict";
-
-/**
- * @template T
- */
-class Queue {
-	/**
-	 * @param {IterableIterator<T>=} items The initial elements.
-	 */
-	constructor(items) {
-		/** @private @type {Set<T>} */
-		this.set = new Set(items);
-		/** @private @type {Iterator<T>} */
-		this.iterator = this.set[Symbol.iterator]();
-	}
-
-	/**
-	 * Returns the number of elements in this queue.
-	 * @returns {number} The number of elements in this queue.
-	 */
-	get length() {
-		return this.set.size;
-	}
-
-	/**
-	 * Appends the specified element to this queue.
-	 * @param {T} item The element to add.
-	 * @returns {void}
-	 */
-	enqueue(item) {
-		this.set.add(item);
-	}
-
-	/**
-	 * Retrieves and removes the head of this queue.
-	 * @returns {T | undefined} The head of the queue of `undefined` if this queue is empty.
-	 */
-	dequeue() {
-		const result = this.iterator.next();
-		if (result.done) return undefined;
-		this.set.delete(result.value);
-		return result.value;
-	}
-}
-
-module.exports = Queue;
+"use strict";
+
+/**
+ * @template T
+ */
+class Queue {
+	/**
+	 * @param {IterableIterator<T>=} items The initial elements.
+	 */
+	constructor(items) {
+		/** @private @type {Set<T>} */
+		this.set = new Set(items);
+		/** @private @type {Iterator<T>} */
+		this.iterator = this.set[Symbol.iterator]();
+	}
+
+	/**
+	 * Returns the number of elements in this queue.
+	 * @returns {number} The number of elements in this queue.
+	 */
+	get length() {
+		return this.set.size;
+	}
+
+	/**
+	 * Appends the specified element to this queue.
+	 * @param {T} item The element to add.
+	 * @returns {void}
+	 */
+	enqueue(item) {
+		this.set.add(item);
+	}
+
+	/**
+	 * Retrieves and removes the head of this queue.
+	 * @returns {T | undefined} The head of the queue of `undefined` if this queue is empty.
+	 */
+	dequeue() {
+		const result = this.iterator.next();
+		if (result.done) return undefined;
+		this.set.delete(result.value);
+		return result.value;
+	}
+}
+
+module.exports = Queue;

package/lib/util/SetHelpers.js

@@ -1,48 +1,48 @@
-"use strict";
-
-/**
- * intersect creates Set containing the intersection of elements between all sets
- * @param {Set[]} sets an array of sets being checked for shared elements
- * @returns {Set<TODO>} returns a new Set containing the intersecting items
- */
-function intersect(sets) {
-	if (sets.length === 0) return new Set();
-	if (sets.length === 1) return new Set(sets[0]);
-	let minSize = Infinity;
-	let minIndex = -1;
-	for (let i = 0; i < sets.length; i++) {
-		const size = sets[i].size;
-		if (size < minSize) {
-			minIndex = i;
-			minSize = size;
-		}
-	}
-	const current = new Set(sets[minIndex]);
-	for (let i = 0; i < sets.length; i++) {
-		if (i === minIndex) continue;
-		const set = sets[i];
-		for (const item of current) {
-			if (!set.has(item)) {
-				current.delete(item);
-			}
-		}
-	}
-	return current;
-}
-
-/**
- * Checks if a set is the subset of another set
- * @param {Set<TODO>} bigSet a Set which contains the original elements to compare against
- * @param {Set<TODO>} smallSet the set whos elements might be contained inside of bigSet
- * @returns {boolean} returns true if smallSet contains all elements inside of the bigSet
- */
-function isSubset(bigSet, smallSet) {
-	if (bigSet.size < smallSet.size) return false;
-	for (const item of smallSet) {
-		if (!bigSet.has(item)) return false;
-	}
-	return true;
-}
-
-exports.intersect = intersect;
-exports.isSubset = isSubset;
+"use strict";
+
+/**
+ * intersect creates Set containing the intersection of elements between all sets
+ * @param {Set[]} sets an array of sets being checked for shared elements
+ * @returns {Set<TODO>} returns a new Set containing the intersecting items
+ */
+function intersect(sets) {
+	if (sets.length === 0) return new Set();
+	if (sets.length === 1) return new Set(sets[0]);
+	let minSize = Infinity;
+	let minIndex = -1;
+	for (let i = 0; i < sets.length; i++) {
+		const size = sets[i].size;
+		if (size < minSize) {
+			minIndex = i;
+			minSize = size;
+		}
+	}
+	const current = new Set(sets[minIndex]);
+	for (let i = 0; i < sets.length; i++) {
+		if (i === minIndex) continue;
+		const set = sets[i];
+		for (const item of current) {
+			if (!set.has(item)) {
+				current.delete(item);
+			}
+		}
+	}
+	return current;
+}
+
+/**
+ * Checks if a set is the subset of another set
+ * @param {Set<TODO>} bigSet a Set which contains the original elements to compare against
+ * @param {Set<TODO>} smallSet the set whos elements might be contained inside of bigSet
+ * @returns {boolean} returns true if smallSet contains all elements inside of the bigSet
+ */
+function isSubset(bigSet, smallSet) {
+	if (bigSet.size < smallSet.size) return false;
+	for (const item of smallSet) {
+		if (!bigSet.has(item)) return false;
+	}
+	return true;
+}
+
+exports.intersect = intersect;
+exports.isSubset = isSubset;