webpack 5.83.1 → 5.85.0

package/lib/config/normalization.js

@@ -7,17 +7,28 @@
 
 const util = require("util");
 
+/** @typedef {import("../../declarations/WebpackOptions").CacheOptionsNormalized} CacheOptions */
+/** @typedef {import("../../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescriptionNormalized */
 /** @typedef {import("../../declarations/WebpackOptions").EntryStatic} EntryStatic */
 /** @typedef {import("../../declarations/WebpackOptions").EntryStaticNormalized} EntryStaticNormalized */
+/** @typedef {import("../../declarations/WebpackOptions").Externals} Externals */
 /** @typedef {import("../../declarations/WebpackOptions").LibraryName} LibraryName */
 /** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptionsNormalized */
 /** @typedef {import("../../declarations/WebpackOptions").OptimizationRuntimeChunk} OptimizationRuntimeChunk */
 /** @typedef {import("../../declarations/WebpackOptions").OptimizationRuntimeChunkNormalized} OptimizationRuntimeChunkNormalized */
 /** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputNormalized */
+/** @typedef {import("../../declarations/WebpackOptions").Plugins} Plugins */
 /** @typedef {import("../../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
 /** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
+/** @typedef {import("../Entrypoint")} Entrypoint */
 
 const handledDeprecatedNoEmitOnErrors = util.deprecate(
+	/**
+	 * @param {boolean} noEmitOnErrors no emit on errors
+	 * @param {boolean | undefined} emitOnErrors emit on errors
+	 * @returns {boolean} emit on errors
+	 */
 	(noEmitOnErrors, emitOnErrors) => {
 		if (emitOnErrors !== undefined && !noEmitOnErrors === !emitOnErrors) {
 			throw new Error(
@@ -117,45 +128,51 @@ const getNormalizedWebpackOptions = config => {
 	return {
 		amd: config.amd,
 		bail: config.bail,
-		cache: optionalNestedConfig(config.cache, cache => {
-			if (cache === false) return false;
-			if (cache === true) {
-				return {
-					type: "memory",
-					maxGenerations: undefined
-				};
-			}
-			switch (cache.type) {
-				case "filesystem":
-					return {
-						type: "filesystem",
-						allowCollectingMemory: cache.allowCollectingMemory,
-						maxMemoryGenerations: cache.maxMemoryGenerations,
-						maxAge: cache.maxAge,
-						profile: cache.profile,
-						buildDependencies: cloneObject(cache.buildDependencies),
-						cacheDirectory: cache.cacheDirectory,
-						cacheLocation: cache.cacheLocation,
-						hashAlgorithm: cache.hashAlgorithm,
-						compression: cache.compression,
-						idleTimeout: cache.idleTimeout,
-						idleTimeoutForInitialStore: cache.idleTimeoutForInitialStore,
-						idleTimeoutAfterLargeChanges: cache.idleTimeoutAfterLargeChanges,
-						name: cache.name,
-						store: cache.store,
-						version: cache.version
-					};
-				case undefined:
-				case "memory":
-					return {
-						type: "memory",
-						maxGenerations: cache.maxGenerations
-					};
-				default:
-					// @ts-expect-error Property 'type' does not exist on type 'never'. ts(2339)
-					throw new Error(`Not implemented cache.type ${cache.type}`);
-			}
-		}),
+		cache:
+			/** @type {NonNullable<CacheOptions>} */
+			(
+				optionalNestedConfig(config.cache, cache => {
+					if (cache === false) return false;
+					if (cache === true) {
+						return {
+							type: "memory",
+							maxGenerations: undefined
+						};
+					}
+					switch (cache.type) {
+						case "filesystem":
+							return {
+								type: "filesystem",
+								allowCollectingMemory: cache.allowCollectingMemory,
+								maxMemoryGenerations: cache.maxMemoryGenerations,
+								maxAge: cache.maxAge,
+								profile: cache.profile,
+								buildDependencies: cloneObject(cache.buildDependencies),
+								cacheDirectory: cache.cacheDirectory,
+								cacheLocation: cache.cacheLocation,
+								hashAlgorithm: cache.hashAlgorithm,
+								compression: cache.compression,
+								idleTimeout: cache.idleTimeout,
+								idleTimeoutForInitialStore: cache.idleTimeoutForInitialStore,
+								idleTimeoutAfterLargeChanges:
+									cache.idleTimeoutAfterLargeChanges,
+								name: cache.name,
+								store: cache.store,
+								version: cache.version,
+								readonly: cache.readonly
+							};
+						case undefined:
+						case "memory":
+							return {
+								type: "memory",
+								maxGenerations: cache.maxGenerations
+							};
+						default:
+							// @ts-expect-error Property 'type' does not exist on type 'never'. ts(2339)
+							throw new Error(`Not implemented cache.type ${cache.type}`);
+					}
+				})
+			),
 		context: config.context,
 		dependencies: config.dependencies,
 		devServer: optionalNestedConfig(config.devServer, devServer => ({
@@ -184,7 +201,7 @@ const getNormalizedWebpackOptions = config => {
 				options === true ? {} : options
 			)
 		})),
-		externals: config.externals,
+		externals: /** @type {NonNullable<Externals>} */ (config.externals),
 		externalsPresets: cloneObject(config.externalsPresets),
 		externalsType: config.externalsType,
 		ignoreWarnings: config.ignoreWarnings
@@ -215,32 +232,36 @@ const getNormalizedWebpackOptions = config => {
 		infrastructureLogging: cloneObject(config.infrastructureLogging),
 		loader: cloneObject(config.loader),
 		mode: config.mode,
-		module: nestedConfig(config.module, module => ({
-			noParse: module.noParse,
-			unsafeCache: module.unsafeCache,
-			parser: keyedNestedConfig(module.parser, cloneObject, {
-				javascript: parserOptions => ({
-					unknownContextRequest: module.unknownContextRequest,
-					unknownContextRegExp: module.unknownContextRegExp,
-					unknownContextRecursive: module.unknownContextRecursive,
-					unknownContextCritical: module.unknownContextCritical,
-					exprContextRequest: module.exprContextRequest,
-					exprContextRegExp: module.exprContextRegExp,
-					exprContextRecursive: module.exprContextRecursive,
-					exprContextCritical: module.exprContextCritical,
-					wrappedContextRegExp: module.wrappedContextRegExp,
-					wrappedContextRecursive: module.wrappedContextRecursive,
-					wrappedContextCritical: module.wrappedContextCritical,
-					// TODO webpack 6 remove
-					strictExportPresence: module.strictExportPresence,
-					strictThisContextOnImports: module.strictThisContextOnImports,
-					...parserOptions
-				})
-			}),
-			generator: cloneObject(module.generator),
-			defaultRules: optionalNestedArray(module.defaultRules, r => [...r]),
-			rules: nestedArray(module.rules, r => [...r])
-		})),
+		module:
+			/** @type {ModuleOptionsNormalized} */
+			(
+				nestedConfig(config.module, module => ({
+					noParse: module.noParse,
+					unsafeCache: module.unsafeCache,
+					parser: keyedNestedConfig(module.parser, cloneObject, {
+						javascript: parserOptions => ({
+							unknownContextRequest: module.unknownContextRequest,
+							unknownContextRegExp: module.unknownContextRegExp,
+							unknownContextRecursive: module.unknownContextRecursive,
+							unknownContextCritical: module.unknownContextCritical,
+							exprContextRequest: module.exprContextRequest,
+							exprContextRegExp: module.exprContextRegExp,
+							exprContextRecursive: module.exprContextRecursive,
+							exprContextCritical: module.exprContextCritical,
+							wrappedContextRegExp: module.wrappedContextRegExp,
+							wrappedContextRecursive: module.wrappedContextRecursive,
+							wrappedContextCritical: module.wrappedContextCritical,
+							// TODO webpack 6 remove
+							strictExportPresence: module.strictExportPresence,
+							strictThisContextOnImports: module.strictThisContextOnImports,
+							...parserOptions
+						})
+					}),
+					generator: cloneObject(module.generator),
+					defaultRules: optionalNestedArray(module.defaultRules, r => [...r]),
+					rules: nestedArray(module.rules, r => [...r])
+				}))
+			),
 		name: config.name,
 		node: nestedConfig(
 			config.node,
@@ -387,7 +408,7 @@ const getNormalizedWebpackOptions = config => {
 				...performance
 			};
 		}),
-		plugins: nestedArray(config.plugins, p => [...p]),
+		plugins: /** @type {Plugins} */ (nestedArray(config.plugins, p => [...p])),
 		profile: config.profile,
 		recordsInputPath:
 			config.recordsInputPath !== undefined
@@ -488,8 +509,11 @@ const getNormalizedEntryStatic = entry => {
 		} else {
 			result[key] = {
 				import:
-					value.import &&
-					(Array.isArray(value.import) ? value.import : [value.import]),
+					/** @type {EntryDescriptionNormalized["import"]} */
+					(
+						value.import &&
+							(Array.isArray(value.import) ? value.import : [value.import])
+					),
 				filename: value.filename,
 				layer: value.layer,
 				runtime: value.runtime,
@@ -499,8 +523,13 @@ const getNormalizedEntryStatic = entry => {
 				asyncChunks: value.asyncChunks,
 				wasmLoading: value.wasmLoading,
 				dependOn:
-					value.dependOn &&
-					(Array.isArray(value.dependOn) ? value.dependOn : [value.dependOn]),
+					/** @type {EntryDescriptionNormalized["dependOn"]} */
+					(
+						value.dependOn &&
+							(Array.isArray(value.dependOn)
+								? value.dependOn
+								: [value.dependOn])
+					),
 				library: value.library
 			};
 		}
@@ -522,6 +551,10 @@ const getNormalizedOptimizationRuntimeChunk = runtimeChunk => {
 	}
 	if (runtimeChunk === true || runtimeChunk === "multiple") {
 		return {
+			/**
+			 * @param {Entrypoint} entrypoint entrypoint
+			 * @returns {string} runtime chunk name
+			 */
 			name: entrypoint => `runtime~${entrypoint.name}`
 		};
 	}

package/lib/config/target.js

@@ -64,20 +64,39 @@ const getDefaultTarget = context => {
  */
 
 ///** @typedef {PlatformTargetProperties | ApiTargetProperties | EcmaTargetProperties | PlatformTargetProperties & ApiTargetProperties | PlatformTargetProperties & EcmaTargetProperties | ApiTargetProperties & EcmaTargetProperties} TargetProperties */
-/** @template T @typedef {{ [P in keyof T]?: never }} Never<T> */
-/** @template A @template B @typedef {(A & Never<B>) | (Never<A> & B) | (A & B)} Mix<A,B> */
+
+/**
+ * @template T
+ * @typedef {{ [P in keyof T]?: never }} Never<T>
+ */
+
+/**
+ * @template A
+ * @template B
+ * @typedef {(A & Never<B>) | (Never<A> & B) | (A & B)} Mix<A, B>
+ */
+
 /** @typedef {Mix<Mix<PlatformTargetProperties, ElectronContextTargetProperties>, Mix<ApiTargetProperties, EcmaTargetProperties>>} TargetProperties */
 
+/**
+ * @param {string} major major version
+ * @param {string | undefined} minor minor version
+ * @returns {(vMajor: number, vMinor?: number) => boolean | undefined} check if version is greater or equal
+ */
 const versionDependent = (major, minor) => {
-	if (!major) return () => /** @type {undefined} */ (undefined);
-	major = +major;
-	minor = minor ? +minor : 0;
+	if (!major) {
+		return () => /** @type {undefined} */ (undefined);
+	}
+	/** @type {number} */
+	const nMajor = +major;
+	/** @type {number} */
+	const nMinor = minor ? +minor : 0;
 	return (vMajor, vMinor = 0) => {
-		return major > vMajor || (major === vMajor && minor >= vMinor);
+		return nMajor > vMajor || (nMajor === vMajor && nMinor >= vMinor);
 	};
 };
 
-/** @type {[string, string, RegExp, (...args: string[]) => TargetProperties | false][]} */
+/** @type {[string, string, RegExp, (...args: string[]) => Partial<TargetProperties>][]} */
 const TARGETS = [
 	[
 		"browserslist / browserslist:env / browserslist:query / browserslist:path-to-config / browserslist:path-to-config:env",
@@ -95,6 +114,7 @@ See https://github.com/browserslist/browserslist#queries for possible ways to pr
 The recommended way is to add a 'browserslist' key to your package.json and list supported browsers (resp. node.js versions).
 You can also more options via the 'target' option: 'browserslist' / 'browserslist:env' / 'browserslist:query' / 'browserslist:path-to-config' / 'browserslist:path-to-config:env'`);
 			}
+
 			return browserslistTargetHandler.resolve(browsers);
 		}
 	],
@@ -294,7 +314,7 @@ const getTargetProperties = (target, context) => {
 		if (match) {
 			const [, ...args] = match;
 			const result = handler(...args, context);
-			if (result) return result;
+			if (result) return /** @type {TargetProperties} */ (result);
 		}
 	}
 	throw new Error(
@@ -304,13 +324,19 @@ const getTargetProperties = (target, context) => {
 	);
 };
 
+/**
+ * @param {TargetProperties[]} targetProperties array of target properties
+ * @returns {TargetProperties} merged target properties
+ */
 const mergeTargetProperties = targetProperties => {
+	/** @type {Set<keyof TargetProperties>} */
 	const keys = new Set();
 	for (const tp of targetProperties) {
 		for (const key of Object.keys(tp)) {
-			keys.add(key);
+			keys.add(/** @type {keyof TargetProperties} */ (key));
 		}
 	}
+	/** @type {Object} */
 	const result = {};
 	for (const key of keys) {
 		let hasTrue = false;
@@ -327,7 +353,8 @@ const mergeTargetProperties = targetProperties => {
 			}
 		}
 		if (hasTrue || hasFalse)
-			result[key] = hasFalse && hasTrue ? null : hasTrue ? true : false;
+			/** @type {TargetProperties} */
+			(result)[key] = hasFalse && hasTrue ? null : hasTrue ? true : false;
 	}
 	return /** @type {TargetProperties} */ (result);
 };

package/lib/container/ContainerEntryModule.js

@@ -273,6 +273,10 @@ class ContainerEntryModule extends Module {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {ContainerEntryModule} deserialized container entry module
+	 */
 	static deserialize(context) {
 		const { read } = context;
 		const obj = new ContainerEntryModule(read(), read(), read());

package/lib/container/ContainerEntryModuleFactory.js

@@ -15,7 +15,7 @@ const ContainerEntryModule = require("./ContainerEntryModule");
 module.exports = class ContainerEntryModuleFactory extends ModuleFactory {
 	/**
 	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
 	 * @returns {void}
 	 */
 	create({ dependencies: [dependency] }, callback) {

package/lib/container/FallbackDependency.js

@@ -12,6 +12,9 @@ const makeSerializable = require("../util/makeSerializable");
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
 class FallbackDependency extends Dependency {
+	/**
+	 * @param {string[]} requests requests
+	 */
 	constructor(requests) {
 		super();
 		this.requests = requests;
@@ -41,6 +44,10 @@ class FallbackDependency extends Dependency {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {FallbackDependency} deserialize fallback dependency
+	 */
 	static deserialize(context) {
 		const { read } = context;
 		const obj = new FallbackDependency(read());

package/lib/container/FallbackItemDependency.js

@@ -9,6 +9,9 @@ const ModuleDependency = require("../dependencies/ModuleDependency");
 const makeSerializable = require("../util/makeSerializable");
 
 class FallbackItemDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request
+	 */
 	constructor(request) {
 		super(request);
 	}

package/lib/container/FallbackModule.js

@@ -136,7 +136,7 @@ class FallbackModule extends Module {
 			`var loop = ${runtimeTemplate.basicFunction("next", [
 				"while(i < ids.length) {",
 				Template.indent([
-					"try { next = __webpack_require__(ids[i++]); } catch(e) { return handleError(e); }",
+					`try { next = ${RuntimeGlobals.require}(ids[i++]); } catch(e) { return handleError(e); }`,
 					"if(next) return next.then ? next.then(handleResult, handleError) : handleResult(next);"
 				]),
 				"}",
@@ -166,6 +166,10 @@ class FallbackModule extends Module {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {FallbackModule} deserialized fallback module
+	 */
 	static deserialize(context) {
 		const { read } = context;
 		const obj = new FallbackModule(read());

package/lib/container/FallbackModuleFactory.js

@@ -15,7 +15,7 @@ const FallbackModule = require("./FallbackModule");
 module.exports = class FallbackModuleFactory extends ModuleFactory {
 	/**
 	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
 	 * @returns {void}
 	 */
 	create({ dependencies: [dependency] }, callback) {

package/lib/container/RemoteModule.js

@@ -164,6 +164,10 @@ class RemoteModule extends Module {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {RemoteModule} deserialized module
+	 */
 	static deserialize(context) {
 		const { read } = context;
 		const obj = new RemoteModule(read(), read(), read(), read());

package/lib/container/RemoteRuntimeModule.js

@@ -9,6 +9,7 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("./RemoteModule")} RemoteModule */
 
 class RemoteRuntimeModule extends RuntimeModule {
@@ -117,7 +118,7 @@ class RemoteRuntimeModule extends RuntimeModule {
 								"module.exports = factory();"
 							])}`
 						])};`,
-						"handleFunction(__webpack_require__, data[2], 0, 0, onExternal, 1);"
+						`handleFunction(${RuntimeGlobals.require}, data[2], 0, 0, onExternal, 1);`
 					])});`
 				]),
 				"}"

package/lib/container/RemoteToExternalDependency.js

@@ -9,6 +9,9 @@ const ModuleDependency = require("../dependencies/ModuleDependency");
 const makeSerializable = require("../util/makeSerializable");
 
 class RemoteToExternalDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request
+	 */
 	constructor(request) {
 		super(request);
 	}