webpack 5.110.3 → 5.111.0

package/lib/NormalModule.js

@@ -8,9 +8,9 @@
 const querystring = require("querystring");
 const {
 	AsyncSeriesBailHook,
+	AsyncSeriesWaterfallHook,
 	HookMap,
-	SyncHook,
-	SyncWaterfallHook
+	SyncHook
 } = require("tapable");
 const {
 	CachedSource,
@@ -33,6 +33,7 @@ const {
 const LazySet = require("./util/LazySet");
 const { isSubset } = require("./util/SetHelpers");
 const { getScheme } = require("./util/URLAbsoluteSpecifier");
+const { getBuildDiagnostics } = require("./util/buildDiagnostics");
 const {
 	concatComparators,
 	keepOriginalOrder,
@@ -182,7 +183,9 @@ const recordSideEffectsBailout = (mod, moduleGraph, dep) => {
 		.getOptimizationBailout(mod)
 		.push(
 			() =>
-				`Dependency (${dep.type}) with side effects at ${formatLocation(dep.loc)}`
+				`Dependency (${dep.type}) with side effects at ${formatLocation(
+					dep.loc
+				)}`
 		);
 };
 
@@ -540,10 +543,12 @@ const createCompilationHooks = () => {
 		 */
 		beforeSnapshot: new SyncHook(["module"]),
 		/**
-		 * @type {SyncWaterfallHook<[Result, NormalModule]>}
+		 * Async since 5.111.0, so a tap can await work of its own — minifying an
+		 * asset, say, which before only a loader could do. `tap` keeps working.
+		 * @type {AsyncSeriesWaterfallHook<[Result, NormalModule]>}
 		 * @since 5.99.0
 		 */
-		processResult: new SyncWaterfallHook(["result", "module"]),
+		processResult: new AsyncSeriesWaterfallHook(["result", "module"]),
 		/**
 		 * @type {AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>}
 		 * @since 5.49.0
@@ -1045,7 +1050,9 @@ class NormalModule extends Module {
 								(parseJson(options));
 						} catch (err) {
 							throw new Error(
-								`Cannot parse string options: ${/** @type {Error} */ (err).message}`,
+								`Cannot parse string options: ${
+									/** @type {Error} */ (err).message
+								}`,
 								{ cause: err }
 							);
 						}
@@ -1298,11 +1305,33 @@ class NormalModule extends Module {
 				});
 				return callback(error);
 			}
-			const result = hooks.processResult.call(
+			hooks.processResult.callAsync(
 				/** @type {Result} */
 				(result_),
-				this
+				this,
+				(hookErr, hookResult) => {
+					if (hookErr) {
+						// Named, so a tap's failure is not read as a loader's.
+						return callback(
+							new (getModuleBuildError())(
+								hookErr instanceof Error
+									? hookErr
+									: new (getNonErrorEmittedError())(hookErr),
+								{ from: "processResult hook" }
+							)
+						);
+					}
+
+					finishResult(/** @type {Result} */ (hookResult));
+				}
 			);
+		};
+
+		/**
+		 * @param {Result} result the result the hook settled on
+		 * @returns {void}
+		 */
+		const finishResult = (result) => {
 			const source = result[0];
 			const sourceMap = result.length >= 1 ? result[1] : null;
 			const extraInfo = result.length >= 2 ? result[2] : null;
@@ -1434,7 +1463,9 @@ class NormalModule extends Module {
 												})
 										).catch((err) => {
 											throw new Error(
-												`Failed to parse source map. ${/** @type {Error} */ (err).message}`
+												`Failed to parse source map. ${
+													/** @type {Error} */ (err).message
+												}`
 											);
 										})
 								);
@@ -1494,7 +1525,8 @@ class NormalModule extends Module {
 				}
 				buildInfo.cacheable = buildInfo.cacheable && result.cacheable;
 				if (result.notCacheableReasons.length > 0) {
-					buildInfo.notCacheableReasons = result.notCacheableReasons;
+					getBuildDiagnostics(buildInfo).notCacheableReasons =
+						result.notCacheableReasons;
 				}
 				processResult(err, result.result);
 			}
@@ -1602,7 +1634,6 @@ class NormalModule extends Module {
 		};
 		this.buildInfo = {
 			cacheable: false,
-			notCacheableReasons: undefined,
 			parsed: true,
 			fileDependencies: undefined,
 			contextDependencies: undefined,
@@ -1620,6 +1651,8 @@ class NormalModule extends Module {
 			pureFunctions: undefined,
 			inlineExports: undefined,
 			moduleConcatenationBailout: undefined,
+			moduleConcatenationRootBailout: undefined,
+			diagnostics: undefined,
 			needCreateRequire: undefined,
 			usesTopLevelUsingDeclaration: undefined
 		};
@@ -2137,7 +2170,7 @@ class NormalModule extends Module {
 			parserOptions: /** @type {EXPECTED_ANY} */ (null),
 			generator: /** @type {EXPECTED_ANY} */ (null),
 			generatorOptions: /** @type {EXPECTED_ANY} */ (null),
-			resolveOptions: /** @type {EXPECTED_ANY} */ (null),
+			resolveOptions: undefined,
 			extractSourceMap: /** @type {EXPECTED_ANY} */ (null)
 		});
 		obj.deserialize(context);

package/lib/NormalModuleFactory.js

@@ -5,7 +5,6 @@
 
 "use strict";
 
-const asyncLib = require("neo-async");
 const {
 	AsyncSeriesBailHook,
 	AsyncSeriesHook,
@@ -30,6 +29,7 @@ const RuleSetCompiler = require("./rules/RuleSetCompiler");
 const UseEffectRulePlugin = require("./rules/UseEffectRulePlugin");
 const LazySet = require("./util/LazySet");
 const { getScheme } = require("./util/URLAbsoluteSpecifier");
+const asyncLib = require("./util/async");
 const { cachedCleverMerge, cachedSetProperty } = require("./util/cleverMerge");
 const {
 	applyCaseCorrections,

package/lib/RuntimeGlobals.js

@@ -15,13 +15,6 @@ module.exports.amdDefine = "__webpack_require__.amdD";
  */
 module.exports.amdOptions = "__webpack_require__.amdO";
 
-/**
- * analyzable single-chunk `import()` that keeps `ensureChunk` timing and deduplication:
- * resolves immediately for an installed chunk, else runs the literal import and installs it
- * Signature: (chunkId, () => Promise) => Promise
- */
-module.exports.analyzableChunkImport = "__webpack_require__.ei";
-
 /**
  * Creates an async module. The body function must be a async function.
  * "module.exports" will be decorated with an AsyncModulePromise.
@@ -254,12 +247,28 @@ module.exports.hasCssModules = "has css modules";
  */
 module.exports.hasFetchPriority = "has fetch priority";
 
+/**
+ * a flag when a deferred startup callback carries a priority
+ */
+module.exports.hasChunkPriority = "has chunk priority";
+
 /**
  * the shorthand for Object.prototype.hasOwnProperty
  * using of it decreases the compiled bundle size
  */
 module.exports.hasOwnProperty = "__webpack_require__.o";
 
+/**
+ * a flag when a deferred namespace is built from a known export list
+ */
+module.exports.hasSealedDeferredNamespace = "has sealed deferred namespace";
+
+/**
+ * a flag when a deferred namespace is synthesized from the module's exports
+ */
+module.exports.hasSynthesizedDeferredNamespace =
+	"has synthesized deferred namespace";
+
 /**
  * function downloading the update manifest
  */
@@ -447,6 +456,11 @@ module.exports.setAnonymousDefaultName = "__webpack_require__.dn";
  */
 module.exports.shareScopeMap = "__webpack_require__.S";
 
+/**
+ * wrap an exports object in a spec Module Namespace Exotic Object
+ */
+module.exports.specNamespaceObject = "__webpack_require__.ns";
+
 /**
  * startup signal from runtime
  * This will be called when the runtime chunk has been loaded.

package/lib/RuntimeModule.js

@@ -136,22 +136,31 @@ class RuntimeModule extends Module {
 	updateHash(hash, context) {
 		hash.update(this.name);
 		hash.update(`${this.stage}`);
-		try {
-			const code =
-				this.fullHash || this.dependentHash
-					? // Do not use getGeneratedCode here, because i. e. compilation hash might be not
-						// ready at this point. We will cache it later instead.
-						this.generate()
-					: this.getGeneratedCode();
-			if (code !== null && code !== undefined) {
-				hash.update(code);
-			}
-		} catch (err) {
-			hash.update(/** @type {Error} */ (err).message);
+		// A failing `generate()` propagates: hashing its message instead pins the etag
+		// of the code generation cache to a constant, which then serves stale code.
+		const code =
+			this.fullHash || this.dependentHash
+				? // Do not use getGeneratedCode here, because i. e. compilation hash might be not
+					// ready at this point. We will cache it later instead.
+					this.generate()
+				: this.getGeneratedCode();
+		if (code !== null && code !== undefined) {
+			hash.update(code);
 		}
 		super.updateHash(hash, context);
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		// Answering `null` rather than "none" keeps a module that never heard of this
+		// out of a dispatch that would skip the handler it installs.
+		return null;
+	}
+
 	/**
 	 * Returns the source types this module can generate.
 	 * @returns {SourceTypes} types available (do not mutate)
@@ -244,6 +253,13 @@ class RuntimeModule extends Module {
 	}
 }
 
+/**
+ * The answer a runtime module gives when it installs no chunk handler at all
+ */
+RuntimeModule.NO_CHUNK_HANDLERS =
+	/** @type {[string, string][]} */
+	([]);
+
 /**
  * Runtime modules without any dependencies to other runtime modules
  */

package/lib/RuntimePlugin.js

@@ -81,6 +81,9 @@ const getGetWorkletBootstrapRuntimeModule = lazyModule(() =>
 const getGlobalRuntimeModule = lazyModule(() =>
 	require("./runtime/GlobalRuntimeModule")
 );
+const getSpecNamespaceObjectRuntimeModule = lazyModule(() =>
+	require("./runtime/SpecNamespaceObjectRuntimeModule")
+);
 const getHasOwnPropertyRuntimeModule = lazyModule(() =>
 	require("./runtime/HasOwnPropertyRuntimeModule")
 );
@@ -214,6 +217,7 @@ const SIMPLE_TREE_RUNTIME_MODULES = [
 		getCreateFakeNamespaceObjectRuntimeModule
 	],
 	[RuntimeGlobals.hasOwnProperty, getHasOwnPropertyRuntimeModule],
+	[RuntimeGlobals.specNamespaceObject, getSpecNamespaceObjectRuntimeModule],
 	[
 		RuntimeGlobals.compatGetDefaultExport,
 		getCompatGetDefaultExportRuntimeModule
@@ -229,7 +233,6 @@ const SIMPLE_TREE_RUNTIME_MODULES = [
 	[RuntimeGlobals.shareScopeMap, getShareRuntimeModule],
 	[RuntimeGlobals.relativeUrl, getRelativeUrlRuntimeModule],
 	[RuntimeGlobals.worker, getWorkerRuntimeModule],
-	[RuntimeGlobals.onChunksLoaded, getOnChunksLoadedRuntimeModule],
 	[RuntimeGlobals.scriptNonce, getNonceRuntimeModule],
 	[RuntimeGlobals.toBinary, getToBinaryRuntimeModule]
 ];
@@ -316,6 +319,16 @@ class RuntimePlugin {
 						return true;
 					});
 			}
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.onChunksLoaded)
+				.tap(PLUGIN_NAME, (chunk, runtimeRequirement) => {
+					compilation.addLazyRuntimeModule(
+						chunk,
+						getOnChunksLoadedRuntimeModule,
+						(Ctor) => new Ctor(runtimeRequirement)
+					);
+					return true;
+				});
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.definePropertyGetters)
 				.tap(PLUGIN_NAME, (chunk, runtimeRequirement) => {
@@ -345,10 +358,20 @@ class RuntimePlugin {
 					const asyncModule = runtimeRequirement.has(
 						RuntimeGlobals.asyncModule
 					);
+					const sealed = runtimeRequirement.has(
+						RuntimeGlobals.hasSealedDeferredNamespace
+					);
+					// An unmarked build keeps both shapes, so a call site that
+					// predates the markers still gets the permissive runtime.
+					const synthesized =
+						!sealed ||
+						runtimeRequirement.has(
+							RuntimeGlobals.hasSynthesizedDeferredNamespace
+						);
 					compilation.addLazyRuntimeModule(
 						chunk,
 						getMakeDeferredNamespaceObjectRuntimeModule,
-						(Ctor) => new Ctor(asyncModule)
+						(Ctor) => new Ctor(asyncModule, sealed, synthesized)
 					);
 					return true;
 				});
@@ -402,7 +425,11 @@ class RuntimePlugin {
 					compilation.addLazyRuntimeModule(
 						chunk,
 						getAsyncModuleRuntimeModule,
-						(Ctor) => new Ctor(experiments.deferImport)
+						(Ctor) =>
+							new Ctor(
+								experiments.deferImport,
+								compilation.outputOptions.strictModuleErrorHandling
+							)
 					);
 					return true;
 				});