webpack 5.97.1 → 5.104.1

package/lib/hmr/LazyCompilationPlugin.js

@@ -10,7 +10,8 @@ const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const Dependency = require("../Dependency");
 const Module = require("../Module");
 const ModuleFactory = require("../ModuleFactory");
-const { JS_TYPES } = require("../ModuleSourceTypesConstants");
+const { JAVASCRIPT_TYPES } = require("../ModuleSourceTypeConstants");
+const { JAVASCRIPT_TYPE } = require("../ModuleSourceTypeConstants");
 const {
 	WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY
 } = require("../ModuleTypeConstants");
@@ -19,21 +20,23 @@ const Template = require("../Template");
 const CommonJsRequireDependency = require("../dependencies/CommonJsRequireDependency");
 const { registerNotSerializable } = require("../util/serialization");
 
-/** @typedef {import("../../declarations/WebpackOptions")} WebpackOptions */
+/** @typedef {import("../config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Module").BuildCallback} BuildCallback */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").LibIdent} LibIdent */
+/** @typedef {import("../Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
+/** @typedef {import("../ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */
 /** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("../ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("../WebpackError")} WebpackError */
 /** @typedef {import("../dependencies/HarmonyImportDependency")} HarmonyImportDependency */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
@@ -42,8 +45,8 @@ const { registerNotSerializable } = require("../util/serialization");
 
 /**
  * @typedef {object} BackendApi
- * @property {function(function((Error | null)=) : void): void} dispose
- * @property {function(Module): ModuleResult} module
+ * @property {(callback: (err?: (Error | null)) => void) => void} dispose
+ * @property {(module: Module) => ModuleResult} module
  */
 
 const HMR_DEPENDENCY_TYPES = new Set([
@@ -54,7 +57,7 @@ const HMR_DEPENDENCY_TYPES = new Set([
 ]);
 
 /**
- * @param {undefined|string|RegExp|Function} test test option
+ * @param {Options["test"]} test test option
  * @param {Module} module the module
  * @returns {boolean | null | string} true, if the module should be selected
  */
@@ -159,7 +162,7 @@ class LazyCompilationProxyModule extends Module {
 
 	/**
 	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
+	 * @returns {LibIdent | null} an identifier for library inclusion
 	 */
 	libIdent(options) {
 		return `${this.originalModule.libIdent(
@@ -169,7 +172,7 @@ class LazyCompilationProxyModule 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) {
@@ -181,7 +184,7 @@ class LazyCompilationProxyModule 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) {
@@ -206,7 +209,7 @@ class LazyCompilationProxyModule extends Module {
 	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
-		return JS_TYPES;
+		return JAVASCRIPT_TYPES;
 	}
 
 	/**
@@ -255,6 +258,7 @@ class LazyCompilationProxyModule extends Module {
 					block,
 					module,
 					request: this.request,
+					dependency: dep,
 					strict: false, // TODO this should be inherited from the original module
 					message: "import()",
 					runtimeRequirements
@@ -287,7 +291,7 @@ class LazyCompilationProxyModule extends Module {
 				keepActive
 			]);
 		}
-		sources.set("javascript", new RawSource(source));
+		sources.set(JAVASCRIPT_TYPE, new RawSource(source));
 		return {
 			sources,
 			runtimeRequirements
@@ -315,13 +319,13 @@ class LazyCompilationDependencyFactory extends ModuleFactory {
 
 	/**
 	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
+	 * @param {ModuleFactoryCallback} callback callback
 	 * @returns {void}
 	 */
 	create(data, callback) {
-		const dependency = /** @type {LazyCompilationDependency} */ (
-			data.dependencies[0]
-		);
+		const dependency =
+			/** @type {LazyCompilationDependency} */
+			(data.dependencies[0]);
 		callback(null, {
 			module: dependency.proxyModule.originalModule
 		});
@@ -331,7 +335,7 @@ class LazyCompilationDependencyFactory extends ModuleFactory {
 /**
  * @callback BackendHandler
  * @param {Compiler} compiler compiler
- * @param {function(Error | null, BackendApi=): void} callback callback
+ * @param {(err: Error | null, backendApi?: BackendApi) => void} callback callback
  * @returns {void}
  */
 
@@ -341,13 +345,23 @@ class LazyCompilationDependencyFactory extends ModuleFactory {
  * @returns {Promise<BackendApi>} backend
  */
 
+/** @typedef {BackendHandler | PromiseBackendHandler} BackEnd */
+
+/** @typedef {(module: Module) => boolean} TestFn */
+
+/**
+ * @typedef {object} Options options
+ * @property {BackEnd} backend the backend
+ * @property {boolean=} entries
+ * @property {boolean=} imports
+ * @property {RegExp | string | TestFn=} test additional filter for lazy compiled entrypoint modules
+ */
+
+const PLUGIN_NAME = "LazyCompilationPlugin";
+
 class LazyCompilationPlugin {
 	/**
-	 * @param {object} options options
-	 * @param {BackendHandler | PromiseBackendHandler} options.backend the backend
-	 * @param {boolean} options.entries true, when entries are lazy compiled
-	 * @param {boolean} options.imports true, when import() modules are lazy compiled
-	 * @param {RegExp | string | (function(Module): boolean) | undefined} options.test additional filter for lazy compiled entrypoint modules
+	 * @param {Options} options options
 	 */
 	constructor({ backend, entries, imports, test }) {
 		this.backend = backend;
@@ -364,31 +378,28 @@ class LazyCompilationPlugin {
 	apply(compiler) {
 		/** @type {BackendApi} */
 		let backend;
-		compiler.hooks.beforeCompile.tapAsync(
-			"LazyCompilationPlugin",
-			(params, callback) => {
-				if (backend !== undefined) return callback();
-				const promise = this.backend(compiler, (err, result) => {
-					if (err) return callback(err);
-					backend = /** @type {BackendApi} */ (result);
+		compiler.hooks.beforeCompile.tapAsync(PLUGIN_NAME, (params, callback) => {
+			if (backend !== undefined) return callback();
+			const promise = this.backend(compiler, (err, result) => {
+				if (err) return callback(err);
+				backend = /** @type {BackendApi} */ (result);
+				callback();
+			});
+			if (promise && promise.then) {
+				promise.then((b) => {
+					backend = b;
 					callback();
-				});
-				if (promise && promise.then) {
-					promise.then(b => {
-						backend = b;
-						callback();
-					}, callback);
-				}
+				}, callback);
 			}
-		);
+		});
 		compiler.hooks.thisCompilation.tap(
-			"LazyCompilationPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				normalModuleFactory.hooks.module.tap(
-					"LazyCompilationPlugin",
-					(originalModule, createData, resolveData) => {
+					PLUGIN_NAME,
+					(module, createData, resolveData) => {
 						if (
-							resolveData.dependencies.every(dep =>
+							resolveData.dependencies.every((dep) =>
 								HMR_DEPENDENCY_TYPES.has(dep.type)
 							)
 						) {
@@ -399,40 +410,42 @@ class LazyCompilationPlugin {
 								/** @type {Module} */
 								(compilation.moduleGraph.getParentModule(hmrDep));
 							const isReferringToDynamicImport = originModule.blocks.some(
-								block =>
+								(block) =>
 									block.dependencies.some(
-										dep =>
+										(dep) =>
 											dep.type === "import()" &&
 											/** @type {HarmonyImportDependency} */ (dep).request ===
 												hmrDep.request
 									)
 							);
-							if (!isReferringToDynamicImport) return;
+							if (!isReferringToDynamicImport) return module;
 						} else if (
 							!resolveData.dependencies.every(
-								dep =>
+								(dep) =>
 									HMR_DEPENDENCY_TYPES.has(dep.type) ||
 									(this.imports &&
 										(dep.type === "import()" ||
 											dep.type === "import() context element")) ||
 									(this.entries && dep.type === "entry")
 							)
-						)
-							return;
+						) {
+							return module;
+						}
 						if (
 							/webpack[/\\]hot[/\\]|webpack-dev-server[/\\]client|webpack-hot-middleware[/\\]client/.test(
 								resolveData.request
 							) ||
-							!checkTest(this.test, originalModule)
-						)
-							return;
-						const moduleInfo = backend.module(originalModule);
-						if (!moduleInfo) return;
+							!checkTest(this.test, module)
+						) {
+							return module;
+						}
+						const moduleInfo = backend.module(module);
+						if (!moduleInfo) return module;
 						const { client, data, active } = moduleInfo;
 
 						return new LazyCompilationProxyModule(
 							compiler.context,
-							originalModule,
+							module,
 							resolveData.request,
 							client,
 							data,
@@ -446,7 +459,7 @@ class LazyCompilationPlugin {
 				);
 			}
 		);
-		compiler.hooks.shutdown.tapAsync("LazyCompilationPlugin", callback => {
+		compiler.hooks.shutdown.tapAsync(PLUGIN_NAME, (callback) => {
 			backend.dispose(callback);
 		});
 	}

package/lib/hmr/lazyCompilationBackend.js

@@ -5,24 +5,24 @@
 
 "use strict";
 
-/** @typedef {import("http").IncomingMessage} IncomingMessage */
 /** @typedef {import("http").RequestListener} RequestListener */
 /** @typedef {import("http").ServerOptions} HttpServerOptions */
-/** @typedef {import("http").ServerResponse} ServerResponse */
+/** @typedef {import("http").Server} HttpServer */
 /** @typedef {import("https").ServerOptions} HttpsServerOptions */
+/** @typedef {import("https").Server} HttpsServer */
 /** @typedef {import("net").AddressInfo} AddressInfo */
-/** @typedef {import("net").Server} Server */
-/** @typedef {import("../../declarations/WebpackOptions").LazyCompilationDefaultBackendOptions} LazyCompilationDefaultBackendOptions */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("./LazyCompilationPlugin").BackendApi} BackendApi */
 /** @typedef {import("./LazyCompilationPlugin").BackendHandler} BackendHandler */
+/** @typedef {import("../../declarations/WebpackOptions").LazyCompilationDefaultBackendOptions} LazyCompilationDefaultBackendOptions */
+
+/** @typedef {HttpServer | HttpsServer} Server */
+/** @typedef {(server: Server) => void} Listen */
+/** @typedef {() => Server} CreateServerFunction */
 
 /**
  * @param {Omit<LazyCompilationDefaultBackendOptions, "client"> & { client: NonNullable<LazyCompilationDefaultBackendOptions["client"]>}} options additional options for the backend
  * @returns {BackendHandler} backend
  */
-module.exports = options => (compiler, callback) => {
+module.exports = (options) => (compiler, callback) => {
 	const logger = compiler.getInfrastructureLogger("LazyCompilationBackend");
 	const activeModules = new Map();
 	const prefix = "/lazy-compilation-using-";
@@ -32,25 +32,29 @@ module.exports = options => (compiler, callback) => {
 		(typeof options.server === "object" &&
 			("key" in options.server || "pfx" in options.server));
 
+	/** @type {CreateServerFunction} */
 	const createServer =
 		typeof options.server === "function"
 			? options.server
 			: (() => {
 					const http = isHttps ? require("https") : require("http");
-					return http.createServer.bind(
+					return /** @type {(this: import("http") | import("https"), options: HttpServerOptions | HttpsServerOptions) => Server} */ (
+						http.createServer
+					).bind(
 						http,
 						/** @type {HttpServerOptions | HttpsServerOptions} */
 						(options.server)
 					);
 				})();
-	/** @type {function(Server): void} */
+	/** @type {Listen} */
 	const listen =
 		typeof options.listen === "function"
 			? options.listen
-			: server => {
+			: (server) => {
 					let listen = options.listen;
-					if (typeof listen === "object" && !("port" in listen))
+					if (typeof listen === "object" && !("port" in listen)) {
 						listen = { ...listen, port: undefined };
+					}
 					server.listen(listen);
 				};
 
@@ -93,20 +97,20 @@ module.exports = options => (compiler, callback) => {
 		if (moduleActivated && compiler.watching) compiler.watching.invalidate();
 	};
 
-	const server = /** @type {Server} */ (createServer());
+	const server = createServer();
 	server.on("request", requestListener);
 
 	let isClosing = false;
 	/** @type {Set<import("net").Socket>} */
 	const sockets = new Set();
-	server.on("connection", socket => {
+	server.on("connection", (socket) => {
 		sockets.add(socket);
 		socket.on("close", () => {
 			sockets.delete(socket);
 		});
 		if (isClosing) socket.destroy();
 	});
-	server.on("clientError", e => {
+	server.on("clientError", (e) => {
 		if (e.message !== "Server is disposing") logger.warn(e);
 	});
 
@@ -116,11 +120,12 @@ module.exports = options => (compiler, callback) => {
 		 * @param {Error} err error
 		 * @returns {void}
 		 */
-		err => {
+		(err) => {
 			if (err) return callback(err);
 			const _addr = server.address();
-			if (typeof _addr === "string")
+			if (typeof _addr === "string") {
 				throw new Error("addr must not be a string");
+			}
 			const addr = /** @type {AddressInfo} */ (_addr);
 			const urlBase =
 				addr.address === "::" || addr.address === "0.0.0.0"
@@ -136,7 +141,7 @@ module.exports = options => (compiler, callback) => {
 					isClosing = true;
 					// Removing the listener is a workaround for a memory leak in node.js
 					server.off("request", requestListener);
-					server.close(err => {
+					server.close((err) => {
 						callback(err);
 					});
 					for (const socket of sockets) {

package/lib/ids/ChunkModuleIdRangePlugin.js

@@ -7,11 +7,12 @@
 
 const { find } = require("../util/SetHelpers");
 const {
-	compareModulesByPreOrderIndexOrIdentifier,
-	compareModulesByPostOrderIndexOrIdentifier
+	compareModulesByPostOrderIndexOrIdentifier,
+	compareModulesByPreOrderIndexOrIdentifier
 } = require("../util/comparators");
 
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
 /**
  * @typedef {object} ChunkModuleIdRangePluginOptions
@@ -21,6 +22,8 @@ const {
  * @property {number=} end end id
  */
 
+const PLUGIN_NAME = "ChunkModuleIdRangePlugin";
+
 class ChunkModuleIdRangePlugin {
 	/**
 	 * @param {ChunkModuleIdRangePluginOptions} options options object
@@ -36,20 +39,21 @@ class ChunkModuleIdRangePlugin {
 	 */
 	apply(compiler) {
 		const options = this.options;
-		compiler.hooks.compilation.tap("ChunkModuleIdRangePlugin", compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			const moduleGraph = compilation.moduleGraph;
-			compilation.hooks.moduleIds.tap("ChunkModuleIdRangePlugin", modules => {
+			compilation.hooks.moduleIds.tap(PLUGIN_NAME, (modules) => {
 				const chunkGraph = compilation.chunkGraph;
 				const chunk = find(
 					compilation.chunks,
-					chunk => chunk.name === options.name
+					(chunk) => chunk.name === options.name
 				);
 				if (!chunk) {
 					throw new Error(
-						`ChunkModuleIdRangePlugin: Chunk with name '${options.name}"' was not found`
+						`${PLUGIN_NAME}: Chunk with name '${options.name}"' was not found`
 					);
 				}
 
+				/** @type {Module[]} */
 				let chunkModules;
 				if (options.order) {
 					let cmpFn;
@@ -63,14 +67,12 @@ class ChunkModuleIdRangePlugin {
 							cmpFn = compareModulesByPostOrderIndexOrIdentifier(moduleGraph);
 							break;
 						default:
-							throw new Error(
-								"ChunkModuleIdRangePlugin: unexpected value of order"
-							);
+							throw new Error(`${PLUGIN_NAME}: unexpected value of order`);
 					}
 					chunkModules = chunkGraph.getOrderedChunkModules(chunk, cmpFn);
 				} else {
-					chunkModules = Array.from(modules)
-						.filter(m => chunkGraph.isModuleInChunk(m, chunk))
+					chunkModules = [...modules]
+						.filter((m) => chunkGraph.isModuleInChunk(m, chunk))
 						.sort(compareModulesByPreOrderIndexOrIdentifier(moduleGraph));
 				}
 
@@ -86,4 +88,5 @@ class ChunkModuleIdRangePlugin {
 		});
 	}
 }
+
 module.exports = ChunkModuleIdRangePlugin;

package/lib/ids/DeterministicChunkIdsPlugin.js

@@ -7,13 +7,12 @@
 
 const { compareChunksNatural } = require("../util/comparators");
 const {
+	assignDeterministicIds,
 	getFullChunkName,
-	getUsedChunkIds,
-	assignDeterministicIds
+	getUsedChunkIds
 } = require("./IdHelpers");
 
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
 
 /**
  * @typedef {object} DeterministicChunkIdsPluginOptions
@@ -21,9 +20,11 @@ const {
  * @property {number=} maxLength maximum length of ids
  */
 
+const PLUGIN_NAME = "DeterministicChunkIdsPlugin";
+
 class DeterministicChunkIdsPlugin {
 	/**
-	 * @param {DeterministicChunkIdsPluginOptions} [options] options
+	 * @param {DeterministicChunkIdsPluginOptions=} options options
 	 */
 	constructor(options = {}) {
 		this.options = options;
@@ -35,42 +36,36 @@ class DeterministicChunkIdsPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"DeterministicChunkIdsPlugin",
-			compilation => {
-				compilation.hooks.chunkIds.tap(
-					"DeterministicChunkIdsPlugin",
-					chunks => {
-						const chunkGraph = compilation.chunkGraph;
-						const context = this.options.context
-							? this.options.context
-							: compiler.context;
-						const maxLength = this.options.maxLength || 3;
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			compilation.hooks.chunkIds.tap(PLUGIN_NAME, (chunks) => {
+				const chunkGraph = compilation.chunkGraph;
+				const context = this.options.context
+					? this.options.context
+					: compiler.context;
+				const maxLength = this.options.maxLength || 3;
 
-						const compareNatural = compareChunksNatural(chunkGraph);
+				const compareNatural = compareChunksNatural(chunkGraph);
 
-						const usedIds = getUsedChunkIds(compilation);
-						assignDeterministicIds(
-							Array.from(chunks).filter(chunk => chunk.id === null),
-							chunk =>
-								getFullChunkName(chunk, chunkGraph, context, compiler.root),
-							compareNatural,
-							(chunk, id) => {
-								const size = usedIds.size;
-								usedIds.add(`${id}`);
-								if (size === usedIds.size) return false;
-								chunk.id = id;
-								chunk.ids = [id];
-								return true;
-							},
-							[10 ** maxLength],
-							10,
-							usedIds.size
-						);
-					}
+				const usedIds = getUsedChunkIds(compilation);
+				assignDeterministicIds(
+					[...chunks].filter((chunk) => chunk.id === null),
+					(chunk) =>
+						getFullChunkName(chunk, chunkGraph, context, compiler.root),
+					compareNatural,
+					(chunk, id) => {
+						const size = usedIds.size;
+						usedIds.add(`${id}`);
+						if (size === usedIds.size) return false;
+						chunk.id = id;
+						chunk.ids = [id];
+						return true;
+					},
+					[10 ** maxLength],
+					10,
+					usedIds.size
 				);
-			}
-		);
+			});
+		});
 	}
 }