webpack 5.76.1 → 5.88.0

package/lib/optimize/RealContentHashPlugin.js

@@ -13,11 +13,18 @@ const { compareSelect, compareStrings } = require("../util/comparators");
 const createHash = require("../util/createHash");
 
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Cache").Etag} Etag */
 /** @typedef {import("../Compilation").AssetInfo} AssetInfo */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {typeof import("../util/Hash")} Hash */
 
 const EMPTY_SET = new Set();
 
+/**
+ * @template T
+ * @param {T | T[]} itemOrItems item or items
+ * @param {Set<T>} list list
+ */
 const addToList = (itemOrItems, list) => {
 	if (Array.isArray(itemOrItems)) {
 		for (const item of itemOrItems) {
@@ -60,6 +67,10 @@ const quoteMeta = str => {
 
 const cachedSourceMap = new WeakMap();
 
+/**
+ * @param {Source} source source
+ * @returns {CachedSource} cached source
+ */
 const toCachedSource = source => {
 	if (source instanceof CachedSource) {
 		return source;
@@ -71,6 +82,10 @@ const toCachedSource = source => {
 	return newSource;
 };
 
+/** @typedef {Set<string>} OwnHashes */
+/** @typedef {Set<string>} ReferencedHashes */
+/** @typedef {Set<string>} Hashes */
+
 /**
  * @typedef {Object} AssetInfoForRealContentHash
  * @property {string} name
@@ -79,11 +94,11 @@ const toCachedSource = source => {
  * @property {RawSource | undefined} newSource
  * @property {RawSource | undefined} newSourceWithoutOwn
  * @property {string} content
- * @property {Set<string>} ownHashes
- * @property {Promise} contentComputePromise
- * @property {Promise} contentComputeWithoutOwnPromise
- * @property {Set<string>} referencedHashes
- * @property {Set<string>} hashes
+ * @property {OwnHashes | undefined} ownHashes
+ * @property {Promise<void> | undefined} contentComputePromise
+ * @property {Promise<void> | undefined} contentComputeWithoutOwnPromise
+ * @property {ReferencedHashes | undefined} referencedHashes
+ * @property {Hashes} hashes
  */
 
 /**
@@ -115,6 +130,11 @@ class RealContentHashPlugin {
 		return hooks;
 	}
 
+	/**
+	 * @param {Object} options options object
+	 * @param {string | Hash} options.hashFunction the hash function to use
+	 * @param {string} options.hashDigest the hash digest to use
+	 */
 	constructor({ hashFunction, hashDigest }) {
 		this._hashFunction = hashFunction;
 		this._hashDigest = hashDigest;
@@ -143,27 +163,25 @@ class RealContentHashPlugin {
 					const assets = compilation.getAssets();
 					/** @type {AssetInfoForRealContentHash[]} */
 					const assetsWithInfo = [];
+					/** @type {Map<string, [AssetInfoForRealContentHash]>} */
 					const hashToAssets = new Map();
 					for (const { source, info, name } of assets) {
 						const cachedSource = toCachedSource(source);
-						const content = cachedSource.source();
-						/** @type {Set<string>} */
+						const content = /** @type {string} */ (cachedSource.source());
+						/** @type {Hashes} */
 						const hashes = new Set();
 						addToList(info.contenthash, hashes);
+						/** @type {AssetInfoForRealContentHash} */
 						const data = {
 							name,
 							info,
 							source: cachedSource,
-							/** @type {RawSource | undefined} */
 							newSource: undefined,
-							/** @type {RawSource | undefined} */
 							newSourceWithoutOwn: undefined,
 							content,
-							/** @type {Set<string>} */
 							ownHashes: undefined,
 							contentComputePromise: undefined,
 							contentComputeWithoutOwnPromise: undefined,
-							/** @type {Set<string>} */
 							referencedHashes: undefined,
 							hashes
 						};
@@ -212,11 +230,17 @@ class RealContentHashPlugin {
 								});
 						})
 					);
+					/**
+					 * @param {string} hash the hash
+					 * @returns {undefined | ReferencedHashes} the referenced hashes
+					 */
 					const getDependencies = hash => {
 						const assets = hashToAssets.get(hash);
 						if (!assets) {
 							const referencingAssets = assetsWithInfo.filter(asset =>
-								asset.referencedHashes.has(hash)
+								/** @type {ReferencedHashes} */ (asset.referencedHashes).has(
+									hash
+								)
 							);
 							const err = new WebpackError(`RealContentHashPlugin
 Some kind of unexpected caching problem occurred.
@@ -236,23 +260,36 @@ ${referencingAssets
 						}
 						const hashes = new Set();
 						for (const { referencedHashes, ownHashes } of assets) {
-							if (!ownHashes.has(hash)) {
-								for (const hash of ownHashes) {
+							if (!(/** @type {OwnHashes} */ (ownHashes).has(hash))) {
+								for (const hash of /** @type {OwnHashes} */ (ownHashes)) {
 									hashes.add(hash);
 								}
 							}
-							for (const hash of referencedHashes) {
+							for (const hash of /** @type {ReferencedHashes} */ (
+								referencedHashes
+							)) {
 								hashes.add(hash);
 							}
 						}
 						return hashes;
 					};
+					/**
+					 * @param {string} hash the hash
+					 * @returns {string} the hash info
+					 */
 					const hashInfo = hash => {
 						const assets = hashToAssets.get(hash);
-						return `${hash} (${Array.from(assets, a => a.name)})`;
+						return `${hash} (${Array.from(
+							/** @type {AssetInfoForRealContentHash[]} */ (assets),
+							a => a.name
+						)})`;
 					};
 					const hashesInOrder = new Set();
 					for (const hash of hashToAssets.keys()) {
+						/**
+						 * @param {string} hash the hash
+						 * @param {Set<string>} stack stack of hashes
+						 */
 						const add = (hash, stack) => {
 							const deps = getDependencies(hash);
 							if (!deps) return;
@@ -276,21 +313,31 @@ ${referencingAssets
 						add(hash, new Set());
 					}
 					const hashToNewHash = new Map();
+					/**
+					 * @param {AssetInfoForRealContentHash} asset asset info
+					 * @returns {Etag} etag
+					 */
 					const getEtag = asset =>
 						cacheGenerate.mergeEtags(
 							cacheGenerate.getLazyHashedEtag(asset.source),
-							Array.from(asset.referencedHashes, hash =>
-								hashToNewHash.get(hash)
+							Array.from(
+								/** @type {ReferencedHashes} */ (asset.referencedHashes),
+								hash => hashToNewHash.get(hash)
 							).join("|")
 						);
+					/**
+					 * @param {AssetInfoForRealContentHash} asset asset info
+					 * @returns {Promise<void>}
+					 */
 					const computeNewContent = asset => {
 						if (asset.contentComputePromise) return asset.contentComputePromise;
 						return (asset.contentComputePromise = (async () => {
 							if (
-								asset.ownHashes.size > 0 ||
-								Array.from(asset.referencedHashes).some(
-									hash => hashToNewHash.get(hash) !== hash
-								)
+								/** @type {OwnHashes} */ (asset.ownHashes).size > 0 ||
+								Array.from(
+									/** @type {ReferencedHashes} */
+									(asset.referencedHashes)
+								).some(hash => hashToNewHash.get(hash) !== hash)
 							) {
 								const identifier = asset.name;
 								const etag = getEtag(asset);
@@ -307,15 +354,20 @@ ${referencingAssets
 							}
 						})());
 					};
+					/**
+					 * @param {AssetInfoForRealContentHash} asset asset info
+					 * @returns {Promise<void>}
+					 */
 					const computeNewContentWithoutOwn = asset => {
 						if (asset.contentComputeWithoutOwnPromise)
 							return asset.contentComputeWithoutOwnPromise;
 						return (asset.contentComputeWithoutOwnPromise = (async () => {
 							if (
-								asset.ownHashes.size > 0 ||
-								Array.from(asset.referencedHashes).some(
-									hash => hashToNewHash.get(hash) !== hash
-								)
+								/** @type {OwnHashes} */ (asset.ownHashes).size > 0 ||
+								Array.from(
+									/** @type {ReferencedHashes} */
+									(asset.referencedHashes)
+								).some(hash => hashToNewHash.get(hash) !== hash)
 							) {
 								const identifier = asset.name + "|without-own";
 								const etag = getEtag(asset);
@@ -326,7 +378,9 @@ ${referencingAssets
 										const newContent = asset.content.replace(
 											hashRegExp,
 											hash => {
-												if (asset.ownHashes.has(hash)) {
+												if (
+													/** @type {OwnHashes} */ (asset.ownHashes).has(hash)
+												) {
 													return "";
 												}
 												return hashToNewHash.get(hash);
@@ -340,17 +394,19 @@ ${referencingAssets
 					};
 					const comparator = compareSelect(a => a.name, compareStrings);
 					for (const oldHash of hashesInOrder) {
-						const assets = hashToAssets.get(oldHash);
+						const assets =
+							/** @type {AssetInfoForRealContentHash[]} */
+							(hashToAssets.get(oldHash));
 						assets.sort(comparator);
 						await Promise.all(
 							assets.map(asset =>
-								asset.ownHashes.has(oldHash)
+								/** @type {OwnHashes} */ (asset.ownHashes).has(oldHash)
 									? computeNewContentWithoutOwn(asset)
 									: computeNewContent(asset)
 							)
 						);
 						const assetsContent = mapAndDeduplicateBuffers(assets, asset => {
-							if (asset.ownHashes.has(oldHash)) {
+							if (/** @type {OwnHashes} */ (asset.ownHashes).has(oldHash)) {
 								return asset.newSourceWithoutOwn
 									? asset.newSourceWithoutOwn.buffer()
 									: asset.source.buffer();

package/lib/optimize/RemoveParentModulesPlugin.js

@@ -9,6 +9,8 @@ const { STAGE_BASIC } = require("../OptimizationStages");
 const Queue = require("../util/Queue");
 const { intersect } = require("../util/SetHelpers");
 
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGroup")} ChunkGroup */
 /** @typedef {import("../Compiler")} Compiler */
 
 class RemoveParentModulesPlugin {
@@ -18,6 +20,10 @@ class RemoveParentModulesPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap("RemoveParentModulesPlugin", compilation => {
+			/**
+			 * @param {Iterable<Chunk>} chunks the chunks
+			 * @param {ChunkGroup[]} chunkGroups the chunk groups
+			 */
 			const handler = (chunks, chunkGroups) => {
 				const chunkGraph = compilation.chunkGraph;
 				const queue = new Queue();

package/lib/optimize/RuntimeChunkPlugin.js

@@ -5,11 +5,17 @@
 
 "use strict";
 
+/** @typedef {import("../Compilation").EntryData} EntryData */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Entrypoint")} Entrypoint */
 
 class RuntimeChunkPlugin {
 	constructor(options) {
 		this.options = {
+			/**
+			 * @param {Entrypoint} entrypoint entrypoint name
+			 * @returns {string} runtime chunk name
+			 */
 			name: entrypoint => `runtime~${entrypoint.name}`,
 			...options
 		};
@@ -26,7 +32,9 @@ class RuntimeChunkPlugin {
 				"RuntimeChunkPlugin",
 				(_, { name: entryName }) => {
 					if (entryName === undefined) return;
-					const data = compilation.entries.get(entryName);
+					const data =
+						/** @type {EntryData} */
+						(compilation.entries.get(entryName));
 					if (data.options.runtime === undefined && !data.options.dependOn) {
 						// Determine runtime chunk name
 						let name = this.options.name;

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -6,11 +6,18 @@
 "use strict";
 
 const glob2regexp = require("glob-to-regexp");
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_ESM,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC
+} = require("../ModuleTypeConstants");
 const { STAGE_DEFAULT } = require("../OptimizationStages");
 const HarmonyExportImportedSpecifierDependency = require("../dependencies/HarmonyExportImportedSpecifierDependency");
 const HarmonyImportSpecifierDependency = require("../dependencies/HarmonyImportSpecifierDependency");
 const formatLocation = require("../formatLocation");
 
+/** @typedef {import("estree").ModuleDeclaration} ModuleDeclaration */
+/** @typedef {import("estree").Statement} Statement */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Module")} Module */
@@ -50,6 +57,8 @@ const globToRegexp = (glob, cache) => {
 	return regexp;
 };
 
+const PLUGIN_NAME = "SideEffectsFlagPlugin";
+
 class SideEffectsFlagPlugin {
 	/**
 	 * @param {boolean} analyseSource analyse source code for side effects
@@ -69,60 +78,54 @@ class SideEffectsFlagPlugin {
 			globToRegexpCache.set(compiler.root, cache);
 		}
 		compiler.hooks.compilation.tap(
-			"SideEffectsFlagPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				const moduleGraph = compilation.moduleGraph;
-				normalModuleFactory.hooks.module.tap(
-					"SideEffectsFlagPlugin",
-					(module, data) => {
-						const resolveData = data.resourceResolveData;
-						if (
-							resolveData &&
-							resolveData.descriptionFileData &&
-							resolveData.relativePath
-						) {
-							const sideEffects = resolveData.descriptionFileData.sideEffects;
-							if (sideEffects !== undefined) {
-								if (module.factoryMeta === undefined) {
-									module.factoryMeta = {};
-								}
-								const hasSideEffects =
-									SideEffectsFlagPlugin.moduleHasSideEffects(
-										resolveData.relativePath,
-										sideEffects,
-										cache
-									);
-								module.factoryMeta.sideEffectFree = !hasSideEffects;
-							}
-						}
-
-						return module;
-					}
-				);
-				normalModuleFactory.hooks.module.tap(
-					"SideEffectsFlagPlugin",
-					(module, data) => {
-						if (typeof data.settings.sideEffects === "boolean") {
+				normalModuleFactory.hooks.module.tap(PLUGIN_NAME, (module, data) => {
+					const resolveData = data.resourceResolveData;
+					if (
+						resolveData &&
+						resolveData.descriptionFileData &&
+						resolveData.relativePath
+					) {
+						const sideEffects = resolveData.descriptionFileData.sideEffects;
+						if (sideEffects !== undefined) {
 							if (module.factoryMeta === undefined) {
 								module.factoryMeta = {};
 							}
-							module.factoryMeta.sideEffectFree = !data.settings.sideEffects;
+							const hasSideEffects = SideEffectsFlagPlugin.moduleHasSideEffects(
+								resolveData.relativePath,
+								sideEffects,
+								cache
+							);
+							module.factoryMeta.sideEffectFree = !hasSideEffects;
 						}
-						return module;
 					}
-				);
+
+					return module;
+				});
+				normalModuleFactory.hooks.module.tap(PLUGIN_NAME, (module, data) => {
+					if (typeof data.settings.sideEffects === "boolean") {
+						if (module.factoryMeta === undefined) {
+							module.factoryMeta = {};
+						}
+						module.factoryMeta.sideEffectFree = !data.settings.sideEffects;
+					}
+					return module;
+				});
 				if (this._analyseSource) {
 					/**
 					 * @param {JavascriptParser} parser the parser
 					 * @returns {void}
 					 */
 					const parserHandler = parser => {
+						/** @type {undefined | Statement | ModuleDeclaration} */
 						let sideEffectsStatement;
-						parser.hooks.program.tap("SideEffectsFlagPlugin", () => {
+						parser.hooks.program.tap(PLUGIN_NAME, () => {
 							sideEffectsStatement = undefined;
 						});
 						parser.hooks.statement.tap(
-							{ name: "SideEffectsFlagPlugin", stage: -100 },
+							{ name: PLUGIN_NAME, stage: -100 },
 							statement => {
 								if (sideEffectsStatement) return;
 								if (parser.scope.topLevelScope !== true) return;
@@ -203,7 +206,7 @@ class SideEffectsFlagPlugin {
 								}
 							}
 						);
-						parser.hooks.finish.tap("SideEffectsFlagPlugin", () => {
+						parser.hooks.finish.tap(PLUGIN_NAME, () => {
 							if (sideEffectsStatement === undefined) {
 								parser.state.module.buildMeta.sideEffectFree = true;
 							} else {
@@ -220,18 +223,18 @@ class SideEffectsFlagPlugin {
 						});
 					};
 					for (const key of [
-						"javascript/auto",
-						"javascript/esm",
-						"javascript/dynamic"
+						JAVASCRIPT_MODULE_TYPE_AUTO,
+						JAVASCRIPT_MODULE_TYPE_ESM,
+						JAVASCRIPT_MODULE_TYPE_DYNAMIC
 					]) {
 						normalModuleFactory.hooks.parser
 							.for(key)
-							.tap("SideEffectsFlagPlugin", parserHandler);
+							.tap(PLUGIN_NAME, parserHandler);
 					}
 				}
 				compilation.hooks.optimizeDependencies.tap(
 					{
-						name: "SideEffectsFlagPlugin",
+						name: PLUGIN_NAME,
 						stage: STAGE_DEFAULT
 					},
 					modules => {
@@ -258,7 +261,7 @@ class SideEffectsFlagPlugin {
 										// TODO improve for export *
 										if (isReexport && dep.name) {
 											const exportInfo = moduleGraph.getExportInfo(
-												connection.originModule,
+												/** @type {Module} */ (connection.originModule),
 												dep.name
 											);
 											exportInfo.moveTarget(
@@ -319,6 +322,12 @@ class SideEffectsFlagPlugin {
 		);
 	}
 
+	/**
+	 * @param {string} moduleName the module name
+	 * @param {undefined | boolean | string | string[]} flagValue the flag value
+	 * @param {Map<string, RegExp>} cache cache for glob to regexp
+	 * @returns {boolean | undefined} true, when the module has side effects, undefined or false when not
+	 */
 	static moduleHasSideEffects(moduleName, flagValue, cache) {
 		switch (typeof flagValue) {
 			case "undefined":