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

package/lib/LazyBarrel.js

@@ -0,0 +1,389 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Haijie Xie @hai-x
+*/
+
+"use strict";
+
+const Dependency = require("./Dependency");
+
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./Compilation").DependencyConstructor} DependencyConstructor */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleFactory")} ModuleFactory */
+
+/**
+ * Defines the deferred request group type used by this module.
+ * @typedef {object} DependencyGroup
+ * @property {ModuleFactory} factory factory for the request
+ * @property {Dependency[]} dependencies deferred dependencies of the request
+ * @property {string | undefined} context request context
+ */
+
+/**
+ * Defines the lazy barrel state type used by this module.
+ * @typedef {object} LazyBarrelState
+ * @property {Set<string> | true} forwardedIds export names requested so far, true for all
+ * @property {LazyBarrelInfo | undefined} lazyBarrelInfo deferred dependencies, undefined until classified
+ */
+
+/**
+ * Defines the lazy barrel unlazy item type used by this module.
+ * @typedef {object} UnlazyDependencyInfo
+ * @property {ModuleFactory} factory factory for the request
+ * @property {Dependency[]} dependencies deferred dependencies of the request
+ * @property {string | undefined} context request context
+ * @property {Module} originModule the lazy barrel module
+ */
+
+/**
+ * Collects the export names a dependency group requests from its target.
+ * @param {Dependency[]} dependencies dependency group resolving to one module
+ * @returns {Set<string> | true} requested export names, true for all
+ */
+function getForwardedIds(dependencies) {
+	/** @type {Set<string>} */
+	const ids = new Set();
+	for (const dependency of dependencies) {
+		// TODO remove in webpack 6
+		// It may be missing on custom dependency types not extending the base Dependency
+		if (!("getForwardId" in dependency)) continue;
+
+		const id = dependency.getForwardId();
+		if (id === true) return true;
+		if (id !== null) ids.add(id);
+	}
+	return ids;
+}
+
+/**
+ * Tracks the deferred (not yet factorized/built) dependencies of a
+ * side-effect-free barrel module and which export names resolve to them.
+ */
+class LazyBarrelInfo {
+	constructor() {
+		/** @type {Map<string, string>} forward id -> request key */
+		this._forwardIdToRequest = new Map();
+		/** @type {Map<string, DependencyGroup>} request key -> still-deferred group */
+		this._requestToDepGroup = new Map();
+		/** @type {Set<string> | undefined} locally provided export names */
+		this._terminalIds = undefined;
+		/** @type {Set<string> | undefined} requests of star re-exports */
+		this._fallbackRequests = undefined;
+	}
+
+	/**
+	 * Records a deferred dependency under its request key.
+	 * @param {string} requestKey request key
+	 * @param {Dependency} dependency dependency to defer
+	 * @param {ModuleFactory} factory factory for the request
+	 * @param {string | undefined} context request context
+	 */
+	addLazy(requestKey, dependency, factory, context) {
+		let group = this._requestToDepGroup.get(requestKey);
+		if (group === undefined) {
+			group = { factory, dependencies: [], context };
+			this._requestToDepGroup.set(requestKey, group);
+		}
+		group.dependencies.push(dependency);
+	}
+
+	/**
+	 * Maps an export name to the request providing it.
+	 * @param {string} id export name
+	 * @param {string} requestKey request key
+	 */
+	addForwardId(id, requestKey) {
+		this._forwardIdToRequest.set(id, requestKey);
+	}
+
+	/**
+	 * Registers a locally provided export name.
+	 * @param {string} id export name
+	 */
+	addTerminal(id) {
+		if (this._terminalIds === undefined) this._terminalIds = new Set();
+		this._terminalIds.add(id);
+	}
+
+	/**
+	 * Registers a star re-export request key.
+	 * @param {string} requestKey request key
+	 */
+	addFallback(requestKey) {
+		if (this._fallbackRequests === undefined) {
+			this._fallbackRequests = new Set();
+		}
+		this._fallbackRequests.add(requestKey);
+	}
+
+	/**
+	 * Returns whether nothing is deferred.
+	 * @returns {boolean} true, when no dependency is deferred
+	 */
+	isEmpty() {
+		return this._requestToDepGroup.size === 0;
+	}
+
+	/**
+	 * Returns the requests of the still-lazy groups.
+	 * @returns {Iterable<string>} still-lazy requests
+	 */
+	getLazyRequests() {
+		return this._requestToDepGroup.keys();
+	}
+
+	/**
+	 * Drops the export-name lookups once no group stays deferred; they only serve
+	 * to find still-deferred groups, so keeping them per module wastes memory.
+	 */
+	_release() {
+		this._forwardIdToRequest.clear();
+		this._terminalIds = undefined;
+		this._fallbackRequests = undefined;
+	}
+
+	/**
+	 * Removes and returns the groups needed to provide the requested export names.
+	 * @param {Set<string> | true} forwardedIds requested export names, true for all
+	 * @returns {DependencyGroup[]} groups that must be processed now
+	 */
+	request(forwardedIds) {
+		/** @type {DependencyGroup[]} */
+		const result = [];
+		/**
+		 * @param {DependencyGroup} group taken group
+		 */
+		const unlazy = (group) => {
+			for (const dependency of group.dependencies) {
+				dependency.setLazy(false);
+			}
+			result.push(group);
+		};
+		if (forwardedIds === true) {
+			for (const group of this._requestToDepGroup.values()) unlazy(group);
+			this._requestToDepGroup.clear();
+			this._release();
+			return result;
+		}
+		/**
+		 * @param {string} requestKey request key to take
+		 */
+		const take = (requestKey) => {
+			const group = this._requestToDepGroup.get(requestKey);
+			if (group === undefined) return;
+			this._requestToDepGroup.delete(requestKey);
+			unlazy(group);
+		};
+		for (const id of forwardedIds) {
+			if (this._terminalIds !== undefined && this._terminalIds.has(id)) {
+				continue;
+			}
+			const requestKey = this._forwardIdToRequest.get(id);
+			if (requestKey !== undefined) {
+				take(requestKey);
+			} else if (this._fallbackRequests !== undefined) {
+				// unknown name: any star re-export may provide it
+				for (const fallbackKey of this._fallbackRequests) take(fallbackKey);
+			}
+		}
+		if (this._requestToDepGroup.size === 0) this._release();
+		return result;
+	}
+}
+
+const esmDependencyCategory = "esm";
+
+/**
+ * Owns the per side-effect-free module lazy barrel state for a `Compilation`,
+ * keeping the deferral bookkeeping out of `Compilation` itself.
+ */
+class LazyBarrelController {
+	/**
+	 * @param {Compilation} compilation the owning compilation
+	 */
+	constructor(compilation) {
+		/** @type {Compilation} */
+		this._compilation = compilation;
+		/** @type {WeakMap<Module, LazyBarrelState>} */
+		this._modules = new WeakMap();
+	}
+
+	/**
+	 * Releases all per-module deferral state. The last consumer is
+	 * `FlagDependencyExportsPlugin`'s cache key during `finishModules`, so the
+	 * bookkeeping is dead weight once sealing starts.
+	 */
+	clear() {
+		this._modules = new WeakMap();
+	}
+
+	/**
+	 * requests of the re-export targets `module` still keeps lazy.
+	 * `FlagDependencyExportsPlugin` folds them into its provided-exports cache
+	 * key, so a barrel whose built targets differ from a cached run does not
+	 * reuse that run's stale exports.
+	 * @param {Module} module the module
+	 * @returns {Iterable<string> | undefined} still-lazy requests, if any
+	 */
+	getLazyRequests(module) {
+		const factoryMeta = module.factoryMeta;
+		if (factoryMeta === undefined || !factoryMeta.sideEffectFree) return;
+		const state = this._modules.get(module);
+		if (state === undefined) return;
+		const info = state.lazyBarrelInfo;
+		if (info === undefined || info.isEmpty()) return;
+		return info.getLazyRequests();
+	}
+
+	/**
+	 * Classifies the re-export dependencies of a side-effect-free module (lazy barrel)
+	 * into deferrable groups and marks the deferred ones.
+	 * @param {Module} module the module whose dependencies are processed
+	 * @returns {boolean} true, when some dependencies were deferred
+	 */
+	classify(module) {
+		const modules = this._modules;
+		const factoryMeta = module.factoryMeta;
+		if (factoryMeta === undefined || !factoryMeta.sideEffectFree) {
+			return false;
+		}
+		const dependencies = module.dependencies;
+		const dependencyFactories = this._compilation.dependencyFactories;
+		/** @type {LazyBarrelInfo | undefined} */
+		let info;
+		let hasFallback = false;
+		for (const dep of dependencies) {
+			// TODO remove in webpack 6
+			// It may be missing on custom dependency types not extending the base Dependency
+			if (!("getLazyUntil" in dep)) continue;
+
+			const until = dep.getLazyUntil();
+			// null (eager) and LAZY_UNTIL_LOCAL (terminal) defer nothing; terminals are
+			// only consulted alongside a star re-export, so they are recorded below
+			if (until === null || until === Dependency.LAZY_UNTIL_LOCAL) continue;
+			// deferrable: setLazy is needed to toggle its deferred state
+			if (!("setLazy" in dep)) continue;
+			const resourceIdent = dep.getResourceIdentifier();
+			if (resourceIdent === null) continue;
+			const factory = dependencyFactories.get(
+				/** @type {DependencyConstructor} */ (dep.constructor)
+			);
+			if (factory === undefined) continue;
+			const category = dep.category;
+			// Match the request grouping key of `processDependencyForResolving`
+			const requestKey =
+				category === esmDependencyCategory
+					? resourceIdent
+					: `${category}${resourceIdent}`;
+			if (info === undefined) info = new LazyBarrelInfo();
+			if (dep.isLazy()) {
+				info.addLazy(requestKey, dep, factory, dep.getContext());
+			}
+			if (until === Dependency.LAZY_UNTIL_ID) {
+				info.addForwardId(
+					/** @type {string} */ (dep.getLazyName()),
+					requestKey
+				);
+			} else if (until === Dependency.LAZY_UNTIL_FALLBACK) {
+				info.addFallback(requestKey);
+				hasFallback = true;
+			}
+		}
+		const state = modules.get(module);
+		// info is only created once a deferrable target exists, so it is never empty here
+		if (info === undefined) {
+			if (state !== undefined) modules.delete(module);
+			return false;
+		}
+		// terminals only matter together with a star re-export (to avoid building it
+		// for a locally-provided name); skip the extra pass otherwise
+		if (hasFallback) {
+			for (const dep of dependencies) {
+				if (
+					"getLazyUntil" in dep &&
+					dep.getLazyUntil() === Dependency.LAZY_UNTIL_LOCAL
+				) {
+					info.addTerminal(/** @type {string} */ (dep.getLazyName()));
+				}
+			}
+		}
+		if (state !== undefined) {
+			// barrel classified after its targets were already requested: replay the
+			// recorded ids so processDependency un-lazies and builds those targets now
+			info.request(state.forwardedIds);
+			// stay lazy only while some targets remain deferred
+			if (info.isEmpty()) return false;
+			state.lazyBarrelInfo = info;
+			return true;
+		}
+
+		modules.set(module, {
+			forwardedIds: new Set(),
+			lazyBarrelInfo: info
+		});
+
+		return true;
+	}
+
+	/**
+	 * Requests the export names that `dependencies` need from a lazy barrel and
+	 * returns the deferred re-export targets that must be built now. Records the
+	 * request when the barrel's dependencies were not classified yet.
+	 * @param {Module} module the resolved module
+	 * @param {Dependency[]} dependencies the dependencies that resolved to the module
+	 * @returns {UnlazyDependencyInfo[] | undefined} items to process, if any
+	 */
+	request(module, dependencies) {
+		// state only exists for side-effect-free modules, so a non-side-effect-free
+		// module never has state — skip the WeakMap lookup entirely for it
+		const factoryMeta = module.factoryMeta;
+		if (factoryMeta === undefined || !factoryMeta.sideEffectFree) return;
+		const modules = this._modules;
+		const state = modules.get(module);
+
+		if (state === undefined) {
+			const forwardedIds = getForwardedIds(dependencies);
+			if (forwardedIds !== true && forwardedIds.size === 0) return;
+			modules.set(module, {
+				forwardedIds,
+				lazyBarrelInfo: undefined
+			});
+			return;
+		}
+
+		const forwardedIds = getForwardedIds(dependencies);
+		if (forwardedIds !== true && forwardedIds.size === 0) return;
+		if (state.forwardedIds !== true) {
+			if (forwardedIds === true) state.forwardedIds = true;
+			else for (const id of forwardedIds) state.forwardedIds.add(id);
+		}
+		const info = state.lazyBarrelInfo;
+		// Pending requests will be replayed during `classify` later
+		if (info === undefined) return;
+		const groups = info.request(forwardedIds);
+		// drop the per-module state once every deferred target has been built
+		if (info.isEmpty()) state.lazyBarrelInfo = undefined;
+		if (groups.length === 0) return;
+		return groups.map((group) => ({
+			factory: group.factory,
+			dependencies: group.dependencies,
+			context: group.context,
+			originModule: module
+		}));
+	}
+
+	/**
+	 * Queues the deferred dependency groups of a lazy barrel requested by a single dependency.
+	 * @param {Module} module the resolved module of the dependency
+	 * @param {Dependency} dependency the requesting dependency
+	 * @param {{ factory: ModuleFactory, dependencies: Dependency[], context: string | undefined, originModule: Module | null }[]} sortedDependencies item list to append to
+	 */
+	unlazyForDependency(module, dependency, sortedDependencies) {
+		const unlazyItems = this.request(module, [dependency]);
+		if (unlazyItems === undefined) return;
+		for (const item of unlazyItems) sortedDependencies.push(item);
+	}
+}
+
+module.exports = LazyBarrelController;

