webpack 5.59.0 → 5.94.0

package/lib/Cache.js

@@ -14,14 +14,14 @@ const {
 /** @typedef {import("./WebpackError")} WebpackError */
 
 /**
- * @typedef {Object} Etag
+ * @typedef {object} Etag
  * @property {function(): string} toString
  */
 
 /**
  * @template T
  * @callback CallbackCache
- * @param {WebpackError=} err
+ * @param {WebpackError | null} err
  * @param {T=} result
  * @returns {void}
  */
@@ -33,16 +33,19 @@ const {
  * @returns {void}
  */
 
-const needCalls = (times, callback) => {
-	return err => {
-		if (--times === 0) {
-			return callback(err);
-		}
-		if (err && times > 0) {
-			times = 0;
-			return callback(err);
-		}
-	};
+/**
+ * @param {number} times times
+ * @param {function(Error=): void} callback callback
+ * @returns {function(Error=): void} callback
+ */
+const needCalls = (times, callback) => err => {
+	if (--times === 0) {
+		return callback(err);
+	}
+	if (err && times > 0) {
+		times = 0;
+		return callback(err);
+	}
 };
 
 class Cache {
@@ -71,6 +74,7 @@ class Cache {
 	 * @returns {void}
 	 */
 	get(identifier, etag, callback) {
+		/** @type {GotHandler[]} */
 		const gotHandlers = [];
 		this.hooks.get.callAsync(identifier, etag, gotHandlers, (err, result) => {
 			if (err) {

package/lib/CacheFacade.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const { forEachBail } = require("enhanced-resolve");
 const asyncLib = require("neo-async");
 const getLazyHashedEtag = require("./cache/getLazyHashedEtag");
 const mergeEtags = require("./cache/mergeEtags");
@@ -18,15 +19,15 @@ const mergeEtags = require("./cache/mergeEtags");
 /**
  * @template T
  * @callback CallbackCache
- * @param {WebpackError=} err
- * @param {T=} result
+ * @param {(Error | null)=} err
+ * @param {(T | null)=} result
  * @returns {void}
  */
 
 /**
  * @template T
  * @callback CallbackNormalErrorCache
- * @param {Error=} err
+ * @param {(Error | null)=} err
  * @param {T=} result
  * @returns {void}
  */
@@ -37,6 +38,7 @@ class MultiItemCache {
 	 */
 	constructor(items) {
 		this._items = items;
+		// eslint-disable-next-line no-constructor-return
 		if (items.length === 1) return /** @type {any} */ (items[0]);
 	}
 
@@ -46,15 +48,7 @@ class MultiItemCache {
 	 * @returns {void}
 	 */
 	get(callback) {
-		const next = i => {
-			this._items[i].get((err, result) => {
-				if (err) return callback(err);
-				if (result !== undefined) return callback(null, result);
-				if (++i >= this._items.length) return callback();
-				next(i);
-			});
-		};
-		next(0);
+		forEachBail(this._items, (item, callback) => item.get(callback), callback);
 	}
 
 	/**
@@ -62,12 +56,15 @@ class MultiItemCache {
 	 * @returns {Promise<T>} promise with the data
 	 */
 	getPromise() {
-		const next = i => {
-			return this._items[i].getPromise().then(result => {
+		/**
+		 * @param {number} i index
+		 * @returns {Promise<T>} promise with the data
+		 */
+		const next = i =>
+			this._items[i].getPromise().then(result => {
 				if (result !== undefined) return result;
 				if (++i < this._items.length) return next(i);
 			});
-		};
 		return next(0);
 	}
 
@@ -199,7 +196,7 @@ class CacheFacade {
 	/**
 	 * @param {Cache} cache the root cache
 	 * @param {string} name the child cache name
-	 * @param {string | HashConstructor} hashFunction the hash function to use
+	 * @param {(string | HashConstructor)=} hashFunction the hash function to use
 	 */
 	constructor(cache, name, hashFunction) {
 		this._cache = cache;

package/lib/CaseSensitiveModulesWarning.js

@@ -14,8 +14,8 @@ const WebpackError = require("./WebpackError");
  * @param {Module[]} modules the modules to be sorted
  * @returns {Module[]} sorted version of original modules
  */
-const sortModules = modules => {
-	return modules.sort((a, b) => {
+const sortModules = modules =>
+	modules.sort((a, b) => {
 		const aIdent = a.identifier();
 		const bIdent = b.identifier();
 		/* istanbul ignore next */
@@ -25,29 +25,29 @@ const sortModules = modules => {
 		/* istanbul ignore next */
 		return 0;
 	});
-};
 
 /**
  * @param {Module[]} modules each module from throw
  * @param {ModuleGraph} moduleGraph the module graph
  * @returns {string} each message from provided modules
  */
-const createModulesListMessage = (modules, moduleGraph) => {
-	return modules
+const createModulesListMessage = (modules, moduleGraph) =>
+	modules
 		.map(m => {
 			let message = `* ${m.identifier()}`;
 			const validReasons = Array.from(
 				moduleGraph.getIncomingConnectionsByOriginModule(m).keys()
-			).filter(x => x);
+			).filter(Boolean);
 
 			if (validReasons.length > 0) {
 				message += `\n    Used by ${validReasons.length} module(s), i. e.`;
-				message += `\n    ${validReasons[0].identifier()}`;
+				message += `\n    ${
+					/** @type {Module[]} */ (validReasons)[0].identifier()
+				}`;
 			}
 			return message;
 		})
 		.join("\n");
-};
 
 class CaseSensitiveModulesWarning extends WebpackError {
 	/**

package/lib/Chunk.js

@@ -22,26 +22,30 @@ const { mergeRuntime } = require("./util/runtime");
 /** @typedef {import("./ChunkGraph").ChunkFilterPredicate} ChunkFilterPredicate */
 /** @typedef {import("./ChunkGraph").ChunkSizeOptions} ChunkSizeOptions */
 /** @typedef {import("./ChunkGraph").ModuleFilterPredicate} ModuleFilterPredicate */
+/** @typedef {import("./ChunkGraph").ModuleId} ModuleId */
 /** @typedef {import("./ChunkGroup")} ChunkGroup */
+/** @typedef {import("./ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("./Compilation").PathData} PathData */
 /** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./TemplatedPathPlugin").TemplatePath} TemplatePath */
 /** @typedef {import("./util/Hash")} Hash */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
+/** @typedef {number | string} ChunkId */
+
 const ChunkFilesSet = createArrayToSetDeprecationSet("chunk.files");
 
 /**
- * @typedef {Object} WithId an object who has an id property *
+ * @typedef {object} WithId an object who has an id property *
  * @property {string | number} id the id of the object
  */
 
 /**
  * @deprecated
- * @typedef {Object} ChunkMaps
+ * @typedef {object} ChunkMaps
  * @property {Record<string|number, string>} hash
  * @property {Record<string|number, Record<string, string>>} contentHash
  * @property {Record<string|number, string>} name
@@ -49,7 +53,7 @@ const ChunkFilesSet = createArrayToSetDeprecationSet("chunk.files");
 
 /**
  * @deprecated
- * @typedef {Object} ChunkModuleMaps
+ * @typedef {object} ChunkModuleMaps
  * @property {Record<string|number, (string|number)[]>} id
  * @property {Record<string|number, string>} hash
  */
@@ -63,28 +67,34 @@ let debugId = 1000;
 class Chunk {
 	/**
 	 * @param {string=} name of chunk being created, is optional (for subclasses)
+	 * @param {boolean} backCompat enable backward-compatibility
 	 */
-	constructor(name) {
-		/** @type {number | string | null} */
+	constructor(name, backCompat = true) {
+		/** @type {ChunkId | null} */
 		this.id = null;
-		/** @type {(number|string)[] | null} */
+		/** @type {ChunkId[] | null} */
 		this.ids = null;
 		/** @type {number} */
 		this.debugId = debugId++;
-		/** @type {string} */
+		/** @type {string | undefined} */
 		this.name = name;
 		/** @type {SortableSet<string>} */
 		this.idNameHints = new SortableSet();
 		/** @type {boolean} */
 		this.preventIntegration = false;
-		/** @type {(string | function(PathData, AssetInfo=): string)?} */
+		/** @type {TemplatePath | undefined} */
 		this.filenameTemplate = undefined;
-		/** @private @type {SortableSet<ChunkGroup>} */
+		/** @type {TemplatePath | undefined} */
+		this.cssFilenameTemplate = undefined;
+		/**
+		 * @private
+		 * @type {SortableSet<ChunkGroup>}
+		 */
 		this._groups = new SortableSet(undefined, compareChunkGroupsByIndex);
 		/** @type {RuntimeSpec} */
 		this.runtime = undefined;
 		/** @type {Set<string>} */
-		this.files = new ChunkFilesSet();
+		this.files = backCompat ? new ChunkFilesSet() : new Set();
 		/** @type {Set<string>} */
 		this.auxiliaryFiles = new Set();
 		/** @type {boolean} */
@@ -115,11 +125,11 @@ class Chunk {
 			return undefined;
 		} else if (entryModules.length === 1) {
 			return entryModules[0];
-		} else {
-			throw new Error(
-				"Module.entryModule: Multiple entry modules are not supported by the deprecated API (Use the new ChunkGroup API)"
-			);
 		}
+
+		throw new Error(
+			"Module.entryModule: Multiple entry modules are not supported by the deprecated API (Use the new ChunkGroup API)"
+		);
 	}
 
 	/**
@@ -262,9 +272,9 @@ class Chunk {
 		if (chunkGraph.canChunksBeIntegrated(this, otherChunk)) {
 			chunkGraph.integrateChunks(this, otherChunk);
 			return true;
-		} else {
-			return false;
 		}
+
+		return false;
 	}
 
 	/**
@@ -347,7 +357,7 @@ class Chunk {
 		const chunkModuleHashMap = Object.create(null);
 
 		for (const asyncChunk of this.getAllAsyncChunks()) {
-			/** @type {(string|number)[]} */
+			/** @type {ChunkId[] | undefined} */
 			let array;
 			for (const module of chunkGraph.getOrderedChunkModulesIterable(
 				asyncChunk,
@@ -356,9 +366,11 @@ class Chunk {
 				if (filterFn(module)) {
 					if (array === undefined) {
 						array = [];
-						chunkModuleIdMap[asyncChunk.id] = array;
+						chunkModuleIdMap[/** @type {ChunkId} */ (asyncChunk.id)] = array;
 					}
-					const moduleId = chunkGraph.getModuleId(module);
+					const moduleId =
+						/** @type {ModuleId} */
+						(chunkGraph.getModuleId(module));
 					array.push(moduleId);
 					chunkModuleHashMap[moduleId] = chunkGraph.getRenderedModuleHash(
 						module,
@@ -402,15 +414,18 @@ class Chunk {
 		const chunkNameMap = Object.create(null);
 
 		for (const chunk of this.getAllAsyncChunks()) {
-			chunkHashMap[chunk.id] = realHash ? chunk.hash : chunk.renderedHash;
+			const id = /** @type {ChunkId} */ (chunk.id);
+			chunkHashMap[id] =
+				/** @type {string} */
+				(realHash ? chunk.hash : chunk.renderedHash);
 			for (const key of Object.keys(chunk.contentHash)) {
 				if (!chunkContentHashMap[key]) {
 					chunkContentHashMap[key] = Object.create(null);
 				}
-				chunkContentHashMap[key][chunk.id] = chunk.contentHash[key];
+				chunkContentHashMap[key][id] = chunk.contentHash[key];
 			}
 			if (chunk.name) {
-				chunkNameMap[chunk.id] = chunk.name;
+				chunkNameMap[id] = chunk.name;
 			}
 		}
 
@@ -502,7 +517,7 @@ class Chunk {
 	}
 
 	/**
-	 * @returns {Iterable<ChunkGroup>} the chunkGroups that the said chunk is referenced in
+	 * @returns {SortableSet<ChunkGroup>} the chunkGroups that the said chunk is referenced in
 	 */
 	get groupsIterable() {
 		this._groups.sort();
@@ -550,7 +565,11 @@ class Chunk {
 		const entryModules =
 			chunkGraph.getChunkEntryModulesWithChunkGroupIterable(this);
 		for (const [m, chunkGroup] of entryModules) {
-			hash.update(`entry${chunkGraph.getModuleId(m)}${chunkGroup.id}`);
+			hash.update(
+				`entry${chunkGraph.getModuleId(m)}${
+					/** @type {ChunkGroup} */ (chunkGroup).id
+				}`
+			);
 		}
 	}
 
@@ -687,14 +706,20 @@ class Chunk {
 				for (const childGroup of group.childrenIterable) {
 					for (const key of Object.keys(childGroup.options)) {
 						if (key.endsWith("Order")) {
-							const name = key.substr(0, key.length - "Order".length);
+							const name = key.slice(0, key.length - "Order".length);
 							let list = lists.get(name);
 							if (list === undefined) {
 								list = [];
 								lists.set(name, list);
 							}
 							list.push({
-								order: childGroup.options[key],
+								order:
+									/** @type {number} */
+									(
+										childGroup.options[
+											/** @type {keyof ChunkGroupOptions} */ (key)
+										]
+									),
 								group: childGroup
 							});
 						}
@@ -715,7 +740,7 @@ class Chunk {
 			for (const item of list) {
 				for (const chunk of item.group.chunks) {
 					if (filterFn && !filterFn(chunk, chunkGraph)) continue;
-					chunkIdSet.add(chunk.id);
+					chunkIdSet.add(/** @type {ChunkId} */ (chunk.id));
 				}
 			}
 			if (chunkIdSet.size > 0) {
@@ -728,13 +753,14 @@ class Chunk {
 	/**
 	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @param {string} type option name
-	 * @returns {{ onChunks: Chunk[], chunks: Set<Chunk> }[]} referenced chunks for a specific type
+	 * @returns {{ onChunks: Chunk[], chunks: Set<Chunk> }[] | undefined} referenced chunks for a specific type
 	 */
 	getChildrenOfTypeInOrder(chunkGraph, type) {
 		const list = [];
 		for (const group of this.groupsIterable) {
 			for (const childGroup of group.childrenIterable) {
-				const order = childGroup.options[type];
+				const order =
+					childGroup.options[/** @type {keyof ChunkGroupOptions} */ (type)];
 				if (order === undefined) continue;
 				list.push({
 					order,
@@ -743,9 +769,10 @@ class Chunk {
 				});
 			}
 		}
-		if (list.length === 0) return undefined;
+		if (list.length === 0) return;
 		list.sort((a, b) => {
-			const cmp = b.order - a.order;
+			const cmp =
+				/** @type {number} */ (b.order) - /** @type {number} */ (a.order);
 			if (cmp !== 0) return cmp;
 			return a.group.compareTo(chunkGraph, b.group);
 		});
@@ -789,7 +816,7 @@ class Chunk {
 				if (chunkMap === undefined) {
 					chunkMaps[key] = chunkMap = Object.create(null);
 				}
-				chunkMap[chunk.id] = data[key];
+				chunkMap[/** @type {ChunkId} */ (chunk.id)] = data[key];
 			}
 		};