webpack 5.97.1 → 5.104.1

package/lib/Chunk.js

@@ -11,53 +11,63 @@ const { intersect } = require("./util/SetHelpers");
 const SortableSet = require("./util/SortableSet");
 const StringXor = require("./util/StringXor");
 const {
-	compareModulesByIdentifier,
 	compareChunkGroupsByIndex,
-	compareModulesById
+	compareModulesById,
+	compareModulesByIdentifier
 } = require("./util/comparators");
 const { createArrayToSetDeprecationSet } = require("./util/deprecation");
 const { mergeRuntime } = require("./util/runtime");
 
-/** @typedef {import("webpack-sources").Source} Source */
 /** @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("./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 */
+/** @typedef {string | null} ChunkName */
+/** @typedef {string | number} ChunkId */
+/** @typedef {SortableSet<string>} IdNameHints */
 
 const ChunkFilesSet = createArrayToSetDeprecationSet("chunk.files");
 
 /**
- * @typedef {object} WithId an object who has an id property *
- * @property {string | number} id the id of the object
+ * @deprecated
+ * @typedef {object} ChunkMaps
+ * @property {Record<ChunkId, string>} hash
+ * @property {Record<ChunkId, Record<string, string>>} contentHash
+ * @property {Record<ChunkId, string>} name
  */
 
 /**
  * @deprecated
- * @typedef {object} ChunkMaps
- * @property {Record<string|number, string>} hash
- * @property {Record<string|number, Record<string, string>>} contentHash
- * @property {Record<string|number, string>} name
+ * @typedef {Record<ChunkId, ChunkId[]>} ChunkModuleIdMap
+ */
+
+/**
+ * @deprecated
+ * @typedef {Record<ModuleId, string>} chunkModuleHashMap
  */
 
 /**
  * @deprecated
  * @typedef {object} ChunkModuleMaps
- * @property {Record<string|number, (string|number)[]>} id
- * @property {Record<string|number, string>} hash
+ * @property {ChunkModuleIdMap} id
+ * @property {chunkModuleHashMap} hash
  */
 
