feat: refactoring project

node_modules/webpack/lib/NormalModuleFactory.js

@@ -52,8 +52,8 @@ const {
 /** @typedef {import("./dependencies/ModuleDependency")} ModuleDependency */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
-/** @typedef {Pick<RuleSetRule, 'type'|'sideEffects'|'parser'|'generator'|'resolve'|'layer'>} ModuleSettings */
-/** @typedef {Partial<NormalModuleCreateData & {settings: ModuleSettings}>} CreateData */
+/** @typedef {Pick<RuleSetRule, 'type' | 'sideEffects' | 'parser' | 'generator' | 'resolve' | 'layer'>} ModuleSettings */
+/** @typedef {Partial<NormalModuleCreateData & { settings: ModuleSettings }>} CreateData */
 
 /**
  * @typedef {object} ResolveData
@@ -68,6 +68,7 @@ const {
  * @property {LazySet<string>} fileDependencies
  * @property {LazySet<string>} missingDependencies
  * @property {LazySet<string>} contextDependencies
+ * @property {Module=} ignoredModule
  * @property {boolean} cacheable allow to use the unsafe cache
  */
 
@@ -116,15 +117,15 @@ const loaderToIdent = data => {
 		return data.loader;
 	}
 	if (typeof data.options === "string") {
-		return data.loader + "?" + data.options;
+		return `${data.loader}?${data.options}`;
 	}
 	if (typeof data.options !== "object") {
 		throw new Error("loader options must be string or object");
 	}
 	if (data.ident) {
-		return data.loader + "??" + data.ident;
+		return `${data.loader}??${data.ident}`;
 	}
-	return data.loader + "?" + JSON.stringify(data.options);
+	return `${data.loader}?${JSON.stringify(data.options)}`;
 };
 
 /**
@@ -135,7 +136,7 @@ const loaderToIdent = data => {
 const stringifyLoadersAndResource = (loaders, resource) => {
 	let str = "";
 	for (const loader of loaders) {
-		str += loaderToIdent(loader) + "!";
+		str += `${loaderToIdent(loader)}!`;
 	}
 	return str + resource;
 };
@@ -145,16 +146,14 @@ const stringifyLoadersAndResource = (loaders, resource) => {
  * @param {(err?: null | Error) => void} callback callback
  * @returns {(err?: null | Error) => void} callback
  */
-const needCalls = (times, callback) => {
-	return err => {
-		if (--times === 0) {
-			return callback(err);
-		}
-		if (err && times > 0) {
-			times = NaN;
-			return callback(err);
-		}
-	};
+const needCalls = (times, callback) => err => {
+	if (--times === 0) {
+		return callback(err);
+	}
+	if (err && times > 0) {
+		times = Number.NaN;
+		return callback(err);
+	}
 };
 
 /**
@@ -171,20 +170,18 @@ const mergeGlobalOptions = (globalOptions, type, localOptions) => {
 	let current = "";
 	for (const part of parts) {
 		current = current ? `${current}/${part}` : part;
-		const options = globalOptions[current];
+		const options =
+			/** @type {T} */
+			(globalOptions[/** @type {keyof T} */ (current)]);
 		if (typeof options === "object") {
-			if (result === undefined) {
-				result = options;
-			} else {
-				result = cachedCleverMerge(result, options);
-			}
+			result =
+				result === undefined ? options : cachedCleverMerge(result, options);
 		}
 	}
 	if (result === undefined) {
 		return localOptions;
-	} else {
-		return cachedCleverMerge(result, localOptions);
 	}
+	return cachedCleverMerge(result, localOptions);
 };
 
 // TODO webpack 6 remove
@@ -200,9 +197,7 @@ const deprecationChangedHookMessage = (name, hook) => {
 			 * @param {TODO} tapped tapped
 			 * @returns {string} name
 			 */
-			tapped => {
-				return tapped.name;
-			}
+			tapped => tapped.name
 		)
 		.join(", ");
 