package/lib/LibraryTemplatePlugin.js

@@ -17,6 +17,7 @@ const EnableLibraryPlugin = require("./library/EnableLibraryPlugin");
 // TODO webpack 6 remove
 class LibraryTemplatePlugin {
 	/**
+	 * Creates an instance of LibraryTemplatePlugin.
 	 * @param {LibraryName} name name of library
 	 * @param {LibraryType} target type of library
 	 * @param {UmdNamedDefine} umdNamedDefine setting this to true will name the UMD module
@@ -34,7 +35,7 @@ class LibraryTemplatePlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */

package/lib/LoaderOptionsPlugin.js

@@ -13,6 +13,7 @@ const NormalModule = require("./NormalModule");
 /** @typedef {import("./ModuleFilenameHelpers").MatchObject} MatchObject  */
 
 /**
+ * Defines the loader context type used by this module.
  * @template T
  * @typedef {import("../declarations/LoaderContext").LoaderContext<T>} LoaderContext
  */
@@ -21,6 +22,7 @@ const PLUGIN_NAME = "LoaderOptionsPlugin";
 
 class LoaderOptionsPlugin {
 	/**
+	 * Creates an instance of LoaderOptionsPlugin.
 	 * @param {LoaderOptionsPluginOptions & MatchObject} options options object
 	 */
 	constructor(options = {}) {
@@ -34,7 +36,7 @@ class LoaderOptionsPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */

package/lib/LoaderTargetPlugin.js

@@ -13,14 +13,16 @@ const PLUGIN_NAME = "LoaderTargetPlugin";
 
 class LoaderTargetPlugin {
 	/**
+	 * Creates an instance of LoaderTargetPlugin.
 	 * @param {string} target the target
 	 */
 	constructor(target) {
+		/** @type {string} */
 		this.target = target;
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */

package/lib/MainTemplate.js

@@ -26,6 +26,7 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./TemplatedPathPlugin").TemplatePath} TemplatePath */
 /** @typedef {import("./TemplatedPathPlugin").PathData} PathData */
 /**
+ * Defines the if set type used by this module.
  * @template T
  * @typedef {import("tapable").IfSet<T>} IfSet
  */
@@ -43,6 +44,7 @@ const getLoadScriptRuntimeModule = memoize(() =>
 // TODO webpack 6 remove this class
 class MainTemplate {
 	/**
+	 * Creates an instance of MainTemplate.
 	 * @param {OutputOptions} outputOptions output options for the MainTemplate
 	 * @param {Compilation} compilation the compilation
 	 */
@@ -53,6 +55,7 @@ class MainTemplate {
 			renderManifest: {
 				tap: util.deprecate(
 					/**
+					 * Handles the callback logic for this hook.
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
 					 * @param {(renderManifestEntries: RenderManifestEntry[], renderManifestOptions: RenderManifestOptions) => RenderManifestEntry[]} fn fn
@@ -87,6 +90,7 @@ class MainTemplate {
 			require: {
 				tap: util.deprecate(
 					/**
+					 * Handles the callback logic for this hook.
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
 					 * @param {(value: string, renderBootstrapContext: RenderBootstrapContext) => string} fn fn
@@ -124,6 +128,7 @@ class MainTemplate {
 			render: {
 				tap: util.deprecate(
 					/**
+					 * Handles the callback logic for this hook.
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
 					 * @param {(source: Source, chunk: Chunk, hash: string | undefined, moduleTemplate: ModuleTemplate, dependencyTemplates: DependencyTemplates) => Source} fn fn
@@ -156,6 +161,7 @@ class MainTemplate {
 			renderWithEntry: {
 				tap: util.deprecate(
 					/**
+					 * Handles the callback logic for this hook.
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
 					 * @param {(source: Source, chunk: Chunk, hash: string | undefined) => Source} fn fn
@@ -182,6 +188,7 @@ class MainTemplate {
 			assetPath: {
 				tap: util.deprecate(
 					/**
+					 * Handles the callback logic for this hook.
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
 					 * @param {(value: string, path: PathData, assetInfo: AssetInfo | undefined) => string} fn fn
@@ -194,6 +201,7 @@ class MainTemplate {
 				),
 				call: util.deprecate(
 					/**
+					 * Handles the call callback for this hook.
 					 * @param {TemplatePath} filename used to get asset path with hash
 					 * @param {PathData} options context data
 					 * @returns {string} interpolated path
@@ -206,6 +214,7 @@ class MainTemplate {
 			hash: {
 				tap: util.deprecate(
 					/**
+					 * Handles the callback logic for this hook.
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
 					 * @param {(hash: Hash) => void} fn fn
@@ -220,6 +229,7 @@ class MainTemplate {
 			hashForChunk: {
 				tap: util.deprecate(
 					/**
+					 * Handles the callback logic for this hook.
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
 					 * @param {(hash: Hash, chunk: Chunk) => void} fn fn
@@ -295,6 +305,7 @@ class MainTemplate {
 
 		this.renderCurrentHashCode = util.deprecate(
 			/**
+			 * Handles the require ensure callback for this hook.
 			 * @deprecated
 			 * @param {string} hash the hash
 			 * @param {number=} length length of the hash
@@ -314,6 +325,7 @@ class MainTemplate {
 
 		this.getPublicPath = util.deprecate(
 			/**
+			 * Handles the callback logic for this hook.
 			 * @param {PathData} options context data
 			 * @returns {string} interpolated path
 			 */ (options) =>
@@ -324,6 +336,7 @@ class MainTemplate {
 
 		this.getAssetPath = util.deprecate(
 			/**
+			 * Handles the callback logic for this hook.
 			 * @param {TemplatePath} path used to get asset path with hash
 			 * @param {PathData} options context data
 			 * @returns {string} interpolated path
@@ -335,6 +348,7 @@ class MainTemplate {
 
 		this.getAssetPathWithInfo = util.deprecate(
 			/**
+			 * Handles the callback logic for this hook.
 			 * @param {TemplatePath} path used to get asset path with hash
 			 * @param {PathData} options context data
 			 * @returns {InterpolatedPathAndAssetInfo} interpolated path and asset info
@@ -357,6 +371,7 @@ Object.defineProperty(MainTemplate.prototype, "requireFn", {
 Object.defineProperty(MainTemplate.prototype, "outputOptions", {
 	get: util.deprecate(
 		/**
+		 * Returns output options.
 		 * @this {MainTemplate}
 		 * @returns {OutputOptions} output options
 		 */

package/lib/ManifestPlugin.js

@@ -28,6 +28,7 @@ const HotUpdateChunk = require("./HotUpdateChunk");
 const PLUGIN_NAME = "ManifestPlugin";
 
 /**
+ * Returns extname.
  * @param {string} filename filename
  * @returns {string} extname
  */
@@ -46,6 +47,7 @@ const DEFAULT_FILENAME = "manifest.json";
 
 class ManifestPlugin {
 	/**
+	 * Creates an instance of ManifestPlugin.
 	 * @param {ManifestPluginOptions} options options
 	 */
 	constructor(options = {}) {
@@ -54,7 +56,7 @@ class ManifestPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -71,7 +73,8 @@ class ManifestPlugin {
 			);
 		});
 
-		const entrypoints = this.options.entrypoints || true;
+		const entrypoints =
+			this.options.entrypoints !== undefined ? this.options.entrypoints : true;
 		const serialize =
 			this.options.serialize ||
 			((manifest) => JSON.stringify(manifest, null, 2));
@@ -89,6 +92,7 @@ class ManifestPlugin {
 					);
 
 					/**
+					 * Creates a hash reg exp.
 					 * @param {string | string[]} value value
 					 * @returns {RegExp} regexp to remove hash
 					 */
@@ -99,6 +103,7 @@ class ManifestPlugin {
 						);
 
 					/**
+					 * Removes the provided name from the manifest plugin.
 					 * @param {string} name name
 					 * @param {AssetInfo | null} info asset info
 					 * @returns {string} hash removed name
@@ -112,6 +117,7 @@ class ManifestPlugin {
 					};
 
 					/**
+					 * Returns chunk name or chunk id.
 					 * @param {Chunk} chunk chunk
 					 * @returns {ChunkName | ChunkId} chunk name or chunk id
 					 */
@@ -163,6 +169,7 @@ class ManifestPlugin {
 					const added = new Set();
 
 					/**
+					 * Processes the provided file.
 					 * @param {string} file file
 					 * @param {string=} usedName usedName
 					 * @returns {void}