+/** @typedef {Set<Chunk>} Chunks */
+/** @typedef {Set<Entrypoint>} Entrypoints */
+/** @typedef {Set<ChunkGroup>} Queue */
+/** @typedef {SortableSet<ChunkGroup>} SortableChunkGroups */
+/** @typedef {Record<string, ChunkId[]>} ChunkChildIdsByOrdersMap */
+/** @typedef {Record<string, ChunkChildIdsByOrdersMap>} ChunkChildIdsByOrdersMapByData */
+
 let debugId = 1000;
 
 /**
@@ -66,7 +76,7 @@ let debugId = 1000;
  */
 class Chunk {
 	/**
-	 * @param {string=} name of chunk being created, is optional (for subclasses)
+	 * @param {ChunkName=} name of chunk being created, is optional (for subclasses)
 	 * @param {boolean} backCompat enable backward-compatibility
 	 */
 	constructor(name, backCompat = true) {
@@ -76,9 +86,9 @@ class Chunk {
 		this.ids = null;
 		/** @type {number} */
 		this.debugId = debugId++;
-		/** @type {string | undefined} */
+		/** @type {ChunkName | undefined} */
 		this.name = name;
-		/** @type {SortableSet<string>} */
+		/** @type {IdNameHints} */
 		this.idNameHints = new SortableSet();
 		/** @type {boolean} */
 		this.preventIntegration = false;
@@ -88,7 +98,7 @@ class Chunk {
 		this.cssFilenameTemplate = undefined;
 		/**
 		 * @private
-		 * @type {SortableSet<ChunkGroup>}
+		 * @type {SortableChunkGroups}
 		 */
 		this._groups = new SortableSet(undefined, compareChunkGroupsByIndex);
 		/** @type {RuntimeSpec} */
@@ -114,13 +124,13 @@ class Chunk {
 	// TODO remove in webpack 6
 	// BACKWARD-COMPAT START
 	get entryModule() {
-		const entryModules = Array.from(
-			ChunkGraph.getChunkGraphForChunk(
+		const entryModules = [
+			...ChunkGraph.getChunkGraphForChunk(
 				this,
 				"Chunk.entryModule",
 				"DEP_WEBPACK_CHUNK_ENTRY_MODULE"
 			).getChunkEntryModulesIterable(this)
-		);
+		];
 		if (entryModules.length === 0) {
 			return undefined;
 		} else if (entryModules.length === 1) {
@@ -197,7 +207,7 @@ class Chunk {
 
 	/**
 	 * @param {Chunk} otherChunk the chunk to compare with
-	 * @returns {-1|0|1} the comparison result
+	 * @returns {-1 | 0 | 1} the comparison result
 	 */
 	compareTo(otherChunk) {
 		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
@@ -351,9 +361,9 @@ class Chunk {
 			"Chunk.getChunkModuleMaps",
 			"DEP_WEBPACK_CHUNK_GET_CHUNK_MODULE_MAPS"
 		);
-		/** @type {Record<string|number, (string|number)[]>} */
+		/** @type {ChunkModuleIdMap} */
 		const chunkModuleIdMap = Object.create(null);
-		/** @type {Record<string|number, string>} */
+		/** @type {chunkModuleHashMap} */
 		const chunkModuleHashMap = Object.create(null);
 
 		for (const asyncChunk of this.getAllAsyncChunks()) {
@@ -406,11 +416,11 @@ class Chunk {
 	 * @returns {ChunkMaps} the chunk map information
 	 */
 	getChunkMaps(realHash) {
-		/** @type {Record<string|number, string>} */
+		/** @type {Record<ChunkId, string>} */
 		const chunkHashMap = Object.create(null);
-		/** @type {Record<string|number, Record<string, string>>} */
+		/** @type {Record<string, Record<ChunkId, string>>} */
 		const chunkContentHashMap = Object.create(null);
-		/** @type {Record<string|number, string>} */
+		/** @type {Record<ChunkId, string>} */
 		const chunkNameMap = Object.create(null);
 
 		for (const chunk of this.getAllAsyncChunks()) {
@@ -517,7 +527,7 @@ class Chunk {
 	}
 
 	/**
-	 * @returns {SortableSet<ChunkGroup>} the chunkGroups that the said chunk is referenced in
+	 * @returns {SortableChunkGroups} the chunkGroups that the said chunk is referenced in
 	 */
 	get groupsIterable() {
 		this._groups.sort();
@@ -574,16 +584,19 @@ class Chunk {
 	}
 
 	/**
-	 * @returns {Set<Chunk>} a set of all the async chunks
+	 * @returns {Chunks} a set of all the async chunks
 	 */
 	getAllAsyncChunks() {
+		/** @type {Queue} */
 		const queue = new Set();
+		/** @type {Chunks} */
 		const chunks = new Set();
 
 		const initialChunks = intersect(
-			Array.from(this.groupsIterable, g => new Set(g.chunks))
+			Array.from(this.groupsIterable, (g) => new Set(g.chunks))
 		);
 
+		/** @type {Queue} */
 		const initialQueue = new Set(this.groupsIterable);
 
 		for (const chunkGroup of initialQueue) {
@@ -611,10 +624,12 @@ class Chunk {
 	}
 
 	/**
-	 * @returns {Set<Chunk>} a set of all the initial chunks (including itself)
+	 * @returns {Chunks} a set of all the initial chunks (including itself)
 	 */
 	getAllInitialChunks() {
+		/** @type {Chunks} */
 		const chunks = new Set();
+		/** @type {Queue} */
 		const queue = new Set(this.groupsIterable);
 		for (const group of queue) {
 			if (group.isInitial()) {
@@ -626,10 +641,12 @@ class Chunk {
 	}
 
 	/**
-	 * @returns {Set<Chunk>} a set of all the referenced chunks (including itself)
+	 * @returns {Chunks} a set of all the referenced chunks (including itself)
 	 */
 	getAllReferencedChunks() {
+		/** @type {Queue} */
 		const queue = new Set(this.groupsIterable);
+		/** @type {Chunks} */
 		const chunks = new Set();
 
 		for (const chunkGroup of queue) {
@@ -645,15 +662,17 @@ class Chunk {
 	}
 
 	/**
-	 * @returns {Set<Entrypoint>} a set of all the referenced entrypoints
+	 * @returns {Entrypoints} a set of all the referenced entrypoints
 	 */
 	getAllReferencedAsyncEntrypoints() {
+		/** @type {Queue} */
 		const queue = new Set(this.groupsIterable);
+		/** @type {Entrypoints} */
 		const entrypoints = new Set();
 
 		for (const chunkGroup of queue) {
 			for (const entrypoint of chunkGroup.asyncEntrypointsIterable) {
-				entrypoints.add(entrypoint);
+				entrypoints.add(/** @type {Entrypoint} */ (entrypoint));
 			}
 			for (const child of chunkGroup.childrenIterable) {
 				queue.add(child);
@@ -667,10 +686,11 @@ class Chunk {
 	 * @returns {boolean} true, if the chunk references async chunks
 	 */
 	hasAsyncChunks() {
+		/** @type {Queue} */
 		const queue = new Set();
 
 		const initialChunks = intersect(
-			Array.from(this.groupsIterable, g => new Set(g.chunks))
+			Array.from(this.groupsIterable, (g) => new Set(g.chunks))
 		);
 
 		for (const chunkGroup of this.groupsIterable) {
@@ -696,7 +716,7 @@ class Chunk {
 	/**
 	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @param {ChunkFilterPredicate=} filterFn function used to filter chunks
-	 * @returns {Record<string, (string | number)[]>} a record object of names to lists of child ids(?)
+	 * @returns {Record<string, ChunkId[]>} a record object of names to lists of child ids(?)
 	 */
 	getChildIdsByOrders(chunkGraph, filterFn) {
 		/** @type {Map<string, {order: number, group: ChunkGroup}[]>} */
@@ -717,7 +737,8 @@ class Chunk {
 									/** @type {number} */
 									(
 										childGroup.options[
-											/** @type {keyof ChunkGroupOptions} */ (key)
+											/** @type {keyof ChunkGroupOptions} */
+											(key)
 										]
 									),
 								group: childGroup
@@ -727,7 +748,7 @@ class Chunk {
 				}
 			}
 		}
-		/** @type {Record<string, (string | number)[]>} */
+		/** @type {Record<string, ChunkId[]>} */
 		const result = Object.create(null);
 		for (const [name, list] of lists) {
 			list.sort((a, b) => {
@@ -735,7 +756,7 @@ class Chunk {
 				if (cmp !== 0) return cmp;
 				return a.group.compareTo(chunkGraph, b.group);
 			});
-			/** @type {Set<string | number>} */
+			/** @type {Set<ChunkId>} */
 			const chunkIdSet = new Set();
 			for (const item of list) {
 				for (const chunk of item.group.chunks) {
@@ -744,7 +765,7 @@ class Chunk {
 				}
 			}
 			if (chunkIdSet.size > 0) {
-				result[name] = Array.from(chunkIdSet);
+				result[name] = [...chunkIdSet];
 			}
 		}
 		return result;
@@ -753,7 +774,7 @@ class Chunk {
 	/**
 	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @param {string} type option name
-	 * @returns {{ onChunks: Chunk[], chunks: Set<Chunk> }[] | undefined} referenced chunks for a specific type
+	 * @returns {{ onChunks: Chunk[], chunks: Chunks }[] | undefined} referenced chunks for a specific type
 	 */
 	getChildrenOfTypeInOrder(chunkGraph, type) {
 		const list = [];
@@ -799,17 +820,17 @@ class Chunk {
 	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @param {boolean=} includeDirectChildren include direct children (by default only children of async children are included)
 	 * @param {ChunkFilterPredicate=} filterFn function used to filter chunks
-	 * @returns {Record<string|number, Record<string, (string | number)[]>>} a record object of names to lists of child ids(?) by chunk id
+	 * @returns {ChunkChildIdsByOrdersMapByData} a record object of names to lists of child ids(?) by chunk id
 	 */
 	getChildIdsByOrdersMap(chunkGraph, includeDirectChildren, filterFn) {
-		/** @type {Record<string|number, Record<string, (string | number)[]>>} */
+		/** @type {ChunkChildIdsByOrdersMapByData} */
 		const chunkMaps = Object.create(null);
 
 		/**
 		 * @param {Chunk} chunk a chunk
 		 * @returns {void}
 		 */
-		const addChildIdsByOrdersToMap = chunk => {
+		const addChildIdsByOrdersToMap = (chunk) => {
 			const data = chunk.getChildIdsByOrders(chunkGraph, filterFn);
 			for (const key of Object.keys(data)) {
 				let chunkMap = chunkMaps[key];
@@ -821,7 +842,7 @@ class Chunk {
 		};
 
 		if (includeDirectChildren) {
-			/** @type {Set<Chunk>} */
+			/** @type {Chunks} */
 			const chunks = new Set();
 			for (const chunkGroup of this.groupsIterable) {
 				for (const chunk of chunkGroup.chunks) {
@@ -849,7 +870,7 @@ class Chunk {
 	 */
 	hasChildByOrder(chunkGraph, type, includeDirectChildren, filterFn) {
 		if (includeDirectChildren) {
-			/** @type {Set<Chunk>} */
+			/** @type {Chunks} */
 			const chunks = new Set();
 			for (const chunkGroup of this.groupsIterable) {
 				for (const chunk of chunkGroup.chunks) {