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

package/lib/optimize/ConstExportsPlugin.js

@@ -0,0 +1,211 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Haijie Xie @hai-x
+*/
+
+"use strict";
+
+const { UsageState } = require("../ExportsInfo");
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../ModuleTypeConstants");
+const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
+const { VariableInfoFlags } = require("../javascript/JavascriptParser");
+const {
+	InlinedUsedName,
+	enableInlineExports,
+	toInlinedValue
+} = require("./InlineExports");
+
+/** @typedef {import("./InlineExports").InlinedValue} InlinedValue */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../ExportsInfo")} ExportsInfo */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptModule").JavascriptModuleBuildInfo} JavascriptModuleBuildInfo */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+
+/** @typedef {{ inlineExports: boolean }} ConstValueParserPluginOptions */
+
+const PLUGIN_NAME = "ConstExportsPlugin";
+
+// Parser tag for top-level `const X = <primitive>` bindings
+const CONST_BINDING_TAG = Symbol("const binding");
+
+class ConstExportsPlugin {
+	/**
+	 * @param {ConstValueParserPluginOptions} options plugin options
+	 */
+	constructor(options) {
+		/** @type {ConstValueParserPluginOptions} */
+		this.options = options;
+	}
+
+	/**
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			PLUGIN_NAME,
+			(compilation, { normalModuleFactory }) => {
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @returns {void}
+				 */
+				const handleInlineExports = (parser) => {
+					parser.hooks.program.tap(PLUGIN_NAME, () => {
+						const buildInfo =
+							/** @type {JavascriptModuleBuildInfo | undefined} */
+							(parser.state.module.buildInfo);
+						if (buildInfo) buildInfo.inlineExports = true;
+					});
+
+					// Propagate inlined constant through evaluator so chained constants and uses see the literal
+					parser.hooks.evaluateIdentifier
+						.for(CONST_BINDING_TAG)
+						.tap(PLUGIN_NAME, (expr) => {
+							const tagData =
+								/** @type {{ value?: InlinedValue } | undefined} */
+								(parser.currentTagData);
+							if (!tagData || !tagData.value) return;
+							const { value } = tagData;
+							const eval_ = new BasicEvaluatedExpression().setRange(
+								/** @type {[number, number]} */ (expr.range)
+							);
+							switch (value.kind) {
+								case "null":
+									return eval_.setNull();
+								case "undefined":
+									return eval_.setUndefined();
+								case "boolean":
+									return eval_.setBoolean(/** @type {boolean} */ (value.value));
+								case "number":
+									return eval_.setNumber(/** @type {number} */ (value.value));
+								case "string":
+									return eval_.setString(/** @type {string} */ (value.value));
+							}
+						});
+				};
+
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @returns {void}
+				 */
+				const handleConstValue = (parser) => {
+					// Only const is tracked; function/class names can be reassigned in sloppy mode.
+					// Re-exports always use getters: cross-module bindings may be mutable,
+					// and SideEffectsFlagPlugin can rewire connections skipping the template.
+					parser.hooks.preDeclarator.tap(
+						PLUGIN_NAME,
+						(declarator, statement) => {
+							// Detect top-level `const` declarations:
+							// - Tag ALL const bindings with CONST_BINDING_TAG (for const detection via tag system)
+							// - Carry inlined primitive value in tag data when eligible (for inline optimization)
+							if (statement.kind !== "const") return;
+							if (parser.scope.topLevelScope !== true) return;
+
+							if (declarator.id.type === "Identifier") {
+								let inlinedValue;
+								if (this.options.inlineExports && declarator.init) {
+									const evaluated = parser.evaluateExpression(declarator.init);
+									inlinedValue = toInlinedValue(evaluated);
+								}
+								parser.tagVariable(
+									declarator.id.name,
+									CONST_BINDING_TAG,
+									inlinedValue ? { value: inlinedValue } : {},
+									VariableInfoFlags.Normal
+								);
+							} else {
+								// Handle destructuring patterns (ObjectPattern, ArrayPattern, etc.)
+								parser.enterPattern(declarator.id, (name) => {
+									parser.tagVariable(
+										name,
+										CONST_BINDING_TAG,
+										{},
+										VariableInfoFlags.Normal
+									);
+								});
+							}
+						}
+					);
+				};
+
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @returns {void}
+				 */
+				const handler = (parser) => {
+					handleConstValue(parser);
+					if (this.options.inlineExports) {
+						handleInlineExports(parser);
+					}
+				};
+
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
+
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, handler);
+
+				if (!this.options.inlineExports) return;
+
+				// Lets HarmonyImportSpecifierDependency.getCondition skip the inline check
+				// (and stay unconditional) when this plugin is not active
+				enableInlineExports(compilation.moduleGraph);
+
+				const moduleGraph = compilation.moduleGraph;
+				compilation.hooks.optimizeDependencies.tap(PLUGIN_NAME, (modules) => {
+					/** @type {Set<ExportsInfo>} */
+					const visited = new Set();
+					/** @type {ExportsInfo[]} */
+					let queue = [];
+					for (const module of modules) {
+						queue.push(moduleGraph.getExportsInfo(module));
+					}
+					while (queue.length > 0) {
+						const items = queue;
+						queue = [];
+						for (const exportsInfo of items) {
+							if (visited.has(exportsInfo)) continue;
+							visited.add(exportsInfo);
+							// Other-export usage means we can't safely inline (some non-statically-known consumer)
+							if (
+								exportsInfo.otherExportsInfo.getUsed(undefined) !==
+								UsageState.Unused
+							) {
+								continue;
+							}
+							for (const exportInfo of exportsInfo.ownedExports) {
+								const inlined = exportInfo.canInline();
+								const doInline =
+									!exportInfo.hasUsedName() &&
+									inlined !== undefined &&
+									exportInfo.provided === true;
+								if (doInline) {
+									exportInfo.setUsedName(new InlinedUsedName(inlined));
+									exportsInfo.markInlinedExports();
+								}
+								if (exportInfo.exportsInfoOwned && exportInfo.exportsInfo) {
+									const used = exportInfo.getUsed(undefined);
+									if (
+										used === UsageState.OnlyPropertiesUsed ||
+										used === UsageState.Unused
+									) {
+										queue.push(exportInfo.exportsInfo);
+									}
+								}
+							}
+						}
+					}
+				});
+			}
+		);
+	}
+}
+
+module.exports = ConstExportsPlugin;
+module.exports.CONST_BINDING_TAG = CONST_BINDING_TAG;

