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

package/lib/hmr/LazyCompilationPlugin.js

@@ -18,6 +18,7 @@ const {
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const CommonJsRequireDependency = require("../dependencies/CommonJsRequireDependency");
+const { resolveByProperty } = require("../util/cleverMerge");
 const { registerNotSerializable } = require("../util/serialization");
 
 /** @typedef {import("../config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
@@ -25,6 +26,7 @@ const { registerNotSerializable } = require("../util/serialization");
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../Module").BuildCallback} BuildCallback */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
@@ -46,6 +48,97 @@ const { registerNotSerializable } = require("../util/serialization");
 /** @typedef {{ client: string, data: string, active: boolean }} ModuleResult */
 
 /**
+ * Library wrappers of these types pass external modules as closure arguments
+ * (e.g. `__WEBPACK_EXTERNAL_MODULE_react__`) baked into the entry chunk at
+ * render time. When `lazyCompilation` activates a proxy for the first time,
+ * any external dependency the lazily-built module pulls in lands in a hot
+ * update chunk that lives outside the original wrapper closure, so the
+ * factory body can't resolve its closure identifier and throws at runtime.
+ * Reserving the externals up front (during the inactive build) folds them
+ * into the initial wrapper, so the closure identifiers are already defined
+ * when the activation update arrives.
+ */
+const CLOSURE_LIBRARY_TYPES = new Set([
+	"umd",
+	"umd2",
+	"amd",
+	"amd-require",
+	"system"
+]);
+
+/**
+ * `enabledLibraryTypes` covers both the global `output.library.type` and any
+ * per-entry `entry.<name>.library.type`, so a UMD/AMD/System wrapper attached
+ * to an individual entry is still detected.
+ * @param {import("../../declarations/WebpackOptions").OutputNormalized} output normalized output option
+ * @returns {boolean} true when at least one library wrapper passes externals as closure arguments
+ */
+const hasClosureLibrary = (output) => {
+	const enabled = output.enabledLibraryTypes;
+	if (enabled) {
+		for (const type of enabled) {
+			if (CLOSURE_LIBRARY_TYPES.has(type)) return true;
+		}
+	}
+	if (output.library && output.library.type) {
+		return CLOSURE_LIBRARY_TYPES.has(output.library.type);
+	}
+	return false;
+};
+
+/**
+ * Collects request strings from statically-enumerable externals (string,
+ * object, and arrays of those). Function and RegExp forms are skipped because
+ * their effective request set isn't knowable until something asks for it.
+ *
+ * Layer resolution mirrors `ExternalModuleFactoryPlugin.resolveLayer`: the
+ * effective map for the proxy's layer is computed via the same
+ * `resolveByProperty(..., "byLayer", layer)` helper that the externals system
+ * uses, so `byLayer.default` fallback and function-form `byLayer` entries are
+ * honored the same way.
+ *
+ * Entries whose effective value is `false` are skipped — `false` explicitly
+ * disables externalization for that request, and reserving it would force the
+ * real module into the entry chunk.
+ * @param {import("../../declarations/WebpackOptions").Externals | undefined} externals normalized externals option
+ * @param {string | null} layer issuer layer for which to resolve `byLayer`
+ * @returns {Set<string>} requests to reserve in the entry chunk
+ */
+const collectStaticExternalRequests = (externals, layer) => {
+	/** @type {Set<string>} */
+	const requests = new Set();
+	if (!externals) return requests;
+	/** @param {import("../../declarations/WebpackOptions").ExternalItem} item one item */
+	const visit = (item) => {
+		if (typeof item === "string") {
+			requests.add(item);
+			return;
+		}
+		if (!item || typeof item !== "object" || item instanceof RegExp) return;
+		const resolved = /** @type {Record<string, unknown>} */ (
+			resolveByProperty(
+				/** @type {Record<string, unknown>} */ (item),
+				"byLayer",
+				layer
+			)
+		);
+		for (const [request, value] of Object.entries(resolved)) {
+			// `false` explicitly opts the request out of externalization; reserving
+			// it would pull the actual module into the entry chunk.
+			if (value === false) continue;
+			requests.add(request);
+		}
+	};
+	if (Array.isArray(externals)) {
+		for (const item of externals) visit(item);
+	} else {
+		visit(externals);
+	}
+	return requests;
+};
+
+/**
+ * Defines the backend api type used by this module.
  * @typedef {object} BackendApi
  * @property {(callback: (err?: (Error | null)) => void) => void} dispose
  * @property {(module: Module) => ModuleResult} module
@@ -59,6 +152,7 @@ const HMR_DEPENDENCY_TYPES = new Set([
 ]);
 
 /**
+ * Checks true, if the module should be selected.
  * @param {Options["test"]} test test option
  * @param {Module} module the module
  * @returns {boolean | null | string} true, if the module should be selected
@@ -81,10 +175,12 @@ const checkTest = (test, module) => {
 
 class LazyCompilationDependency extends Dependency {
 	/**
+	 * Creates an instance of LazyCompilationDependency.
 	 * @param {LazyCompilationProxyModule} proxyModule proxy module
 	 */
 	constructor(proxyModule) {
 		super();
+		/** @type {LazyCompilationProxyModule} */
 		this.proxyModule = proxyModule;
 	}
 
@@ -97,6 +193,7 @@ class LazyCompilationDependency extends Dependency {
 	}
 
 	/**
+	 * Returns an identifier to merge equal requests.
 	 * @returns {string | null} an identifier to merge equal requests
 	 */
 	getResourceIdentifier() {
@@ -106,8 +203,17 @@ class LazyCompilationDependency extends Dependency {
 
 registerNotSerializable(LazyCompilationDependency);
 
+/**
+ * Defines the build info properties specific to lazy compilation proxy modules.
+ * @typedef {object} KnownLazyCompilationProxyModuleBuildInfo
+ * @property {boolean=} active whether the proxied module was active when built
+ */
+
+/** @typedef {BuildInfo & KnownLazyCompilationProxyModuleBuildInfo} LazyCompilationProxyModuleBuildInfo */
+
 class LazyCompilationProxyModule extends Module {
 	/**
+	 * Creates an instance of LazyCompilationProxyModule.
 	 * @param {string} context context
 	 * @param {Module} originalModule an original module
 	 * @param {string} request request
@@ -121,14 +227,23 @@ class LazyCompilationProxyModule extends Module {
 			context,
 			originalModule.layer
 		);
+		// Redeclared with the lazy compilation proxy specific shape
+		/** @type {LazyCompilationProxyModuleBuildInfo | undefined} */
+		this.buildInfo = undefined;
+		/** @type {Module} */
 		this.originalModule = originalModule;
+		/** @type {string} */
 		this.request = request;
+		/** @type {string} */
 		this.client = client;
+		/** @type {string} */
 		this.data = data;
+		/** @type {boolean} */
 		this.active = active;
 	}
 
 	/**
+	 * Returns the unique identifier used to reference this module.
 	 * @returns {string} a unique identifier of the module
 	 */
 	identifier() {
@@ -136,6 +251,7 @@ class LazyCompilationProxyModule extends Module {
 	}
 
 	/**
+	 * Returns a human-readable identifier for this module.
 	 * @param {RequestShortener} requestShortener the request shortener
 	 * @returns {string} a user readable identifier of the module
 	 */
@@ -163,6 +279,7 @@ class LazyCompilationProxyModule extends Module {
 	}
 
 	/**
+	 * Gets the library identifier.
 	 * @param {LibIdentOptions} options options
 	 * @returns {LibIdent | null} an identifier for library inclusion
 	 */
@@ -173,6 +290,7 @@ class LazyCompilationProxyModule extends Module {
 	}
 
 	/**
+	 * Checks whether the module needs to be rebuilt for the current build state.
 	 * @param {NeedBuildContext} context context info
 	 * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
@@ -182,6 +300,7 @@ class LazyCompilationProxyModule extends Module {
 	}
 
 	/**
+	 * Builds the module using the provided compilation context.
 	 * @param {WebpackOptions} options webpack options
 	 * @param {Compilation} compilation the compilation
 	 * @param {ResolverWithOptions} resolver the resolver
@@ -203,11 +322,25 @@ class LazyCompilationProxyModule extends Module {
 			const block = new AsyncDependenciesBlock({});
 			block.addDependency(dep);
 			this.addBlock(block);
+		} else if (hasClosureLibrary(compilation.options.output)) {
+			// Reserve statically-declared externals as dependencies of the inactive
+			// proxy so the initial entry chunk's library wrapper already exposes
+			// their closure identifiers (e.g. `__WEBPACK_EXTERNAL_MODULE_react__`).
+			// Once the proxy activates and the lazily-built module references those
+			// externals, the identifiers resolve normally instead of throwing.
+			const requests = collectStaticExternalRequests(
+				options.externals,
+				this.layer
+			);
+			for (const request of requests) {
+				this.addDependency(new CommonJsRequireDependency(request));
+			}
 		}
 		callback();
 	}
 
 	/**
+	 * Returns the source types this module can generate.
 	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
@@ -215,6 +348,7 @@ class LazyCompilationProxyModule extends Module {
 	}
 
 	/**
+	 * Returns the estimated size for the requested source type.
 	 * @param {string=} type the source type for which the size should be estimated
 	 * @returns {number} the estimated size of the module (must be non-zero)
 	 */
@@ -223,6 +357,7 @@ class LazyCompilationProxyModule extends Module {
 	}
 
 	/**
+	 * Generates code and runtime requirements for this module.
 	 * @param {CodeGenerationContext} context context for code generation
 	 * @returns {CodeGenerationResult} result
 	 */
@@ -237,17 +372,19 @@ class LazyCompilationProxyModule extends Module {
 		);
 		const clientModule = moduleGraph.getModule(clientDep);
 		const block = this.blocks[0];
+		const cst = runtimeTemplate.renderConst();
+		const lt = runtimeTemplate.renderLet();
 		const client = Template.asString([
-			`var client = ${runtimeTemplate.moduleExports({
+			`${cst} client = ${runtimeTemplate.moduleExports({
 				module: clientModule,
 				chunkGraph,
 				request: clientDep.userRequest,
 				runtimeRequirements
 			})}`,
-			`var data = ${JSON.stringify(this.data)};`
+			`${cst} data = ${JSON.stringify(this.data)};`
 		]);
 		const keepActive = Template.asString([
-			`var dispose = client.keepAlive({ data: data, active: ${JSON.stringify(
+			`${cst} dispose = client.keepAlive({ data: data, active: ${JSON.stringify(
 				Boolean(block)
 			)}, module: module, onError: onError });`
 		]);
@@ -275,7 +412,7 @@ class LazyCompilationProxyModule extends Module {
 						chunkGraph.getModuleId(module)
 					)}, function() { module.hot.invalidate(); });`,
 					"module.hot.dispose(function(data) { delete data.resolveSelf; dispose(data); });",
-					"if (module.hot.data && module.hot.data.resolveSelf) module.hot.data.resolveSelf(module.exports);"
+					`if (${runtimeTemplate.optionalChaining("module.hot.data", "resolveSelf")}) module.hot.data.resolveSelf(module.exports);`
 				]),
 				"}",
 				"function onError() { /* ignore */ }",
@@ -284,12 +421,12 @@ class LazyCompilationProxyModule extends Module {
 		} else {
 			source = Template.asString([
 				client,
-				"var resolveSelf, onError;",
+				`${lt} resolveSelf, onError;`,
 				"module.exports = new Promise(function(resolve, reject) { resolveSelf = resolve; onError = reject; });",
 				"if (module.hot) {",
 				Template.indent([
 					"module.hot.accept();",
-					"if (module.hot.data && module.hot.data.resolveSelf) module.hot.data.resolveSelf(module.exports);",
+					`if (${runtimeTemplate.optionalChaining("module.hot.data", "resolveSelf")}) module.hot.data.resolveSelf(module.exports);`,
 					"module.hot.dispose(function(data) { data.resolveSelf = resolveSelf; dispose(data); });"
 				]),
 				"}",
@@ -304,6 +441,7 @@ class LazyCompilationProxyModule extends Module {
 	}
 
 	/**
+	 * Updates the hash with the data contributed by this instance.
 	 * @param {Hash} hash the hash used to track dependencies
 	 * @param {UpdateHashContext} context context
 	 * @returns {void}
@@ -323,6 +461,7 @@ class LazyCompilationDependencyFactory extends ModuleFactory {
 	}
 
 	/**
+	 * Processes the provided data.
 	 * @param {ModuleFactoryCreateData} data data object
 	 * @param {ModuleFactoryCallback} callback callback
 	 * @returns {void}
@@ -338,6 +477,7 @@ class LazyCompilationDependencyFactory extends ModuleFactory {
 }
 
 /**
+ * Defines the backend handler callback.
  * @callback BackendHandler
  * @param {Compiler} compiler compiler
  * @param {(err: Error | null, backendApi?: BackendApi) => void} callback callback
@@ -345,6 +485,7 @@ class LazyCompilationDependencyFactory extends ModuleFactory {
  */
 
 /**
+ * Defines the promise backend handler callback.
  * @callback PromiseBackendHandler
  * @param {Compiler} compiler compiler
  * @returns {Promise<BackendApi>} backend
@@ -355,6 +496,7 @@ class LazyCompilationDependencyFactory extends ModuleFactory {
 /** @typedef {(module: Module) => boolean} TestFn */
 
 /**
+ * Defines the options type used by this module.
  * @typedef {object} Options options
  * @property {BackEnd} backend the backend
  * @property {boolean=} entries
@@ -366,17 +508,22 @@ const PLUGIN_NAME = "LazyCompilationPlugin";
 
 class LazyCompilationPlugin {
 	/**
+	 * Creates an instance of LazyCompilationPlugin.
 	 * @param {Options} options options
 	 */
 	constructor({ backend, entries, imports, test }) {
+		/** @type {BackEnd} */
 		this.backend = backend;
+		/** @type {boolean | undefined} */
 		this.entries = entries;
+		/** @type {boolean | undefined} */
 		this.imports = imports;
+		/** @type {string | RegExp | TestFn | undefined} */
 		this.test = test;
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */

package/lib/hmr/lazyCompilationBackend.js

@@ -19,6 +19,7 @@
 /** @typedef {() => Server} CreateServerFunction */
 
 /**
+ * Returns backend.
  * @param {Omit<LazyCompilationDefaultBackendOptions, "client"> & { client: NonNullable<LazyCompilationDefaultBackendOptions["client"]> }} options additional options for the backend
  * @returns {BackendHandler} backend
  */
@@ -26,6 +27,9 @@ module.exports = (options) => (compiler, callback) => {
 	const logger = compiler.getInfrastructureLogger("LazyCompilationBackend");
 	/** @type {Map<string, number>} */
 	const activeModules = new Map();
+	/** @type {Set<NodeJS.Timeout>} */
+	const idleTimers = new Set();
+	let isClosing = false;
 	const prefix = "/lazy-compilation-using-";
 
 	const isHttps =
@@ -66,19 +70,33 @@ module.exports = (options) => (compiler, callback) => {
 		if (req.url === undefined) return;
 		const keys = req.url.slice(prefix.length).split("@");
 		req.socket.on("close", () => {
-			setTimeout(() => {
+			// Shutting down: skip the idle-decrement timer entirely.
+			if (isClosing) return;
+			const timer = setTimeout(() => {
+				idleTimers.delete(timer);
 				for (const key of keys) {
 					const oldValue = activeModules.get(key) || 0;
-					activeModules.set(key, oldValue - 1);
-					if (oldValue === 1) {
-						logger.log(
-							`${key} is no longer in use. Next compilation will skip this module.`
-						);
+					// Drop the entry at zero so the map doesn't retain idle modules
+					// and the count can't drift negative.
+					if (oldValue <= 1) {
+						activeModules.delete(key);
+						if (oldValue === 1) {
+							logger.log(
+								`${key} is no longer in use. Next compilation will skip this module.`
+							);
+						}
+					} else {
+						activeModules.set(key, oldValue - 1);
 					}
 				}
 			}, 120000);
+			// Don't keep the process alive just to decrement idle counters.
+			if (timer.unref) timer.unref();
+			idleTimers.add(timer);
 		});
-		req.socket.setNoDelay(true);
+		// Not all runtimes expose `setNoDelay` on the request socket (e.g. Deno's
+		// HTTP server); it's only a latency optimization, so skip it when absent.
+		if (req.socket.setNoDelay) req.socket.setNoDelay(true);
 		res.writeHead(200, {
 			"content-type": "text/event-stream",
 			"Access-Control-Allow-Origin": "*",
@@ -101,7 +119,6 @@ module.exports = (options) => (compiler, callback) => {
 	const server = createServer();
 	server.on("request", requestListener);
 
-	let isClosing = false;
 	/** @type {Set<import("net").Socket>} */
 	const sockets = new Set();
 	server.on("connection", (socket) => {
@@ -112,12 +129,21 @@ module.exports = (options) => (compiler, callback) => {
 		if (isClosing) socket.destroy();
 	});
 	server.on("clientError", (e) => {
-		if (e.message !== "Server is disposing") logger.warn(e);
+		// A closing browser tab or a test tearing down aborts the request and
+		// resets the socket; that surfaces here as ECONNRESET and is benign.
+		if (
+			e.message === "Server is disposing" ||
+			/** @type {NodeJS.ErrnoException} */ (e).code === "ECONNRESET"
+		) {
+			return;
+		}
+		logger.warn(e);
 	});
 
 	server.on(
 		"listening",
 		/**
+		 * Handles the callback logic for this hook.
 		 * @param {Error} err error
 		 * @returns {void}
 		 */
@@ -140,14 +166,29 @@ module.exports = (options) => (compiler, callback) => {
 			callback(null, {
 				dispose(callback) {
 					isClosing = true;
+					for (const timer of idleTimers) clearTimeout(timer);
+					idleTimers.clear();
 					// Removing the listener is a workaround for a memory leak in node.js
 					server.off("request", requestListener);
-					server.close((err) => {
-						callback(err);
-					});
 					for (const socket of sockets) {
 						socket.destroy(new Error("Server is disposing"));
 					}
+					// Some runtimes (e.g. Deno) don't emit "connection", so `sockets`
+					// misses the open SSE connections and `server.close` would hang;
+					// force-close everything before waiting for it.
+					if (server.closeAllConnections) server.closeAllConnections();
+					server.close((err) => {
+						// `closeAllConnections()` already stops the server on some runtimes
+						// (e.g. Bun), so `close` then reports ERR_SERVER_NOT_RUNNING; the
+						// server is closed either way, so that's not a dispose failure.
+						callback(
+							err &&
+								/** @type {NodeJS.ErrnoException} */ (err).code !==
+									"ERR_SERVER_NOT_RUNNING"
+								? err
+								: null
+						);
+					});
 				},
 				module(originalModule) {
 					const key = `${encodeURIComponent(