webpack 5.59.0 → 5.94.0

package/lib/dependencies/HarmonyExportInitFragment.js

@@ -8,10 +8,15 @@
 const InitFragment = require("../InitFragment");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const { first } = require("../util/SetHelpers");
+const { propertyName } = require("../util/propertyName");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 
+/**
+ * @param {Iterable<string>} iterable iterable strings
+ * @returns {string} result
+ */
 const joinIterableWithComma = iterable => {
 	// This is more performant than Array.from().join(", ")
 	// as it doesn't create an array
@@ -32,7 +37,7 @@ const EMPTY_MAP = new Map();
 const EMPTY_SET = new Set();
 
 /**
- * @typedef {GenerateContext} Context
+ * @extends {InitFragment<GenerateContext>} Context
  */
 class HarmonyExportInitFragment extends InitFragment {
 	/**
@@ -98,6 +103,10 @@ class HarmonyExportInitFragment extends InitFragment {
 		);
 	}
 
+	/**
+	 * @param {HarmonyExportInitFragment} other other
+	 * @returns {HarmonyExportInitFragment} merged result
+	 */
 	merge(other) {
 		let exportMap;
 		if (this.exportMap.size === 0) {
@@ -129,8 +138,8 @@ class HarmonyExportInitFragment extends InitFragment {
 	}
 
 	/**
-	 * @param {Context} context context
-	 * @returns {string|Source} the source code that will be included as initialization code
+	 * @param {GenerateContext} context context
+	 * @returns {string | Source | undefined} the source code that will be included as initialization code
 	 */
 	getContent({ runtimeTemplate, runtimeRequirements }) {
 		runtimeRequirements.add(RuntimeGlobals.exports);
@@ -140,14 +149,17 @@ class HarmonyExportInitFragment extends InitFragment {
 			this.unusedExports.size > 1
 				? `/* unused harmony exports ${joinIterableWithComma(
 						this.unusedExports
-				  )} */\n`
+					)} */\n`
 				: this.unusedExports.size > 0
-				? `/* unused harmony export ${first(this.unusedExports)} */\n`
-				: "";
+					? `/* unused harmony export ${first(this.unusedExports)} */\n`
+					: "";
 		const definitions = [];
-		for (const [key, value] of this.exportMap) {
+		const orderedExportMap = Array.from(this.exportMap).sort(([a], [b]) =>
+			a < b ? -1 : 1
+		);
+		for (const [key, value] of orderedExportMap) {
 			definitions.push(
-				`\n/* harmony export */   ${JSON.stringify(
+				`\n/* harmony export */   ${propertyName(
 					key
 				)}: ${runtimeTemplate.returningFunction(value)}`
 			);
@@ -156,7 +168,7 @@ class HarmonyExportInitFragment extends InitFragment {
 			this.exportMap.size > 0
 				? `/* harmony export */ ${RuntimeGlobals.definePropertyGetters}(${
 						this.exportsArgument
-				  }, {${definitions.join(",")}\n/* harmony export */ });\n`
+					}, {${definitions.join(",")}\n/* harmony export */ });\n`
 				: "";
 		return `${definePart}${unusedPart}`;
 	}

package/lib/dependencies/HarmonyExportSpecifierDependency.js

@@ -15,8 +15,14 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
 class HarmonyExportSpecifierDependency extends NullDependency {
+	/**
+	 * @param {TODO} id id
+	 * @param {TODO} name name
+	 */
 	constructor(id, name) {
 		super();
 		this.id = id;
@@ -49,6 +55,9 @@ class HarmonyExportSpecifierDependency extends NullDependency {
 		return false;
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 		write(this.id);
@@ -56,6 +65,9 @@ class HarmonyExportSpecifierDependency extends NullDependency {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 		this.id = read();

package/lib/dependencies/HarmonyExports.js

@@ -5,6 +5,10 @@
 
 "use strict";
 
+const RuntimeGlobals = require("../RuntimeGlobals");
+
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Parser").ParserState} ParserState */
 
 /** @type {WeakMap<ParserState, boolean>} */
@@ -15,17 +19,19 @@ const parserStateExportsState = new WeakMap();
  * @param {boolean} isStrictHarmony strict harmony mode should be enabled
  * @returns {void}
  */
-exports.enable = (parserState, isStrictHarmony) => {
+module.exports.enable = (parserState, isStrictHarmony) => {
 	const value = parserStateExportsState.get(parserState);
 	if (value === false) return;
 	parserStateExportsState.set(parserState, true);
 	if (value !== true) {
-		parserState.module.buildMeta.exportsType = "namespace";
-		parserState.module.buildInfo.strict = true;
-		parserState.module.buildInfo.exportsArgument = "__webpack_exports__";
+		const buildMeta = /** @type {BuildMeta} */ (parserState.module.buildMeta);
+		buildMeta.exportsType = "namespace";
+		const buildInfo = /** @type {BuildInfo} */ (parserState.module.buildInfo);
+		buildInfo.strict = true;
+		buildInfo.exportsArgument = RuntimeGlobals.exports;
 		if (isStrictHarmony) {
-			parserState.module.buildMeta.strictHarmonyModule = true;
-			parserState.module.buildInfo.moduleArgument = "__webpack_module__";
+			buildMeta.strictHarmonyModule = true;
+			buildInfo.moduleArgument = "__webpack_module__";
 		}
 	}
 };
@@ -34,7 +40,7 @@ exports.enable = (parserState, isStrictHarmony) => {
  * @param {ParserState} parserState parser state
  * @returns {boolean} true, when enabled
  */
-exports.isEnabled = parserState => {
+module.exports.isEnabled = parserState => {
 	const value = parserStateExportsState.get(parserState);
 	return value === true;
 };

package/lib/dependencies/HarmonyImportDependency.js

@@ -20,24 +20,53 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ExportsInfo")} ExportsInfo */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
+const ExportPresenceModes = {
+	NONE: /** @type {0} */ (0),
+	WARN: /** @type {1} */ (1),
+	AUTO: /** @type {2} */ (2),
+	ERROR: /** @type {3} */ (3),
+	/**
+	 * @param {string | false} str param
+	 * @returns {0 | 1 | 2 | 3} result
+	 */
+	fromUserOption(str) {
+		switch (str) {
+			case "error":
+				return ExportPresenceModes.ERROR;
+			case "warn":
+				return ExportPresenceModes.WARN;
+			case "auto":
+				return ExportPresenceModes.AUTO;
+			case false:
+				return ExportPresenceModes.NONE;
+			default:
+				throw new Error(`Invalid export presence value ${str}`);
+		}
+	}
+};
+
 class HarmonyImportDependency extends ModuleDependency {
 	/**
-	 *
 	 * @param {string} request request string
 	 * @param {number} sourceOrder source order
-	 * @param {Record<string, any>=} assertions import assertions
+	 * @param {ImportAttributes=} attributes import attributes
 	 */
-	constructor(request, sourceOrder, assertions) {
+	constructor(request, sourceOrder, attributes) {
 		super(request);
 		this.sourceOrder = sourceOrder;
-		this.assertions = assertions;
+		this.assertions = attributes;
 	}
 
 	get category() {
@@ -59,16 +88,21 @@ class HarmonyImportDependency extends ModuleDependency {
 	 * @returns {string} name of the variable for the import
 	 */
 	getImportVar(moduleGraph) {
-		const module = moduleGraph.getParentModule(this);
-		const meta = moduleGraph.getMeta(module);
+		const module = /** @type {Module} */ (moduleGraph.getParentModule(this));
+		const meta = /** @type {TODO} */ (moduleGraph.getMeta(module));
 		let importVarMap = meta.importVarMap;
 		if (!importVarMap) meta.importVarMap = importVarMap = new Map();
-		let importVar = importVarMap.get(moduleGraph.getModule(this));
+		let importVar = importVarMap.get(
+			/** @type {Module} */ (moduleGraph.getModule(this))
+		);
 		if (importVar) return importVar;
 		importVar = `${Template.toIdentifier(
 			`${this.userRequest}`
 		)}__WEBPACK_IMPORTED_MODULE_${importVarMap.size}__`;
-		importVarMap.set(moduleGraph.getModule(this), importVar);
+		importVarMap.set(
+			/** @type {Module} */ (moduleGraph.getModule(this)),
+			importVar
+		);
 		return importVar;
 	}
 
@@ -83,7 +117,7 @@ class HarmonyImportDependency extends ModuleDependency {
 	) {
 		return runtimeTemplate.importStatement({
 			update,
-			module: moduleGraph.getModule(this),
+			module: /** @type {Module} */ (moduleGraph.getModule(this)),
 			chunkGraph,
 			importVar: this.getImportVar(moduleGraph),
 			request: this.request,
@@ -105,10 +139,12 @@ class HarmonyImportDependency extends ModuleDependency {
 			return;
 		}
 
-		const parentModule = moduleGraph.getParentModule(this);
+		const parentModule =
+			/** @type {Module} */
+			(moduleGraph.getParentModule(this));
 		const exportsType = importedModule.getExportsType(
 			moduleGraph,
-			parentModule.buildMeta.strictHarmonyModule
+			/** @type {BuildMeta} */ (parentModule.buildMeta).strictHarmonyModule
 		);
 		if (exportsType === "namespace" || exportsType === "default-with-named") {
 			if (ids.length === 0) {
@@ -133,8 +169,8 @@ class HarmonyImportDependency extends ModuleDependency {
 						const moreInfo = !Array.isArray(providedExports)
 							? " (possible exports unknown)"
 							: providedExports.length === 0
-							? " (module has no exports)"
-							: ` (possible exports: ${providedExports.join(", ")})`;
+								? " (module has no exports)"
+								: ` (possible exports: ${providedExports.join(", ")})`;
 						return [
 							new HarmonyLinkingError(
 								`export ${ids
@@ -146,7 +182,9 @@ class HarmonyImportDependency extends ModuleDependency {
 							)
 						];
 					}
-					exportsInfo = exportInfo.getNestedExportsInfo();
+					exportsInfo =
+						/** @type {ExportsInfo} */
+						(exportInfo.getNestedExportsInfo());
 				}
 
 				// General error message
@@ -183,7 +221,8 @@ class HarmonyImportDependency extends ModuleDependency {
 				if (
 					ids.length > 0 &&
 					ids[0] !== "default" &&
-					importedModule.buildMeta.defaultObject === "redirect-warn"
+					/** @type {BuildMeta} */
+					(importedModule.buildMeta).defaultObject === "redirect-warn"
 				) {
 					// For these modules only the default export is supported
 					return [
@@ -200,6 +239,9 @@ class HarmonyImportDependency extends ModuleDependency {
 		}
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 		write(this.sourceOrder);
@@ -207,6 +249,9 @@ class HarmonyImportDependency extends ModuleDependency {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 		this.sourceOrder = read();
@@ -257,8 +302,8 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 		const runtimeCondition = dep.weak
 			? false
 			: connection
-			? filterRuntime(runtime, r => connection.isTargetActive(r))
-			: true;
+				? filterRuntime(runtime, r => connection.isTargetActive(r))
+				: true;
 
 		if (module && referencedModule) {
 			let emittedModules = importEmittedMap.get(module);
@@ -305,7 +350,7 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 					importStatement[1],
 					InitFragment.STAGE_ASYNC_HARMONY_IMPORTS,
 					dep.sourceOrder,
-					key + " compat",
+					`${key} compat`,
 					runtimeCondition
 				)
 			);
@@ -323,7 +368,6 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 	}
 
 	/**
-	 *
 	 * @param {Module} module the module
 	 * @param {Module} referencedModule the referenced module
 	 * @returns {RuntimeSpec | boolean} runtimeCondition in which this import has been emitted
@@ -334,3 +378,5 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 		return emittedModules.get(referencedModule) || false;
 	}
 };
+
+module.exports.ExportPresenceModes = ExportPresenceModes;