webpack 5.59.0 → 5.94.0

package/lib/ids/HashedModuleIdsPlugin.js

@@ -10,9 +10,13 @@ const {
 } = require("../util/comparators");
 const createSchemaValidation = require("../util/create-schema-validation");
 const createHash = require("../util/createHash");
-const { getUsedModuleIds, getFullModuleName } = require("./IdHelpers");
+const {
+	getUsedModuleIdsAndModules,
+	getFullModuleName
+} = require("./IdHelpers");
 
 /** @typedef {import("../../declarations/plugins/HashedModuleIdsPlugin").HashedModuleIdsPluginOptions} HashedModuleIdsPluginOptions */
+/** @typedef {import("../Compiler")} Compiler */
 
 const validate = createSchemaValidation(
 	require("../../schemas/plugins/HashedModuleIdsPlugin.check.js"),
@@ -32,7 +36,7 @@ class HashedModuleIdsPlugin {
 
 		/** @type {HashedModuleIdsPluginOptions} */
 		this.options = {
-			context: null,
+			context: undefined,
 			hashFunction: "md4",
 			hashDigest: "base64",
 			hashDigestLength: 4,
@@ -40,35 +44,39 @@ class HashedModuleIdsPlugin {
 		};
 	}
 
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
 	apply(compiler) {
 		const options = this.options;
 		compiler.hooks.compilation.tap("HashedModuleIdsPlugin", compilation => {
-			compilation.hooks.moduleIds.tap("HashedModuleIdsPlugin", modules => {
+			compilation.hooks.moduleIds.tap("HashedModuleIdsPlugin", () => {
 				const chunkGraph = compilation.chunkGraph;
 				const context = this.options.context
 					? this.options.context
 					: compiler.context;
 
-				const usedIds = getUsedModuleIds(compilation);
-				const modulesInNaturalOrder = Array.from(modules)
-					.filter(m => {
-						if (!m.needId) return false;
-						if (chunkGraph.getNumberOfModuleChunks(m) === 0) return false;
-						return chunkGraph.getModuleId(module) === null;
-					})
-					.sort(
-						compareModulesByPreOrderIndexOrIdentifier(compilation.moduleGraph)
-					);
+				const [usedIds, modules] = getUsedModuleIdsAndModules(compilation);
+				const modulesInNaturalOrder = modules.sort(
+					compareModulesByPreOrderIndexOrIdentifier(compilation.moduleGraph)
+				);
 				for (const module of modulesInNaturalOrder) {
 					const ident = getFullModuleName(module, context, compiler.root);
-					const hash = createHash(options.hashFunction);
+					const hash = createHash(
+						/** @type {NonNullable<HashedModuleIdsPluginOptions["hashFunction"]>} */ (
+							options.hashFunction
+						)
+					);
 					hash.update(ident || "");
 					const hashId = /** @type {string} */ (
 						hash.digest(options.hashDigest)
 					);
 					let len = options.hashDigestLength;
-					while (usedIds.has(hashId.substr(0, len))) len++;
-					const moduleId = hashId.substr(0, len);
+					while (usedIds.has(hashId.slice(0, len)))
+						/** @type {number} */ (len)++;
+					const moduleId = hashId.slice(0, len);
 					chunkGraph.setModuleId(module, moduleId);
 					usedIds.add(moduleId);
 				}

package/lib/ids/IdHelpers.js

@@ -25,7 +25,7 @@ const getHash = (str, len, hashFunction) => {
 	const hash = createHash(hashFunction);
 	hash.update(str);
 	const digest = /** @type {string} */ (hash.digest("hex"));
-	return digest.substr(0, len);
+	return digest.slice(0, len);
 };
 
 /**
@@ -43,7 +43,7 @@ const avoidNumber = str => {
 	} else if (firstChar > 57) {
 		return str;
 	}
-	if (str === +str + "") {
+	if (str === String(Number(str))) {
 		return `_${str}`;
 	}
 	return str;
@@ -53,12 +53,9 @@ const avoidNumber = str => {
  * @param {string} request the request
  * @returns {string} id representation
  */
-const requestToId = request => {
-	return request
-		.replace(/^(\.\.?\/)+/, "")
-		.replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, "_");
-};
-exports.requestToId = requestToId;
+const requestToId = request =>
+	request.replace(/^(\.\.?\/)+/, "").replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, "_");
+module.exports.requestToId = requestToId;
 
 /**
  * @param {string} string the string
@@ -78,7 +75,7 @@ const shortenLongString = (string, delimiter, hashFunction) => {
 /**
  * @param {Module} module the module
  * @param {string} context context directory
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {object=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} short module name
  */
 const getShortModuleName = (module, context, associatedObjectForCache) => {
@@ -91,14 +88,14 @@ const getShortModuleName = (module, context, associatedObjectForCache) => {
 		);
 	return "";
 };
-exports.getShortModuleName = getShortModuleName;
+module.exports.getShortModuleName = getShortModuleName;
 
 /**
  * @param {string} shortName the short name
  * @param {Module} module the module
  * @param {string} context context directory
  * @param {string | Hash} hashFunction hash function to use
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {object=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} long module name
  */
 const getLongModuleName = (
@@ -111,22 +108,17 @@ const getLongModuleName = (
 	const fullName = getFullModuleName(module, context, associatedObjectForCache);
 	return `${shortName}?${getHash(fullName, 4, hashFunction)}`;
 };
-exports.getLongModuleName = getLongModuleName;
+module.exports.getLongModuleName = getLongModuleName;
 
 /**
  * @param {Module} module the module
  * @param {string} context context directory
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {object=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} full module name
  */
-const getFullModuleName = (module, context, associatedObjectForCache) => {
-	return makePathsRelative(
-		context,
-		module.identifier(),
-		associatedObjectForCache
-	);
-};
-exports.getFullModuleName = getFullModuleName;
+const getFullModuleName = (module, context, associatedObjectForCache) =>
+	makePathsRelative(context, module.identifier(), associatedObjectForCache);
+module.exports.getFullModuleName = getFullModuleName;
 
 /**
  * @param {Chunk} chunk the chunk
@@ -134,7 +126,7 @@ exports.getFullModuleName = getFullModuleName;
  * @param {string} context context directory
  * @param {string} delimiter delimiter for names
  * @param {string | Hash} hashFunction hash function to use
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {object=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} short chunk name
  */
 const getShortChunkName = (
@@ -156,7 +148,7 @@ const getShortChunkName = (
 		.join(delimiter);
 	return shortenLongString(chunkName, delimiter, hashFunction);
 };
-exports.getShortChunkName = getShortChunkName;
+module.exports.getShortChunkName = getShortChunkName;
 
 /**
  * @param {Chunk} chunk the chunk
@@ -164,7 +156,7 @@ exports.getShortChunkName = getShortChunkName;
  * @param {string} context context directory
  * @param {string} delimiter delimiter for names
  * @param {string | Hash} hashFunction hash function to use
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {object=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} short chunk name
  */
 const getLongChunkName = (
@@ -191,13 +183,13 @@ const getLongChunkName = (
 		.join(delimiter);
 	return shortenLongString(chunkName, delimiter, hashFunction);
 };
-exports.getLongChunkName = getLongChunkName;
+module.exports.getLongChunkName = getLongChunkName;
 
 /**
  * @param {Chunk} chunk the chunk
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {string} context context directory
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {object=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} full chunk name
  */
 const getFullChunkName = (
@@ -213,7 +205,7 @@ const getFullChunkName = (
 	);
 	return fullModuleNames.join();
 };
-exports.getFullChunkName = getFullChunkName;
+module.exports.getFullChunkName = getFullChunkName;
 
 /**
  * @template K
@@ -234,29 +226,38 @@ const addToMapOfItems = (map, key, value) => {
 
 /**
  * @param {Compilation} compilation the compilation
- * @returns {Set<string>} used module ids as strings
+ * @param {function(Module): boolean=} filter filter modules
+ * @returns {[Set<string>, Module[]]} used module ids as strings and modules without id matching the filter
  */
-const getUsedModuleIds = compilation => {
+const getUsedModuleIdsAndModules = (compilation, filter) => {
 	const chunkGraph = compilation.chunkGraph;
 
+	const modules = [];
+
 	/** @type {Set<string>} */
 	const usedIds = new Set();
 	if (compilation.usedModuleIds) {
 		for (const id of compilation.usedModuleIds) {
-			usedIds.add(id + "");
+			usedIds.add(String(id));
 		}
 	}
 
 	for (const module of compilation.modules) {
+		if (!module.needId) continue;
 		const moduleId = chunkGraph.getModuleId(module);
 		if (moduleId !== null) {
-			usedIds.add(moduleId + "");
+			usedIds.add(String(moduleId));
+		} else if (
+			(!filter || filter(module)) &&
+			chunkGraph.getNumberOfModuleChunks(module) !== 0
+		) {
+			modules.push(module);
 		}
 	}
 
-	return usedIds;
+	return [usedIds, modules];
 };
-exports.getUsedModuleIds = getUsedModuleIds;
+module.exports.getUsedModuleIdsAndModules = getUsedModuleIdsAndModules;
 
 /**
  * @param {Compilation} compilation the compilation
@@ -267,20 +268,20 @@ const getUsedChunkIds = compilation => {
 	const usedIds = new Set();
 	if (compilation.usedChunkIds) {
 		for (const id of compilation.usedChunkIds) {
-			usedIds.add(id + "");
+			usedIds.add(String(id));
 		}
 	}
 
 	for (const chunk of compilation.chunks) {
 		const chunkId = chunk.id;
 		if (chunkId !== null) {
-			usedIds.add(chunkId + "");
+			usedIds.add(String(chunkId));
 		}
 	}
 
 	return usedIds;
 };
-exports.getUsedChunkIds = getUsedChunkIds;
+module.exports.getUsedChunkIds = getUsedChunkIds;
 
 /**
  * @template T
@@ -348,7 +349,7 @@ const assignNames = (
 	unnamedItems.sort(comparator);
 	return unnamedItems;
 };
-exports.assignNames = assignNames;
+module.exports.assignNames = assignNames;
 
 /**
  * @template T
@@ -359,6 +360,7 @@ exports.assignNames = assignNames;
  * @param {number[]} ranges usable ranges for ids
  * @param {number} expandFactor factor to create more ranges
  * @param {number} extraSpace extra space to allocate, i. e. when some ids are already used
+ * @param {number} salt salting number to initialize hashing
  * @returns {void}
  */
 const assignDeterministicIds = (
@@ -368,13 +370,14 @@ const assignDeterministicIds = (
 	assignId,
 	ranges = [10],
 	expandFactor = 10,
-	extraSpace = 0
+	extraSpace = 0,
+	salt = 0
 ) => {
 	items.sort(comparator);
 
 	// max 5% fill rate
 	const optimalRange = Math.min(
-		Math.ceil(items.length * 20) + extraSpace,
+		items.length * 20 + extraSpace,
 		Number.MAX_SAFE_INTEGER
 	);
 
@@ -384,42 +387,49 @@ const assignDeterministicIds = (
 		i++;
 		if (i < ranges.length) {
 			range = Math.min(ranges[i], Number.MAX_SAFE_INTEGER);
-		} else {
+		} else if (expandFactor) {
 			range = Math.min(range * expandFactor, Number.MAX_SAFE_INTEGER);
+		} else {
+			break;
 		}
 	}
 
 	for (const item of items) {
 		const ident = getName(item);
 		let id;
-		let i = 0;
+		let i = salt;
 		do {
 			id = numberHash(ident + i++, range);
 		} while (!assignId(item, id));
 	}
 };
-exports.assignDeterministicIds = assignDeterministicIds;
+module.exports.assignDeterministicIds = assignDeterministicIds;
 
 /**
+ * @param {Set<string>} usedIds used ids
  * @param {Iterable<Module>} modules the modules
  * @param {Compilation} compilation the compilation
  * @returns {void}
  */
-const assignAscendingModuleIds = (modules, compilation) => {
+const assignAscendingModuleIds = (usedIds, modules, compilation) => {
 	const chunkGraph = compilation.chunkGraph;
 
-	const usedIds = getUsedModuleIds(compilation);
-
 	let nextId = 0;
 	let assignId;
 	if (usedIds.size > 0) {
+		/**
+		 * @param {Module} module the module
+		 */
 		assignId = module => {
 			if (chunkGraph.getModuleId(module) === null) {
-				while (usedIds.has(nextId + "")) nextId++;
+				while (usedIds.has(String(nextId))) nextId++;
 				chunkGraph.setModuleId(module, nextId++);
 			}
 		};
 	} else {
+		/**
+		 * @param {Module} module the module
+		 */
 		assignId = module => {
 			if (chunkGraph.getModuleId(module) === null) {
 				chunkGraph.setModuleId(module, nextId++);
@@ -430,7 +440,7 @@ const assignAscendingModuleIds = (modules, compilation) => {
 		assignId(module);
 	}
 };
-exports.assignAscendingModuleIds = assignAscendingModuleIds;
+module.exports.assignAscendingModuleIds = assignAscendingModuleIds;
 
 /**
  * @param {Iterable<Chunk>} chunks the chunks
@@ -444,7 +454,7 @@ const assignAscendingChunkIds = (chunks, compilation) => {
 	if (usedIds.size > 0) {
 		for (const chunk of chunks) {
 			if (chunk.id === null) {
-				while (usedIds.has(nextId + "")) nextId++;
+				while (usedIds.has(String(nextId))) nextId++;
 				chunk.id = nextId;
 				chunk.ids = [nextId];
 				nextId++;
@@ -460,4 +470,4 @@ const assignAscendingChunkIds = (chunks, compilation) => {
 		}
 	}
 };
-exports.assignAscendingChunkIds = assignAscendingChunkIds;
+module.exports.assignAscendingChunkIds = assignAscendingChunkIds;

package/lib/ids/NamedChunkIdsPlugin.js

@@ -14,11 +14,21 @@ const {
 	assignAscendingChunkIds
 } = require("./IdHelpers");
 
+/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} Output */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
 
+/**
+ * @typedef {object} NamedChunkIdsPluginOptions
+ * @property {string} [context] context
+ * @property {string} [delimiter] delimiter
+ */
+
 class NamedChunkIdsPlugin {
+	/**
+	 * @param {NamedChunkIdsPluginOptions=} options options
+	 */
 	constructor(options) {
 		this.delimiter = (options && options.delimiter) || "-";
 		this.context = options && options.context;
@@ -31,7 +41,9 @@ class NamedChunkIdsPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap("NamedChunkIdsPlugin", compilation => {
-			const { hashFunction } = compilation.outputOptions;
+			const hashFunction =
+				/** @type {NonNullable<Output["hashFunction"]>} */
+				(compilation.outputOptions.hashFunction);
 			compilation.hooks.chunkIds.tap("NamedChunkIdsPlugin", chunks => {
 				const chunkGraph = compilation.chunkGraph;
 				const context = this.context ? this.context : compiler.context;

package/lib/ids/NamedModuleIdsPlugin.js

@@ -10,16 +10,25 @@ const {
 	getShortModuleName,
 	getLongModuleName,
 	assignNames,
-	getUsedModuleIds,
+	getUsedModuleIdsAndModules,
 	assignAscendingModuleIds
 } = require("./IdHelpers");
 
+/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} Output */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
 
+/**
+ * @typedef {object} NamedModuleIdsPluginOptions
+ * @property {string} [context] context
+ */
+
 class NamedModuleIdsPlugin {
-	constructor(options) {
-		this.options = options || {};
+	/**
+	 * @param {NamedModuleIdsPluginOptions} [options] options
+	 */
+	constructor(options = {}) {
+		this.options = options;
 	}
 
 	/**
@@ -30,28 +39,27 @@ class NamedModuleIdsPlugin {
 	apply(compiler) {
 		const { root } = compiler;
 		compiler.hooks.compilation.tap("NamedModuleIdsPlugin", compilation => {
-			const { hashFunction } = compilation.outputOptions;
-			compilation.hooks.moduleIds.tap("NamedModuleIdsPlugin", modules => {
+			const hashFunction =
+				/** @type {NonNullable<Output["hashFunction"]>} */
+				(compilation.outputOptions.hashFunction);
+			compilation.hooks.moduleIds.tap("NamedModuleIdsPlugin", () => {
 				const chunkGraph = compilation.chunkGraph;
 				const context = this.options.context
 					? this.options.context
 					: compiler.context;
 
+				const [usedIds, modules] = getUsedModuleIdsAndModules(compilation);
 				const unnamedModules = assignNames(
-					Array.from(modules).filter(module => {
-						if (!module.needId) return false;
-						if (chunkGraph.getNumberOfModuleChunks(module) === 0) return false;
-						return chunkGraph.getModuleId(module) === null;
-					}),
+					modules,
 					m => getShortModuleName(m, context, root),
 					(m, shortName) =>
 						getLongModuleName(shortName, m, context, hashFunction, root),
 					compareModulesByIdentifier,
-					getUsedModuleIds(compilation),
+					usedIds,
 					(m, name) => chunkGraph.setModuleId(m, name)
 				);
 				if (unnamedModules.length > 0) {
-					assignAscendingModuleIds(unnamedModules, compilation);
+					assignAscendingModuleIds(usedIds, unnamedModules, compilation);
 				}
 			});
 		});

package/lib/ids/NaturalModuleIdsPlugin.js

@@ -8,7 +8,10 @@
 const {
 	compareModulesByPreOrderIndexOrIdentifier
 } = require("../util/comparators");
-const { assignAscendingModuleIds } = require("./IdHelpers");
+const {
+	assignAscendingModuleIds,
+	getUsedModuleIdsAndModules
+} = require("./IdHelpers");
 
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
@@ -22,18 +25,12 @@ class NaturalModuleIdsPlugin {
 	apply(compiler) {
 		compiler.hooks.compilation.tap("NaturalModuleIdsPlugin", compilation => {
 			compilation.hooks.moduleIds.tap("NaturalModuleIdsPlugin", modules => {
-				const chunkGraph = compilation.chunkGraph;
-				const modulesInNaturalOrder = Array.from(modules)
-					.filter(
-						m =>
-							m.needId &&
-							chunkGraph.getNumberOfModuleChunks(m) > 0 &&
-							chunkGraph.getModuleId(m) === null
-					)
-					.sort(
-						compareModulesByPreOrderIndexOrIdentifier(compilation.moduleGraph)
-					);
-				assignAscendingModuleIds(modulesInNaturalOrder, compilation);
+				const [usedIds, modulesInNaturalOrder] =
+					getUsedModuleIdsAndModules(compilation);
+				modulesInNaturalOrder.sort(
+					compareModulesByPreOrderIndexOrIdentifier(compilation.moduleGraph)
+				);
+				assignAscendingModuleIds(usedIds, modulesInNaturalOrder, compilation);
 			});
 		});
 	}

package/lib/ids/OccurrenceChunkIdsPlugin.js

@@ -60,8 +60,12 @@ class OccurrenceChunkIdsPlugin {
 
 				const chunksInOccurrenceOrder = Array.from(chunks).sort((a, b) => {
 					if (prioritiseInitial) {
-						const aEntryOccurs = occursInInitialChunksMap.get(a);
-						const bEntryOccurs = occursInInitialChunksMap.get(b);
+						const aEntryOccurs =
+							/** @type {number} */
+							(occursInInitialChunksMap.get(a));
+						const bEntryOccurs =
+							/** @type {number} */
+							(occursInInitialChunksMap.get(b));
 						if (aEntryOccurs > bEntryOccurs) return -1;
 						if (aEntryOccurs < bEntryOccurs) return 1;
 					}

package/lib/ids/OccurrenceModuleIdsPlugin.js

@@ -9,7 +9,10 @@ const {
 	compareModulesByPreOrderIndexOrIdentifier
 } = require("../util/comparators");
 const createSchemaValidation = require("../util/create-schema-validation");
-const { assignAscendingModuleIds } = require("./IdHelpers");
+const {
+	assignAscendingModuleIds,
+	getUsedModuleIdsAndModules
+} = require("./IdHelpers");
 
 /** @typedef {import("../../declarations/plugins/ids/OccurrenceModuleIdsPlugin").OccurrenceModuleIdsPluginOptions} OccurrenceModuleIdsPluginOptions */
 /** @typedef {import("../Compiler")} Compiler */
@@ -44,15 +47,11 @@ class OccurrenceModuleIdsPlugin {
 		compiler.hooks.compilation.tap("OccurrenceModuleIdsPlugin", compilation => {
 			const moduleGraph = compilation.moduleGraph;
 
-			compilation.hooks.moduleIds.tap("OccurrenceModuleIdsPlugin", modules => {
+			compilation.hooks.moduleIds.tap("OccurrenceModuleIdsPlugin", () => {
 				const chunkGraph = compilation.chunkGraph;
 
-				const modulesInOccurrenceOrder = Array.from(modules).filter(
-					m =>
-						m.needId &&
-						chunkGraph.getNumberOfModuleChunks(m) > 0 &&
-						chunkGraph.getModuleId(m) === null
-				);
+				const [usedIds, modulesInOccurrenceOrder] =
+					getUsedModuleIdsAndModules(compilation);
 
 				const occursInInitialChunksMap = new Map();
 				const occursInAllChunksMap = new Map();
@@ -82,7 +81,7 @@ class OccurrenceModuleIdsPlugin {
 					] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
 						if (!originModule) continue;
 						if (!connections.some(c => c.isTargetActive(undefined))) continue;
-						sum += initialChunkChunkMap.get(originModule);
+						sum += initialChunkChunkMap.get(originModule) || 0;
 					}
 					return sum;
 				};
@@ -121,7 +120,7 @@ class OccurrenceModuleIdsPlugin {
 					}
 				}
 
-				for (const m of modules) {
+				for (const m of modulesInOccurrenceOrder) {
 					const result =
 						countOccurs(m) +
 						chunkGraph.getNumberOfModuleChunks(m) +
@@ -147,7 +146,11 @@ class OccurrenceModuleIdsPlugin {
 					return naturalCompare(a, b);
 				});
 
-				assignAscendingModuleIds(modulesInOccurrenceOrder, compilation);
+				assignAscendingModuleIds(
+					usedIds,
+					modulesInOccurrenceOrder,
+					compilation
+				);
 			});
 		});
 	}