webpack 5.59.0 → 5.94.0

package/lib/util/deterministicGrouping.js

@@ -25,7 +25,6 @@
 // 3.2% that 5 or more groups are invalidated
 
 /**
- *
  * @param {string} a key
  * @param {string} b key
  * @returns {number} the similarity as number
@@ -94,7 +93,8 @@ const subtractSizeFrom = (total, size) => {
 };
 
 /**
- * @param {Iterable<Node>} nodes some nodes
+ * @template T
+ * @param {Iterable<Node<T>>} nodes some nodes
  * @returns {Record<string, number>} total size
  */
 const sumSize = nodes => {
@@ -105,43 +105,58 @@ const sumSize = nodes => {
 	return sum;
 };
 
+/**
+ * @param {Record<string, number>} size size
+ * @param {Record<string, number>} maxSize minimum size
+ * @returns {boolean} true, when size is too big
+ */
 const isTooBig = (size, maxSize) => {
 	for (const key of Object.keys(size)) {
 		const s = size[key];
 		if (s === 0) continue;
 		const maxSizeValue = maxSize[key];
-		if (typeof maxSizeValue === "number") {
-			if (s > maxSizeValue) return true;
-		}
+		if (typeof maxSizeValue === "number" && s > maxSizeValue) return true;
 	}
 	return false;
 };
 
+/**
+ * @param {Record<string, number>} size size
+ * @param {Record<string, number>} minSize minimum size
+ * @returns {boolean} true, when size is too small
+ */
 const isTooSmall = (size, minSize) => {
 	for (const key of Object.keys(size)) {
 		const s = size[key];
 		if (s === 0) continue;
 		const minSizeValue = minSize[key];
-		if (typeof minSizeValue === "number") {
-			if (s < minSizeValue) return true;
-		}
+		if (typeof minSizeValue === "number" && s < minSizeValue) return true;
 	}
 	return false;
 };
 
+/**
+ * @param {Record<string, number>} size size
+ * @param {Record<string, number>} minSize minimum size
+ * @returns {Set<string>} set of types that are too small
+ */
 const getTooSmallTypes = (size, minSize) => {
 	const types = new Set();
 	for (const key of Object.keys(size)) {
 		const s = size[key];
 		if (s === 0) continue;
 		const minSizeValue = minSize[key];
-		if (typeof minSizeValue === "number") {
-			if (s < minSizeValue) types.add(key);
-		}
+		if (typeof minSizeValue === "number" && s < minSizeValue) types.add(key);
 	}
 	return types;
 };
 
+/**
+ * @template T
+ * @param {TODO} size size
+ * @param {Set<string>} types types
+ * @returns {number} number of matching size types
+ */
 const getNumberOfMatchingSizeTypes = (size, types) => {
 	let i = 0;
 	for (const key of Object.keys(size)) {
@@ -150,6 +165,11 @@ const getNumberOfMatchingSizeTypes = (size, types) => {
 	return i;
 };
 
+/**
+ * @param {Record<string, number>} size size
+ * @param {Set<string>} types types
+ * @returns {number} selective size sum
+ */
 const selectiveSizeSum = (size, types) => {
 	let sum = 0;
 	for (const key of Object.keys(size)) {
@@ -180,20 +200,20 @@ class Node {
 class Group {
 	/**
 	 * @param {Node<T>[]} nodes nodes
-	 * @param {number[]} similarities similarities between the nodes (length = nodes.length - 1)
+	 * @param {number[] | null} similarities similarities between the nodes (length = nodes.length - 1)
 	 * @param {Record<string, number>=} size size of the group
 	 */
 	constructor(nodes, similarities, size) {
 		this.nodes = nodes;
 		this.similarities = similarities;
 		this.size = size || sumSize(nodes);
-		/** @type {string} */
+		/** @type {string | undefined} */
 		this.key = undefined;
 	}
 
 	/**
-	 * @param {function(Node): boolean} filter filter function
-	 * @returns {Node[]} removed nodes
+	 * @param {function(Node<T>): boolean} filter filter function
+	 * @returns {Node<T>[] | undefined} removed nodes
 	 */
 	popNodes(filter) {
 		const newNodes = [];
@@ -208,15 +228,15 @@ class Group {
 				if (newNodes.length > 0) {
 					newSimilarities.push(
 						lastNode === this.nodes[i - 1]
-							? this.similarities[i - 1]
-							: similarity(lastNode.key, node.key)
+							? /** @type {number[]} */ (this.similarities)[i - 1]
+							: similarity(/** @type {Node<T>} */ (lastNode).key, node.key)
 					);
 				}
 				newNodes.push(node);
 				lastNode = node;
 			}
 		}
-		if (resultNodes.length === this.nodes.length) return undefined;
+		if (resultNodes.length === this.nodes.length) return;
 		this.nodes = newNodes;
 		this.similarities = newSimilarities;
 		this.size = sumSize(newNodes);
@@ -225,14 +245,15 @@ class Group {
 }
 
 /**
- * @param {Iterable<Node>} nodes nodes
+ * @template T
+ * @param {Iterable<Node<T>>} nodes nodes
  * @returns {number[]} similarities
  */
 const getSimilarities = nodes => {
 	// calculate similarities between lexically adjacent nodes
 	/** @type {number[]} */
 	const similarities = [];
-	let last = undefined;
+	let last;
 	for (const node of nodes) {
 		if (last !== undefined) {
 			similarities.push(similarity(last.key, node.key));
@@ -244,7 +265,7 @@ const getSimilarities = nodes => {
 
 /**
  * @template T
- * @typedef {Object} GroupedItems<T>
+ * @typedef {object} GroupedItems<T>
  * @property {string} key
  * @property {T[]} items
  * @property {Record<string, number>} size
@@ -252,7 +273,7 @@ const getSimilarities = nodes => {
 
 /**
  * @template T
- * @typedef {Object} Options
+ * @typedef {object} Options
  * @property {Record<string, number>} maxSize maximum size of a group
  * @property {Record<string, number>} minSize minimum size of a group (preferred over maximum size)
  * @property {Iterable<T>} items a list of items
@@ -297,6 +318,11 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 	if (initialNodes.length > 0) {
 		const initialGroup = new Group(initialNodes, getSimilarities(initialNodes));
 
+		/**
+		 * @param {Group<T>} group group
+		 * @param {Record<string, number>} consideredSize size of the group to consider
+		 * @returns {boolean} true, if the group was modified
+		 */
 		const removeProblematicNodes = (group, consideredSize = group.size) => {
 			const problemTypes = getTooSmallTypes(consideredSize, minSize);
 			if (problemTypes.size > 0) {
@@ -338,16 +364,15 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 					result.push(new Group(problemNodes, null));
 				}
 				return true;
-			} else {
-				return false;
 			}
+			return false;
 		};
 
 		if (initialGroup.nodes.length > 0) {
 			const queue = [initialGroup];
 
 			while (queue.length) {
-				const group = queue.pop();
+				const group = /** @type {Group<T>} */ (queue.pop());
 				// only groups bigger than maxSize need to be splitted
 				if (!isTooBig(group.size, maxSize)) {
 					result.push(group);
@@ -365,14 +390,14 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 				// going minSize from left and right
 				// at least one node need to be included otherwise we get stuck
 				let left = 1;
-				let leftSize = Object.create(null);
+				const leftSize = Object.create(null);
 				addSizeTo(leftSize, group.nodes[0].size);
 				while (left < group.nodes.length && isTooSmall(leftSize, minSize)) {
 					addSizeTo(leftSize, group.nodes[left].size);
 					left++;
 				}
 				let right = group.nodes.length - 2;
-				let rightSize = Object.create(null);
+				const rightSize = Object.create(null);
 				addSizeTo(rightSize, group.nodes[group.nodes.length - 1].size);
 				while (right >= 0 && isTooSmall(rightSize, minSize)) {
 					addSizeTo(rightSize, group.nodes[right].size);
@@ -420,7 +445,7 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 					let best = -1;
 					let bestSimilarity = Infinity;
 					let pos = left;
-					let rightSize = sumSize(group.nodes.slice(pos));
+					const rightSize = sumSize(group.nodes.slice(pos));
 
 					//       pos v   v right
 					// [ O O O ] O O O [ O O O ]
@@ -428,7 +453,9 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 					// rightSize ^^^^^^^^^^^^^^^
 
 					while (pos <= right + 1) {
-						const similarity = group.similarities[pos - 1];
+						const similarity = /** @type {number[]} */ (group.similarities)[
+							pos - 1
+						];
 						if (
 							similarity < bestSimilarity &&
 							!isTooSmall(leftSize, minSize) &&
@@ -458,7 +485,9 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 				/** @type {number[]} */
 				const rightSimilarities = [];
 				for (let i = right + 2; i < group.nodes.length; i++) {
-					rightSimilarities.push(group.similarities[i - 1]);
+					rightSimilarities.push(
+						/** @type {number[]} */ (group.similarities)[i - 1]
+					);
 					rightNodes.push(group.nodes[i]);
 				}
 				queue.push(new Group(rightNodes, rightSimilarities));
@@ -467,7 +496,9 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 				/** @type {number[]} */
 				const leftSimilarities = [];
 				for (let i = 1; i < left; i++) {
-					leftSimilarities.push(group.similarities[i - 1]);
+					leftSimilarities.push(
+						/** @type {number[]} */ (group.similarities)[i - 1]
+					);
 					leftNodes.push(group.nodes[i]);
 				}
 				queue.push(new Group(leftNodes, leftSimilarities));
@@ -497,12 +528,13 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 	}
 
 	// return the results
-	return result.map(group => {
-		/** @type {GroupedItems} */
-		return {
-			key: group.key,
-			items: group.nodes.map(node => node.item),
-			size: group.size
-		};
-	});
+	return result.map(
+		group =>
+			/** @type {GroupedItems<T>} */
+			({
+				key: group.key,
+				items: group.nodes.map(node => node.item),
+				size: group.size
+			})
+	);
 };

package/lib/util/extractUrlAndGlobal.js

@@ -11,5 +11,8 @@
  */
 module.exports = function extractUrlAndGlobal(urlAndGlobal) {
 	const index = urlAndGlobal.indexOf("@");
+	if (index <= 0 || index === urlAndGlobal.length - 1) {
+		throw new Error(`Invalid request "${urlAndGlobal}"`);
+	}
 	return [urlAndGlobal.substring(index + 1), urlAndGlobal.substring(0, index)];
 };

package/lib/util/findGraphRoots.js

@@ -41,7 +41,7 @@ class Cycle {
 
 /**
  * @template T
- * @typedef {Object} StackEntry
+ * @typedef {object} StackEntry
  * @property {Node<T>} node
  * @property {Node<T>[]} openEdges
  */
@@ -109,7 +109,9 @@ module.exports = (items, getDependencies) => {
 				// Are there still edges unprocessed in the current node?
 				if (topOfStack.openEdges.length > 0) {
 					// Process one dependency
-					const dependency = topOfStack.openEdges.pop();
+					const dependency =
+						/** @type {Node<T>} */
+						(topOfStack.openEdges.pop());
 					switch (dependency.marker) {
 						case NO_MARKER:
 							// dependency has not be visited yet
@@ -169,7 +171,7 @@ module.exports = (items, getDependencies) => {
 							// so it's not really a root cycle
 							// remove the cycle from the root cycles
 							// and convert it to a normal node
-							rootCycles.delete(dependency.cycle);
+							rootCycles.delete(/** @type {Cycle<T>} */ (dependency.cycle));
 							dependency.marker = DONE_MARKER;
 							break;
 						// DONE_MARKER: nothing to do, don't recurse into dependencies
@@ -223,7 +225,7 @@ module.exports = (items, getDependencies) => {
 	// When roots were found, return them
 	if (roots.size > 0) {
 		return Array.from(roots, r => r.item);
-	} else {
-		throw new Error("Implementation of findGraphRoots is broken");
 	}
+
+	throw new Error("Implementation of findGraphRoots is broken");
 };