@@ -227,16 +222,19 @@ const ruleSetCompiler = new RuleSetCompiler([
 	new BasicMatcherRulePlugin("issuer"),
 	new BasicMatcherRulePlugin("compiler"),
 	new BasicMatcherRulePlugin("issuerLayer"),
-	new ObjectMatcherRulePlugin(
-		"assert",
-		"assertions",
-		value => value && /** @type {any} */ (value)._isLegacyAssert !== undefined
-	),
-	new ObjectMatcherRulePlugin(
-		"with",
-		"assertions",
-		value => value && !(/** @type {any} */ (value)._isLegacyAssert)
-	),
+	new ObjectMatcherRulePlugin("assert", "assertions", value => {
+		if (value) {
+			return /** @type {any} */ (value)._isLegacyAssert !== undefined;
+		}
+
+		return false;
+	}),
+	new ObjectMatcherRulePlugin("with", "assertions", value => {
+		if (value) {
+			return !(/** @type {any} */ (value)._isLegacyAssert);
+		}
+		return false;
+	}),
 	new ObjectMatcherRulePlugin("descriptionData"),
 	new BasicEffectRulePlugin("type"),
 	new BasicEffectRulePlugin("sideEffects"),
@@ -254,7 +252,7 @@ class NormalModuleFactory extends ModuleFactory {
 	 * @param {InputFileSystem} param.fs file system
 	 * @param {ResolverFactory} param.resolverFactory resolverFactory
 	 * @param {ModuleOptions} param.options options
-	 * @param {object=} param.associatedObjectForCache an object to which the cache will be attached
+	 * @param {object} param.associatedObjectForCache an object to which the cache will be attached
 	 * @param {boolean=} param.layers enable layers
 	 */
 	constructor({
@@ -285,13 +283,13 @@ class NormalModuleFactory extends ModuleFactory {
 			afterResolve: new AsyncSeriesBailHook(["resolveData"]),
 			/** @type {AsyncSeriesBailHook<[ResolveData["createData"], ResolveData], Module | void>} */
 			createModule: new AsyncSeriesBailHook(["createData", "resolveData"]),
-			/** @type {SyncWaterfallHook<[Module, ResolveData["createData"], ResolveData], Module>} */
+			/** @type {SyncWaterfallHook<[Module, ResolveData["createData"], ResolveData]>} */
 			module: new SyncWaterfallHook(["module", "createData", "resolveData"]),
-			/** @type {HookMap<SyncBailHook<[ParserOptions], Parser>>} */
+			/** @type {HookMap<SyncBailHook<[ParserOptions], Parser | void>>} */
 			createParser: new HookMap(() => new SyncBailHook(["parserOptions"])),
 			/** @type {HookMap<SyncBailHook<[TODO, ParserOptions], void>>} */
 			parser: new HookMap(() => new SyncHook(["parser", "parserOptions"])),
-			/** @type {HookMap<SyncBailHook<[GeneratorOptions], Generator>>} */
+			/** @type {HookMap<SyncBailHook<[GeneratorOptions], Generator | void>>} */
 			createGenerator: new HookMap(
 				() => new SyncBailHook(["generatorOptions"])
 			),
@@ -299,7 +297,7 @@ class NormalModuleFactory extends ModuleFactory {
 			generator: new HookMap(
 				() => new SyncHook(["generator", "generatorOptions"])
 			),
-			/** @type {HookMap<SyncBailHook<[TODO, ResolveData], Module>>} */
+			/** @type {HookMap<SyncBailHook<[TODO, ResolveData], Module | void>>} */
 			createModuleClass: new HookMap(
 				() => new SyncBailHook(["createData", "resolveData"])
 			)
@@ -348,8 +346,10 @@ class NormalModuleFactory extends ModuleFactory {
 
 					if (typeof result === "object")
 						throw new Error(
-							deprecationChangedHookMessage("resolve", this.hooks.resolve) +
-								" Returning a Module object will result in this module used as result."
+							`${deprecationChangedHookMessage(
+								"resolve",
+								this.hooks.resolve
+							)} Returning a Module object will result in this module used as result.`
 						);
 
 					this.hooks.afterResolve.callAsync(resolveData, (err, result) => {
@@ -380,14 +380,16 @@ class NormalModuleFactory extends ModuleFactory {
 									// TODO webpack 6 make it required and move javascript/wasm/asset properties to own module
 									createdModule = this.hooks.createModuleClass
 										.for(
-											/** @type {ModuleSettings} */ (createData.settings).type
+											/** @type {ModuleSettings} */
+											(createData.settings).type
 										)
 										.call(createData, resolveData);
 
 									if (!createdModule) {
 										createdModule = /** @type {Module} */ (
 											new NormalModule(
-												/** @type {NormalModuleCreateData} */ (createData)
+												/** @type {NormalModuleCreateData} */
+												(createData)
 											)
 										);
 									}
@@ -427,7 +429,7 @@ class NormalModuleFactory extends ModuleFactory {
 				const loaderResolver = this.getResolver("loader");
 
 				/** @type {ResourceData | undefined} */
-				let matchResourceData = undefined;
+				let matchResourceData;
 				/** @type {string} */
 				let unresolvedResource;
 				/** @type {ParsedLoaderRequest[]} */
@@ -538,8 +540,8 @@ class NormalModuleFactory extends ModuleFactory {
 								item.ident = ident;
 							}
 						}
-					} catch (e) {
-						return callback(/** @type {Error} */ (e));
+					} catch (identErr) {
+						return callback(/** @type {Error} */ (identErr));
 					}
 
 					if (!resourceData) {
@@ -617,10 +619,15 @@ class NormalModuleFactory extends ModuleFactory {
 							} else if (
 								typeof r.value === "object" &&
 								r.value !== null &&
-								typeof settings[r.type] === "object" &&
-								settings[r.type] !== null
+								typeof settings[
+									/** @type {keyof ModuleSettings} */ (r.type)
+								] === "object" &&
+								settings[/** @type {keyof ModuleSettings} */ (r.type)] !== null
 							) {
-								settings[r.type] = cachedCleverMerge(settings[r.type], r.value);
+								settings[r.type] = cachedCleverMerge(
+									settings[/** @type {keyof ModuleSettings} */ (r.type)],
+									r.value
+								);
 							} else {
 								settings[r.type] = r.value;
 							}
@@ -652,7 +659,7 @@ class NormalModuleFactory extends ModuleFactory {
 						}
 						for (const loader of /** @type {LoaderItem[]} */ (preLoaders))
 							allLoaders.push(loader);
-						let type = /** @type {string} */ (settings.type);
+						const type = /** @type {string} */ (settings.type);
 						const resolveOptions = settings.resolve;
 						const layer = settings.layer;
 						if (layer !== undefined && !layers) {
@@ -688,8 +695,8 @@ class NormalModuleFactory extends ModuleFactory {
 								generatorOptions: settings.generator,
 								resolveOptions
 							});
-						} catch (e) {
-							return callback(/** @type {Error} */ (e));
+						} catch (createDataErr) {
+							return callback(/** @type {Error} */ (createDataErr));
 						}
 						callback();
 					});
@@ -772,12 +779,17 @@ class NormalModuleFactory extends ModuleFactory {
 							unresolvedResource,
 							normalResolver,
 							resolveContext,
-							(err, resolvedResource, resolvedResourceResolveData) => {
+							(err, _resolvedResource, resolvedResourceResolveData) => {
 								if (err) return continueCallback(err);
-								if (resolvedResource !== false) {
+								if (_resolvedResource !== false) {
+									const resolvedResource =
+										/** @type {string} */
+										(_resolvedResource);
 									resourceData = {
 										resource: resolvedResource,
-										data: resolvedResourceResolveData,
+										data:
+											/** @type {ResolveRequest} */
+											(resolvedResourceResolveData),
 										...cacheParseResource(resolvedResource)
 									};
 								}
@@ -883,12 +895,19 @@ class NormalModuleFactory extends ModuleFactory {
 
 			// Ignored
 			if (result === false) {
-				return callback(null, {
+				/** @type {ModuleFactoryResult} * */
+				const factoryResult = {
 					fileDependencies,
 					missingDependencies,
 					contextDependencies,
 					cacheable: resolveData.cacheable
-				});
+				};
+
+				if (resolveData.ignoredModule) {
+					factoryResult.module = resolveData.ignoredModule;
+				}
+
+				return callback(null, factoryResult);
 			}
 
 			if (typeof result === "object")
@@ -909,6 +928,7 @@ class NormalModuleFactory extends ModuleFactory {
 					});
 				}
 
+				/** @type {ModuleFactoryResult} * */
 				const factoryResult = {
 					module,
 					fileDependencies,
@@ -1066,13 +1086,12 @@ Add the extension to the request.`
 											/(\.[^.]+)(\?|$)/,
 											"$2"
 										);
-										if (resolver.options.extensions.has(match[1])) {
-											hint = `Did you mean '${fixedRequest}'?`;
-										} else {
-											hint = `Did you mean '${fixedRequest}'? Also note that '${match[1]}' is not in 'resolve.extensions' yet and need to be added for this to work?`;
-										}
+										hint = resolver.options.extensions.has(match[1])
+											? `Did you mean '${fixedRequest}'?`
+											: `Did you mean '${fixedRequest}'? Also note that '${match[1]}' is not in 'resolve.extensions' yet and need to be added for this to work?`;
 									} else {
-										hint = `Did you mean to omit the extension or to remove 'resolve.enforceExtension'?`;
+										hint =
+											"Did you mean to omit the extension or to remove 'resolve.enforceExtension'?";
 									}
 									return callback(
 										null,
@@ -1151,18 +1170,17 @@ If changing the source code is not an option there is also a resolve options cal
 						if (
 							err &&
 							/^[^/]*$/.test(item.loader) &&
-							!/-loader$/.test(item.loader)
+							!item.loader.endsWith("-loader")
 						) {
 							return resolver.resolve(
 								contextInfo,
 								context,
-								item.loader + "-loader",
+								`${item.loader}-loader`,
 								resolveContext,
 								err2 => {
 									if (!err2) {
 										err.message =
-											err.message +
-											"\n" +
+											`${err.message}\n` +
 											"BREAKING CHANGE: It's no longer allowed to omit the '-loader' suffix when using loaders.\n" +
 											`                 You need to specify '${item.loader}-loader' instead of '${item.loader}',\n` +
 											"                 see https://webpack.js.org/migrate/3/#automatic-loader-module-name-extension-removed";
@@ -1173,7 +1191,9 @@ If changing the source code is not an option there is also a resolve options cal
 						}
 						if (err) return callback(err);
 
-						const parsedResult = this._parseResourceWithoutFragment(result);
+						const parsedResult = this._parseResourceWithoutFragment(
+							/** @type {string} */ (result)
+						);
 
 						const type = /\.mjs$/i.test(parsedResult.path)
 							? "module"