feat: refactoring project

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(