webpack 5.90.2 → 5.91.0

package/lib/ExternalModuleFactoryPlugin.js

@@ -7,9 +7,16 @@
 
 const util = require("util");
 const ExternalModule = require("./ExternalModule");
+const ContextElementDependency = require("./dependencies/ContextElementDependency");
+const CssImportDependency = require("./dependencies/CssImportDependency");
+const HarmonyImportDependency = require("./dependencies/HarmonyImportDependency");
+const ImportDependency = require("./dependencies/ImportDependency");
 const { resolveByProperty, cachedSetProperty } = require("./util/cleverMerge");
 
 /** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
+/** @typedef {import("./Compilation").DepConstructor} DepConstructor */
+/** @typedef {import("./ExternalModule").DependencyMeta} DependencyMeta */
+/** @typedef {import("./Module")} Module */
 /** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
 
 const UNSPECIFIED_EXTERNAL_TYPE_REGEXP = /^[a-z0-9-]+ /;
@@ -67,7 +74,7 @@ class ExternalModuleFactoryPlugin {
 				/**
 				 * @param {string|string[]|boolean|Record<string, string|string[]>} value the external config
 				 * @param {string|undefined} type type of external
-				 * @param {function(Error=, ExternalModule=): void} callback callback
+				 * @param {function((Error | null)=, ExternalModule=): void} callback callback
 				 * @returns {void}
 				 */
 				const handleExternal = (value, type, callback) => {
@@ -105,12 +112,34 @@ class ExternalModuleFactoryPlugin {
 							];
 						}
 					}
+
+					// TODO make it pluggable/add hooks to `ExternalModule` to allow output modules own externals?
+					/** @type {DependencyMeta | undefined} */
+					let dependencyMeta;
+
+					if (
+						dependency instanceof HarmonyImportDependency ||
+						dependency instanceof ImportDependency ||
+						dependency instanceof ContextElementDependency
+					) {
+						dependencyMeta = {
+							attributes: dependency.assertions
+						};
+					} else if (dependency instanceof CssImportDependency) {
+						dependencyMeta = {
+							layer: dependency.layer,
+							supports: dependency.supports,
+							media: dependency.media
+						};
+					}
+
 					callback(
 						null,
 						new ExternalModule(
 							externalConfig,
 							type || globalType,
-							dependency.request
+							dependency.request,
+							dependencyMeta
 						)
 					);
 				};
