webpack 5.94.0 → 5.96.0

package/lib/dependencies/ImportParserPlugin.js

@@ -8,20 +8,20 @@
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const CommentCompilationWarning = require("../CommentCompilationWarning");
 const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
+const { getImportAttributes } = require("../javascript/JavascriptParser");
 const ContextDependencyHelpers = require("./ContextDependencyHelpers");
-const { getAttributes } = require("./HarmonyImportDependencyParserPlugin");
 const ImportContextDependency = require("./ImportContextDependency");
 const ImportDependency = require("./ImportDependency");
 const ImportEagerDependency = require("./ImportEagerDependency");
 const ImportWeakDependency = require("./ImportWeakDependency");
 
-/** @typedef {import("estree").ImportExpression} ImportExpression */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
 /** @typedef {import("../ContextModule").ContextMode} ContextMode */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").ImportExpression} ImportExpression */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
 class ImportParserPlugin {
@@ -85,7 +85,7 @@ class ImportParserPlugin {
 					parser.state.module.addWarning(
 						new CommentCompilationWarning(
 							`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
-							comment.loc
+							/** @type {DependencyLocation} */ (comment.loc)
 						)
 					);
 				}
@@ -126,7 +126,7 @@ class ImportParserPlugin {
 							)
 						);
 					} else {
-						mode = importOptions.webpackMode;
+						mode = /** @type {ContextMode} */ (importOptions.webpackMode);
 					}
 				}
 				if (importOptions.webpackPrefetch !== undefined) {
@@ -162,7 +162,9 @@ class ImportParserPlugin {
 						typeof importOptions.webpackFetchPriority === "string" &&
 						["high", "low", "auto"].includes(importOptions.webpackFetchPriority)
 					) {
-						groupOptions.fetchPriority = importOptions.webpackFetchPriority;
+						groupOptions.fetchPriority =
+							/** @type {"low" | "high" | "auto"} */
+							(importOptions.webpackFetchPriority);
 					} else {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
@@ -258,7 +260,7 @@ class ImportParserPlugin {
 			}
 
 			if (param.isString()) {
-				const attributes = getAttributes(expr);
+				const attributes = getImportAttributes(expr);
 
 				if (mode === "eager") {
 					const dep = new ImportEagerDependency(
@@ -321,7 +323,7 @@ class ImportParserPlugin {
 					typePrefix: "import()",
 					category: "esm",
 					referencedExports: exports,
-					attributes: getAttributes(expr)
+					attributes: getImportAttributes(expr)
 				},
 				parser
 			);

package/lib/dependencies/LoaderPlugin.js

@@ -76,6 +76,12 @@ 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(
 							{
@@ -88,6 +94,8 @@ class LoaderPlugin {
 								recursive: false
 							},
 							err => {
+								compilation.factorizeQueue.setContext(oldFactorizeQueueContext);
+								compilation.addModuleQueue.setContext(oldAddModuleQueueContext);
 								compilation.buildQueue.decreaseParallelism();
 								if (err) {
 									return callback(err);
@@ -173,6 +181,13 @@ 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(
 							{
@@ -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,6 +224,7 @@ class LoaderPlugin {
 										}
 									},
 									(err, result) => {
+										compilation.buildQueue.decreaseParallelism();
 										if (err) return callback(err);
 										const {
 											fileDependencies,

package/lib/dependencies/SystemPlugin.js

@@ -125,7 +125,8 @@ class SystemPlugin {
 								/** @type {import("estree").Literal} */
 								(expr.arguments[0]),
 							loc: expr.loc,
-							range: expr.range
+							range: expr.range,
+							options: null
 						});
 					});
 				};

package/lib/dependencies/URLPlugin.js

@@ -19,6 +19,7 @@ const InnerGraph = require("../optimize/InnerGraph");
 const ConstDependency = require("./ConstDependency");
 const URLDependency = require("./URLDependency");
 
+/** @typedef {import("estree").MemberExpression} MemberExpression */
 /** @typedef {import("estree").NewExpression} NewExpressionNode */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Compiler")} Compiler */
@@ -50,6 +51,11 @@ class URLPlugin {
 				 */
 				const getUrl = module => pathToFileURL(module.resource);
 
+				/**
+				 * @param {Parser} parser parser parser
+				 * @param {MemberExpression} arg arg
+				 * @returns {boolean} true when it is `meta.url`, otherwise false
+				 */
 				const isMetaUrl = (parser, arg) => {
 					const chain = parser.extractMemberExpressionChain(arg);
 
@@ -117,7 +123,7 @@ class URLPlugin {
 								parser.state.module.addWarning(
 									new CommentCompilationWarning(
 										`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
-										comment.loc
+										/** @type {DependencyLocation} */ (comment.loc)
 									)
 								);
 							}

package/lib/dependencies/WorkerPlugin.js

@@ -251,7 +251,7 @@ class WorkerPlugin {
 								parser.state.module.addWarning(
 									new CommentCompilationWarning(
 										`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
-										comment.loc
+										/** @type {DependencyLocation} */ (comment.loc)
 									)
 								);
 							}

package/lib/esm/ModuleChunkLoadingRuntimeModule.js

@@ -113,10 +113,12 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 			ModuleChunkLoadingRuntimeModule.getCompilationHooks(compilation);
 		const withPrefetch =
 			environment.document &&
-			this._runtimeRequirements.has(RuntimeGlobals.prefetchChunkHandlers);
+			this._runtimeRequirements.has(RuntimeGlobals.prefetchChunkHandlers) &&
+			chunk.hasChildByOrder(chunkGraph, "prefetch", true, chunkHasJs);
 		const withPreload =
 			environment.document &&
-			this._runtimeRequirements.has(RuntimeGlobals.preloadChunkHandlers);
+			this._runtimeRequirements.has(RuntimeGlobals.preloadChunkHandlers) &&
+			chunk.hasChildByOrder(chunkGraph, "preload", true, chunkHasJs);
 		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
 		const hasJsMatcher = compileBooleanMatcher(conditionMap);
 		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);

package/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

package/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

package/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");
@@ -73,8 +74,6 @@ const checkTest = (test, module) => {
 	return false;
 };
 
-const TYPES = new Set(["javascript"]);
-
 class LazyCompilationDependency extends Dependency {
 	/**
 	 * @param {LazyCompilationProxyModule} proxyModule proxy module
@@ -207,7 +206,7 @@ class LazyCompilationProxyModule extends Module {
 	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
-		return TYPES;
+		return JS_TYPES;
 	}
 
 	/**
@@ -329,10 +328,23 @@ 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) | undefined} options.test additional filter for lazy compiled entrypoint modules

package/lib/hmr/lazyCompilationBackend.js

@@ -16,13 +16,7 @@
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("./LazyCompilationPlugin").BackendApi} BackendApi */
-
-/**
- * @callback BackendHandler
- * @param {Compiler} compiler compiler
- * @param {function(Error | null, BackendApi=): void} callback callback
- * @returns {void}
- */
+/** @typedef {import("./LazyCompilationPlugin").BackendHandler} BackendHandler */
 
 /**
  * @param {Omit<LazyCompilationDefaultBackendOptions, "client"> & { client: NonNullable<LazyCompilationDefaultBackendOptions["client"]>}} options additional options for the backend

package/lib/index.js

@@ -70,7 +70,13 @@ const memoize = require("./util/memoize");
  */
 const lazyFunction = factory => {
 	const fac = memoize(factory);
-	const f = /** @type {any} */ ((...args) => fac()(...args));
+	const f = /** @type {any} */ (
+		/**
+		 * @param {...any} args args
+		 * @returns {T} result
+		 */
+		(...args) => fac()(...args)
+	);
 	return /** @type {T} */ (f);
 };
 
@@ -113,13 +119,21 @@ module.exports = mergeExports(fn, {
 	get webpack() {
 		return require("./webpack");
 	},
+	/**
+	 * @returns {function(Configuration): void} validate fn
+	 */
 	get validate() {
 		const webpackOptionsSchemaCheck = require("../schemas/WebpackOptions.check.js");
-		const getRealValidate = memoize(() => {
-			const validateSchema = require("./validateSchema");
-			const webpackOptionsSchema = require("../schemas/WebpackOptions.json");
-			return options => validateSchema(webpackOptionsSchema, options);
-		});
+		const getRealValidate = memoize(
+			/**
+			 * @returns {function(Configuration): void} validate fn
+			 */
+			() => {
+				const validateSchema = require("./validateSchema");
+				const webpackOptionsSchema = require("../schemas/WebpackOptions.json");
+				return options => validateSchema(webpackOptionsSchema, options);
+			}
+		);
 		return options => {
 			if (!webpackOptionsSchemaCheck(options)) getRealValidate()(options);
 		};
@@ -475,6 +489,15 @@ module.exports = mergeExports(fn, {
 		},
 		get JsonpTemplatePlugin() {
 			return require("./web/JsonpTemplatePlugin");
+		},
+		get CssLoadingRuntimeModule() {
+			return require("./css/CssLoadingRuntimeModule");
+		}
+	},
+
+	esm: {
+		get ModuleChunkLoadingRuntimeModule() {
+			return require("./esm/ModuleChunkLoadingRuntimeModule");
 		}
 	},
 
@@ -517,6 +540,12 @@ module.exports = mergeExports(fn, {
 		}
 	},
 
+	css: {
+		get CssModulesPlugin() {
+			return require("./css/CssModulesPlugin");
+		}
+	},
+
 	library: {
 		get AbstractLibraryPlugin() {
 			return require("./library/AbstractLibraryPlugin");

package/lib/javascript/EnableChunkLoadingPlugin.js

@@ -51,8 +51,8 @@ class EnableChunkLoadingPlugin {
 			throw new Error(
 				`Chunk loading type "${type}" is not enabled. ` +
 					"EnableChunkLoadingPlugin need to be used to enable this type of chunk loading. " +
-					`This usually happens through the "output.enabledChunkLoadingTypes" option. ` +
-					`If you are using a function as entry which sets "chunkLoading", you need to add all potential chunk loading types to "output.enabledChunkLoadingTypes". ` +
+					'This usually happens through the "output.enabledChunkLoadingTypes" option. ' +
+					'If you are using a function as entry which sets "chunkLoading", you need to add all potential chunk loading types to "output.enabledChunkLoadingTypes". ' +
 					`These types are enabled: ${Array.from(
 						getEnabledTypes(compiler)
 					).join(", ")}`

package/lib/javascript/JavascriptGenerator.js

@@ -9,6 +9,7 @@ const util = require("util");
 const { RawSource, ReplaceSource } = require("webpack-sources");
 const Generator = require("../Generator");
 const InitFragment = require("../InitFragment");
+const { JS_TYPES } = require("../ModuleSourceTypesConstants");
 const HarmonyCompatibilityDependency = require("../dependencies/HarmonyCompatibilityDependency");
 
 /** @typedef {import("webpack-sources").Source} Source */
@@ -20,6 +21,7 @@ const HarmonyCompatibilityDependency = require("../dependencies/HarmonyCompatibi
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
+/** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
@@ -40,15 +42,13 @@ const deprecatedGetInitFragments = util.deprecate(
 	"DEP_WEBPACK_JAVASCRIPT_GENERATOR_GET_INIT_FRAGMENTS"
 );
 
-const TYPES = new Set(["javascript"]);
-
 class JavascriptGenerator extends Generator {
 	/**
 	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
+	 * @returns {SourceTypes} available types (do not mutate)
 	 */
 	getTypes(module) {
-		return TYPES;
+		return JS_TYPES;
 	}
 
 	/**
@@ -93,7 +93,7 @@ class JavascriptGenerator extends Generator {
 	/**
 	 * @param {NormalModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * @returns {Source | null} generated code
 	 */
 	generate(module, generateContext) {
 		const originalSource = module.originalSource();
@@ -190,9 +190,9 @@ class JavascriptGenerator extends Generator {
 	 * @returns {void}
 	 */
 	sourceDependency(module, dependency, initFragments, source, generateContext) {
-		const constructor = /** @type {new (...args: any[]) => Dependency} */ (
-			dependency.constructor
-		);
+		const constructor =
+			/** @type {new (...args: EXPECTED_ANY[]) => Dependency} */
+			(dependency.constructor);
 		const template = generateContext.dependencyTemplates.get(constructor);
 		if (!template) {
 			throw new Error(