webpack 5.97.1 → 5.104.1

package/lib/DelegatedPlugin.js

@@ -11,6 +11,8 @@ const DelegatedSourceDependency = require("./dependencies/DelegatedSourceDepende
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./DelegatedModuleFactoryPlugin").Options} Options */
 
+const PLUGIN_NAME = "DelegatedPlugin";
+
 class DelegatedPlugin {
 	/**
 	 * @param {Options} options options
@@ -26,7 +28,7 @@ class DelegatedPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"DelegatedPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					DelegatedSourceDependency,
@@ -35,7 +37,7 @@ class DelegatedPlugin {
 			}
 		);
 
-		compiler.hooks.compile.tap("DelegatedPlugin", ({ normalModuleFactory }) => {
+		compiler.hooks.compile.tap(PLUGIN_NAME, ({ normalModuleFactory }) => {
 			new DelegatedModuleFactoryPlugin({
 				associatedObjectForCache: compiler.root,
 				...this.options

package/lib/DependenciesBlock.js

@@ -8,8 +8,6 @@
 const makeSerializable = require("./util/makeSerializable");
 
 /** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./ChunkGroup")} ChunkGroup */
 /** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */

package/lib/Dependency.js

@@ -5,13 +5,10 @@
 
 "use strict";
 
-const RawModule = require("./RawModule");
 const memoize = require("./util/memoize");
 
-/** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("./ChunkGraph")} ChunkGraph */
 /** @typedef {import("./DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./ModuleGraphConnection")} ModuleGraphConnection */
@@ -22,7 +19,7 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("./util/Hash")} Hash */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
-
+/** @typedef {import("./dependencies/ModuleDependency")} ModuleDependency */
 /**
  * @typedef {object} UpdateHashContext
  * @property {ChunkGraph} chunkGraph
@@ -63,10 +60,12 @@ const memoize = require("./util/memoize");
  * @property {boolean=} hidden export is not visible, because another export blends over it
  */
 
+/** @typedef {Set<string>} ExportsSpecExcludeExports */
+
 /**
  * @typedef {object} ExportsSpec
  * @property {(string | ExportSpec)[] | true | null} exports exported names, true for unknown exports or null for no exports
- * @property {Set<string>=} excludeExports when exports = true, list of unaffected exports
+ * @property {ExportsSpecExcludeExports=} excludeExports when exports = true, list of unaffected exports
  * @property {(Set<string> | null)=} hideExports list of maybe prior exposed, but now hidden exports
  * @property {ModuleGraphConnection=} from when reexported: from which module
  * @property {number=} priority when reexported: with which priority
@@ -81,13 +80,20 @@ const memoize = require("./util/memoize");
  * @property {boolean=} canMangle when false, referenced export can not be mangled, defaults to true
  */
 
-/** @typedef {function(ModuleGraphConnection, RuntimeSpec): ConnectionState} GetConditionFn */
+/** @typedef {string[][]} RawReferencedExports */
+/** @typedef {(string[] | ReferencedExport)[]} ReferencedExports */
+
+/** @typedef {(moduleGraphConnection: ModuleGraphConnection, runtime: RuntimeSpec) => ConnectionState} GetConditionFn */
 
 const TRANSITIVE = Symbol("transitive");
 
-const getIgnoredModule = memoize(
-	() => new RawModule("/* (ignored) */", "ignored", "(ignored)")
-);
+const getIgnoredModule = memoize(() => {
+	const RawModule = require("./RawModule");
+
+	const module = new RawModule("/* (ignored) */", "ignored", "(ignored)");
+	module.factoryMeta = { sideEffectFree: true };
+	return module;
+});
 
 class Dependency {
 	constructor() {
@@ -101,7 +107,7 @@ class Dependency {
 		/** @type {boolean} */
 		this.weak = false;
 		// TODO check if this can be moved into ModuleDependency
-		/** @type {boolean} */
+		/** @type {boolean | undefined} */
 		this.optional = false;
 		this._locSL = 0;
 		this._locSC = 0;
@@ -131,8 +137,10 @@ class Dependency {
 	 */
 	get loc() {
 		if (this._loc !== undefined) return this._loc;
+
 		/** @type {SyntheticDependencyLocation & RealDependencyLocation} */
 		const loc = {};
+
 		if (this._locSL > 0) {
 			loc.start = { line: this._locSL, column: this._locSC };
 		}
@@ -145,6 +153,7 @@ class Dependency {
 		if (this._locI !== undefined) {
 			loc.index = this._locI;
 		}
+
 		return (this._loc = loc);
 	}
 
@@ -221,7 +230,7 @@ class Dependency {
 	 * Returns list of exports referenced by this dependency
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 * @returns {ReferencedExports} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
 		return Dependency.EXPORTS_OBJECT_REFERENCED;
@@ -288,7 +297,7 @@ class Dependency {
 
 	/**
 	 * @param {string} context context directory
-	 * @returns {Module | null} a module
+	 * @returns {Module} ignored module
 	 */
 	createIgnoredModule(context) {
 		return getIgnoredModule();
@@ -323,17 +332,16 @@ class Dependency {
 	}
 }
 
-/** @type {string[][]} */
+/** @type {RawReferencedExports} */
 Dependency.NO_EXPORTS_REFERENCED = [];
-/** @type {string[][]} */
+/** @type {RawReferencedExports} */
 Dependency.EXPORTS_OBJECT_REFERENCED = [[]];
 
-// eslint-disable-next-line no-warning-comments
-// @ts-ignore https://github.com/microsoft/TypeScript/issues/42919
+// TODO remove in webpack 6
 Object.defineProperty(Dependency.prototype, "module", {
 	/**
 	 * @deprecated
-	 * @returns {never} throws
+	 * @returns {EXPECTED_ANY} throws
 	 */
 	get() {
 		throw new Error(
@@ -352,9 +360,19 @@ Object.defineProperty(Dependency.prototype, "module", {
 	}
 });
 
-// eslint-disable-next-line no-warning-comments
-// @ts-ignore https://github.com/microsoft/TypeScript/issues/42919
+/**
+ * @param {Dependency} dependency dep
+ * @returns {boolean} true if the dependency is a low priority dependency
+ */
+Dependency.isLowPriorityDependency = (dependency) =>
+	/** @type {ModuleDependency} */ (dependency).sourceOrder === Infinity;
+
+// TODO remove in webpack 6
 Object.defineProperty(Dependency.prototype, "disconnect", {
+	/**
+	 * @deprecated
+	 * @returns {EXPECTED_ANY} throws
+	 */
 	get() {
 		throw new Error(
 			"disconnect was removed from Dependency (Dependency no longer carries graph specific information)"

package/lib/DependencyTemplate.js

@@ -41,6 +41,7 @@
 /**
  * @typedef {object} CssDependencyTemplateContextExtras
  * @property {CssData} cssData the css exports data
+ * @property {string} type the css exports data
  */
 
 /**
@@ -62,6 +63,7 @@ class DependencyTemplate {
 	 */
 	apply(dependency, source, templateContext) {
 		const AbstractMethodError = require("./AbstractMethodError");
+
 		throw new AbstractMethodError();
 	}
 }

package/lib/DependencyTemplates.js

@@ -5,20 +5,19 @@
 
 "use strict";
 
+const { DEFAULTS } = require("./config/defaults");
 const createHash = require("./util/createHash");
 
-/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Compilation").DependencyConstructor} DependencyConstructor */
 /** @typedef {import("./DependencyTemplate")} DependencyTemplate */
 /** @typedef {typeof import("./util/Hash")} Hash */
 
-/** @typedef {new (...args: any[]) => Dependency} DependencyConstructor */
-
 class DependencyTemplates {
 	/**
 	 * @param {string | Hash} hashFunction the hash function to use
 	 */
-	constructor(hashFunction = "md4") {
-		/** @type {Map<Function, DependencyTemplate>} */
+	constructor(hashFunction = DEFAULTS.HASH_FUNCTION) {
+		/** @type {Map<DependencyConstructor, DependencyTemplate>} */
 		this._map = new Map();
 		/** @type {string} */
 		this._hash = "31d6cfe0d16ae931b73c59d7e0c089c0";
@@ -49,7 +48,7 @@ class DependencyTemplates {
 	updateHash(part) {
 		const hash = createHash(this._hashFunction);
 		hash.update(`${this._hash}${part}`);
-		this._hash = /** @type {string} */ (hash.digest("hex"));
+		this._hash = hash.digest("hex");
 	}
 
 	getHash() {

package/lib/DllEntryPlugin.js

@@ -10,8 +10,12 @@ const DllEntryDependency = require("./dependencies/DllEntryDependency");
 const EntryDependency = require("./dependencies/EntryDependency");
 
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
+
 /** @typedef {string[]} Entries */
-/** @typedef {{ name: string, filename: TODO }} Options */
+/** @typedef {EntryOptions & { name: string }} Options */
+
+const PLUGIN_NAME = "DllEntryPlugin";
 
 class DllEntryPlugin {
 	/**
@@ -32,7 +36,7 @@ class DllEntryPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"DllEntryPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				const dllModuleFactory = new DllModuleFactory();
 				compilation.dependencyFactories.set(
@@ -45,7 +49,7 @@ class DllEntryPlugin {
 				);
 			}
 		);
-		compiler.hooks.make.tapAsync("DllEntryPlugin", (compilation, callback) => {
+		compiler.hooks.make.tapAsync(PLUGIN_NAME, (compilation, callback) => {
 			compilation.addEntry(
 				this.context,
 				new DllEntryDependency(
@@ -60,7 +64,7 @@ class DllEntryPlugin {
 					this.options.name
 				),
 				this.options,
-				error => {
+				(error) => {
 					if (error) return callback(error);
 					callback();
 				}

package/lib/DllModule.js

@@ -7,27 +7,26 @@
 
 const { RawSource } = require("webpack-sources");
 const Module = require("./Module");
-const { JS_TYPES } = require("./ModuleSourceTypesConstants");
+const {
+	JAVASCRIPT_TYPE,
+	JAVASCRIPT_TYPES
+} = require("./ModuleSourceTypeConstants");
 const { JAVASCRIPT_MODULE_TYPE_DYNAMIC } = require("./ModuleTypeConstants");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const makeSerializable = require("./util/makeSerializable");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("./Generator").SourceTypes} SourceTypes */
+/** @typedef {import("./Module").BuildCallback} BuildCallback */
 /** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("./Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("./Module").SourceContext} SourceContext */
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./WebpackError")} WebpackError */
 /** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("./util/Hash")} Hash */
@@ -57,7 +56,7 @@ class DllModule extends Module {
 	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
-		return JS_TYPES;
+		return JAVASCRIPT_TYPES;
 	}
 
 	/**
@@ -80,7 +79,7 @@ class DllModule extends Module {
 	 * @param {Compilation} compilation the compilation
 	 * @param {ResolverWithOptions} resolver the resolver
 	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
+	 * @param {BuildCallback} callback callback function
 	 * @returns {void}
 	 */
 	build(options, compilation, resolver, fs, callback) {
@@ -96,7 +95,7 @@ class DllModule extends Module {
 	codeGeneration(context) {
 		const sources = new Map();
 		sources.set(
-			"javascript",
+			JAVASCRIPT_TYPE,
 			new RawSource(`module.exports = ${RuntimeGlobals.require};`)
 		);
 		return {
@@ -107,7 +106,7 @@ class DllModule extends Module {
 
 	/**
 	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
 	 */
 	needBuild(context, callback) {

package/lib/DllModuleFactory.js

@@ -8,8 +8,8 @@
 const DllModule = require("./DllModule");
 const ModuleFactory = require("./ModuleFactory");
 
+/** @typedef {import("./ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */
 /** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
 /** @typedef {import("./dependencies/DllEntryDependency")} DllEntryDependency */
 
 class DllModuleFactory extends ModuleFactory {
@@ -20,7 +20,7 @@ class DllModuleFactory extends ModuleFactory {
 
 	/**
 	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
+	 * @param {ModuleFactoryCallback} callback callback
 	 * @returns {void}
 	 */
 	create(data, callback) {

package/lib/DllPlugin.js

@@ -16,7 +16,7 @@ const createSchemaValidation = require("./util/create-schema-validation");
 /** @typedef {import("./DllEntryPlugin").Options} Options */
 
 const validate = createSchemaValidation(
-	require("../schemas/plugins/DllPlugin.check.js"),
+	require("../schemas/plugins/DllPlugin.check"),
 	() => require("../schemas/plugins/DllPlugin.json"),
 	{
 		name: "Dll Plugin",
@@ -24,6 +24,8 @@ const validate = createSchemaValidation(
 	}
 );
 
+const PLUGIN_NAME = "DllPlugin";
+
 class DllPlugin {
 	/**
 	 * @param {DllPluginOptions} options options object
@@ -42,27 +44,28 @@ class DllPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.entryOption.tap("DllPlugin", (context, entry) => {
+		compiler.hooks.entryOption.tap(PLUGIN_NAME, (context, entry) => {
 			if (typeof entry !== "function") {
 				for (const name of Object.keys(entry)) {
 					/** @type {Options} */
-					const options = { name, filename: entry.filename };
+					const options = { name };
 					new DllEntryPlugin(
 						context,
-						/** @type {Entries} */ (entry[name].import),
+						/** @type {Entries} */
+						(entry[name].import),
 						options
 					).apply(compiler);
 				}
 			} else {
 				throw new Error(
-					"DllPlugin doesn't support dynamic entry (function) yet"
+					`${PLUGIN_NAME} doesn't support dynamic entry (function) yet`
 				);
 			}
 			return true;
 		});
 		new LibManifestPlugin(this.options).apply(compiler);
 		if (!this.options.entryOnly) {
-			new FlagAllModulesAsUsedPlugin("DllPlugin").apply(compiler);
+			new FlagAllModulesAsUsedPlugin(PLUGIN_NAME).apply(compiler);
 		}
 	}
 }

package/lib/DllReferencePlugin.js

@@ -18,10 +18,11 @@ const makePathsRelative = require("./util/identifier").makePathsRelative;
 /** @typedef {import("../declarations/plugins/DllReferencePlugin").DllReferencePluginOptionsContent} DllReferencePluginOptionsContent */
 /** @typedef {import("../declarations/plugins/DllReferencePlugin").DllReferencePluginOptionsManifest} DllReferencePluginOptionsManifest */
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Compiler").CompilationParams} CompilationParams */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
 const validate = createSchemaValidation(
-	require("../schemas/plugins/DllReferencePlugin.check.js"),
+	require("../schemas/plugins/DllReferencePlugin.check"),
 	() => require("../schemas/plugins/DllReferencePlugin.json"),
 	{
 		name: "Dll Reference Plugin",
@@ -31,6 +32,8 @@ const validate = createSchemaValidation(
 
 /** @typedef {{ path: string, data: DllReferencePluginOptionsManifest | undefined, error: Error | undefined }} CompilationDataItem */
 
+const PLUGIN_NAME = "DllReferencePlugin";
+
 class DllReferencePlugin {
 	/**
 	 * @param {DllReferencePluginOptions} options options object
@@ -38,7 +41,7 @@ class DllReferencePlugin {
 	constructor(options) {
 		validate(options);
 		this.options = options;
-		/** @type {WeakMap<object, CompilationDataItem>} */
+		/** @type {WeakMap<CompilationParams, CompilationDataItem>} */
 		this._compilationData = new WeakMap();
 	}
 
@@ -49,7 +52,7 @@ class DllReferencePlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"DllReferencePlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					DelegatedSourceDependency,
@@ -58,51 +61,48 @@ class DllReferencePlugin {
 			}
 		);
 
-		compiler.hooks.beforeCompile.tapAsync(
-			"DllReferencePlugin",
-			(params, callback) => {
-				if ("manifest" in this.options) {
-					const manifest = this.options.manifest;
-					if (typeof manifest === "string") {
-						/** @type {InputFileSystem} */
-						(compiler.inputFileSystem).readFile(manifest, (err, result) => {
-							if (err) return callback(err);
-							/** @type {CompilationDataItem} */
-							const data = {
-								path: manifest,
-								data: undefined,
-								error: undefined
-							};
-							// Catch errors parsing the manifest so that blank
-							// or malformed manifest files don't kill the process.
-							try {
-								data.data = parseJson(
-									/** @type {Buffer} */ (result).toString("utf-8")
-								);
-							} catch (parseErr) {
-								// Store the error in the params so that it can
-								// be added as a compilation error later on.
-								const manifestPath = makePathsRelative(
-									/** @type {string} */ (compiler.options.context),
-									manifest,
-									compiler.root
-								);
-								data.error = new DllManifestError(
-									manifestPath,
-									/** @type {Error} */ (parseErr).message
-								);
-							}
-							this._compilationData.set(params, data);
-							return callback();
-						});
-						return;
-					}
+		compiler.hooks.beforeCompile.tapAsync(PLUGIN_NAME, (params, callback) => {
+			if ("manifest" in this.options) {
+				const manifest = this.options.manifest;
+				if (typeof manifest === "string") {
+					/** @type {InputFileSystem} */
+					(compiler.inputFileSystem).readFile(manifest, (err, result) => {
+						if (err) return callback(err);
+						/** @type {CompilationDataItem} */
+						const data = {
+							path: manifest,
+							data: undefined,
+							error: undefined
+						};
+						// Catch errors parsing the manifest so that blank
+						// or malformed manifest files don't kill the process.
+						try {
+							data.data = parseJson(
+								/** @type {Buffer} */ (result).toString("utf8")
+							);
+						} catch (parseErr) {
+							// Store the error in the params so that it can
+							// be added as a compilation error later on.
+							const manifestPath = makePathsRelative(
+								compiler.context,
+								manifest,
+								compiler.root
+							);
+							data.error = new DllManifestError(
+								manifestPath,
+								/** @type {Error} */ (parseErr).message
+							);
+						}
+						this._compilationData.set(params, data);
+						return callback();
+					});
+					return;
 				}
-				return callback();
 			}
-		);
+			return callback();
+		});
 
-		compiler.hooks.compile.tap("DllReferencePlugin", params => {
+		compiler.hooks.compile.tap(PLUGIN_NAME, (params) => {
 			let name = this.options.name;
 			let sourceType = this.options.sourceType;
 			let resolvedContent =
@@ -142,9 +142,7 @@ class DllReferencePlugin {
 				source,
 				type: this.options.type,
 				scope: this.options.scope,
-				context:
-					/** @type {string} */
-					(this.options.context || compiler.options.context),
+				context: this.options.context || compiler.context,
 				content:
 					/** @type {DllReferencePluginOptionsContent} */
 					(resolvedContent),
@@ -153,27 +151,24 @@ class DllReferencePlugin {
 			}).apply(normalModuleFactory);
 		});
 
-		compiler.hooks.compilation.tap(
-			"DllReferencePlugin",
-			(compilation, params) => {
-				if ("manifest" in this.options) {
-					const manifest = this.options.manifest;
-					if (typeof manifest === "string") {
-						const data = /** @type {CompilationDataItem} */ (
-							this._compilationData.get(params)
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation, params) => {
+			if ("manifest" in this.options) {
+				const manifest = this.options.manifest;
+				if (typeof manifest === "string") {
+					const data = /** @type {CompilationDataItem} */ (
+						this._compilationData.get(params)
+					);
+					// If there was an error parsing the manifest file, add the
+					// error as a compilation error to make the compilation fail.
+					if (data.error) {
+						compilation.errors.push(
+							/** @type {DllManifestError} */ (data.error)
 						);
-						// If there was an error parsing the manifest file, add the
-						// error as a compilation error to make the compilation fail.
-						if (data.error) {
-							compilation.errors.push(
-								/** @type {DllManifestError} */ (data.error)
-							);
-						}
-						compilation.fileDependencies.add(manifest);
 					}
+					compilation.fileDependencies.add(manifest);
 				}
 			}
-		);
+		});
 	}
 }