webpack 5.72.0 → 5.74.0

package/lib/dependencies/ContextElementDependency.js

@@ -49,20 +49,6 @@ class ContextElementDependency extends ModuleDependency {
 		return "context element";
 	}
 
-	/**
-	 * @returns {string | undefined} a request context
-	 */
-	getContext() {
-		return this._context;
-	}
-
-	/**
-	 * @returns {string | null} an identifier to merge equal requests
-	 */
-	getResourceIdentifier() {
-		return `context${this._context || ""}|${super.getResourceIdentifier()}`;
-	}
-
 	get category() {
 		return this._category;
 	}
@@ -86,7 +72,6 @@ class ContextElementDependency extends ModuleDependency {
 		const { write } = context;
 		write(this._typePrefix);
 		write(this._category);
-		write(this._context);
 		write(this.referencedExports);
 		super.serialize(context);
 	}
@@ -95,7 +80,6 @@ class ContextElementDependency extends ModuleDependency {
 		const { read } = context;
 		this._typePrefix = read();
 		this._category = read();
-		this._context = read();
 		this.referencedExports = read();
 		super.deserialize(context);
 	}

package/lib/dependencies/HarmonyEvaluatedImportSpecifierDependency.js

@@ -61,17 +61,49 @@ HarmonyEvaluatedImportSpecifierDependency.Template = class HarmonyEvaluatedImpor
 		const dep = /** @type {HarmonyEvaluatedImportSpecifierDependency} */ (
 			dependency
 		);
-		const { moduleGraph, runtime } = templateContext;
+		const { module, moduleGraph, runtime } = templateContext;
 		const connection = moduleGraph.getConnection(dep);
 		// Skip rendering depending when dependency is conditional
 		if (connection && !connection.isTargetActive(runtime)) return;
 
 		const exportsInfo = moduleGraph.getExportsInfo(connection.module);
 		const ids = dep.getIds(moduleGraph);
