webpack 5.98.0 → 5.99.1

package/lib/ExportsInfo.js

@@ -10,6 +10,7 @@ const SortableSet = require("./util/SortableSet");
 const makeSerializable = require("./util/makeSerializable");
 const { forEachRuntime } = require("./util/runtime");
 
+/** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./Dependency").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
@@ -34,6 +35,12 @@ const RETURNS_TRUE = () => true;
 const CIRCULAR = Symbol("circular target");
 
 class RestoreProvidedData {
+	/**
+	 * @param {TODO[]} exports exports
+	 * @param {ExportInfo["provided"]} otherProvided other provided
+	 * @param {ExportInfo["canMangleProvide"]} otherCanMangleProvide other can mangle provide
+	 * @param {ExportInfo["terminalBinding"]} otherTerminalBinding other terminal binding
+	 */
 	constructor(
 		exports,
 		otherProvided,
@@ -78,7 +85,7 @@ class ExportsInfo {
 	constructor() {
 		/** @type {Exports} */
 		this._exports = new Map();
-		this._otherExportsInfo = new ExportInfo(null);
+		this._otherExportsInfo = new ExportInfo(/** @type {TODO} */ (null));
 		this._sideEffectsOnlyInfo = new ExportInfo("*side effects only*");
 		this._exportsAreOrdered = false;
 		/** @type {ExportsInfo=} */
@@ -288,7 +295,7 @@ class ExportsInfo {
 	/**
 	 * @param {boolean=} canMangle true, if exports can still be mangled (defaults to false)
 	 * @param {Set<string>=} excludeExports list of unaffected exports
-	 * @param {any=} targetKey use this as key for the target
+	 * @param {Dependency=} targetKey use this as key for the target
 	 * @param {ModuleGraphConnection=} targetModule set this module as target
 	 * @param {number=} priority priority
 	 * @returns {boolean} true, if this call changed something
@@ -777,7 +784,7 @@ class ExportsInfo {
 	}
 
 	/**
-	 * @param {{ otherProvided: any, otherCanMangleProvide: any, otherTerminalBinding: any, exports: any }} data data
+	 * @param {RestoreProvidedData} data data
 	 */
 	restoreProvided({
 		otherProvided,
@@ -809,9 +816,18 @@ class ExportsInfo {
 	}
 }
 
+/** @typedef {Map<string, RuntimeUsageStateType>} UsedInRuntime */
+
 /** @typedef {{ module: Module, export: string[] }} TargetItemWithoutConnection */
-/** @typedef {{ module: Module, connection: ModuleGraphConnection, export: string[] | undefined }} TargetItem */
-/** @typedef {Map<any, { connection: ModuleGraphConnection | null, export: string[], priority: number }>} Target */
+
+/** @typedef {{ module: Module, connection: ModuleGraphConnection, export: string[] | undefined }} TargetItemWithConnection */
+
+/** @typedef {(target: TargetItemWithConnection) => boolean} ResolveTargetFilter */
+
+/** @typedef {(module: Module) => boolean} ValidTargetModuleFilter */
+
+/** @typedef {{ connection: ModuleGraphConnection, export: string[], priority: number }} TargetItem */
+/** @typedef {Map<Dependency | undefined, TargetItem>} Target */
 
 class ExportInfo {
 	/**
@@ -833,7 +849,7 @@ class ExportInfo {
 		this._globalUsed = initFrom ? initFrom._globalUsed : undefined;
 		/**
 		 * @private
-		 * @type {Map<string, RuntimeUsageStateType>}
+		 * @type {UsedInRuntime | undefined}
 		 */
 		this._usedInRuntime =
 			initFrom && initFrom._usedInRuntime
@@ -896,7 +912,7 @@ class ExportInfo {
 	// TODO webpack 5 remove
 	/**
 	 * @private
-	 * @param {*} v v
+	 * @param {EXPECTED_ANY} v v
 	 */
 	set used(v) {
 		throw new Error("REMOVED");
@@ -911,7 +927,7 @@ class ExportInfo {
 	// TODO webpack 5 remove
 	/**
 	 * @private
-	 * @param {*} v v
+	 * @param {EXPECTED_ANY} v v
 	 */
 	set usedName(v) {
 		throw new Error("REMOVED");
@@ -996,7 +1012,7 @@ class ExportInfo {
 	}
 
 	/**
-	 * @param {function(UsageStateType): boolean} condition compare with old value
+	 * @param {(condition: UsageStateType) => boolean} condition compare with old value
 	 * @param {UsageStateType} newValue set when condition is true
 	 * @param {RuntimeSpec} runtime only apply to this runtime
 	 * @returns {boolean} true when something has changed
@@ -1015,7 +1031,8 @@ class ExportInfo {
 			if (newValue !== UsageState.Unused && condition(UsageState.Unused)) {
 				this._usedInRuntime = new Map();
 				forEachRuntime(runtime, runtime =>
-					this._usedInRuntime.set(/** @type {string} */ (runtime), newValue)
+					/** @type {UsedInRuntime} */
+					(this._usedInRuntime).set(/** @type {string} */ (runtime), newValue)
 				);
 				return true;
 			}
@@ -1023,15 +1040,18 @@ class ExportInfo {
 			let changed = false;
 			forEachRuntime(runtime, _runtime => {
 				const runtime = /** @type {string} */ (_runtime);
+				const usedInRuntime =
+					/** @type {UsedInRuntime} */
+					(this._usedInRuntime);
 				let oldValue =
 					/** @type {UsageStateType} */
-					(this._usedInRuntime.get(runtime));
+					(usedInRuntime.get(runtime));
 				if (oldValue === undefined) oldValue = UsageState.Unused;
 				if (newValue !== oldValue && condition(oldValue)) {
 					if (newValue === UsageState.Unused) {
-						this._usedInRuntime.delete(runtime);
+						usedInRuntime.delete(runtime);
 					} else {
-						this._usedInRuntime.set(runtime, newValue);
+						usedInRuntime.set(runtime, newValue);
 					}
 					changed = true;
 				}
@@ -1059,7 +1079,8 @@ class ExportInfo {
 			if (newValue !== UsageState.Unused) {
 				this._usedInRuntime = new Map();
 				forEachRuntime(runtime, runtime =>
-					this._usedInRuntime.set(/** @type {string} */ (runtime), newValue)
+					/** @type {UsedInRuntime} */
+					(this._usedInRuntime).set(/** @type {string} */ (runtime), newValue)
 				);
 				return true;
 			}
@@ -1067,15 +1088,18 @@ class ExportInfo {
 			let changed = false;
 			forEachRuntime(runtime, _runtime => {
 				const runtime = /** @type {string} */ (_runtime);
+				const usedInRuntime =
+					/** @type {UsedInRuntime} */
+					(this._usedInRuntime);
 				let oldValue =
 					/** @type {UsageStateType} */
-					(this._usedInRuntime.get(runtime));
+					(usedInRuntime.get(runtime));
 				if (oldValue === undefined) oldValue = UsageState.Unused;
 				if (newValue !== oldValue) {
 					if (newValue === UsageState.Unused) {
-						this._usedInRuntime.delete(runtime);
+						usedInRuntime.delete(runtime);
 					} else {
-						this._usedInRuntime.set(runtime, newValue);
+						usedInRuntime.set(runtime, newValue);
 					}
 					changed = true;
 				}
@@ -1089,7 +1113,7 @@ class ExportInfo {
 	}
 
 	/**
-	 * @param {any} key the key
+	 * @param {Dependency} key the key
 	 * @returns {boolean} true, if something has changed
 	 */
 	unsetTarget(key) {
@@ -1102,7 +1126,7 @@ class ExportInfo {
 	}
 
 	/**
-	 * @param {any} key the key
+	 * @param {Dependency} key the key
 	 * @param {ModuleGraphConnection} connection the target module if a single one
 	 * @param {(string[] | null)=} exportName the exported name
 	 * @param {number=} priority priority
@@ -1203,7 +1227,8 @@ class ExportInfo {
 				} else if (
 					runtime !== undefined &&
 					Array.from(runtime).every(
-						runtime => !this._usedInRuntime.has(runtime)
+						runtime =>
+							!(/** @type {UsedInRuntime} */ (this._usedInRuntime).has(runtime))
 					)
 				) {
 					return false;
@@ -1232,7 +1257,7 @@ class ExportInfo {
 
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {function(TargetItem): boolean} resolveTargetFilter filter function to further resolve target
+	 * @param {ResolveTargetFilter} resolveTargetFilter filter function to further resolve target
 	 * @returns {ExportInfo | ExportsInfo | undefined} the terminal binding export(s) info if known
 	 */
 	getTerminalBinding(moduleGraph, resolveTargetFilter = RETURNS_TRUE) {
@@ -1262,6 +1287,7 @@ class ExportInfo {
 		if (maxPriority === minPriority) return (this._maxTarget = this._target);
 
 		// This is an edge case
+		/** @type {Target} */
 		const map = new Map();
 		for (const [key, value] of /** @type {Target} */ (this._target)) {
 			if (maxPriority === value.priority) {
@@ -1274,7 +1300,7 @@ class ExportInfo {
 
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {function(Module): boolean} validTargetModuleFilter a valid target module
+	 * @param {ValidTargetModuleFilter} validTargetModuleFilter a valid target module
 	 * @returns {TargetItemWithoutConnection | null | undefined | false} the target, undefined when there is no target, false when no target is valid
 	 */
 	findTarget(moduleGraph, validTargetModuleFilter) {
@@ -1283,7 +1309,7 @@ class ExportInfo {
 
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {function(Module): boolean} validTargetModuleFilter a valid target module
+	 * @param {ValidTargetModuleFilter} validTargetModuleFilter a valid target module
 	 * @param {Set<ExportInfo>} alreadyVisited set of already visited export info to avoid circular references
 	 * @returns {TargetItemWithoutConnection | null | undefined | false} the target, undefined when there is no target, false when no target is valid
 	 */
@@ -1324,8 +1350,8 @@ class ExportInfo {
 
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {function(TargetItem): boolean} resolveTargetFilter filter function to further resolve target
-	 * @returns {TargetItem | undefined} the target
+	 * @param {ResolveTargetFilter} resolveTargetFilter filter function to further resolve target
+	 * @returns {TargetItemWithConnection | undefined} the target
 	 */
 	getTarget(moduleGraph, resolveTargetFilter = RETURNS_TRUE) {
 		const result = this._getTarget(moduleGraph, resolveTargetFilter, undefined);
@@ -1335,15 +1361,15 @@ class ExportInfo {
 
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {function(TargetItem): boolean} resolveTargetFilter filter function to further resolve target
+	 * @param {ResolveTargetFilter} resolveTargetFilter filter function to further resolve target
 	 * @param {Set<ExportInfo> | undefined} alreadyVisited set of already visited export info to avoid circular references
-	 * @returns {TargetItem | CIRCULAR | undefined} the target
+	 * @returns {TargetItemWithConnection | CIRCULAR | undefined} the target
 	 */
 	_getTarget(moduleGraph, resolveTargetFilter, alreadyVisited) {
 		/**
-		 * @param {TargetItem | null} inputTarget unresolved target
+		 * @param {TargetItem | undefined | null} inputTarget unresolved target
 		 * @param {Set<ExportInfo>} alreadyVisited set of already visited export info to avoid circular references
-		 * @returns {TargetItem | CIRCULAR | null} resolved target
+		 * @returns {TargetItemWithConnection | CIRCULAR | null} resolved target
 		 */
 		const resolveTarget = (inputTarget, alreadyVisited) => {
 			if (!inputTarget) return null;
@@ -1354,7 +1380,7 @@ class ExportInfo {
 					export: undefined
 				};
 			}
-			/** @type {TargetItem} */
+			/** @type {TargetItemWithConnection} */
 			let target = {
 				module: inputTarget.connection.module,
 				connection: inputTarget.connection,
@@ -1365,7 +1391,7 @@ class ExportInfo {
 			for (;;) {
 				const exportsInfo = moduleGraph.getExportsInfo(target.module);
 				const exportInfo = exportsInfo.getExportInfo(
-					/** @type {NonNullable<TargetItem["export"]>} */
+					/** @type {NonNullable<TargetItemWithConnection["export"]>} */
 					(target.export)[0]
 				);
 				if (!exportInfo) return target;
@@ -1378,7 +1404,7 @@ class ExportInfo {
 				if (newTarget === CIRCULAR) return CIRCULAR;
 				if (!newTarget) return target;
 				if (
-					/** @type {NonNullable<TargetItem["export"]>} */
+					/** @type {NonNullable<TargetItemWithConnection["export"]>} */
 					(target.export).length === 1
 				) {
 					target = newTarget;
@@ -1389,10 +1415,10 @@ class ExportInfo {
 						connection: newTarget.connection,
 						export: newTarget.export
 							? newTarget.export.concat(
-									/** @type {NonNullable<TargetItem["export"]>} */
+									/** @type {NonNullable<TargetItemWithConnection["export"]>} */
 									(target.export).slice(1)
 								)
-							: /** @type {NonNullable<TargetItem["export"]>} */
+							: /** @type {NonNullable<TargetItemWithConnection["export"]>} */
 								(target.export).slice(1)
 					};
 				}
@@ -1433,17 +1459,20 @@ class ExportInfo {
 	/**
 	 * Move the target forward as long resolveTargetFilter is fulfilled
 	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {function(TargetItem): boolean} resolveTargetFilter filter function to further resolve target
-	 * @param {function(TargetItem): ModuleGraphConnection=} updateOriginalConnection updates the original connection instead of using the target connection
-	 * @returns {TargetItem | undefined} the resolved target when moved
+	 * @param {ResolveTargetFilter} resolveTargetFilter filter function to further resolve target
+	 * @param {(target: TargetItemWithConnection) => ModuleGraphConnection=} updateOriginalConnection updates the original connection instead of using the target connection
+	 * @returns {TargetItemWithConnection | undefined} the resolved target when moved
 	 */
 	moveTarget(moduleGraph, resolveTargetFilter, updateOriginalConnection) {
 		const target = this._getTarget(moduleGraph, resolveTargetFilter, undefined);
 		if (target === CIRCULAR) return;
 		if (!target) return;
 		const originalTarget =
-			/** @type {Target} */
-			(this._getMaxTarget()).values().next().value;
+			/** @type {TargetItem} */
+			(
+				/** @type {Target} */
+				(this._getMaxTarget()).values().next().value
+			);
 		if (
 			originalTarget.connection === target.connection &&
 			originalTarget.export === target.export
@@ -1457,7 +1486,9 @@ class ExportInfo {
 			connection: updateOriginalConnection
 				? updateOriginalConnection(target)
 				: target.connection,
-			export: /** @type {NonNullable<TargetItem["export"]>} */ (target.export),
+			export: /** @type {NonNullable<TargetItemWithConnection["export"]>} */ (
+				target.export
+			),
 			priority: 0
 		});
 		return target;
@@ -1622,3 +1653,4 @@ class ExportInfo {
 module.exports = ExportsInfo;
 module.exports.ExportInfo = ExportInfo;
 module.exports.UsageState = UsageState;
+module.exports.RestoreProvidedData = RestoreProvidedData;

package/lib/ExternalModule.js

@@ -19,6 +19,7 @@ const {
 const { JAVASCRIPT_MODULE_TYPE_DYNAMIC } = require("./ModuleTypeConstants");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const Template = require("./Template");
+const { DEFAULTS } = require("./config/defaults");
 const StaticExportsDependency = require("./dependencies/StaticExportsDependency");
 const createHash = require("./util/createHash");
 const extractUrlAndGlobal = require("./util/extractUrlAndGlobal");
@@ -31,16 +32,19 @@ const { register } = require("./util/serialization");
 /** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./ChunkGraph")} ChunkGraph */
 /** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./Compilation").UnsafeCacheData} UnsafeCacheData */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("./DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("./ExportsInfo")} ExportsInfo */
 /** @typedef {import("./Generator").GenerateContext} GenerateContext */
 /** @typedef {import("./Generator").SourceTypes} SourceTypes */
+/** @typedef {import("./Module").BuildCallback} BuildCallback */
 /** @typedef {import("./Module").BuildInfo} BuildInfo */
 /** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
 /** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("./Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
 /** @typedef {import("./Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
@@ -212,7 +216,7 @@ const getSourceForImportExternal = (
 
 /**
  * @param {string} key key
- * @param {any | undefined} value value
+ * @param {TODO | undefined} value value
  * @returns {undefined | string} replaced value
  */
 const importAssertionReplacer = (key, value) => {
@@ -233,7 +237,12 @@ class ModuleExternalInitFragment extends InitFragment {
 	 * @param {ImportDependencyMeta=} dependencyMeta the dependency meta
 	 * @param {string | HashConstructor=} hashFunction the hash function to use
 	 */
-	constructor(request, ident, dependencyMeta, hashFunction = "md4") {
+	constructor(
+		request,
+		ident,
+		dependencyMeta,
+		hashFunction = DEFAULTS.HASH_FUNCTION
+	) {
 		if (ident === undefined) {
 			ident = Template.toIdentifier(request);
 			if (ident !== request) {
@@ -554,7 +563,7 @@ class ExternalModule extends Module {
 
 	/**
 	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
 	 */
 	needBuild(context, callback) {
@@ -566,7 +575,7 @@ class ExternalModule extends Module {
 	 * @param {Compilation} compilation the compilation
 	 * @param {ResolverWithOptions} resolver the resolver
 	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
+	 * @param {BuildCallback} callback callback function
 	 * @returns {void}
 	 */
 	build(options, compilation, resolver, fs, callback) {
@@ -647,7 +656,7 @@ class ExternalModule extends Module {
 
 	/**
 	 * restore unsafe cache data
-	 * @param {object} unsafeCacheData data from getUnsafeCacheData
+	 * @param {UnsafeCacheData} unsafeCacheData data from getUnsafeCacheData
 	 * @param {NormalModuleFactory} normalModuleFactory the normal module factory handling the unsafe caching
 	 */
 	restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {

package/lib/ExternalModuleFactoryPlugin.js

@@ -15,10 +15,13 @@ const ImportDependency = require("./dependencies/ImportDependency");
 const { resolveByProperty, cachedSetProperty } = require("./util/cleverMerge");
 
 /** @typedef {import("../declarations/WebpackOptions").ExternalItemFunctionData} ExternalItemFunctionData */
+/** @typedef {import("../declarations/WebpackOptions").ExternalItemObjectKnown} ExternalItemObjectKnown */
+/** @typedef {import("../declarations/WebpackOptions").ExternalItemObjectUnknown} ExternalItemObjectUnknown */
 /** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
 /** @typedef {import("./Compilation").DepConstructor} DepConstructor */
 /** @typedef {import("./ExternalModule").DependencyMeta} DependencyMeta */
 /** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleFactory").IssuerLayer} IssuerLayer */
 /** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
 
 const UNSPECIFIED_EXTERNAL_TYPE_REGEXP = /^[a-z0-9-]+ /;
@@ -27,7 +30,7 @@ const EMPTY_RESOLVE_OPTIONS = {};
 // TODO webpack 6 remove this
 const callDeprecatedExternals = util.deprecate(
 	/**
-	 * @param {TODO} externalsFunction externals function
+	 * @param {EXPECTED_FUNCTION} externalsFunction externals function
 	 * @param {string} context context
 	 * @param {string} request request
 	 * @param {(err: Error | null | undefined, value: ExternalValue | undefined, ty: ExternalType | undefined) => void} cb cb
@@ -40,19 +43,26 @@ const callDeprecatedExternals = util.deprecate(
 	"DEP_WEBPACK_EXTERNALS_FUNCTION_PARAMETERS"
 );
 
+/** @typedef {ExternalItemObjectKnown & ExternalItemObjectUnknown} ExternalItemObject */
+
+/**
+ * @template {ExternalItemObject} T
+ * @typedef {WeakMap<T, Map<IssuerLayer, Omit<T, "byLayer">>>} ExternalWeakCache
+ */
+
+/** @type {ExternalWeakCache<ExternalItemObject>} */
 const cache = new WeakMap();
 
 /**
- * @template {object} T
- * @param {T} obj obj
- * @param {TODO} layer layer
- * @returns {Omit<T, "byLayer">} result
+ * @param {ExternalItemObject} obj obj
+ * @param {IssuerLayer} layer layer
+ * @returns {Omit<ExternalItemObject, "byLayer">} result
  */
 const resolveLayer = (obj, layer) => {
-	let map = cache.get(/** @type {object} */ (obj));
+	let map = cache.get(obj);
 	if (map === undefined) {
 		map = new Map();
-		cache.set(/** @type {object} */ (obj), map);
+		cache.set(obj, map);
 	} else {
 		const cacheEntry = map.get(layer);
 		if (cacheEntry !== undefined) return cacheEntry;
@@ -89,10 +99,12 @@ class ExternalModuleFactoryPlugin {
 				const dependency = data.dependencies[0];
 				const dependencyType = data.dependencyType;
 
+				/** @typedef {(err?: Error | null, externalModule?: ExternalModule) => void} HandleExternalCallback */
+
 				/**
 				 * @param {ExternalValue} value the external config
 				 * @param {ExternalType | undefined} type type of external
-				 * @param {function((Error | null)=, ExternalModule=): void} callback callback
+				 * @param {HandleExternalCallback} callback callback
 				 * @returns {void}
 				 */
 				const handleExternal = (value, type, callback) => {
@@ -176,7 +188,7 @@ class ExternalModuleFactoryPlugin {
 
 				/**
 				 * @param {Externals} externals externals config
-				 * @param {function((Error | null)=, ExternalModule=): void} callback callback
+				 * @param {HandleExternalCallback} callback callback
 				 * @returns {void}
 				 */
 				const handleExternals = (externals, callback) => {
@@ -273,8 +285,7 @@ class ExternalModuleFactoryPlugin {
 												context,
 												request,
 												resolveContext,
-												/** @type {TODO} */
-												(callback)
+												callback
 											);
 										} else {
 											return new Promise((resolve, reject) => {
@@ -300,7 +311,8 @@ class ExternalModuleFactoryPlugin {
 					} else if (typeof externals === "object") {
 						const resolvedExternals = resolveLayer(
 							externals,
-							contextInfo.issuerLayer
+							/** @type {IssuerLayer} */
+							(contextInfo.issuerLayer)
 						);
 						if (
 							Object.prototype.hasOwnProperty.call(