webpack 5.97.1 → 5.99.0

package/lib/AsyncDependenciesBlock.js

@@ -19,9 +19,11 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("./util/Hash")} Hash */
 
+/** @typedef {(ChunkGroupOptions & { entryOptions?: EntryOptions }) | string} GroupOptions */
+
 class AsyncDependenciesBlock extends DependenciesBlock {
 	/**
-	 * @param {(ChunkGroupOptions & { entryOptions?: EntryOptions }) | null} groupOptions options for the group
+	 * @param {GroupOptions | null} groupOptions options for the group
 	 * @param {(DependencyLocation | null)=} loc the line of code
 	 * @param {(string | null)=} request the request
 	 */

package/lib/BannerPlugin.js

@@ -19,7 +19,7 @@ const createSchemaValidation = require("./util/create-schema-validation");
 /** @typedef {import("./TemplatedPathPlugin").TemplatePath} TemplatePath */
 
 const validate = createSchemaValidation(
-	/** @type {(function(typeof import("../schemas/plugins/BannerPlugin.json")): boolean)} */
+	/** @type {((value: typeof import("../schemas/plugins/BannerPlugin.json")) => boolean)} */
 	(require("../schemas/plugins/BannerPlugin.check.js")),
 	() => require("../schemas/plugins/BannerPlugin.json"),
 	{

package/lib/Cache.js

@@ -15,7 +15,7 @@ const {
 
 /**
  * @typedef {object} Etag
- * @property {function(): string} toString
+ * @property {() => string} toString
  */
 
 /**
@@ -26,17 +26,19 @@ const {
  * @returns {void}
  */
 
+/** @typedef {TODO} Data */
+
 /**
  * @callback GotHandler
- * @param {any} result
- * @param {function(Error=): void} callback
+ * @param {TODO} result
+ * @param {(err?: Error) => void} callback
  * @returns {void}
  */
 
 /**
  * @param {number} times times
- * @param {function(Error=): void} callback callback
- * @returns {function(Error=): void} callback
+ * @param {(err?: Error) => void} callback callback
+ * @returns {(err?: Error) => void} callback
  */
 const needCalls = (times, callback) => err => {
 	if (--times === 0) {
@@ -51,9 +53,9 @@ const needCalls = (times, callback) => err => {
 class Cache {
 	constructor() {
 		this.hooks = {
-			/** @type {AsyncSeriesBailHook<[string, Etag | null, GotHandler[]], any>} */
+			/** @type {AsyncSeriesBailHook<[string, Etag | null, GotHandler[]], Data>} */
 			get: new AsyncSeriesBailHook(["identifier", "etag", "gotHandlers"]),
-			/** @type {AsyncParallelHook<[string, Etag | null, any]>} */
+			/** @type {AsyncParallelHook<[string, Etag | null, Data]>} */
 			store: new AsyncParallelHook(["identifier", "etag", "data"]),
 			/** @type {AsyncParallelHook<[Iterable<string>]>} */
 			storeBuildDependencies: new AsyncParallelHook(["dependencies"]),

package/lib/CacheFacade.js

@@ -39,7 +39,7 @@ class MultiItemCache {
 	constructor(items) {
 		this._items = items;
 		// eslint-disable-next-line no-constructor-return
-		if (items.length === 1) return /** @type {any} */ (items[0]);
+		if (items.length === 1) return /** @type {TODO} */ (items[0]);
 	}
 
 	/**
@@ -160,7 +160,7 @@ class ItemCacheFacade {
 
 	/**
 	 * @template T
-	 * @param {function(CallbackNormalErrorCache<T>): void} computer function to compute the value if not cached
+	 * @param {(callback: CallbackNormalErrorCache<T>) => void} computer function to compute the value if not cached
 	 * @param {CallbackNormalErrorCache<T>} callback signals when the value is retrieved
 	 * @returns {void}
 	 */
@@ -180,7 +180,7 @@ class ItemCacheFacade {
 
 	/**
 	 * @template T
-	 * @param {function(): Promise<T> | T} computer function to compute the value if not cached
+	 * @param {() => Promise<T> | T} computer function to compute the value if not cached
 	 * @returns {Promise<T>} promise with the data
 	 */
 	async providePromise(computer) {
@@ -310,7 +310,7 @@ class CacheFacade {
 	 * @template T
 	 * @param {string} identifier the cache identifier
 	 * @param {Etag | null} etag the etag
-	 * @param {function(CallbackNormalErrorCache<T>): void} computer function to compute the value if not cached
+	 * @param {(callback: CallbackNormalErrorCache<T>) => void} computer function to compute the value if not cached
 	 * @param {CallbackNormalErrorCache<T>} callback signals when the value is retrieved
 	 * @returns {void}
 	 */
@@ -332,7 +332,7 @@ class CacheFacade {
 	 * @template T
 	 * @param {string} identifier the cache identifier
 	 * @param {Etag | null} etag the etag
-	 * @param {function(): Promise<T> | T} computer function to compute the value if not cached
+	 * @param {() => Promise<T> | T} computer function to compute the value if not cached
 	 * @returns {Promise<T>} promise with the data
 	 */
 	async providePromise(identifier, etag, computer) {

package/lib/Chunk.js

@@ -66,7 +66,7 @@ let debugId = 1000;
  */
 class Chunk {
 	/**
-	 * @param {string=} name of chunk being created, is optional (for subclasses)
+	 * @param {(string | null)=} name of chunk being created, is optional (for subclasses)
 	 * @param {boolean} backCompat enable backward-compatibility
 	 */
 	constructor(name, backCompat = true) {
@@ -76,7 +76,7 @@ class Chunk {
 		this.ids = null;
 		/** @type {number} */
 		this.debugId = debugId++;
-		/** @type {string | undefined} */
+		/** @type {string | null | undefined} */
 		this.name = name;
 		/** @type {SortableSet<string>} */
 		this.idNameHints = new SortableSet();

package/lib/ChunkGraph.js

@@ -8,6 +8,7 @@
 const util = require("util");
 const Entrypoint = require("./Entrypoint");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
+const { DEFAULTS } = require("./config/defaults");
 const { first } = require("./util/SetHelpers");
 const SortableSet = require("./util/SortableSet");
 const {
@@ -35,6 +36,7 @@ const {
 /** @typedef {import("./Generator").SourceTypes} SourceTypes */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
+/** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("./RuntimeModule")} RuntimeModule */
@@ -61,7 +63,7 @@ const compareModuleIterables = compareIterables(compareModulesByIdentifier);
 class ModuleHashInfo {
 	/**
 	 * @param {string} hash hash
-	 * @param {string} renderedHash  rendered hash
+	 * @param {string} renderedHash rendered hash
 	 */
 	constructor(hash, renderedHash) {
 		this.hash = hash;
@@ -69,8 +71,6 @@ class ModuleHashInfo {
 	}
 }
 
-/** @template T @typedef {(set: SortableSet<T>) => T[]} SetToArrayFunction<T> */
-
 /**
  * @template T
  * @param {SortableSet<T>} set the set
@@ -92,7 +92,7 @@ const getModuleRuntimes = chunks => {
 
 /**
  * @param {WeakMap<Module, Set<string>> | undefined} sourceTypesByModule sourceTypesByModule
- * @returns {function (SortableSet<Module>): Map<string, SortableSet<Module>>} modules by source type
+ * @returns {(set: SortableSet<Module>) => Map<string, SortableSet<Module>>} modules by source type
  */
 const modulesBySourceType = sourceTypesByModule => set => {
 	/** @type {Map<string, SortableSet<Module>>} */
@@ -121,19 +121,22 @@ const modulesBySourceType = sourceTypesByModule => set => {
 };
 const defaultModulesBySourceType = modulesBySourceType(undefined);
 
+/**
+ * @typedef {(set: SortableSet<Module>) => Module[]} ModuleSetToArrayFunction
+ */
+
 /**
  * @template T
- * @type {WeakMap<Function, any>}
+ * @type {WeakMap<ModuleComparator, ModuleSetToArrayFunction>}
  */
 const createOrderedArrayFunctionMap = new WeakMap();
 
 /**
  * @template T
- * @param {function(T, T): -1|0|1} comparator comparator function
- * @returns {SetToArrayFunction<T>} set as ordered array
+ * @param {ModuleComparator} comparator comparator function
+ * @returns {ModuleSetToArrayFunction} set as ordered array
  */
 const createOrderedArrayFunction = comparator => {
-	/** @type {SetToArrayFunction<T>} */
 	let fn = createOrderedArrayFunctionMap.get(comparator);
 	if (fn !== undefined) return fn;
 	fn = set => {
@@ -205,11 +208,11 @@ class ChunkGraphModule {
 		this.hashes = undefined;
 		/** @type {ModuleId | null} */
 		this.id = null;
-		/** @type {RuntimeSpecMap<Set<string>> | undefined} */
+		/** @type {RuntimeSpecMap<Set<string>, RuntimeRequirements> | undefined} */
 		this.runtimeRequirements = undefined;
-		/** @type {RuntimeSpecMap<string> | undefined} */
+		/** @type {RuntimeSpecMap<string, bigint> | undefined} */
 		this.graphHashes = undefined;
-		/** @type {RuntimeSpecMap<string> | undefined} */
+		/** @type {RuntimeSpecMap<string, string> | undefined} */
 		this.graphHashesWithConnections = undefined;
 	}
 }
@@ -237,12 +240,14 @@ class ChunkGraphChunk {
 	}
 }
 
+/** @typedef {(a: Module, b: Module) => -1 | 0 | 1} ModuleComparator */
+
 class ChunkGraph {
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @param {string | Hash} hashFunction the hash function to use
 	 */
-	constructor(moduleGraph, hashFunction = "md4") {
+	constructor(moduleGraph, hashFunction = DEFAULTS.HASH_FUNCTION) {
 		/**
 		 * @private
 		 * @type {WeakMap<Module, ChunkGraphModule>}
@@ -535,7 +540,7 @@ class ChunkGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @param {function(Chunk, Chunk): -1|0|1} sortFn sort function
+	 * @param {(a: Chunk, b: Chunk) => -1 | 0 | 1} sortFn sort function
 	 * @returns {Iterable<Chunk>} iterable of chunks (do not modify)
 	 */
 	getOrderedModuleChunksIterable(module, sortFn) {
@@ -686,7 +691,7 @@ class ChunkGraph {
 
 	/**
 	 * @param {Chunk} chunk the chunk
-	 * @param {function(Module, Module): -1|0|1} comparator comparator function
+	 * @param {ModuleComparator} comparator comparator function
 	 * @returns {Iterable<Module>} return the modules for this chunk
 	 */
 	getOrderedChunkModulesIterable(chunk, comparator) {
@@ -698,7 +703,7 @@ class ChunkGraph {
 	/**
 	 * @param {Chunk} chunk the chunk
 	 * @param {string} sourceType source type
-	 * @param {function(Module, Module): -1|0|1} comparator comparator function
+	 * @param {ModuleComparator} comparator comparator function
 	 * @returns {Iterable<Module> | undefined} return the modules for this chunk
 	 */
 	getOrderedChunkModulesIterableBySourceType(chunk, sourceType, comparator) {
@@ -722,7 +727,7 @@ class ChunkGraph {
 
 	/**
 	 * @param {Chunk} chunk the chunk
-	 * @param {function(Module, Module): -1|0|1} comparator comparator function
+	 * @param {ModuleComparator} comparator comparator function
 	 * @returns {Module[]} return the modules for this chunk (cached, do not modify)
 	 */
 	getOrderedChunkModules(chunk, comparator) {

package/lib/ChunkTemplate.js

@@ -42,7 +42,7 @@ class ChunkTemplate {
 					/**
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
-					 * @param {function(RenderManifestEntry[], RenderManifestOptions): RenderManifestEntry[]} fn function
+					 * @param {(renderManifestEntries: RenderManifestEntry[], renderManifestOptions: RenderManifestOptions) => RenderManifestEntry[]} fn function
 					 */
 					(options, fn) => {
 						compilation.hooks.renderManifest.tap(
@@ -62,7 +62,7 @@ class ChunkTemplate {
 					/**
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
-					 * @param {function(Source, ModuleTemplate, RenderContext): Source} fn function
+					 * @param {(source: Source, moduleTemplate: ModuleTemplate, renderContext: RenderContext) => Source} fn function
 					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()
@@ -84,7 +84,7 @@ class ChunkTemplate {
 					/**
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
-					 * @param {function(Source, ModuleTemplate, RenderContext): Source} fn function
+					 * @param {(source: Source, moduleTemplate: ModuleTemplate, renderContext: RenderContext) => Source} fn function
 					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()
@@ -106,7 +106,7 @@ class ChunkTemplate {
 					/**
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
-					 * @param {function(Source, Chunk): Source} fn function
+					 * @param {(source: Source, chunk: Chunk) => Source} fn function
 					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()
@@ -132,7 +132,7 @@ class ChunkTemplate {
 					/**
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
-					 * @param {function(Hash): void} fn function
+					 * @param {(hash: Hash) => void} fn function
 					 */
 					(options, fn) => {
 						compilation.hooks.fullHash.tap(options, fn);
@@ -146,7 +146,7 @@ class ChunkTemplate {
 					/**
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
-					 * @param {function(Hash, Chunk, ChunkHashContext): void} fn function
+					 * @param {(hash: Hash, chunk: Chunk, chunkHashContext: ChunkHashContext) => void} fn function
 					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()

package/lib/CleanPlugin.js

@@ -19,9 +19,7 @@ const processAsyncTree = require("./util/processAsyncTree");
 /** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
 /** @typedef {import("./util/fs").StatsCallback} StatsCallback */
 
-/** @typedef {(function(string):boolean)|RegExp} IgnoreItem */
 /** @typedef {Map<string, number>} Assets */
-/** @typedef {function(IgnoreItem): void} AddToIgnoreCallback */
 
 /**
  * @typedef {object} CleanPluginCompilationHooks
@@ -51,7 +49,7 @@ const validate = createSchemaValidation(
 const _10sec = 10 * 1000;
 
 /**
- * marge assets map 2 into map 1
+ * merge assets map 2 into map 1
  * @param {Assets} as1 assets
  * @param {Assets} as2 assets
  * @returns {void}
@@ -63,11 +61,13 @@ const mergeAssets = (as1, as2) => {
 	}
 };
 
+/** @typedef {Set<string>} Diff */
+
 /**
  * @param {OutputFileSystem} fs filesystem
  * @param {string} outputPath output path
  * @param {Map<string, number>} currentAssets filename of the current assets (must not start with .. or ., must only use / as path separator)
- * @param {function((Error | null)=, Set<string>=): void} callback returns the filenames of the assets that shouldn't be there
+ * @param {(err?: Error | null, set?: Diff) => void} callback returns the filenames of the assets that shouldn't be there
  * @returns {void}
  */
 const getDiffToFs = (fs, outputPath, currentAssets, callback) => {
@@ -116,7 +116,7 @@ const getDiffToFs = (fs, outputPath, currentAssets, callback) => {
 /**
  * @param {Assets} currentAssets assets list
  * @param {Assets} oldAssets old assets list
- * @returns {Set<string>} diff
+ * @returns {Diff} diff
  */
 const getDiffToOldAssets = (currentAssets, oldAssets) => {
 	const diff = new Set();
@@ -148,9 +148,9 @@ const doStat = (fs, filename, callback) => {
  * @param {string} outputPath output path
  * @param {boolean} dry only log instead of fs modification
  * @param {Logger} logger logger
- * @param {Set<string>} diff filenames of the assets that shouldn't be there
- * @param {function(string): boolean | void} isKept check if the entry is ignored
- * @param {function(Error=, Assets=): void} callback callback
+ * @param {Diff} diff filenames of the assets that shouldn't be there
+ * @param {(path: string) => boolean | void} isKept check if the entry is ignored
+ * @param {(err?: Error, assets?: Assets) => void} callback callback
  * @returns {void}
  */
 const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
@@ -402,7 +402,7 @@ class CleanPlugin {
 
 				/**
 				 * @param {(Error | null)=} err err
-				 * @param {Set<string>=} diff diff
+				 * @param {Diff=} diff diff
 				 */
 				const diffCallback = (err, diff) => {
 					if (err) {
@@ -415,7 +415,7 @@ class CleanPlugin {
 						outputPath,
 						dry,
 						logger,
-						/** @type {Set<string>} */ (diff),
+						/** @type {Diff} */ (diff),
 						isKept,
 						(err, keptAssets) => {
 							if (err) {

package/lib/CodeGenerationResults.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const { DEFAULTS } = require("./config/defaults");
 const { getOrInsert } = require("./util/MapHelpers");
 const { first } = require("./util/SetHelpers");
 const createHash = require("./util/createHash");
@@ -21,7 +22,7 @@ class CodeGenerationResults {
 	/**
 	 * @param {string | Hash} hashFunction the hash function to use
 	 */
-	constructor(hashFunction = "md4") {
+	constructor(hashFunction = DEFAULTS.HASH_FUNCTION) {
 		/** @type {Map<Module, RuntimeSpecMap<CodeGenerationResult>>} */
 		this.map = new Map();
 		this._hashFunction = hashFunction;
@@ -116,7 +117,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	 * @param {Module} module the module
 	 * @param {RuntimeSpec} runtime runtime(s)
 	 * @param {string} key data key
-	 * @returns {any} data generated by code generation
+	 * @returns {TODO | undefined} data generated by code generation
 	 */
 	getData(module, runtime, key) {
 		const data = this.get(module, runtime).data;
@@ -126,7 +127,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	/**
 	 * @param {Module} module the module
 	 * @param {RuntimeSpec} runtime runtime(s)
-	 * @returns {any} hash of the code generation
+	 * @returns {string} hash of the code generation
 	 */
 	getHash(module, runtime) {
 		const info = this.get(module, runtime);

package/lib/CompatibilityPlugin.js

@@ -18,6 +18,7 @@ const ConstDependency = require("./dependencies/ConstDependency");
 /** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("./javascript/JavascriptParser").Range} Range */
+/** @typedef {import("./javascript/JavascriptParser").TagData} TagData */
 
 const nestedWebpackIdentifierTag = Symbol("nested webpack identifier");
 const PLUGIN_NAME = "CompatibilityPlugin";
@@ -145,7 +146,9 @@ class CompatibilityPlugin {
 					parser.hooks.expression
 						.for(nestedWebpackIdentifierTag)
 						.tap(PLUGIN_NAME, expr => {
-							const { name, declaration } = parser.currentTagData;
+							const { name, declaration } =
+								/** @type {TagData} */
+								(parser.currentTagData);
 							if (!declaration.updated) {
 								const dep = new ConstDependency(name, declaration.range);
 								dep.loc = declaration.loc;