package/lib/optimize/EnsureChunkConditionsPlugin.js

@@ -15,13 +15,14 @@ const PLUGIN_NAME = "EnsureChunkConditionsPlugin";
 
 class EnsureChunkConditionsPlugin {
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			/**
+			 * Handles the hook callback for this code path.
 			 * @param {Iterable<Chunk>} chunks the chunks
 			 */
 			const handler = (chunks) => {

package/lib/optimize/FlagIncludedChunksPlugin.js

@@ -16,7 +16,7 @@ const PLUGIN_NAME = "FlagIncludedChunksPlugin";
 
 class FlagIncludedChunksPlugin {
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -46,6 +46,7 @@ class FlagIncludedChunksPlugin {
 				const modulos = Array.from(
 					{ length: 31 },
 					/**
+					 * Handles the callback logic for this hook.
 					 * @param {number} x x
 					 * @param {number} i i
 					 * @returns {number} result
@@ -75,6 +76,12 @@ class FlagIncludedChunksPlugin {
 					chunkModulesHash.set(chunk, hash);
 				}
 
+				// Chunks that received an included id and need their `ids` re-sorted
+				// once, after all pushes — instead of re-sorting on every push
+				// inside the nested loop below (https://github.com/webpack/webpack/issues/18837).
+				/** @type {Set<Chunk>} */
+				const chunksWithIncludedIds = new Set();
+
 				for (const chunkA of chunks) {
 					const chunkAHash =
 						/** @type {number} */
@@ -124,11 +131,15 @@ class FlagIncludedChunksPlugin {
 
 						/** @type {ChunkId[]} */
 						(chunkB.ids).push(/** @type {ChunkId} */ (chunkA.id));
-						// https://github.com/webpack/webpack/issues/18837
-						/** @type {ChunkId[]} */
-						(chunkB.ids).sort(compareIds);
+						chunksWithIncludedIds.add(chunkB);
 					}
 				}
+
+				// Sort each affected chunk's ids once (https://github.com/webpack/webpack/issues/18837).
+				for (const chunk of chunksWithIncludedIds) {
+					/** @type {ChunkId[]} */
+					(chunk.ids).sort(compareIds);
+				}
 			});
 		});
 	}

package/lib/optimize/InlineExports.js