-		const value = exportsInfo.isExportProvided(ids);
+
+		let value;
+
+		const exportsType = connection.module.getExportsType(
+			moduleGraph,
+			module.buildMeta.strictHarmonyModule
+		);
+		switch (exportsType) {
+			case "default-with-named": {
+				if (ids[0] === "default") {
+					value =
+						ids.length === 1 || exportsInfo.isExportProvided(ids.slice(1));
+				} else {
+					value = exportsInfo.isExportProvided(ids);
+				}
+				break;
+			}
+			case "namespace": {
+				if (ids[0] === "__esModule") {
+					value = ids.length === 1 || undefined;
+				} else {
+					value = exportsInfo.isExportProvided(ids);
+				}
+				break;
+			}
+			case "dynamic": {
+				if (ids[0] !== "default") {
+					value = exportsInfo.isExportProvided(ids);
+				}
+				break;
+			}
+			// default-only could lead to runtime error, when default value is primitive
+		}
 
 		if (typeof value === "boolean") {
-			source.replace(dep.range[0], dep.range[1] - 1, `${value}`);
+			source.replace(dep.range[0], dep.range[1] - 1, ` ${value}`);
 		} else {
 			const usedName = exportsInfo.getUsedName(ids, runtime);
 

package/lib/dependencies/ImportParserPlugin.js

@@ -14,10 +14,14 @@ const ImportDependency = require("./ImportDependency");
 const ImportEagerDependency = require("./ImportEagerDependency");
 const ImportWeakDependency = require("./ImportWeakDependency");
 
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
 /** @typedef {import("../ContextModule").ContextMode} ContextMode */
 
 class ImportParserPlugin {
+	/**
+	 * @param {JavascriptParserOptions} options options
+	 */
 	constructor(options) {
 		this.options = options;
 	}
@@ -28,7 +32,7 @@ class ImportParserPlugin {
 
 			let chunkName = null;
 			/** @type {ContextMode} */
-			let mode = "lazy";
+			let mode = this.options.dynamicImportMode;
 			let include = null;
 			let exclude = null;
 			/** @type {string[][] | null} */
@@ -36,6 +40,17 @@ class ImportParserPlugin {
 			/** @type {RawChunkGroupOptions} */
 			const groupOptions = {};
 
+			const { dynamicImportPreload, dynamicImportPrefetch } = this.options;
+			if (dynamicImportPreload !== undefined && dynamicImportPreload !== false)
+				groupOptions.preloadOrder =
+					dynamicImportPreload === true ? 0 : dynamicImportPreload;
+			if (
+				dynamicImportPrefetch !== undefined &&
+				dynamicImportPrefetch !== false
+			)
+				groupOptions.prefetchOrder =
+					dynamicImportPrefetch === true ? 0 : dynamicImportPrefetch;
+
 			const { options: importOptions, errors: commentErrors } =
 				parser.parseCommentOptions(expr.range);
 
@@ -175,16 +190,22 @@ class ImportParserPlugin {
 				}
 			}
 
-			if (param.isString()) {
-				if (mode !== "lazy" && mode !== "eager" && mode !== "weak") {
-					parser.state.module.addWarning(
-						new UnsupportedFeatureWarning(
-							`\`webpackMode\` expected 'lazy', 'eager' or 'weak', but received: ${mode}.`,
-							expr.loc
-						)
-					);
-				}
+			if (
+				mode !== "lazy" &&
+				mode !== "lazy-once" &&
+				mode !== "eager" &&
+				mode !== "weak"
+			) {
+				parser.state.module.addWarning(
+					new UnsupportedFeatureWarning(
+						`\`webpackMode\` expected 'lazy', 'lazy-once', 'eager' or 'weak', but received: ${mode}.`,
+						expr.loc
+					)
+				);
+				mode = "lazy";
+			}
 
+			if (param.isString()) {
 				if (mode === "eager") {
 					const dep = new ImportEagerDependency(
 						param.string,
@@ -215,21 +236,6 @@ class ImportParserPlugin {
 				}
 				return true;
 			} else {
-				if (
-					mode !== "lazy" &&
-					mode !== "lazy-once" &&
-					mode !== "eager" &&
-					mode !== "weak"
-				) {
-					parser.state.module.addWarning(
-						new UnsupportedFeatureWarning(
-							`\`webpackMode\` expected 'lazy', 'lazy-once', 'eager' or 'weak', but received: ${mode}.`,
-							expr.loc
-						)
-					);
-					mode = "lazy";
-				}
-
 				if (mode === "weak") {
 					mode = "async-weak";
 				}

package/lib/dependencies/JsonExportsDependency.js

@@ -13,18 +13,21 @@ 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("../util/Hash")} Hash */
 
 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) => {
+						return {
+							name: `${idx}`,
+							canMangle: true,
+							exports: getExportsFromData(item)
+						};
+				  })
+				: undefined;
 		} else {
 			const exports = [];
 			for (const key of Object.keys(data)) {
@@ -42,12 +45,11 @@ const getExportsFromData = data => {
 
 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 +63,7 @@ class JsonExportsDependency extends NullDependency {
 	 */
 	getExports(moduleGraph) {
 		return {
-			exports: this.exports,
+			exports: getExportsFromData(this.data && this.data.get()),
 			dependencies: undefined
 		};
 	}
@@ -73,23 +75,18 @@ 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);
 	}
 
 	serialize(context) {
 		const { write } = context;
-		write(this.exports);
+		write(this.data);
 		super.serialize(context);
 	}
 
 	deserialize(context) {
 		const { read } = context;
-		this.exports = read();
+		this.data = read();
 		super.deserialize(context);
 	}
 }
@@ -100,4 +97,3 @@ makeSerializable(
 );
 
 module.exports = JsonExportsDependency;
-module.exports.getExportsFromData = getExportsFromData;

package/lib/dependencies/LoaderDependency.js

@@ -7,6 +7,11 @@
 
 const ModuleDependency = require("./ModuleDependency");
 
+/** @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 +27,14 @@ class LoaderDependency extends ModuleDependency {
 	get category() {
 		return "loader";
 	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+	 */
+	getCondition(moduleGraph) {
+		return false;
+	}
 }
 
 module.exports = LoaderDependency;

package/lib/dependencies/LoaderImportDependency.js

@@ -7,6 +7,11 @@
 
 const ModuleDependency = require("./ModuleDependency");
 
+/** @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 +28,14 @@ class LoaderImportDependency extends ModuleDependency {
 	get category() {
 		return "loaderImport";
 	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+	 */
+	getCondition(moduleGraph) {
+		return false;
+	}
 }
 
 module.exports = LoaderImportDependency;

package/lib/dependencies/ModuleDependency.js

@@ -26,13 +26,21 @@ class ModuleDependency extends Dependency {
 		// assertions must be serialized by subclasses that use it
 		/** @type {Record<string, any> | undefined} */
 		this.assertions = undefined;
+		this._context = undefined;
+	}
+
+	/**
+	 * @returns {string | undefined} a request context
+	 */
+	getContext() {
+		return this._context;
 	}
 
 	/**
 	 * @returns {string | null} an identifier to merge equal requests
 	 */
 	getResourceIdentifier() {
-		let str = `module${this.request}`;
+		let str = `context${this._context || ""}|module${this.request}`;
 		if (this.assertions !== undefined) {
 			str += JSON.stringify(this.assertions);
 		}
@@ -63,6 +71,7 @@ class ModuleDependency extends Dependency {
 		const { write } = context;
 		write(this.request);
 		write(this.userRequest);
+		write(this._context);
 		write(this.range);
 		super.serialize(context);
 	}
@@ -71,6 +80,7 @@ class ModuleDependency extends Dependency {
 		const { read } = context;
 		this.request = read();
 		this.userRequest = read();
+		this._context = read();
 		this.range = read();
 		super.deserialize(context);
 	}

package/lib/dependencies/ProvidedDependency.js

@@ -5,19 +5,21 @@
 
 "use strict";
 
+const Dependency = require("../Dependency");
 const InitFragment = require("../InitFragment");
 const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
  * @param {string[]|null} path the property path array
@@ -29,10 +31,16 @@ const pathToString = path =>
 		: "";
 
 class ProvidedDependency extends ModuleDependency {
-	constructor(request, identifier, path, range) {
+	/**
+	 * @param {string} request request
+	 * @param {string} identifier identifier
+	 * @param {string[]} ids ids
+	 * @param {[number, number]} range range
+	 */
+	constructor(request, identifier, ids, range) {
 		super(request);
 		this.identifier = identifier;
-		this.path = path;
+		this.ids = ids;
 		this.range = range;
 		this._hashUpdate = undefined;
 	}
@@ -45,6 +53,18 @@ class ProvidedDependency extends ModuleDependency {
 		return "esm";
 	}
 
+	/**
+	 * 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
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		let ids = this.ids;
+		if (ids.length === 0) return Dependency.EXPORTS_OBJECT_REFERENCED;
+		return [ids];
+	}
+
 	/**
 	 * Update the hash
 	 * @param {Hash} hash hash to be updated
@@ -53,8 +73,7 @@ class ProvidedDependency extends ModuleDependency {
 	 */
 	updateHash(hash, context) {
 		if (this._hashUpdate === undefined) {
-			this._hashUpdate =
-				this.identifier + (this.path ? this.path.join(",") : "null");
+			this._hashUpdate = this.identifier + (this.ids ? this.ids.join(",") : "");
 		}
 		hash.update(this._hashUpdate);
 	}
@@ -62,14 +81,14 @@ class ProvidedDependency extends ModuleDependency {
 	serialize(context) {
 		const { write } = context;
 		write(this.identifier);
-		write(this.path);
+		write(this.ids);
 		super.serialize(context);
 	}
 
 	deserialize(context) {
 		const { read } = context;
 		this.identifier = read();
-		this.path = read();
+		this.ids = read();
 		super.deserialize(context);
 	}
 }
@@ -90,6 +109,7 @@ class ProvidedDependencyTemplate extends ModuleDependency.Template {
 		dependency,
 		source,
 		{
+			runtime,
 			runtimeTemplate,
 			moduleGraph,
 			chunkGraph,
@@ -98,6 +118,9 @@ class ProvidedDependencyTemplate extends ModuleDependency.Template {
 		}
 	) {
 		const dep = /** @type {ProvidedDependency} */ (dependency);
+		const connection = moduleGraph.getConnection(dep);
+		const exportsInfo = moduleGraph.getExportsInfo(connection.module);
+		const usedName = exportsInfo.getUsedName(dep.ids, runtime);
 		initFragments.push(
 			new InitFragment(
 				`/* provided dependency */ var ${
@@ -107,7 +130,7 @@ class ProvidedDependencyTemplate extends ModuleDependency.Template {
 					chunkGraph,
 					request: dep.request,
 					runtimeRequirements
-				})}${pathToString(dep.path)};\n`,
+				})}${pathToString(/** @type {string[]} */ (usedName))};\n`,
 				InitFragment.STAGE_PROVIDES,
 				1,
 				`provided ${dep.identifier}`

package/lib/dependencies/RequireResolveContextDependency.js

@@ -10,8 +10,8 @@ const ContextDependency = require("./ContextDependency");
 const ContextDependencyTemplateAsId = require("./ContextDependencyTemplateAsId");
 
 class RequireResolveContextDependency extends ContextDependency {
-	constructor(options, range, valueRange) {
-		super(options);
+	constructor(options, range, valueRange, context) {
+		super(options, context);
 
 		this.range = range;
 		this.valueRange = valueRange;

package/lib/dependencies/RequireResolveDependency.js

@@ -15,10 +15,11 @@ const ModuleDependencyAsId = require("./ModuleDependencyTemplateAsId");
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 class RequireResolveDependency extends ModuleDependency {
-	constructor(request, range) {
+	constructor(request, range, context) {
 		super(request);
 
 		this.range = range;
+		this._context = context;
 	}
 
 	get type() {

package/lib/dependencies/URLPlugin.js

@@ -5,12 +5,15 @@
 
 "use strict";
 
+const { pathToFileURL } = require("url");
+const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
 const { approve } = require("../javascript/JavascriptParserHelpers");
 const InnerGraph = require("../optimize/InnerGraph");
 const URLDependency = require("./URLDependency");
 
 /** @typedef {import("estree").NewExpression} NewExpressionNode */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 
 class URLPlugin {
@@ -27,6 +30,13 @@ class URLPlugin {
 					new URLDependency.Template()
 				);
 
+				/**
+				 * @param {NormalModule} module module
+				 * @returns {URL} file url
+				 */
+				const getUrl = module => {
+					return pathToFileURL(module.resource);
+				};
 				/**
 				 * @param {JavascriptParser} parser parser
 				 * @param {object} parserOptions options
@@ -67,6 +77,17 @@ class URLPlugin {
 					};
 
 					parser.hooks.canRename.for("URL").tap("URLPlugin", approve);
+					parser.hooks.evaluateNewExpression
+						.for("URL")
+						.tap("URLPlugin", expr => {
+							const request = getUrlRequest(expr);
+							if (!request) return;
+							const url = new URL(request, getUrl(parser.state.module));
+
+							return new BasicEvaluatedExpression()
+								.setString(url.toString())
+								.setRange(expr.range);
+						});
 					parser.hooks.new.for("URL").tap("URLPlugin", _expr => {
 						const expr = /** @type {NewExpressionNode} */ (_expr);
 

package/lib/index.js

@@ -28,6 +28,7 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./Compilation").Asset} Asset */
 /** @typedef {import("./Compilation").AssetInfo} AssetInfo */
 /** @typedef {import("./Compilation").EntryOptions} EntryOptions */
+/** @typedef {import("./Compilation").PathData} PathData */
 /** @typedef {import("./Compiler").AssetEmittedInfo} AssetEmittedInfo */
 /** @typedef {import("./MultiStats")} MultiStats */
 /** @typedef {import("./Parser").ParserState} ParserState */
@@ -341,6 +342,9 @@ module.exports = mergeExports(fn, {
 		get ModuleDependency() {
 			return require("./dependencies/ModuleDependency");
 		},
+		get HarmonyImportDependency() {
+			return require("./dependencies/HarmonyImportDependency");
+		},
 		get ConstDependency() {
 			return require("./dependencies/ConstDependency");
 		},