feat: refactoring project

node_modules/webpack/lib/dependencies/LoaderPlugin.js

@@ -10,17 +10,12 @@ const LazySet = require("../util/LazySet");
 const LoaderDependency = require("./LoaderDependency");
 const LoaderImportDependency = require("./LoaderImportDependency");
 
+/** @typedef {import("../../declarations/LoaderContext").LoaderPluginLoaderContext} LoaderPluginLoaderContext */
 /** @typedef {import("../Compilation").DepConstructor} DepConstructor */
+/** @typedef {import("../Compilation").ExecuteModuleResult} ExecuteModuleResult */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
-
-/**
- * @callback LoadModuleCallback
- * @param {(Error | null)=} err error object
- * @param {string | Buffer=} source source code
- * @param {object=} map source map
- * @param {Module=} module loaded module if successful
- */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
 
 /**
  * @callback ImportModuleCallback
@@ -66,11 +61,6 @@ class LoaderPlugin {
 			NormalModule.getCompilationHooks(compilation).loader.tap(
 				"LoaderPlugin",
 				loaderContext => {
-					/**
-					 * @param {string} request the request string to load the module from
-					 * @param {LoadModuleCallback} callback callback returning the loaded module or error
-					 * @returns {void}
-					 */
 					loaderContext.loadModule = (request, callback) => {
 						const dep = new LoaderDependency(request);
 						dep.loc = {
@@ -86,16 +76,26 @@ class LoaderPlugin {
 								)
 							);
 						}
+						const oldFactorizeQueueContext =
+							compilation.factorizeQueue.getContext();
+						compilation.factorizeQueue.setContext("load-module");
+						const oldAddModuleQueueContext =
+							compilation.addModuleQueue.getContext();
+						compilation.addModuleQueue.setContext("load-module");
 						compilation.buildQueue.increaseParallelism();
 						compilation.handleModuleCreation(
 							{
 								factory,
 								dependencies: [dep],
-								originModule: loaderContext._module,
+								originModule:
+									/** @type {NormalModule} */
+									(loaderContext._module),
 								context: loaderContext.context,
 								recursive: false
 							},
 							err => {
+								compilation.factorizeQueue.setContext(oldFactorizeQueueContext);
+								compilation.addModuleQueue.setContext(oldAddModuleQueueContext);
 								compilation.buildQueue.decreaseParallelism();
 								if (err) {
 									return callback(err);
@@ -117,7 +117,8 @@ class LoaderPlugin {
 										)
 									);
 								}
-								let source, map;
+								let map;
+								let source;
 								if (moduleSource.sourceAndMap) {
 									const sourceAndMap = moduleSource.sourceAndMap();
 									map = sourceAndMap.map;
@@ -149,15 +150,20 @@ class LoaderPlugin {
 								for (const d of buildDependencies) {
 									loaderContext.addBuildDependency(d);
 								}
-								return callback(null, source, map, referencedModule);
+								return callback(
+									null,
+									source,
+									/** @type {object | null} */ (map),
+									referencedModule
+								);
 							}
 						);
 					};
 
 					/**
 					 * @param {string} request the request string to load the module from
-					 * @param {ImportModuleOptions=} options options
-					 * @param {ImportModuleCallback=} callback callback returning the exports
+					 * @param {ImportModuleOptions} options options
+					 * @param {ImportModuleCallback} callback callback returning the exports
 					 * @returns {void}
 					 */
 					const importModule = (request, options, callback) => {
@@ -175,12 +181,21 @@ class LoaderPlugin {
 								)
 							);
 						}
+
+						const oldFactorizeQueueContext =
+							compilation.factorizeQueue.getContext();
+						compilation.factorizeQueue.setContext("import-module");
+						const oldAddModuleQueueContext =
+							compilation.addModuleQueue.getContext();
+						compilation.addModuleQueue.setContext("import-module");
 						compilation.buildQueue.increaseParallelism();
 						compilation.handleModuleCreation(
 							{
 								factory,
 								dependencies: [dep],
-								originModule: loaderContext._module,
+								originModule:
+									/** @type {NormalModule} */
+									(loaderContext._module),
 								contextInfo: {
 									issuerLayer: options.layer
 								},
@@ -189,6 +204,8 @@ class LoaderPlugin {
 								checkCycle: true
 							},
 							err => {
+								compilation.factorizeQueue.setContext(oldFactorizeQueueContext);
+								compilation.addModuleQueue.setContext(oldAddModuleQueueContext);
 								compilation.buildQueue.decreaseParallelism();
 								if (err) {
 									return callback(err);
@@ -197,6 +214,7 @@ class LoaderPlugin {
 								if (!referencedModule) {
 									return callback(new Error("Cannot load the module"));
 								}
+								compilation.buildQueue.increaseParallelism();
 								compilation.executeModule(
 									referencedModule,
 									{
@@ -206,43 +224,55 @@ class LoaderPlugin {
 										}
 									},
 									(err, result) => {
+										compilation.buildQueue.decreaseParallelism();
 										if (err) return callback(err);
-										for (const d of result.fileDependencies) {
+										const {
+											fileDependencies,
+											contextDependencies,
+											missingDependencies,
+											buildDependencies,
+											cacheable,
+											assets,
+											exports
+										} = /** @type {ExecuteModuleResult} */ (result);
+										for (const d of fileDependencies) {
 											loaderContext.addDependency(d);
 										}
-										for (const d of result.contextDependencies) {
+										for (const d of contextDependencies) {
 											loaderContext.addContextDependency(d);
 										}
-										for (const d of result.missingDependencies) {
+										for (const d of missingDependencies) {
 											loaderContext.addMissingDependency(d);
 										}
-										for (const d of result.buildDependencies) {
+										for (const d of buildDependencies) {
 											loaderContext.addBuildDependency(d);
 										}
-										if (result.cacheable === false)
-											loaderContext.cacheable(false);
-										for (const [name, { source, info }] of result.assets) {
-											const { buildInfo } = loaderContext._module;
+										if (cacheable === false) loaderContext.cacheable(false);
+										for (const [name, { source, info }] of assets) {
+											const buildInfo =
+												/** @type {BuildInfo} */
+												(
+													/** @type {NormalModule} */ (loaderContext._module)
+														.buildInfo
+												);
 											if (!buildInfo.assets) {
 												buildInfo.assets = Object.create(null);
 												buildInfo.assetsInfo = new Map();
 											}
-											buildInfo.assets[name] = source;
-											buildInfo.assetsInfo.set(name, info);
+											/** @type {NonNullable<BuildInfo["assets"]>} */
+											(buildInfo.assets)[name] = source;
+											/** @type {NonNullable<BuildInfo["assetsInfo"]>} */
+											(buildInfo.assetsInfo).set(name, info);
 										}
-										callback(null, result.exports);
+										callback(null, exports);
 									}
 								);
 							}
 						);
 					};
 
-					/**
-					 * @param {string} request the request string to load the module from
-					 * @param {ImportModuleOptions} options options
-					 * @param {ImportModuleCallback=} callback callback returning the exports
-					 * @returns {Promise<any> | void} exports
-					 */
+					// eslint-disable-next-line no-warning-comments
+					// @ts-ignore Overloading doesn't work
 					loaderContext.importModule = (request, options, callback) => {
 						if (!callback) {
 							return new Promise((resolve, reject) => {