feat: refactoring project

node_modules/webpack/lib/hmr/HotModuleReplacement.runtime.js

@@ -1,3 +1,4 @@
+// @ts-nocheck
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
@@ -201,7 +202,7 @@ module.exports = function () {
 				if (idx >= 0) registeredStatusHandlers.splice(idx, 1);
 			},
 
-			//inherit from previous dispose call
+			// inherit from previous dispose call
 			data: currentModuleData[moduleId]
 		};
 		currentChildModule = undefined;
@@ -293,11 +294,10 @@ module.exports = function () {
 						return waitForBlockingPromises(function () {
 							if (applyOnUpdate) {
 								return internalApply(applyOnUpdate);
-							} else {
-								return setStatus("ready").then(function () {
-									return updatedModules;
-								});
 							}
+							return setStatus("ready").then(function () {
+								return updatedModules;
+							});
 						});
 					});
 				});

node_modules/webpack/lib/hmr/HotModuleReplacementRuntimeModule.js

@@ -13,6 +13,7 @@ class HotModuleReplacementRuntimeModule extends RuntimeModule {
 	constructor() {
 		super("hot module replacement", RuntimeModule.STAGE_BASIC);
 	}
+
 	/**
 	 * @returns {string | null} runtime code
 	 */

node_modules/webpack/lib/hmr/JavascriptHotModuleReplacement.runtime.js

@@ -1,3 +1,4 @@
+// @ts-nocheck
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
@@ -117,15 +118,12 @@ module.exports = function () {
 			if ($hasOwnProperty$(currentUpdate, moduleId)) {
 				var newModuleFactory = currentUpdate[moduleId];
 				/** @type {TODO} */
-				var result;
-				if (newModuleFactory) {
-					result = getAffectedModuleEffects(moduleId);
-				} else {
-					result = {
-						type: "disposed",
-						moduleId: moduleId
-					};
-				}
+				var result = newModuleFactory
+					? getAffectedModuleEffects(moduleId)
+					: {
+							type: "disposed",
+							moduleId: moduleId
+						};
 				/** @type {Error|false} */
 				var abortError = false;
 				var doApply = false;
@@ -376,17 +374,17 @@ module.exports = function () {
 									moduleId: moduleId,
 									module: $moduleCache$[moduleId]
 								});
-							} catch (err2) {
+							} catch (err1) {
 								if (options.onErrored) {
 									options.onErrored({
 										type: "self-accept-error-handler-errored",
 										moduleId: moduleId,
-										error: err2,
+										error: err1,
 										originalError: err
 									});
 								}
 								if (!options.ignoreErrored) {
-									reportError(err2);
+									reportError(err1);
 									reportError(err);
 								}
 							}

node_modules/webpack/lib/hmr/LazyCompilationPlugin.js

@@ -10,6 +10,7 @@ const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const Dependency = require("../Dependency");
 const Module = require("../Module");
 const ModuleFactory = require("../ModuleFactory");
+const { JS_TYPES } = require("../ModuleSourceTypesConstants");
 const {
 	WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY
 } = require("../ModuleTypeConstants");
@@ -37,10 +38,12 @@ const { registerNotSerializable } = require("../util/serialization");
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
+/** @typedef {{ client: string, data: string, active: boolean }} ModuleResult */
+
 /**
  * @typedef {object} BackendApi
- * @property {function(Error=): void} dispose
- * @property {function(Module): { client: string, data: string, active: boolean }} module
+ * @property {function(function((Error | null)=) : void): void} dispose
+ * @property {function(Module): ModuleResult} module
  */
 
 const HMR_DEPENDENCY_TYPES = new Set([
@@ -53,7 +56,7 @@ const HMR_DEPENDENCY_TYPES = new Set([
 /**
  * @param {undefined|string|RegExp|Function} test test option
  * @param {Module} module the module
- * @returns {boolean} true, if the module should be selected
+ * @returns {boolean | null | string} true, if the module should be selected
  */
 const checkTest = (test, module) => {
 	if (test === undefined) return true;
@@ -71,9 +74,10 @@ const checkTest = (test, module) => {
 	return false;
 };
 
-const TYPES = new Set(["javascript"]);
-
 class LazyCompilationDependency extends Dependency {
+	/**
+	 * @param {LazyCompilationProxyModule} proxyModule proxy module
+	 */
 	constructor(proxyModule) {
 		super();
 		this.proxyModule = proxyModule;
@@ -98,6 +102,14 @@ class LazyCompilationDependency extends Dependency {
 registerNotSerializable(LazyCompilationDependency);
 
 class LazyCompilationProxyModule extends Module {
+	/**
+	 * @param {string} context context
+	 * @param {Module} originalModule an original module
+	 * @param {string} request request
+	 * @param {ModuleResult["client"]} client client
+	 * @param {ModuleResult["data"]} data data
+	 * @param {ModuleResult["active"]} active true when active, otherwise false
+	 */
 	constructor(context, originalModule, request, client, data, active) {
 		super(
 			WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY,
@@ -194,7 +206,7 @@ class LazyCompilationProxyModule extends Module {
 	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
-		return TYPES;
+		return JS_TYPES;
 	}
 
 	/**
@@ -229,13 +241,13 @@ class LazyCompilationProxyModule extends Module {
 		]);
 		const keepActive = Template.asString([
 			`var dispose = client.keepAlive({ data: data, active: ${JSON.stringify(
-				!!block
+				Boolean(block)
 			)}, module: module, onError: onError });`
 		]);
 		let source;
 		if (block) {
 			const dep = block.dependencies[0];
-			const module = moduleGraph.getModule(dep);
+			const module = /** @type {Module} */ (moduleGraph.getModule(dep));
 			source = Template.asString([
 				client,
 				`module.exports = ${runtimeTemplate.moduleNamespacePromise({
@@ -264,7 +276,7 @@ class LazyCompilationProxyModule extends Module {
 			source = Template.asString([
 				client,
 				"var resolveSelf, onError;",
-				`module.exports = new Promise(function(resolve, reject) { resolveSelf = resolve; onError = reject; });`,
+				"module.exports = new Promise(function(resolve, reject) { resolveSelf = resolve; onError = reject; });",
 				"if (module.hot) {",
 				Template.indent([
 					"module.hot.accept();",
@@ -297,9 +309,8 @@ class LazyCompilationProxyModule extends Module {
 registerNotSerializable(LazyCompilationProxyModule);
 
 class LazyCompilationDependencyFactory extends ModuleFactory {
-	constructor(factory) {
+	constructor() {
 		super();
-		this._factory = factory;
 	}
 
 	/**
@@ -317,13 +328,26 @@ class LazyCompilationDependencyFactory extends ModuleFactory {
 	}
 }
 
+/**
+ * @callback BackendHandler
+ * @param {Compiler} compiler compiler
+ * @param {function(Error | null, BackendApi=): void} callback callback
+ * @returns {void}
+ */
+
+/**
+ * @callback PromiseBackendHandler
+ * @param {Compiler} compiler compiler
+ * @returns {Promise<BackendApi>} backend
+ */
+
 class LazyCompilationPlugin {
 	/**
 	 * @param {object} options options
-	 * @param {(function(Compiler, function(Error?, BackendApi?): void): void) | function(Compiler): Promise<BackendApi>} options.backend the backend
+	 * @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)} options.test additional filter for lazy compiled entrypoint modules
+	 * @param {RegExp | string | (function(Module): boolean) | undefined} options.test additional filter for lazy compiled entrypoint modules
 	 */
 	constructor({ backend, entries, imports, test }) {
 		this.backend = backend;
@@ -331,12 +355,14 @@ class LazyCompilationPlugin {
 		this.imports = imports;
 		this.test = test;
 	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
+		/** @type {BackendApi} */
 		let backend;
 		compiler.hooks.beforeCompile.tapAsync(
 			"LazyCompilationPlugin",
@@ -344,7 +370,7 @@ class LazyCompilationPlugin {
 				if (backend !== undefined) return callback();
 				const promise = this.backend(compiler, (err, result) => {
 					if (err) return callback(err);
-					backend = result;
+					backend = /** @type {BackendApi} */ (result);
 					callback();
 				});
 				if (promise && promise.then) {
@@ -370,7 +396,8 @@ class LazyCompilationPlugin {
 							// an import() or not
 							const hmrDep = resolveData.dependencies[0];
 							const originModule =
-								compilation.moduleGraph.getParentModule(hmrDep);
+								/** @type {Module} */
+								(compilation.moduleGraph.getParentModule(hmrDep));
 							const isReferringToDynamicImport = originModule.blocks.some(
 								block =>
 									block.dependencies.some(

node_modules/webpack/lib/hmr/lazyCompilationBackend.js

@@ -5,17 +5,18 @@
 
 "use strict";
 
+/** @typedef {import("http").IncomingMessage} IncomingMessage */
+/** @typedef {import("http").RequestListener} RequestListener */
 /** @typedef {import("http").ServerOptions} HttpServerOptions */
+/** @typedef {import("http").ServerResponse} ServerResponse */
 /** @typedef {import("https").ServerOptions} HttpsServerOptions */
+/** @typedef {import("net").AddressInfo} AddressInfo */
+/** @typedef {import("net").Server} Server */
 /** @typedef {import("../../declarations/WebpackOptions").LazyCompilationDefaultBackendOptions} LazyCompilationDefaultBackendOptions */
 /** @typedef {import("../Compiler")} Compiler */
-
-/**
- * @callback BackendHandler
- * @param {Compiler} compiler compiler
- * @param {function((Error | null)=, any=): void} callback callback
- * @returns {void}
- */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("./LazyCompilationPlugin").BackendApi} BackendApi */
+/** @typedef {import("./LazyCompilationPlugin").BackendHandler} BackendHandler */
 
 /**
  * @param {Omit<LazyCompilationDefaultBackendOptions, "client"> & { client: NonNullable<LazyCompilationDefaultBackendOptions["client"]>}} options additional options for the backend
@@ -36,8 +37,13 @@ module.exports = options => (compiler, callback) => {
 			? options.server
 			: (() => {
 					const http = isHttps ? require("https") : require("http");
-					return http.createServer.bind(http, options.server);
+					return http.createServer.bind(
+						http,
+						/** @type {HttpServerOptions | HttpsServerOptions} */
+						(options.server)
+					);
 				})();
+	/** @type {function(Server): void} */
 	const listen =
 		typeof options.listen === "function"
 			? options.listen
@@ -50,7 +56,9 @@ module.exports = options => (compiler, callback) => {
 
 	const protocol = options.protocol || (isHttps ? "https" : "http");
 
+	/** @type {RequestListener} */
 	const requestListener = (req, res) => {
+		if (req.url === undefined) return;
 		const keys = req.url.slice(prefix.length).split("@");
 		req.socket.on("close", () => {
 			setTimeout(() => {
@@ -85,7 +93,7 @@ module.exports = options => (compiler, callback) => {
 		if (moduleActivated && compiler.watching) compiler.watching.invalidate();
 	};
 
-	const server = /** @type {import("net").Server} */ (createServer());
+	const server = /** @type {Server} */ (createServer());
 	server.on("request", requestListener);
 
 	let isClosing = false;
@@ -101,43 +109,53 @@ module.exports = options => (compiler, callback) => {
 	server.on("clientError", e => {
 		if (e.message !== "Server is disposing") logger.warn(e);
 	});
-	server.on("listening", err => {
-		if (err) return callback(err);
-		const addr = server.address();
-		if (typeof addr === "string") throw new Error("addr must not be a string");
-		const urlBase =
-			addr.address === "::" || addr.address === "0.0.0.0"
-				? `${protocol}://localhost:${addr.port}`
-				: addr.family === "IPv6"
-					? `${protocol}://[${addr.address}]:${addr.port}`
-					: `${protocol}://${addr.address}:${addr.port}`;
-		logger.log(
-			`Server-Sent-Events server for lazy compilation open at ${urlBase}.`
-		);
-		callback(null, {
-			dispose(callback) {
-				isClosing = true;
-				// Removing the listener is a workaround for a memory leak in node.js
-				server.off("request", requestListener);
-				server.close(err => {
-					callback(err);
-				});
-				for (const socket of sockets) {
-					socket.destroy(new Error("Server is disposing"));
+
+	server.on(
+		"listening",
+		/**
+		 * @param {Error} err error
+		 * @returns {void}
+		 */
+		err => {
+			if (err) return callback(err);
+			const _addr = server.address();
+			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"
+					? `${protocol}://localhost:${addr.port}`
+					: addr.family === "IPv6"
+						? `${protocol}://[${addr.address}]:${addr.port}`
+						: `${protocol}://${addr.address}:${addr.port}`;
+			logger.log(
+				`Server-Sent-Events server for lazy compilation open at ${urlBase}.`
+			);
+			callback(null, {
+				dispose(callback) {
+					isClosing = true;
+					// Removing the listener is a workaround for a memory leak in node.js
+					server.off("request", requestListener);
+					server.close(err => {
+						callback(err);
+					});
+					for (const socket of sockets) {
+						socket.destroy(new Error("Server is disposing"));
+					}
+				},
+				module(originalModule) {
+					const key = `${encodeURIComponent(
+						originalModule.identifier().replace(/\\/g, "/").replace(/@/g, "_")
+					).replace(/%(2F|3A|24|26|2B|2C|3B|3D)/g, decodeURIComponent)}`;
+					const active = activeModules.get(key) > 0;
+					return {
+						client: `${options.client}?${encodeURIComponent(urlBase + prefix)}`,
+						data: key,
+						active
+					};
 				}
-			},
-			module(originalModule) {
-				const key = `${encodeURIComponent(
-					originalModule.identifier().replace(/\\/g, "/").replace(/@/g, "_")
-				).replace(/%(2F|3A|24|26|2B|2C|3B|3D|3A)/g, decodeURIComponent)}`;
-				const active = activeModules.get(key) > 0;
-				return {
-					client: `${options.client}?${encodeURIComponent(urlBase + prefix)}`,
-					data: key,
-					active
-				};
-			}
-		});
-	});
+			});
+		}
+	);
 	listen(server);
 };