@depup/webpack 5.106.1-depup.0 → 5.109.2-depup.0

package/lib/dependencies/HarmonyExportInitFragment.js

@@ -15,6 +15,7 @@ const { propertyName } = require("../util/property");
 /** @typedef {import("../ExportsInfo").UsedName} UsedName */
 
 /**
+ * Join iterable with comma.
  * @param {Iterable<string>} iterable iterable strings
  * @returns {string} result
  */
@@ -43,10 +44,12 @@ const EMPTY_MAP = new Map();
 const EMPTY_SET = new Set();
 
 /**
+ * Represents HarmonyExportInitFragment.
  * @extends {InitFragment<GenerateContext>} Context
  */
 class HarmonyExportInitFragment extends InitFragment {
 	/**
+	 * Creates an instance of HarmonyExportInitFragment.
 	 * @param {string} exportsArgument the exports identifier
 	 * @param {ExportMap} exportMap mapping from used name to exposed variable name
 	 * @param {UnusedExports} unusedExports list of unused export names
@@ -66,6 +69,7 @@ class HarmonyExportInitFragment extends InitFragment {
 	}
 
 	/**
+	 * Merges the provided values into a single result.
 	 * @param {HarmonyExportInitFragment[]} fragments all fragments to merge
 	 * @returns {HarmonyExportInitFragment} merged fragment
 	 */
@@ -115,6 +119,7 @@ class HarmonyExportInitFragment extends InitFragment {
 	}
 
 	/**
+	 * Returns merged result.
 	 * @param {HarmonyExportInitFragment} other other
 	 * @returns {HarmonyExportInitFragment} merged result
 	 */
@@ -151,13 +156,11 @@ class HarmonyExportInitFragment extends InitFragment {
 	}
 
 	/**
+	 * Returns 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);
-		runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
-
 		const unusedPart =
 			this.unusedExports.size > 1
 				? `/* unused harmony exports ${joinIterableWithComma(
@@ -166,24 +169,29 @@ class HarmonyExportInitFragment extends InitFragment {
 				: this.unusedExports.size > 0
 					? `/* unused harmony export ${first(this.unusedExports)} */\n`
 					: "";
-		/** @type {string[]} */
-		const definitions = [];
-		const orderedExportMap = [...this.exportMap].sort(([a], [b]) =>
-			a < b ? -1 : 1
-		);
-		for (const [key, value] of orderedExportMap) {
-			definitions.push(
-				`\n/* harmony export */   ${propertyName(
-					/** @type {string} */ (key)
-				)}: ${runtimeTemplate.returningFunction(value)}`
-			);
+		let definePart = "";
+		if (this.exportMap.size > 0) {
+			/** @type {string[]} */
+			const definitions = [];
+			const orderedExportMap =
+				this.exportMap.size > 1
+					? [...this.exportMap].sort(([a], [b]) => (a < b ? -1 : 1))
+					: this.exportMap;
+			for (const [key, value] of orderedExportMap) {
+				definitions.push(
+					`\n/* harmony export */   ${propertyName(
+						/** @type {string} */ (key)
+					)}: ${runtimeTemplate.returningFunction(value)}`
+				);
+			}
+			runtimeRequirements.add(RuntimeGlobals.exports);
+			runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+			definePart = `/* harmony export */ ${
+				RuntimeGlobals.definePropertyGetters
+			}(${this.exportsArgument}, {${definitions.join(
+				","
+			)}\n/* harmony export */ });\n`;
 		}
-		const definePart =
-			this.exportMap.size > 0
-				? `/* harmony export */ ${RuntimeGlobals.definePropertyGetters}(${
-						this.exportsArgument
-					}, {${definitions.join(",")}\n/* harmony export */ });\n`
-				: "";
 		return `${definePart}${unusedPart}`;
 	}
 }

package/lib/dependencies/HarmonyExportSpecifierDependency.js

@@ -5,44 +5,84 @@
 
 "use strict";
 
+const Dependency = require("../Dependency");
+const { InlinedUsedName } = require("../optimize/InlineExports");
 const makeSerializable = require("../util/makeSerializable");
+const ExportBindingInitFragment = require("./ExportBindingInitFragment");
 const HarmonyExportInitFragment = require("./HarmonyExportInitFragment");
 const NullDependency = require("./NullDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").LazyUntil} LazyUntil */
 /** @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 */
+/** @typedef {import("../optimize/InlineExports").InlinedValue} InlinedValue */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[string, string, InlinedValue | null | undefined]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[string, string, InlinedValue | null | undefined]>} ObjectSerializerContext */
 /** @typedef {import("./HarmonyExportInitFragment").UnusedExports} UnusedExports */
 /** @typedef {import("./HarmonyExportInitFragment").ExportMap} ExportMap */
+/** @typedef {import("../javascript/JavascriptModule").JavascriptModuleBuildInfo} JavascriptModuleBuildInfo */
 
 class HarmonyExportSpecifierDependency extends NullDependency {
 	/**
+	 * Creates an instance of HarmonyExportSpecifierDependency.
 	 * @param {string} id the id
 	 * @param {string} name the name
+	 * @param {InlinedValue | null=} constValue undefined = not const, null = const but not inline-eligible, InlinedValue = const and inline-eligible
 	 */
-	constructor(id, name) {
+	constructor(id, name, constValue) {
 		super();
+		/** @type {string} */
 		this.id = id;
+		/** @type {string} */
 		this.name = name;
+		/** @type {InlinedValue | null | undefined} */
+		this.constValue = constValue;
 	}
 
 	get type() {
 		return "harmony export specifier";
 	}
 
+	/**
+	 * Returns how this dependency may be deferred when its parent module is side-effect-free (lazy barrel optimization).
+	 * @returns {LazyUntil | null} lazy classification, null when it must be processed eagerly
+	 */
+	getLazyUntil() {
+		return Dependency.LAZY_UNTIL_LOCAL;
+	}
+
+	/**
+	 * Returns the export name for a `LAZY_UNTIL_LOCAL`/`LAZY_UNTIL_ID` classification (lazy barrel optimization).
+	 * @returns {string | null} export name, null when not applicable
+	 */
+	getLazyName() {
+		return this.name;
+	}
+
 	/**
 	 * Returns the exported names
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @returns {ExportsSpec | undefined} export names
 	 */
 	getExports(moduleGraph) {
+		const module = moduleGraph.getParentModule(this);
+		const pureFunctions =
+			module &&
+			module.buildInfo &&
+			/** @type {JavascriptModuleBuildInfo} */ (module.buildInfo).pureFunctions;
+		const isPure = Boolean(pureFunctions && pureFunctions.has(this.id));
+
 		return {
-			exports: [this.name],
+			exports: [
+				{
+					name: this.name,
+					isPure: isPure || undefined,
+					inlined: this.constValue || undefined
+				}
+			],
 			priority: 1,
 			terminalBinding: true,
 			dependencies: undefined
@@ -50,6 +90,7 @@ class HarmonyExportSpecifierDependency extends NullDependency {
 	}
 
 	/**
+	 * Gets module evaluation side effects state.
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
 	 */
@@ -58,23 +99,25 @@ class HarmonyExportSpecifierDependency extends NullDependency {
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-		write(this.id);
-		write(this.name);
+		context.write(this.id).write(this.name).write(this.constValue);
 		super.serialize(context);
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-		this.id = read();
-		this.name = read();
-		super.deserialize(context);
+		this.id = context.read();
+		const c1 = context.rest;
+		this.name = c1.read();
+		const c2 = c1.rest;
+		this.constValue = c2.read();
+		super.deserialize(c2.rest);
 	}
 }
 
@@ -87,6 +130,7 @@ HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependen
 	NullDependency.Template
 ) {
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Dependency} dependency the dependency for which the template should be applied
 	 * @param {ReplaceSource} source the current replace source which can be modified
 	 * @param {DependencyTemplateContext} templateContext the context object
@@ -115,12 +159,38 @@ HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependen
 			return;
 		}
 
-		/** @type {ExportMap} */
-		const map = new Map();
-		map.set(used, `/* binding */ ${dep.id}`);
-		initFragments.push(
-			new HarmonyExportInitFragment(module.exportsArgument, map, undefined)
-		);
+		if (used instanceof InlinedUsedName) {
+			// Inlined: importing side substitutes the literal directly, skip export init
+			return;
+		}
+
+		const canUseValueBinding =
+			dep.constValue !== undefined &&
+			/** @type {import("../Module").BuildInfo} */ (module.buildInfo)
+				.isCircular === false;
+
+		if (canUseValueBinding) {
+			initFragments.push(
+				new ExportBindingInitFragment(
+					module.exportsArgument,
+					[
+						{
+							name: used,
+							value: `/* binding */ ${dep.id}`,
+							bindingType: "value"
+						}
+					],
+					true
+				)
+			);
+		} else {
+			/** @type {ExportMap} */
+			const map = new Map();
+			map.set(used, `/* binding */ ${dep.id}`);
+			initFragments.push(
+				new HarmonyExportInitFragment(module.exportsArgument, map, undefined)
+			);
+		}
 	}
 };
 

package/lib/dependencies/HarmonyExports.js

@@ -9,12 +9,14 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 
 /** @typedef {import("../Module").BuildInfo} BuildInfo */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../javascript/JavascriptModule").JavascriptModuleBuildMeta} JavascriptModuleBuildMeta */
 /** @typedef {import("../javascript/JavascriptParser").JavascriptParserState} JavascriptParserState */
 
 /** @type {WeakMap<JavascriptParserState, boolean>} */
 const parserStateExportsState = new WeakMap();
 
 /**
+ * Processes the provided parser state.
  * @param {JavascriptParserState} parserState parser state
  * @param {boolean} isStrictHarmony strict harmony mode should be enabled
  * @returns {void}
@@ -24,7 +26,9 @@ module.exports.enable = (parserState, isStrictHarmony) => {
 	if (value === false) return;
 	parserStateExportsState.set(parserState, true);
 	if (value !== true) {
-		const buildMeta = /** @type {BuildMeta} */ (parserState.module.buildMeta);
+		const buildMeta =
+			/** @type {JavascriptModuleBuildMeta} */
+			(parserState.module.buildMeta);
 		buildMeta.exportsType = "namespace";
 		const buildInfo = /** @type {BuildInfo} */ (parserState.module.buildInfo);
 		buildInfo.strict = true;
@@ -37,6 +41,7 @@ module.exports.enable = (parserState, isStrictHarmony) => {
 };
 
 /**
+ * Returns true, when enabled.
  * @param {JavascriptParserState} parserState parser state
  * @returns {boolean} true, when enabled
  */

package/lib/dependencies/HarmonyImportDependency.js

@@ -7,11 +7,12 @@
 
 const ConditionalInitFragment = require("../ConditionalInitFragment");
 const Dependency = require("../Dependency");
-const HarmonyLinkingError = require("../HarmonyLinkingError");
 const InitFragment = require("../InitFragment");
 const Template = require("../Template");
 const AwaitDependenciesInitFragment = require("../async-modules/AwaitDependenciesInitFragment");
+const isGeneratorLowered = require("../async-modules/isGeneratorLowered");
 const { filterRuntime, mergeRuntime } = require("../util/runtime");
+const HarmonyLinkingError = require("./HarmonyLinkingError");
 const { ImportPhase, ImportPhaseUtils } = require("./ImportPhase");
 const ModuleDependency = require("./ModuleDependency");
 
@@ -23,7 +24,7 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../errors/WebpackError")} WebpackError */
 /** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
 /** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
@@ -38,6 +39,7 @@ const ExportPresenceModes = {
 	AUTO: /** @type {ExportPresenceMode} */ (2),
 	ERROR: /** @type {ExportPresenceMode} */ (3),
 	/**
+	 * Returns result.
 	 * @param {string | false} str param
 	 * @returns {ExportPresenceMode} result
 	 */
@@ -90,6 +92,7 @@ const getNonOptionalPart = (members, membersOptionals) => {
 
 class HarmonyImportDependency extends ModuleDependency {
 	/**
+	 * Creates an instance of HarmonyImportDependency.
 	 * @param {string} request request string
 	 * @param {number} sourceOrder source order
 	 * @param {ImportPhaseType=} phase import phase
@@ -102,8 +105,12 @@ class HarmonyImportDependency extends ModuleDependency {
 		attributes = undefined
 	) {
 		super(request, sourceOrder);
+		/** @type {ImportPhaseType} */
 		this.phase = phase;
+		/** @type {ImportAttributes | undefined} */
 		this.attributes = attributes;
+		/** @type {boolean} */
+		this._lazyMake = false;
 	}
 
 	get category() {
@@ -111,6 +118,31 @@ class HarmonyImportDependency extends ModuleDependency {
 	}
 
 	/**
+	 * Whether the lazy barrel currently defers creating this dependency's target module (lazy barrel optimization).
+	 * @returns {boolean} true while deferred, so it must not be processed or rendered
+	 */
+	isLazy() {
+		return this._lazyMake;
+	}
+
+	/**
+	 * Sets whether the lazy barrel defers creating this dependency's target module (lazy barrel optimization).
+	 * @param {boolean} value true to defer, false to create it now
+	 */
+	setLazy(value) {
+		this._lazyMake = value;
+	}
+
+	/**
+	 * Returns true if this dependency can be concatenated
+	 * @returns {boolean} true if this dependency can be concatenated
+	 */
+	canConcatenate() {
+		return true;
+	}
+
+	/**
+	 * Returns an identifier to merge equal requests.
 	 * @returns {string | null} an identifier to merge equal requests
 	 */
 	getResourceIdentifier() {
@@ -136,6 +168,7 @@ class HarmonyImportDependency extends ModuleDependency {
 	}
 
 	/**
+	 * Returns name of the variable for the import.
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @returns {string} name of the variable for the import
 	 */
@@ -158,7 +191,7 @@ class HarmonyImportDependency extends ModuleDependency {
 
 		let importVar = importVarMap.get(importedModule);
 		if (importVar) return importVar;
-		importVar = `${Template.toIdentifier(`${this.userRequest}`)}__WEBPACK_${
+		importVar = `${Template.toIdentifier(this.userRequest)}__WEBPACK_${
 			isDeferred ? "DEFERRED_" : ""
 		}IMPORTED_MODULE_${importVarMap.size}__`;
 		importVarMap.set(importedModule, importVar);
@@ -166,6 +199,7 @@ class HarmonyImportDependency extends ModuleDependency {
 	}
 
 	/**
+	 * Gets module exports.
 	 * @param {DependencyTemplateContext} context the template context
 	 * @returns {string} the expression
 	 */
@@ -184,6 +218,7 @@ class HarmonyImportDependency extends ModuleDependency {
 	}
 
 	/**
+	 * Gets import statement.
 	 * @param {boolean} update create new variables or update existing one
 	 * @param {DependencyTemplateContext} templateContext the template context
 	 * @returns {[string, string]} the import statement and the compat statement
@@ -206,6 +241,7 @@ class HarmonyImportDependency extends ModuleDependency {
 	}
 
 	/**
+	 * Gets linking errors.
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @param {Ids} ids imported ids
 	 * @param {string} additionalMessage extra info included in the error message
@@ -324,22 +360,26 @@ class HarmonyImportDependency extends ModuleDependency {
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
 		const { write } = context;
 		write(this.attributes);
 		write(this.phase);
+		write(this._lazyMake);
 		super.serialize(context);
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
 		const { read } = context;
 		this.attributes = read();
 		this.phase = read();
+		this._lazyMake = read();
 		super.deserialize(context);
 	}
 }
@@ -353,6 +393,7 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 	ModuleDependency.Template
 ) {
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Dependency} dependency the dependency for which the template should be applied
 	 * @param {ReplaceSource} source the current replace source which can be modified
 	 * @param {DependencyTemplateContext} templateContext the context object
@@ -363,6 +404,10 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 		const { module, chunkGraph, moduleGraph, runtime } = templateContext;
 
 		const connection = moduleGraph.getConnection(dep);
+		// deferred by lazy barrel: never resolved, must not render a missing module
+		if (connection === undefined && dep.isLazy()) {
+			return;
+		}
 		if (connection && !connection.isTargetActive(runtime)) return;
 
 		const referencedModule = connection && connection.module;
@@ -431,8 +476,18 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 				)
 			);
 			const importVar = dep.getImportVar(templateContext.moduleGraph);
+			// When the consuming module is emitted as a generator (target without
+			// `async`/`await`), the dependency `await` must become `yield`.
+			const generatorLowered = isGeneratorLowered(
+				/** @type {Module} */ (module),
+				moduleGraph,
+				templateContext.runtimeTemplate
+			);
 			templateContext.initFragments.push(
-				new AwaitDependenciesInitFragment(new Map([[importVar, importVar]]))
+				new AwaitDependenciesInitFragment(
+					new Map([[importVar, importVar]]),
+					generatorLowered
+				)
 			);
 			templateContext.initFragments.push(
 				new ConditionalInitFragment(
@@ -457,6 +512,7 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 	}
 
 	/**
+	 * Gets import emitted runtime.
 	 * @param {Module} module the module
 	 * @param {Module} referencedModule the referenced module
 	 * @returns {RuntimeSpec | boolean} runtimeCondition in which this import has been emitted