@@ -0,0 +1,178 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Haijie Xie @hai-x
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const { propertyAccess } = require("../util/property");
+
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+const MAX_INLINE_BYTES = 6;
+
+/** @typedef {"null" | "undefined" | "boolean" | "number" | "string"} InlinedValueKind */
+
+class InlinedValue {
+	/**
+	 * @param {InlinedValueKind} kind value kind
+	 * @param {null | undefined | boolean | number | string} value raw value
+	 */
+	constructor(kind, value) {
+		/** @type {InlinedValueKind} */
+		this.kind = kind;
+		/** @type {string | number | boolean | null | undefined} */
+		this.value = value;
+	}
+
+	/**
+	 * @returns {string} rendered literal source
+	 */
+	renderLiteral() {
+		switch (this.kind) {
+			case "null":
+				return "null";
+			case "undefined":
+				return "undefined";
+			case "boolean":
+				return this.value ? "true" : "false";
+			case "number":
+				return String(this.value);
+			case "string":
+				return JSON.stringify(this.value);
+		}
+	}
+
+	/**
+	 * @param {string} comment leading comment text
+	 * @returns {string} parenthesized literal with comment
+	 */
+	render(comment) {
+		return `(${comment}${this.renderLiteral()})`;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize({ write }) {
+		write(this.kind);
+		write(this.value);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize({ read }) {
+		this.kind = read();
+		this.value = read();
+	}
+}
+
+makeSerializable(
+	InlinedValue,
+	"webpack/lib/optimize/InlineExports",
+	"InlinedValue"
+);
+
+class InlinedUsedName {
+	/**
+	 * @param {InlinedValue} value inlined value
+	 * @param {string[]=} suffix nested property access after the literal
+	 */
+	constructor(value, suffix) {
+		/** @type {InlinedValue} */
+		this.value = value;
+		/** @type {string[]} */
+		this.suffix = suffix || [];
+	}
+
+	/**
+	 * @param {string} comment leading comment text
+	 * @returns {string} rendered literal with property access suffix
+	 */
+	render(comment) {
+		return this.value.render(comment) + propertyAccess(this.suffix);
+	}
+}
+
+/**
+ * Convert an evaluated expression into an inlined primitive value if it qualifies.
+ * @param {import("../javascript/BasicEvaluatedExpression")} evaluated evaluated expression
+ * @returns {InlinedValue | undefined} inlined value or undefined
+ */
+const toInlinedValue = (evaluated) => {
+	if (!evaluated) return;
+	if (evaluated.isNull()) return new InlinedValue("null", null);
+	if (evaluated.isUndefined()) return new InlinedValue("undefined", undefined);
+	if (evaluated.isBoolean()) {
+		return new InlinedValue("boolean", /** @type {boolean} */ (evaluated.bool));
+	}
+	if (evaluated.isNumber()) {
+		const num = /** @type {number} */ (evaluated.number);
+		if (String(num).length > MAX_INLINE_BYTES) return;
+		return new InlinedValue("number", num);
+	}
+	if (evaluated.isString()) {
+		const str = /** @type {string} */ (evaluated.string);
+		if (str.length > MAX_INLINE_BYTES) return;
+		return new InlinedValue("string", str);
+	}
+};
+
+/** @type {WeakSet<ModuleGraph>} */
+const inlineEnabledModuleGraphs = new WeakSet();
+
+/**
+ * Marks export inlining as active for this module graph (set by InlineExportsPlugin).
+ * @param {ModuleGraph} moduleGraph module graph
+ * @returns {void}
+ */
+const enableInlineExports = (moduleGraph) => {
+	inlineEnabledModuleGraphs.add(moduleGraph);
+};
+
+/**
+ * @param {ModuleGraph} moduleGraph module graph
+ * @returns {boolean} true when InlineExportsPlugin is active for this module graph
+ */
+const isInlineExportsEnabled = (moduleGraph) =>
+	inlineEnabledModuleGraphs.has(moduleGraph);
+
+/**
+ * @param {Module} module the target module
+ * @returns {boolean} true when inlining is enabled for this module
+ */
+const isInlineEnabled = (module) =>
+	Boolean(
+		module.buildInfo &&
+		/** @type {import("../Module").BuildInfo} */
+		(module.buildInfo).inlineExports
+	);
+
+/**
+ * Check whether an import to `module` for `ids` resolves to an inlined value.
+ * @param {ModuleGraph} moduleGraph module graph
+ * @param {Module} module the target module
+ * @param {string[]} ids import ids
+ * @param {RuntimeSpec} runtime runtime
+ * @returns {boolean} true if the export is inlined
+ */
+const isExportInlined = (moduleGraph, module, ids, runtime) => {
+	if (!ids || ids.length === 0) return false;
+	if (!isInlineEnabled(module)) return false;
+	return moduleGraph.getExportsInfo(module).hasInlinedUsedName(ids, runtime);
+};
+
+module.exports.InlinedUsedName = InlinedUsedName;
+module.exports.InlinedValue = InlinedValue;
+module.exports.MAX_INLINE_BYTES = MAX_INLINE_BYTES;
+module.exports.enableInlineExports = enableInlineExports;
+module.exports.isExportInlined = isExportInlined;
+module.exports.isInlineEnabled = isInlineEnabled;
+module.exports.isInlineExportsEnabled = isInlineExportsEnabled;
+module.exports.toInlinedValue = toInlinedValue;