@@ -128,7 +157,13 @@ class ExternalModuleFactoryPlugin {
 					} else if (Array.isArray(externals)) {
 						let i = 0;
 						const next = () => {
+							/** @type {boolean | undefined} */
 							let asyncFlag;
+							/**
+							 * @param {(Error | null)=} err err
+							 * @param {ExternalModule=} module module
+							 * @returns {void}
+							 */
 							const handleExternalsAndCallback = (err, module) => {
 								if (err) return callback(err);
 								if (!module) {

package/lib/FileSystemInfo.js

@@ -3394,7 +3394,7 @@ class FileSystemInfo {
 							timestampHash: info,
 							hash: info || ""
 						}),
-						fromSymlink: (fle, target, callback) => {
+						fromSymlink: (file, target, callback) => {
 							callback(null, {
 								timestampHash: target,
 								hash: target,

package/lib/Generator.js

@@ -13,6 +13,7 @@
 /** @typedef {import("./DependencyTemplate")} DependencyTemplate */
 /** @typedef {import("./DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
+/** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./NormalModule")} NormalModule */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
@@ -25,7 +26,7 @@
  * @property {RuntimeTemplate} runtimeTemplate the runtime template
  * @property {ModuleGraph} moduleGraph the module graph
  * @property {ChunkGraph} chunkGraph the chunk graph
- * @property {Set<string>} runtimeRequirements the requirements for runtime
+ * @property {RuntimeRequirements} runtimeRequirements the requirements for runtime
  * @property {RuntimeSpec} runtime the runtime
  * @property {RuntimeSpec[]} [runtimes] the runtimes
  * @property {ConcatenationScope=} concatenationScope when in concatenated module, information about other concatenated modules

package/lib/HookWebpackError.js

@@ -12,7 +12,7 @@ const WebpackError = require("./WebpackError");
 /**
  * @template T
  * @callback Callback
- * @param {Error=} err
+ * @param {Error | null} err
  * @param {T=} stats
  * @returns {void}
  */
@@ -51,7 +51,7 @@ module.exports.makeWebpackError = makeWebpackError;
 
 /**
  * @template T
- * @param {function((WebpackError | null)=, T=): void} callback webpack error callback
+ * @param {function(WebpackError | null, T=): void} callback webpack error callback
  * @param {string} hook name of hook
  * @returns {Callback<T>} generic callback
  */

package/lib/InitFragment.js

@@ -40,7 +40,7 @@ const sortFragmentWithIndex = ([a, i], [b, j]) => {
  */
 class InitFragment {
 	/**
-	 * @param {string | Source} content the source code that will be included as initialization code
+	 * @param {string | Source | undefined} content the source code that will be included as initialization code
 	 * @param {number} stage category of initialization code (contribute to order)
 	 * @param {number} position position in the category (contribute to order)
 	 * @param {string=} key unique key to avoid emitting the same initialization code twice
@@ -56,7 +56,7 @@ class InitFragment {
 
 	/**
 	 * @param {GenerateContext} context context
-	 * @returns {string | Source} the source code that will be included as initialization code
+	 * @returns {string | Source | undefined} the source code that will be included as initialization code
 	 */
 	getContent(context) {
 		return this.content;
@@ -171,7 +171,9 @@ class InitFragment {
 
 makeSerializable(InitFragment, "webpack/lib/InitFragment");
 
-InitFragment.prototype.merge = undefined;
+InitFragment.prototype.merge =
+	/** @type {TODO} */
+	(undefined);
 
 InitFragment.STAGE_CONSTANTS = 10;
 InitFragment.STAGE_ASYNC_BOUNDARY = 20;

package/lib/LibManifestPlugin.js

@@ -12,6 +12,7 @@ const { compareModulesById } = require("./util/comparators");
 const { dirname, mkdirp } = require("./util/fs");
 
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Compiler").IntermediateFileSystem} IntermediateFileSystem */
 /** @typedef {import("./Module").BuildMeta} BuildMeta */
 
 /**
@@ -52,6 +53,8 @@ class LibManifestPlugin {
 			},
 			(compilation, callback) => {
 				const moduleGraph = compilation.moduleGraph;
+				// store used paths to detect issue and output an error. #18200
+				const usedPaths = new Set();
 				asyncLib.forEach(
 					Array.from(compilation.chunks),
 					(chunk, callback) => {
@@ -63,6 +66,11 @@ class LibManifestPlugin {
 						const targetPath = compilation.getPath(this.options.path, {
 							chunk
 						});
+						if (usedPaths.has(targetPath)) {
+							callback(new Error(`each chunk must have a unique path`));
+							return;
+						}
+						usedPaths.add(targetPath);
 						const name =
 							this.options.name &&
 							compilation.getPath(this.options.name, {
@@ -113,16 +121,16 @@ class LibManifestPlugin {
 							? JSON.stringify(manifest, null, 2)
 							: JSON.stringify(manifest);
 						const buffer = Buffer.from(manifestContent, "utf8");
+						const intermediateFileSystem =
+							/** @type {IntermediateFileSystem} */ (
+								compiler.intermediateFileSystem
+							);
 						mkdirp(
-							compiler.intermediateFileSystem,
-							dirname(compiler.intermediateFileSystem, targetPath),
+							intermediateFileSystem,
+							dirname(intermediateFileSystem, targetPath),
 							err => {
 								if (err) return callback(err);
-								compiler.intermediateFileSystem.writeFile(
-									targetPath,
-									buffer,
-									callback
-								);
+								intermediateFileSystem.writeFile(targetPath, buffer, callback);
 							}
 						);
 					},

package/lib/Module.js

@@ -21,12 +21,14 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("./ChunkGroup")} ChunkGroup */
 /** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
 /** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
 /** @typedef {import("./ConcatenationScope")} ConcatenationScope */
 /** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("./DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("./ExportsInfo").UsageStateType} UsageStateType */
 /** @typedef {import("./FileSystemInfo")} FileSystemInfo */
+/** @typedef {import("./FileSystemInfo").Snapshot} Snapshot */
 /** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("./ModuleTypeConstants").ModuleTypes} ModuleTypes */
 /** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
@@ -62,7 +64,7 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {RuntimeSpec} runtime the runtime code should be generated for
  * @property {RuntimeSpec[]} [runtimes] the runtimes code should be generated for
  * @property {ConcatenationScope=} concatenationScope when in concatenated module, information about other concatenated modules
- * @property {CodeGenerationResults} codeGenerationResults code generation results of other modules (need to have a codeGenerationDependency to use that)
+ * @property {CodeGenerationResults | undefined} codeGenerationResults code generation results of other modules (need to have a codeGenerationDependency to use that)
  * @property {Compilation=} compilation the compilation
  * @property {ReadonlySet<string>=} sourceTypes source types
  */
@@ -73,11 +75,14 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {ChunkGraph} chunkGraph the chunk graph
  */
 
+/** @typedef {Set<string>} RuntimeRequirements */
+/** @typedef {ReadonlySet<string>} ReadOnlyRuntimeRequirements */
+
 /**
  * @typedef {Object} CodeGenerationResult
  * @property {Map<string, Source>} sources the resulting sources for all source types
  * @property {Map<string, any>=} data the resulting data for all source types
- * @property {ReadonlySet<string>} runtimeRequirements the runtime requirements
+ * @property {ReadOnlyRuntimeRequirements} runtimeRequirements the runtime requirements
  * @property {string=} hash a hash of the code generation result (will be automatically calculated from sources and runtimeRequirements if not provided)
  */
 
@@ -100,6 +105,21 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {boolean=} sideEffectFree
  */
 
+/**
+ * @typedef {Object} KnownBuildInfo
+ * @property {boolean=} cacheable
+ * @property {boolean=} parsed
+ * @property {LazySet<string>=} fileDependencies
+ * @property {LazySet<string>=} contextDependencies
+ * @property {LazySet<string>=} missingDependencies
+ * @property {LazySet<string>=} buildDependencies
+ * @property {(Map<string, string | Set<string>>)=} valueDependencies
+ * @property {TODO=} hash
+ * @property {Record<string, Source>=} assets
+ * @property {Map<string, AssetInfo | undefined>=} assetsInfo
+ * @property {(Snapshot | null)=} snapshot
+ */
+
 /**
  * @typedef {Object} NeedBuildContext
  * @property {Compilation} compilation
@@ -108,13 +128,17 @@ const makeSerializable = require("./util/makeSerializable");
  */
 
 /** @typedef {KnownBuildMeta & Record<string, any>} BuildMeta */
-/** @typedef {Record<string, any>} BuildInfo */
+/** @typedef {KnownBuildInfo & Record<string, any>} BuildInfo */
 
 /**
  * @typedef {Object} FactoryMeta
  * @property {boolean=} sideEffectFree
  */
 
+/** @typedef {Set<string>} SourceTypes */
+
+/** @typedef {{ factoryMeta: FactoryMeta | undefined, resolveOptions: ResolveOptions | undefined }} UnsafeCacheData */
+
 const EMPTY_RESOLVE_OPTIONS = {};
 
 let debugId = 1000;
@@ -249,6 +273,9 @@ class Module extends DependenciesBlock {
 		).setProfile(this, value);
 	}
 
+	/**
+	 * @returns {number | null} the pre order index
+	 */
 	get index() {
 		return ModuleGraph.getModuleGraphForModule(
 			this,
@@ -257,6 +284,9 @@ class Module extends DependenciesBlock {
 		).getPreOrderIndex(this);
 	}
 
+	/**
+	 * @param {number} value the pre order index
+	 */
 	set index(value) {
 		ModuleGraph.getModuleGraphForModule(
 			this,
@@ -265,6 +295,9 @@ class Module extends DependenciesBlock {
 		).setPreOrderIndex(this, value);
 	}
 
+	/**
+	 * @returns {number | null} the post order index
+	 */
 	get index2() {
 		return ModuleGraph.getModuleGraphForModule(
 			this,
@@ -273,6 +306,9 @@ class Module extends DependenciesBlock {
 		).getPostOrderIndex(this);
 	}
 
+	/**
+	 * @param {number} value the post order index
+	 */
 	set index2(value) {
 		ModuleGraph.getModuleGraphForModule(
 			this,
@@ -281,6 +317,9 @@ class Module extends DependenciesBlock {
 		).setPostOrderIndex(this, value);
 	}
 
+	/**
+	 * @returns {number | null} the depth
+	 */
 	get depth() {
 		return ModuleGraph.getModuleGraphForModule(
 			this,
@@ -289,6 +328,9 @@ class Module extends DependenciesBlock {
 		).getDepth(this);
 	}
 
+	/**
+	 * @param {number} value the depth
+	 */
 	set depth(value) {
 		ModuleGraph.getModuleGraphForModule(
 			this,
@@ -297,6 +339,9 @@ class Module extends DependenciesBlock {
 		).setDepth(this, value);
 	}
 
+	/**
+	 * @returns {Module | null | undefined} issuer
+	 */
 	get issuer() {
 		return ModuleGraph.getModuleGraphForModule(
 			this,
@@ -305,6 +350,9 @@ class Module extends DependenciesBlock {
 		).getIssuer(this);
 	}
 
+	/**
+	 * @param {Module | null} value issuer
+	 */
 	set issuer(value) {
 		ModuleGraph.getModuleGraphForModule(
 			this,
@@ -812,7 +860,7 @@ class Module extends DependenciesBlock {
 
 	/**
 	 * @abstract
-	 * @returns {Set<string>} types available (do not mutate)
+	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
 		// Better override this method to return the correct types
@@ -851,6 +899,7 @@ class Module extends DependenciesBlock {
 			codeGenerationResults: undefined
 		};
 		const sources = this.codeGeneration(codeGenContext).sources;
+
 		return type ? sources.get(type) : sources.get(first(this.getSourceTypes()));
 	}
 
@@ -956,7 +1005,7 @@ class Module extends DependenciesBlock {
 	/**
 	 * Module should be unsafe cached. Get data that's needed for that.
 	 * This data will be passed to restoreFromUnsafeCache later.
-	 * @returns {object} cached data
+	 * @returns {UnsafeCacheData} cached data
 	 */
 	getUnsafeCacheData() {
 		return {

package/lib/ModuleFilenameHelpers.js

@@ -115,7 +115,7 @@ const asRegExp = test => {
  * @template T
  * Returns a lazy object. The object is lazy in the sense that the properties are
  * only evaluated when they are accessed. This is only obtained by setting a function as the value for each key.
- * @param {Record<string, () => T>} obj the object to covert to a lazy access object
+ * @param {Record<string, () => T>} obj the object to convert to a lazy access object
  * @returns {Object} the lazy access object
  */
 const lazyObject = obj => {

package/lib/ModuleGraph.js

@@ -89,13 +89,16 @@ const getConnectionsByModule = set => {
 	return map;
 };
 
+/** @typedef {SortableSet<ModuleGraphConnection>} IncomingConnections */
+/** @typedef {SortableSet<ModuleGraphConnection>} OutgoingConnections */
+
 class ModuleGraphModule {
 	constructor() {
-		/** @type {SortableSet<ModuleGraphConnection>} */
+		/** @type {IncomingConnections} */
 		this.incomingConnections = new SortableSet();
-		/** @type {SortableSet<ModuleGraphConnection> | undefined} */
+		/** @type {OutgoingConnections | undefined} */
 		this.outgoingConnections = undefined;
-		/** @type {Module | null} */
+		/** @type {Module | null | undefined} */
 		this.issuer = undefined;
 		/** @type {(string | OptimizationBailoutFunction)[]} */
 		this.optimizationBailout = [];
@@ -107,31 +110,47 @@ class ModuleGraphModule {
 		this.postOrderIndex = null;
 		/** @type {number | null} */
 		this.depth = null;
-		/** @type {ModuleProfile | undefined | null} */
+		/** @type {ModuleProfile | undefined} */
 		this.profile = undefined;
 		/** @type {boolean} */
 		this.async = false;
-		/** @type {ModuleGraphConnection[]} */
+		/** @type {ModuleGraphConnection[] | undefined} */
 		this._unassignedConnections = undefined;
 	}
 }
 
 class ModuleGraph {
 	constructor() {
-		/** @type {WeakMap<Dependency, ModuleGraphConnection | null>} */
+		/**
+		 * @type {WeakMap<Dependency, ModuleGraphConnection | null>}
+		 * @private
+		 */
 		this._dependencyMap = new WeakMap();
-		/** @type {Map<Module, ModuleGraphModule>} */
+		/**
+		 * @type {Map<Module, ModuleGraphModule>}
+		 * @private
+		 */
 		this._moduleMap = new Map();
-		/** @type {WeakMap<any, Object>} */
+		/**
+		 * @type {WeakMap<any, Object>}
+		 * @private
+		 */
 		this._metaMap = new WeakMap();
-
-		/** @type {WeakTupleMap<any[], any> | undefined} */
+		/**
+		 * @type {WeakTupleMap<any[], any> | undefined}
+		 * @private
+		 */
 		this._cache = undefined;
-
-		/** @type {Map<Module, WeakTupleMap<any, any>>} */
+		/**
+		 * @type {Map<Module, WeakTupleMap<any, any>> | undefined}
+		 * @private
+		 */
 		this._moduleMemCaches = undefined;
 
-		/** @type {string | undefined} */
+		/**
+		 * @type {string | undefined}
+		 * @private
+		 */
 		this._cacheStage = undefined;
 	}
 
@@ -163,7 +182,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Dependency} dependency the dependency
-	 * @returns {Module} parent module
+	 * @returns {Module | undefined} parent module
 	 */
 	getParentModule(dependency) {
 		return dependency._parentModule;
@@ -171,7 +190,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Dependency} dependency the dependency
-	 * @returns {DependenciesBlock} parent block
+	 * @returns {DependenciesBlock | undefined} parent block
 	 */
 	getParentBlock(dependency) {
 		return dependency._parentDependenciesBlock;
@@ -186,7 +205,7 @@ class ModuleGraph {
 	}
 
 	/**
-	 * @param {Module} originModule the referencing module
+	 * @param {Module | null} originModule the referencing module
 	 * @param {Dependency} dependency the referencing dependency
 	 * @param {Module} module the referenced module
 	 * @returns {void}
@@ -231,8 +250,11 @@ class ModuleGraph {
 		newConnection.module = module;
 		this._dependencyMap.set(dependency, newConnection);
 		connection.setActive(false);
-		const originMgm = this._getModuleGraphModule(connection.originModule);
-		originMgm.outgoingConnections.add(newConnection);
+		const originMgm = this._getModuleGraphModule(
+			/** @type {Module} */ (connection.originModule)
+		);
+		/** @type {OutgoingConnections} */
+		(originMgm.outgoingConnections).add(newConnection);
 		const targetMgm = this._getModuleGraphModule(module);
 		targetMgm.incomingConnections.add(newConnection);
 	}
@@ -242,11 +264,16 @@ class ModuleGraph {
 	 * @returns {void}
 	 */
 	removeConnection(dependency) {
-		const connection = this.getConnection(dependency);
+		const connection =
+			/** @type {ModuleGraphConnection} */
+			(this.getConnection(dependency));
 		const targetMgm = this._getModuleGraphModule(connection.module);
 		targetMgm.incomingConnections.delete(connection);
-		const originMgm = this._getModuleGraphModule(connection.originModule);
-		originMgm.outgoingConnections.delete(connection);
+		const originMgm = this._getModuleGraphModule(
+			/** @type {Module} */ (connection.originModule)
+		);
+		/** @type {OutgoingConnections} */
+		(originMgm.outgoingConnections).delete(connection);
 		this._dependencyMap.set(dependency, null);
 	}
 
@@ -256,7 +283,9 @@ class ModuleGraph {
 	 * @returns {void}
 	 */
 	addExplanation(dependency, explanation) {
-		const connection = this.getConnection(dependency);
+		const connection =
+			/** @type {ModuleGraphConnection} */
+			(this.getConnection(dependency));
 		connection.addExplanation(explanation);
 	}
 
@@ -468,7 +497,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} reasons why a module is included, in a map by source module
+	 * @returns {readonly Map<Module | undefined | null, readonly ModuleGraphConnection[]>} reasons why a module is included, in a map by source module
 	 */
 	getIncomingConnectionsByOriginModule(module) {
 		const connections = this._getModuleGraphModule(module).incomingConnections;
@@ -488,7 +517,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @returns {ModuleProfile | null} the module profile
+	 * @returns {ModuleProfile | undefined} the module profile
 	 */
 	getProfile(module) {
 		const mgm = this._getModuleGraphModule(module);
@@ -497,7 +526,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @param {ModuleProfile | null} profile the module profile
+	 * @param {ModuleProfile | undefined} profile the module profile
 	 * @returns {void}
 	 */
 	setProfile(module, profile) {
@@ -507,7 +536,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @returns {Module | null} the issuer module
+	 * @returns {Module | null | undefined} the issuer module
 	 */
 	getIssuer(module) {
 		const mgm = this._getModuleGraphModule(module);
@@ -789,7 +818,7 @@ class ModuleGraph {
 		const fn = args.pop();
 		if (this._moduleMemCaches && this._cacheStage) {
 			const memCache = this._moduleMemCaches.get(
-				this.getParentModule(dependency)
+				/** @type {Module} */ (this.getParentModule(dependency))
 			);
 			if (memCache !== undefined) {
 				return memCache.provide(dependency, this._cacheStage, ...args, () =>

package/lib/ModuleGraphConnection.js

@@ -6,6 +6,7 @@
 "use strict";
 
 /** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Dependency").GetConditionFn} GetConditionFn */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
@@ -56,7 +57,7 @@ class ModuleGraphConnection {
 	 * @param {Module} module the referenced module
 	 * @param {string=} explanation some extra detail
 	 * @param {boolean=} weak the reference is weak
-	 * @param {false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState=} condition condition for the connection
+	 * @param {false | null | GetConditionFn | undefined} condition condition for the connection
 	 */
 	constructor(
 		originModule,