webpack 5.59.0 → 5.94.0

package/lib/dependencies/ImportPlugin.js

@@ -5,13 +5,22 @@
 
 "use strict";
 
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../ModuleTypeConstants");
 const ImportContextDependency = require("./ImportContextDependency");
 const ImportDependency = require("./ImportDependency");
 const ImportEagerDependency = require("./ImportEagerDependency");
 const ImportParserPlugin = require("./ImportParserPlugin");
 const ImportWeakDependency = require("./ImportWeakDependency");
 
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../javascript/JavascriptParser")} Parser */
+
+const PLUGIN_NAME = "ImportPlugin";
 
 class ImportPlugin {
 	/**
@@ -21,7 +30,7 @@ class ImportPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"ImportPlugin",
+			PLUGIN_NAME,
 			(compilation, { contextModuleFactory, normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					ImportDependency,
@@ -59,6 +68,11 @@ class ImportPlugin {
 					new ImportContextDependency.Template()
 				);
 
+				/**
+				 * @param {Parser} parser parser parser
+				 * @param {JavascriptParserOptions} parserOptions parserOptions
+				 * @returns {void}
+				 */
 				const handler = (parser, parserOptions) => {
 					if (parserOptions.import !== undefined && !parserOptions.import)
 						return;
@@ -67,14 +81,14 @@ class ImportPlugin {
 				};
 
 				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("ImportPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("ImportPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, handler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("ImportPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, handler);
 			}
 		);
 	}

package/lib/dependencies/ImportWeakDependency.js

@@ -12,16 +12,21 @@ const ImportDependency = require("./ImportDependency");
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
 class ImportWeakDependency extends ImportDependency {
 	/**
 	 * @param {string} request the request
-	 * @param {[number, number]} range expression range
-	 * @param {string[][]=} referencedExports list of referenced exports
+	 * @param {Range} range expression range
+	 * @param {(string[][] | null)=} referencedExports list of referenced exports
+	 * @param {ImportAttributes=} attributes import attributes
 	 */
-	constructor(request, range, referencedExports) {
-		super(request, range, referencedExports);
+	constructor(request, range, referencedExports, attributes) {
+		super(request, range, referencedExports, attributes);
 		this.weak = true;
 	}
 
@@ -52,9 +57,9 @@ ImportWeakDependency.Template = class ImportDependencyTemplate extends (
 		const dep = /** @type {ImportWeakDependency} */ (dependency);
 		const content = runtimeTemplate.moduleNamespacePromise({
 			chunkGraph,
-			module: moduleGraph.getModule(dep),
+			module: /** @type {Module} */ (moduleGraph.getModule(dep)),
 			request: dep.request,
-			strict: module.buildMeta.strictHarmonyModule,
+			strict: /** @type {BuildMeta} */ (module.buildMeta).strictHarmonyModule,
 			message: "import() weak",
 			weak: true,
 			runtimeRequirements

package/lib/dependencies/JsonExportsDependency.js

@@ -13,41 +13,47 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../json/JsonData")} JsonData */
+/** @typedef {import("../json/JsonData").RawJsonData} RawJsonData */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 
+/**
+ * @param {RawJsonData} data data
+ * @returns {TODO} value
+ */
 const getExportsFromData = data => {
 	if (data && typeof data === "object") {
 		if (Array.isArray(data)) {
-			return data.map((item, idx) => {
-				return {
-					name: `${idx}`,
-					canMangle: true,
-					exports: getExportsFromData(item)
-				};
+			return data.length < 100
+				? data.map((item, idx) => ({
+						name: `${idx}`,
+						canMangle: true,
+						exports: getExportsFromData(item)
+					}))
+				: undefined;
+		}
+		const exports = [];
+		for (const key of Object.keys(data)) {
+			exports.push({
+				name: key,
+				canMangle: true,
+				exports: getExportsFromData(data[key])
 			});
-		} else {
-			const exports = [];
-			for (const key of Object.keys(data)) {
-				exports.push({
-					name: key,
-					canMangle: true,
-					exports: getExportsFromData(data[key])
-				});
-			}
-			return exports;
 		}
+		return exports;
 	}
 	return undefined;
 };
 
 class JsonExportsDependency extends NullDependency {
 	/**
-	 * @param {(string | ExportSpec)[]} exports json exports
+	 * @param {JsonData} data json data
 	 */
-	constructor(exports) {
+	constructor(data) {
 		super();
-		this.exports = exports;
-		this._hashUpdate = undefined;
+		this.data = data;
 	}
 
 	get type() {
@@ -61,7 +67,9 @@ class JsonExportsDependency extends NullDependency {
 	 */
 	getExports(moduleGraph) {
 		return {
-			exports: this.exports,
+			exports: getExportsFromData(
+				this.data && /** @type {RawJsonData} */ (this.data.get())
+			),
 			dependencies: undefined
 		};
 	}
@@ -73,23 +81,24 @@ class JsonExportsDependency extends NullDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		if (this._hashUpdate === undefined) {
-			this._hashUpdate = this.exports
-				? JSON.stringify(this.exports)
-				: "undefined";
-		}
-		hash.update(this._hashUpdate);
+		this.data.updateHash(hash);
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
-		write(this.exports);
+		write(this.data);
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
-		this.exports = read();
+		this.data = read();
 		super.deserialize(context);
 	}
 }
@@ -100,4 +109,3 @@ makeSerializable(
 );
 
 module.exports = JsonExportsDependency;
-module.exports.getExportsFromData = getExportsFromData;

package/lib/dependencies/LoaderDependency.js

@@ -7,6 +7,12 @@
 
 const ModuleDependency = require("./ModuleDependency");
 
+/** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
 class LoaderDependency extends ModuleDependency {
 	/**
 	 * @param {string} request request string
@@ -22,6 +28,14 @@ class LoaderDependency extends ModuleDependency {
 	get category() {
 		return "loader";
 	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | GetConditionFn} function to determine if the connection is active
+	 */
+	getCondition(moduleGraph) {
+		return false;
+	}
 }
 
 module.exports = LoaderDependency;

package/lib/dependencies/LoaderImportDependency.js

@@ -7,6 +7,12 @@
 
 const ModuleDependency = require("./ModuleDependency");
 
+/** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
 class LoaderImportDependency extends ModuleDependency {
 	/**
 	 * @param {string} request request string
@@ -23,6 +29,14 @@ class LoaderImportDependency extends ModuleDependency {
 	get category() {
 		return "loaderImport";
 	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | GetConditionFn} function to determine if the connection is active
+	 */
+	getCondition(moduleGraph) {
+		return false;
+	}
 }
 
 module.exports = LoaderImportDependency;

package/lib/dependencies/LoaderPlugin.js

@@ -10,33 +10,29 @@ const LazySet = require("../util/LazySet");
 const LoaderDependency = require("./LoaderDependency");
 const LoaderImportDependency = require("./LoaderImportDependency");
 
+/** @typedef {import("../../declarations/LoaderContext").LoaderPluginLoaderContext} LoaderPluginLoaderContext */
 /** @typedef {import("../Compilation").DepConstructor} DepConstructor */
+/** @typedef {import("../Compilation").ExecuteModuleResult} ExecuteModuleResult */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
-
-/**
- * @callback LoadModuleCallback
- * @param {Error=} err error object
- * @param {string | Buffer=} source source code
- * @param {object=} map source map
- * @param {Module=} module loaded module if successful
- */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
 
 /**
  * @callback ImportModuleCallback
- * @param {Error=} err error object
+ * @param {(Error | null)=} err error object
  * @param {any=} exports exports of the evaluated module
  */
 
 /**
- * @typedef {Object} ImportModuleOptions
+ * @typedef {object} ImportModuleOptions
  * @property {string=} layer the target layer
  * @property {string=} publicPath the target public path
+ * @property {string=} baseUri target base uri
  */
 
 class LoaderPlugin {
 	/**
-	 * @param {Object} options options
+	 * @param {object} options options
 	 */
 	constructor(options = {}) {}
 
@@ -65,11 +61,6 @@ class LoaderPlugin {
 			NormalModule.getCompilationHooks(compilation).loader.tap(
 				"LoaderPlugin",
 				loaderContext => {
-					/**
-					 * @param {string} request the request string to load the module from
-					 * @param {LoadModuleCallback} callback callback returning the loaded module or error
-					 * @returns {void}
-					 */
 					loaderContext.loadModule = (request, callback) => {
 						const dep = new LoaderDependency(request);
 						dep.loc = {
@@ -90,7 +81,9 @@ class LoaderPlugin {
 							{
 								factory,
 								dependencies: [dep],
-								originModule: loaderContext._module,
+								originModule:
+									/** @type {NormalModule} */
+									(loaderContext._module),
 								context: loaderContext.context,
 								recursive: false
 							},
@@ -116,7 +109,8 @@ class LoaderPlugin {
 										)
 									);
 								}
-								let source, map;
+								let map;
+								let source;
 								if (moduleSource.sourceAndMap) {
 									const sourceAndMap = moduleSource.sourceAndMap();
 									map = sourceAndMap.map;
@@ -148,15 +142,20 @@ class LoaderPlugin {
 								for (const d of buildDependencies) {
 									loaderContext.addBuildDependency(d);
 								}
-								return callback(null, source, map, referencedModule);
+								return callback(
+									null,
+									source,
+									/** @type {object | null} */ (map),
+									referencedModule
+								);
 							}
 						);
 					};
 
 					/**
 					 * @param {string} request the request string to load the module from
-					 * @param {ImportModuleOptions=} options options
-					 * @param {ImportModuleCallback=} callback callback returning the exports
+					 * @param {ImportModuleOptions} options options
+					 * @param {ImportModuleCallback} callback callback returning the exports
 					 * @returns {void}
 					 */
 					const importModule = (request, options, callback) => {
@@ -179,12 +178,15 @@ class LoaderPlugin {
 							{
 								factory,
 								dependencies: [dep],
-								originModule: loaderContext._module,
+								originModule:
+									/** @type {NormalModule} */
+									(loaderContext._module),
 								contextInfo: {
 									issuerLayer: options.layer
 								},
 								context: loaderContext.context,
-								connectOrigin: false
+								connectOrigin: false,
+								checkCycle: true
 							},
 							err => {
 								compilation.buildQueue.decreaseParallelism();
@@ -199,47 +201,59 @@ class LoaderPlugin {
 									referencedModule,
 									{
 										entryOptions: {
+											baseUri: options.baseUri,
 											publicPath: options.publicPath
 										}
 									},
 									(err, result) => {
 										if (err) return callback(err);
-										for (const d of result.fileDependencies) {
+										const {
+											fileDependencies,
+											contextDependencies,
+											missingDependencies,
+											buildDependencies,
+											cacheable,
+											assets,
+											exports
+										} = /** @type {ExecuteModuleResult} */ (result);
+										for (const d of fileDependencies) {
 											loaderContext.addDependency(d);
 										}
-										for (const d of result.contextDependencies) {
+										for (const d of contextDependencies) {
 											loaderContext.addContextDependency(d);
 										}
-										for (const d of result.missingDependencies) {
+										for (const d of missingDependencies) {
 											loaderContext.addMissingDependency(d);
 										}
-										for (const d of result.buildDependencies) {
+										for (const d of buildDependencies) {
 											loaderContext.addBuildDependency(d);
 										}
-										if (result.cacheable === false)
-											loaderContext.cacheable(false);
-										for (const [name, { source, info }] of result.assets) {
-											const { buildInfo } = loaderContext._module;
+										if (cacheable === false) loaderContext.cacheable(false);
+										for (const [name, { source, info }] of assets) {
+											const buildInfo =
+												/** @type {BuildInfo} */
+												(
+													/** @type {NormalModule} */ (loaderContext._module)
+														.buildInfo
+												);
 											if (!buildInfo.assets) {
 												buildInfo.assets = Object.create(null);
 												buildInfo.assetsInfo = new Map();
 											}
-											buildInfo.assets[name] = source;
-											buildInfo.assetsInfo.set(name, info);
+											/** @type {NonNullable<BuildInfo["assets"]>} */
+											(buildInfo.assets)[name] = source;
+											/** @type {NonNullable<BuildInfo["assetsInfo"]>} */
+											(buildInfo.assetsInfo).set(name, info);
 										}
-										callback(null, result.exports);
+										callback(null, exports);
 									}
 								);
 							}
 						);
 					};
 
-					/**
-					 * @param {string} request the request string to load the module from
-					 * @param {ImportModuleOptions} options options
-					 * @param {ImportModuleCallback=} callback callback returning the exports
-					 * @returns {Promise<any> | void} exports
-					 */
+					// eslint-disable-next-line no-warning-comments
+					// @ts-ignore Overloading doesn't work
 					loaderContext.importModule = (request, options, callback) => {
 						if (!callback) {
 							return new Promise((resolve, reject) => {

package/lib/dependencies/LocalModule.js

@@ -7,7 +7,14 @@
 
 const makeSerializable = require("../util/makeSerializable");
 
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
 class LocalModule {
+	/**
+	 * @param {string} name name
+	 * @param {number} idx index
+	 */
 	constructor(name, idx) {
 		this.name = name;
 		this.idx = idx;
@@ -18,10 +25,16 @@ class LocalModule {
 		this.used = true;
 	}
 
+	/**
+	 * @returns {string} variable name
+	 */
 	variableName() {
-		return "__WEBPACK_LOCAL_MODULE_" + this.idx + "__";
+		return `__WEBPACK_LOCAL_MODULE_${this.idx}__`;
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 
@@ -30,6 +43,9 @@ class LocalModule {
 		write(this.used);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 

package/lib/dependencies/LocalModuleDependency.js

@@ -11,8 +11,17 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./LocalModule")} LocalModule */
 
 class LocalModuleDependency extends NullDependency {
+	/**
+	 * @param {LocalModule} localModule local module
+	 * @param {Range | undefined} range range
+	 * @param {boolean} callNew true, when the local module should be called with new
+	 */
 	constructor(localModule, range, callNew) {
 		super();
 
@@ -21,6 +30,9 @@ class LocalModuleDependency extends NullDependency {
 		this.callNew = callNew;
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 
@@ -31,6 +43,9 @@ class LocalModuleDependency extends NullDependency {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 

package/lib/dependencies/LocalModulesHelpers.js

@@ -7,11 +7,18 @@
 
 const LocalModule = require("./LocalModule");
 
+/** @typedef {import("../javascript/JavascriptParser").ParserState} ParserState */
+
+/**
+ * @param {string} parent parent module
+ * @param {string} mod module to resolve
+ * @returns {string} resolved module
+ */
 const lookup = (parent, mod) => {
 	if (mod.charAt(0) !== ".") return mod;
 
-	var path = parent.split("/");
-	var segments = mod.split("/");
+	const path = parent.split("/");
+	const segments = mod.split("/");
 	path.pop();
 
 	for (let i = 0; i < segments.length; i++) {
@@ -26,7 +33,12 @@ const lookup = (parent, mod) => {
 	return path.join("/");
 };
 
-exports.addLocalModule = (state, name) => {
+/**
+ * @param {ParserState} state parser state
+ * @param {string} name name
+ * @returns {LocalModule} local module
+ */
+module.exports.addLocalModule = (state, name) => {
 	if (!state.localModules) {
 		state.localModules = [];
 	}
@@ -35,7 +47,13 @@ exports.addLocalModule = (state, name) => {
 	return m;
 };
 
-exports.getLocalModule = (state, name, namedModule) => {
+/**
+ * @param {ParserState} state parser state
+ * @param {string} name name
+ * @param {string} [namedModule] named module
+ * @returns {LocalModule | null} local module or null
+ */
+module.exports.getLocalModule = (state, name, namedModule) => {
 	if (!state.localModules) return null;
 	if (namedModule) {
 		// resolve dependency name relative to the defining named module

package/lib/dependencies/ModuleDecoratorDependency.js

@@ -18,6 +18,8 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
@@ -48,7 +50,7 @@ class ModuleDecoratorDependency extends NullDependency {
 	 * @returns {string | null} an identifier to merge equal requests
 	 */
 	getResourceIdentifier() {
-		return `self`;
+		return "self";
 	}
 
 	/**
@@ -76,6 +78,9 @@ class ModuleDecoratorDependency extends NullDependency {
 		hash.update(this._hashUpdate);
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 		write(this.decorator);
@@ -83,6 +88,9 @@ class ModuleDecoratorDependency extends NullDependency {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 		this.decorator = read();