webpack 5.97.1 → 5.104.1

package/lib/FlagAllModulesAsUsedPlugin.js

@@ -26,9 +26,9 @@ class FlagAllModulesAsUsedPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			const moduleGraph = compilation.moduleGraph;
-			compilation.hooks.optimizeDependencies.tap(PLUGIN_NAME, modules => {
+			compilation.hooks.optimizeDependencies.tap(PLUGIN_NAME, (modules) => {
 				/** @type {RuntimeSpec} */
 				let runtime;
 				for (const [name, { options }] of compilation.entries) {

package/lib/FlagDependencyExportsPlugin.js

@@ -14,6 +14,7 @@ const Queue = require("./util/Queue");
 /** @typedef {import("./Dependency").ExportSpec} ExportSpec */
 /** @typedef {import("./Dependency").ExportsSpec} ExportsSpec */
 /** @typedef {import("./ExportsInfo")} ExportsInfo */
+/** @typedef {import("./ExportsInfo").RestoreProvidedData} RestoreProvidedData */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./Module").BuildInfo} BuildInfo */
 
@@ -27,7 +28,7 @@ class FlagDependencyExportsPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			const moduleGraph = compilation.moduleGraph;
 			const cache = compilation.getCache(PLUGIN_NAME);
 			compilation.hooks.finishModules.tapAsync(
@@ -102,7 +103,7 @@ class FlagDependencyExportsPlugin {
 								}
 							);
 						},
-						err => {
+						(err) => {
 							logger.timeEnd("restore cached provided exports");
 							if (err) return callback(err);
 
@@ -128,7 +129,7 @@ class FlagDependencyExportsPlugin {
 							 * @param {DependenciesBlock} depBlock the dependencies block
 							 * @returns {void}
 							 */
-							const processDependenciesBlock = depBlock => {
+							const processDependenciesBlock = (depBlock) => {
 								for (const dep of depBlock.dependencies) {
 									processDependency(dep);
 								}
@@ -141,7 +142,7 @@ class FlagDependencyExportsPlugin {
 							 * @param {Dependency} dep the dependency
 							 * @returns {void}
 							 */
-							const processDependency = dep => {
+							const processDependency = (dep) => {
 								const exportDesc = dep.getExports(moduleGraph);
 								if (!exportDesc) return;
 								exportsSpecsFromDependencies.set(dep, exportDesc);
@@ -199,20 +200,27 @@ class FlagDependencyExportsPlugin {
 												name = exportNameOrSpec;
 											} else {
 												name = exportNameOrSpec.name;
-												if (exportNameOrSpec.canMangle !== undefined)
+												if (exportNameOrSpec.canMangle !== undefined) {
 													canMangle = exportNameOrSpec.canMangle;
-												if (exportNameOrSpec.export !== undefined)
+												}
+												if (exportNameOrSpec.export !== undefined) {
 													fromExport = exportNameOrSpec.export;
-												if (exportNameOrSpec.exports !== undefined)
+												}
+												if (exportNameOrSpec.exports !== undefined) {
 													exports = exportNameOrSpec.exports;
-												if (exportNameOrSpec.from !== undefined)
+												}
+												if (exportNameOrSpec.from !== undefined) {
 													from = exportNameOrSpec.from;
-												if (exportNameOrSpec.priority !== undefined)
+												}
+												if (exportNameOrSpec.priority !== undefined) {
 													priority = exportNameOrSpec.priority;
-												if (exportNameOrSpec.terminalBinding !== undefined)
+												}
+												if (exportNameOrSpec.terminalBinding !== undefined) {
 													terminalBinding = exportNameOrSpec.terminalBinding;
-												if (exportNameOrSpec.hidden !== undefined)
+												}
+												if (exportNameOrSpec.hidden !== undefined) {
 													hidden = exportNameOrSpec.hidden;
+												}
 											}
 											const exportInfo = exportsInfo.getExportInfo(name);
 
@@ -368,7 +376,8 @@ class FlagDependencyExportsPlugin {
 								(module, callback) => {
 									if (
 										typeof (
-											/** @type {BuildInfo} */ (module.buildInfo).hash
+											/** @type {BuildInfo} */
+											(module.buildInfo).hash
 										) !== "string"
 									) {
 										// not cacheable
@@ -390,7 +399,7 @@ class FlagDependencyExportsPlugin {
 										callback
 									);
 								},
-								err => {
+								(err) => {
 									logger.timeEnd("store provided exports into cache");
 									callback(err);
 								}
@@ -400,18 +409,19 @@ class FlagDependencyExportsPlugin {
 				}
 			);
 
-			/** @type {WeakMap<Module, any>} */
+			/** @type {WeakMap<Module, RestoreProvidedData>} */
 			const providedExportsCache = new WeakMap();
-			compilation.hooks.rebuildModule.tap(PLUGIN_NAME, module => {
+			compilation.hooks.rebuildModule.tap(PLUGIN_NAME, (module) => {
 				providedExportsCache.set(
 					module,
 					moduleGraph.getExportsInfo(module).getRestoreProvidedData()
 				);
 			});
-			compilation.hooks.finishRebuildingModule.tap(PLUGIN_NAME, module => {
-				moduleGraph
-					.getExportsInfo(module)
-					.restoreProvided(providedExportsCache.get(module));
+			compilation.hooks.finishRebuildingModule.tap(PLUGIN_NAME, (module) => {
+				moduleGraph.getExportsInfo(module).restoreProvided(
+					/** @type {RestoreProvidedData} */
+					(providedExportsCache.get(module))
+				);
 			});
 		});
 	}

package/lib/FlagDependencyUsagePlugin.js

@@ -13,11 +13,10 @@ const ArrayQueue = require("./util/ArrayQueue");
 const TupleQueue = require("./util/TupleQueue");
 const { getEntryRuntime, mergeRuntimeOwned } = require("./util/runtime");
 
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./ChunkGroup")} ChunkGroup */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./DependenciesBlock")} DependenciesBlock */
 /** @typedef {import("./Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("./Dependency").ReferencedExports} ReferencedExports */
 /** @typedef {import("./ExportsInfo")} ExportsInfo */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
@@ -41,11 +40,11 @@ class FlagDependencyUsagePlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			const moduleGraph = compilation.moduleGraph;
 			compilation.hooks.optimizeDependencies.tap(
 				{ name: PLUGIN_NAME, stage: STAGE_DEFAULT },
-				modules => {
+				(modules) => {
 					if (compilation.moduleMemCaches) {
 						throw new Error(
 							"optimization.usedExports can't be used with cacheUnaffected as export usage is a global effect"
@@ -56,12 +55,12 @@ class FlagDependencyUsagePlugin {
 					/** @type {Map<ExportsInfo, Module>} */
 					const exportInfoToModuleMap = new Map();
 
-					/** @type {TupleQueue<[Module, RuntimeSpec]>} */
+					/** @type {TupleQueue<Module, RuntimeSpec>} */
 					const queue = new TupleQueue();
 
 					/**
 					 * @param {Module} module module to process
-					 * @param {(string[] | ReferencedExport)[]} usedExports list of used exports
+					 * @param {ReferencedExports} usedExports list of used exports
 					 * @param {RuntimeSpec} runtime part of which runtime
 					 * @param {boolean} forceSideEffects always apply side effects
 					 * @returns {void}
@@ -108,7 +107,7 @@ class FlagDependencyUsagePlugin {
 											if (nestedInfo) {
 												if (
 													exportInfo.setUsedConditionally(
-														used => used === UsageState.Unused,
+														(used) => used === UsageState.Unused,
 														UsageState.OnlyPropertiesUsed,
 														runtime
 													)
@@ -127,7 +126,7 @@ class FlagDependencyUsagePlugin {
 										}
 										if (
 											exportInfo.setUsedConditionally(
-												v => v !== UsageState.Used,
+												(v) => v !== UsageState.Used,
 												UsageState.Used,
 												runtime
 											)
@@ -168,7 +167,7 @@ class FlagDependencyUsagePlugin {
 					 * @returns {void}
 					 */
 					const processModule = (module, runtime, forceSideEffects) => {
-						/** @type {Map<Module, (string[] | ReferencedExport)[] | Map<string, string[] | ReferencedExport>>} */
+						/** @type {Map<Module, ReferencedExports | Map<string, string[] | ReferencedExport>>} */
 						const map = new Map();
 
 						/** @type {ArrayQueue<DependenciesBlock>} */
@@ -274,7 +273,7 @@ class FlagDependencyUsagePlugin {
 							} else {
 								processReferencedModule(
 									module,
-									Array.from(referencedExports.values()),
+									[...referencedExports.values()],
 									runtime,
 									forceSideEffects
 								);

package/lib/FlagEntryExportAsUsedPlugin.js

@@ -27,7 +27,7 @@ class FlagEntryExportAsUsedPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, compilation => {
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			const moduleGraph = compilation.moduleGraph;
 			compilation.hooks.seal.tap(PLUGIN_NAME, () => {
 				for (const [

package/lib/Generator.js

@@ -5,15 +5,17 @@
 
 "use strict";
 
+const { JAVASCRIPT_TYPE } = require("./ModuleSourceTypeConstants");
+
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("./ChunkGraph")} ChunkGraph */
 /** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
-/** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./ConcatenationScope")} ConcatenationScope */
-/** @typedef {import("./DependencyTemplate")} DependencyTemplate */
 /** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./Module").CodeGenerationResultData} CodeGenerationResultData */
 /** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
 /** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */
+/** @typedef {import("./Module").SourceType} SourceType */
 /** @typedef {import("./Module").SourceTypes} SourceTypes */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./NormalModule")} NormalModule */
@@ -31,8 +33,16 @@
  * @property {RuntimeSpec} runtime the runtime
  * @property {ConcatenationScope=} concatenationScope when in concatenated module, information about other concatenated modules
  * @property {CodeGenerationResults=} codeGenerationResults code generation results of other modules (need to have a codeGenerationDependency to use that)
- * @property {string} type which kind of code should be generated
- * @property {function(): Map<string, any>=} getData get access to the code generation data
+ * @property {SourceType} type which kind of code should be generated
+ * @property {() => CodeGenerationResultData=} getData get access to the code generation data
+ */
+
+/**
+ * @callback GenerateErrorFn
+ * @param {Error} error the error
+ * @param {NormalModule} module module for which the code should be generated
+ * @param {GenerateContext} generateContext context for generate
+ * @returns {Source | null} generated code
  */
 
 /**
@@ -45,7 +55,7 @@
 
 class Generator {
 	/**
-	 * @param {Record<string, Generator>} map map of types
+	 * @param {{ [key in SourceType]?: Generator }} map map of types
 	 * @returns {ByTypeGenerator} generator by type
 	 */
 	static byType(map) {
@@ -60,6 +70,7 @@ class Generator {
 	 */
 	getTypes(module) {
 		const AbstractMethodError = require("./AbstractMethodError");
+
 		throw new AbstractMethodError();
 	}
 
@@ -67,11 +78,12 @@ class Generator {
 	/**
 	 * @abstract
 	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
+	 * @param {SourceType=} type source type
 	 * @returns {number} estimate size of the module
 	 */
 	getSize(module, type) {
 		const AbstractMethodError = require("./AbstractMethodError");
+
 		throw new AbstractMethodError();
 	}
 
@@ -87,6 +99,7 @@ class Generator {
 		{ dependencyTemplates, runtimeTemplate, moduleGraph, type }
 	) {
 		const AbstractMethodError = require("./AbstractMethodError");
+
 		throw new AbstractMethodError();
 	}
 
@@ -108,14 +121,34 @@ class Generator {
 	}
 }
 
+/**
+ * @this {ByTypeGenerator}
+ * @type {GenerateErrorFn}
+ */
+function generateError(error, module, generateContext) {
+	const type = generateContext.type;
+	const generator =
+		/** @type {Generator & { generateError?: GenerateErrorFn }} */
+		(this.map[type]);
+	if (!generator) {
+		throw new Error(`Generator.byType: no generator specified for ${type}`);
+	}
+	if (typeof generator.generateError === "undefined") {
+		return null;
+	}
+	return generator.generateError(error, module, generateContext);
+}
+
 class ByTypeGenerator extends Generator {
 	/**
-	 * @param {Record<string, Generator>} map map of types
+	 * @param {{ [key in SourceType]?: Generator }} map map of types
 	 */
 	constructor(map) {
 		super();
 		this.map = map;
-		this._types = new Set(Object.keys(map));
+		this._types = /** @type {SourceTypes} */ (new Set(Object.keys(map)));
+		/** @type {GenerateErrorFn | undefined} */
+		this.generateError = generateError.bind(this);
 	}
 
 	/**
@@ -128,10 +161,10 @@ class ByTypeGenerator extends Generator {
 
 	/**
 	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
+	 * @param {SourceType=} type source type
 	 * @returns {number} estimate size of the module
 	 */
-	getSize(module, type = "javascript") {
+	getSize(module, type = JAVASCRIPT_TYPE) {
 		const t = type;
 		const generator = this.map[t];
 		return generator ? generator.getSize(module, t) : 0;

package/lib/GraphHelpers.js

@@ -5,11 +5,9 @@
 
 "use strict";
 
-/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
 /** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./ChunkGroup")} ChunkGroup */
-/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("./Module")} Module */
+/** @typedef {import(".").Entrypoint} Entrypoint */
 
 /**
  * @param {ChunkGroup} chunkGroup the ChunkGroup to connect
@@ -33,6 +31,16 @@ const connectChunkGroupParentAndChild = (parent, child) => {
 	}
 };
 
+/**
+ * @param {Entrypoint} entrypoint the entrypoint
+ * @param {Entrypoint} dependOnEntrypoint the dependOnEntrypoint
+ * @returns {void}
+ */
+const connectEntrypointAndDependOn = (entrypoint, dependOnEntrypoint) => {
+	entrypoint.addDependOn(dependOnEntrypoint);
+};
+
 module.exports.connectChunkGroupAndChunk = connectChunkGroupAndChunk;
 module.exports.connectChunkGroupParentAndChild =
 	connectChunkGroupParentAndChild;
+module.exports.connectEntrypointAndDependOn = connectEntrypointAndDependOn;

package/lib/HookWebpackError.js

@@ -6,8 +6,10 @@
 "use strict";
 
 const WebpackError = require("./WebpackError");
+const makeSerializable = require("./util/makeSerializable");
 
-/** @typedef {import("./Module")} Module */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
 /**
  * @template T
@@ -24,18 +26,43 @@ class HookWebpackError extends WebpackError {
 	 * @param {string} hook name of hook
 	 */
 	constructor(error, hook) {
-		super(error.message);
+		super(error ? error.message : undefined, error ? { cause: error } : {});
 
-		this.name = "HookWebpackError";
 		this.hook = hook;
 		this.error = error;
+		this.name = "HookWebpackError";
 		this.hideStack = true;
-		this.details = `caused by plugins in ${hook}\n${error.stack}`;
+		this.stack += `\n-- inner error --\n${error ? error.stack : ""}`;
+		this.details = `caused by plugins in ${hook}\n${error ? error.stack : ""}`;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
 
-		this.stack += `\n-- inner error --\n${error.stack}`;
+		write(this.error);
+		write(this.hook);
+
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+
+		this.error = read();
+		this.hook = read();
+
+		super.deserialize(context);
 	}
 }
 
+makeSerializable(HookWebpackError, "webpack/lib/HookWebpackError");
+
 module.exports = HookWebpackError;
 
 /**
@@ -47,11 +74,12 @@ const makeWebpackError = (error, hook) => {
 	if (error instanceof WebpackError) return error;
 	return new HookWebpackError(error, hook);
 };
+
 module.exports.makeWebpackError = makeWebpackError;
 
 /**
  * @template T
- * @param {function(WebpackError | null, T=): void} callback webpack error callback
+ * @param {(err: WebpackError | null, result?: T) => void} callback webpack error callback
  * @param {string} hook name of hook
  * @returns {Callback<T>} generic callback
  */
@@ -71,7 +99,7 @@ module.exports.makeWebpackErrorCallback = makeWebpackErrorCallback;
 
 /**
  * @template T
- * @param {function(): T} fn function which will be wrapping in try catch
+ * @param {() => T} fn function which will be wrapping in try catch
  * @param {string} hook name of hook
  * @returns {T} the result
  */