@depup/webpack 5.109.0-depup.0 → 5.110.1-depup.0

package/lib/loaders/loadLoader.js

@@ -6,9 +6,13 @@
 "use strict";
 
 const { pathToFileURL } = require("url");
-const LoaderLoadingError = require("../errors/LoaderLoadingError");
+const memoize = require("../util/memoize");
 
-/** @typedef {import("./LoaderRunner").LoaderObject} LoaderObject */
+const getLoaderLoadingError = memoize(() =>
+	require("../errors/LoaderLoadingError")
+);
+
+/** @import { LoaderObject } from "./LoaderRunner" */
 
 /**
  * Lazily-compiled dynamic `import()`. Built on first use so this file still
@@ -26,7 +30,7 @@ let importModule;
 function handleResult(loader, module, callback) {
 	if (typeof module !== "function" && typeof module !== "object") {
 		return callback(
-			new LoaderLoadingError(
+			new (getLoaderLoadingError())(
 				`Module '${loader.path}' is not a loader (export function or es6 module)`
 			)
 		);
@@ -41,7 +45,7 @@ function handleResult(loader, module, callback) {
 		typeof loader.pitch !== "function"
 	) {
 		return callback(
-			new LoaderLoadingError(
+			new (getLoaderLoadingError())(
 				`Module '${loader.path}' is not a loader (must have normal or pitch function)`
 			)
 		);

package/lib/logging/createConsoleLogger.js

@@ -7,10 +7,13 @@
 
 const { LogType } = require("./Logger");
 
-/** @typedef {import("../../declarations/WebpackOptions").FilterItemTypes} FilterItemTypes */
-/** @typedef {import("../../declarations/WebpackOptions").FilterTypes} FilterTypes */
-/** @typedef {import("./Logger").LogTypeEnum} LogTypeEnum */
-/** @typedef {import("./Logger").Args} Args */
+/**
+ * @import {
+ * 	FilterItemTypes,
+ * 	FilterTypes
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import { LogTypeEnum, Args } from "./Logger" */
 
 /** @typedef {(item: string) => boolean} FilterFunction */
 /** @typedef {(value: string, type: LogTypeEnum, args?: Args) => void} LoggingFunction */

package/lib/node/CommonJsChunkLoadingPlugin.js

@@ -8,9 +8,9 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const StartupChunkDependenciesPlugin = require("../runtime/StartupChunkDependenciesPlugin");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
+/** @import Chunk from "../Chunk" */
+/** @import Compiler from "../Compiler" */
+/** @import { RuntimeRequirements } from "../Module" */
 
 /**
  * Defines the common js chunk loading plugin options type used by this module.
@@ -71,30 +71,44 @@ class CommonJsChunkLoadingPlugin {
 			const handler = (chunk, set) => {
 				if (onceForChunkSet.has(chunk)) return;
 				onceForChunkSet.add(chunk);
+				if (!isEnabledForChunk(chunk)) return;
+				compilation.addRuntimeModule(chunk, new ChunkLoadingRuntimeModule(set));
+			};
+			/**
+			 * Installing a chunk is the only part that writes the module factories and
+			 * looks a chunk id up; a base uri or `onChunksLoaded` comes without either.
+			 * Kept off `handler`, which runs once per chunk and so cannot see which of the
+			 * requirements below the chunk ends up with.
+			 * @param {Chunk} chunk chunk
+			 * @param {RuntimeRequirements} set runtime requirements
+			 */
+			const installHandler = (chunk, set) => {
 				if (!isEnabledForChunk(chunk)) return;
 				set.add(RuntimeGlobals.moduleFactoriesAddOnly);
 				set.add(RuntimeGlobals.hasOwnProperty);
-				compilation.addRuntimeModule(chunk, new ChunkLoadingRuntimeModule(set));
 			};
 
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.ensureChunkHandlers)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.hmrDownloadManifest)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.baseURI)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.externalInstallChunk)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.onChunksLoaded)
-				.tap(PLUGIN_NAME, handler);
+			for (const requirement of [
+				RuntimeGlobals.ensureChunkHandlers,
+				RuntimeGlobals.hmrDownloadUpdateHandlers,
+				RuntimeGlobals.hmrDownloadManifest,
+				RuntimeGlobals.baseURI,
+				RuntimeGlobals.externalInstallChunk,
+				RuntimeGlobals.onChunksLoaded
+			]) {
+				compilation.hooks.runtimeRequirementInTree
+					.for(requirement)
+					.tap(PLUGIN_NAME, handler);
+			}
+			for (const requirement of [
+				RuntimeGlobals.ensureChunkHandlers,
+				RuntimeGlobals.externalInstallChunk,
+				RuntimeGlobals.hmrDownloadUpdateHandlers
+			]) {
+				compilation.hooks.runtimeRequirementInTree
+					.for(requirement)
+					.tap(PLUGIN_NAME, installHandler);
+			}
 
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.ensureChunkHandlers)

package/lib/node/NodeEnvironmentPlugin.js

@@ -11,9 +11,13 @@ const createConsoleLogger = require("../logging/createConsoleLogger");
 const NodeWatchFileSystem = require("./NodeWatchFileSystem");
 const nodeConsole = require("./nodeConsole");
 
-/** @typedef {import("../../declarations/WebpackOptions").InfrastructureLogging} InfrastructureLogging */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+/**
+ * @import {
+ * 	InfrastructureLogging
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import Compiler from "../Compiler" */
+/** @import { InputFileSystem } from "../util/fs" */
 
 /**
  * Defines the node environment plugin options type used by this module.
@@ -62,6 +66,16 @@ class NodeEnvironmentPlugin {
 		compiler.outputFileSystem = fs;
 		compiler.intermediateFileSystem = fs;
 		compiler.watchFileSystem = new NodeWatchFileSystem(inputFileSystem);
+		// Symmetric to the beforeRun purge below: the stat/readdir/readFile caches
+		// would otherwise outlive `close()` for as long as the compiler is held.
+		compiler.hooks.shutdown.tap(PLUGIN_NAME, () => {
+			if (
+				compiler.inputFileSystem === inputFileSystem &&
+				inputFileSystem.purge
+			) {
+				inputFileSystem.purge();
+			}
+		});
 		compiler.hooks.beforeRun.tap(PLUGIN_NAME, (compiler) => {
 			if (
 				compiler.inputFileSystem === inputFileSystem &&

package/lib/node/NodeSourcePlugin.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-/** @typedef {import("../Compiler")} Compiler */
+/** @import Compiler from "../Compiler" */
 
 class NodeSourcePlugin {
 	/**

package/lib/node/NodeTargetPlugin.js

@@ -8,8 +8,8 @@
 const ExternalsPlugin = require("../ExternalsPlugin");
 const { builtins } = require("./nodeBuiltins");
 
-/** @typedef {import("../../declarations/WebpackOptions").ExternalsType} ExternalsType */
-/** @typedef {import("../Compiler")} Compiler */
+/** @import { ExternalsType } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
 
 class NodeTargetPlugin {
 	/**
@@ -39,5 +39,6 @@ class NodeTargetPlugin {
 	}
 }
 
+NodeTargetPlugin.builtins = builtins;
+
 module.exports = NodeTargetPlugin;
-module.exports.builtins = builtins;

package/lib/node/NodeTemplatePlugin.js

@@ -8,7 +8,7 @@
 const CommonJsChunkFormatPlugin = require("../javascript/CommonJsChunkFormatPlugin");
 const EnableChunkLoadingPlugin = require("../javascript/EnableChunkLoadingPlugin");
 
-/** @typedef {import("../Compiler")} Compiler */
+/** @import Compiler from "../Compiler" */
 
 /**
  * Represents the node template plugin runtime component.

package/lib/node/NodeWatchFileSystem.js

@@ -6,15 +6,75 @@
 "use strict";
 
 const util = require("util");
-const Watchpack = require("watchpack");
+const memoize = require("../util/memoize");
+
+// watchpack is only reachable from `watch`, so non-watch builds never load it
+const getWatchpack = memoize(() => require("watchpack"));
 
 /** @typedef {InstanceType<import("watchpack")>} Watchpack */
-/** @typedef {import("watchpack").TimeInfoEntries} TimeInfoEntries */
-/** @typedef {import("watchpack").WatchOptions} WatchOptions */
-/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("../util/fs").WatchMethod} WatchMethod */
-/** @typedef {import("../util/fs").Changes} Changes */
-/** @typedef {import("../util/fs").Removals} Removals */
+/** @import { TimeInfoEntries, WatchOptions } from "watchpack" */
+/**
+ * @import {
+ * 	InputFileSystem,
+ * 	WatchMethod,
+ * 	Changes,
+ * 	Removals
+ * } from "../util/fs"
+ */
+
+// Watchpack pools DirectoryWatchers per options object identity; interning by
+// value lets a MultiCompiler's children share one pool instead of one scan each.
+/** @type {Map<string, WatchOptions>} */
+const canonicalWatchOptions = new Map();
+/** @type {WeakMap<RegExp, string>} */
+const regExpKeys = new WeakMap();
+let nextRegExpKey = 0;
+
+// A RegExp keys by reference, so two configs spelling the same one inline do
+// not share a pool.
+/**
+ * @param {WatchOptions["ignored"]} ignored the `ignored` option
+ * @returns {string} key describing it, or "" when it cannot be keyed
+ */
+const ignoredKey = (ignored) => {
+	if (ignored === undefined || ignored === null) return "-";
+	if (typeof ignored === "string") return `s${ignored}`;
+	if (Array.isArray(ignored)) return `a${JSON.stringify(ignored)}`;
+	if (!(ignored instanceof RegExp)) return "";
+	let key = regExpKeys.get(ignored);
+	if (key === undefined) {
+		key = `r${nextRegExpKey++}`;
+		regExpKeys.set(ignored, key);
+	}
+	return key;
+};
+
+// Snapshot rather than keep the caller's object: mutating it later would hand
+// the next caller options it never asked for.
+/**
+ * @param {WatchOptions} options watch options
+ * @returns {WatchOptions} a shared object equal to `options`, or `options`
+ */
+const getCanonicalWatchOptions = (options) => {
+	const ignored = ignoredKey(options.ignored);
+	if (ignored === "") return options;
+	const key = `${options.aggregateTimeout}|${Boolean(
+		options.followSymlinks
+	)}|${options.poll}|${ignored}`;
+	const canonical = canonicalWatchOptions.get(key);
+	if (canonical !== undefined) return canonical;
+	/** @type {WatchOptions} */
+	const snapshot = {
+		aggregateTimeout: options.aggregateTimeout,
+		followSymlinks: options.followSymlinks,
+		ignored: Array.isArray(options.ignored)
+			? [...options.ignored]
+			: options.ignored,
+		poll: options.poll
+	};
+	canonicalWatchOptions.set(key, snapshot);
+	return snapshot;
+};
 
 class NodeWatchFileSystem {
 	/**
@@ -28,8 +88,9 @@ class NodeWatchFileSystem {
 		this.watcherOptions = {
 			aggregateTimeout: 0
 		};
+		// `watch` replaces this with a watcher built from its own options
 		/** @type {Watchpack | null} */
-		this.watcher = new Watchpack(this.watcherOptions);
+		this.watcher = null;
 	}
 
 	/** @type {WatchMethod} */
@@ -64,7 +125,7 @@ class NodeWatchFileSystem {
 			throw new Error("Invalid arguments: 'callbackUndelayed'");
 		}
 		const oldWatcher = this.watcher;
-		this.watcher = new Watchpack(options);
+		this.watcher = new (getWatchpack())(getCanonicalWatchOptions(options));
 
 		if (callbackUndelayed) {
 			this.watcher.once("change", callbackUndelayed);

package/lib/node/ReadFileChunkLoadingRuntimeModule.js

@@ -10,19 +10,16 @@ const Template = require("../Template");
 const {
 	generateJavascriptHMR
 } = require("../hmr/JavascriptHotModuleReplacementHelper");
-const {
-	chunkHasJs,
-	getChunkFilenameTemplate
-} = require("../javascript/JavascriptModulesPlugin");
+const { chunkHasJs } = require("../javascript/JavascriptModulesPlugin");
 const { getInitialChunkIds } = require("../javascript/StartupHelpers");
+const { renderBaseUri } = require("../runtime/baseUri");
 const compileBooleanMatcher = require("../util/compileBooleanMatcher");
-const { getUndoPath } = require("../util/identifier");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
+/** @import Chunk from "../Chunk" */
+/** @import ChunkGraph from "../ChunkGraph" */
+/** @import Compilation from "../Compilation" */
+/** @import RuntimeTemplate from "../RuntimeTemplate" */
+/** @import { ReadOnlyRuntimeRequirements } from "../Module" */
 
 class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 	/**
@@ -45,15 +42,14 @@ class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 	 */
 	_generateBaseUri(chunk, rootOutputDir, runtimeTemplate) {
 		const options = chunk.getEntryOptions();
-		if (options && options.baseUri) {
-			return `${RuntimeGlobals.baseURI} = ${JSON.stringify(options.baseUri)};`;
-		}
-
-		return `${RuntimeGlobals.baseURI} = require(${runtimeTemplate.renderNodePrefixForCoreModule("url")}).pathToFileURL(${
-			rootOutputDir
-				? `__dirname + ${JSON.stringify(`/${rootOutputDir}`)}`
-				: "__filename"
-		});`;
+		return renderBaseUri(
+			options ? options.baseUri : undefined,
+			`require(${runtimeTemplate.renderNodePrefixForCoreModule("url")}).pathToFileURL(${
+				rootOutputDir
+					? `__dirname + ${JSON.stringify(`/${rootOutputDir}`)}`
+					: "__filename"
+			})`
+		);
 	}
 
 	/**
@@ -86,18 +82,7 @@ class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 		const hasJsMatcher = compileBooleanMatcher(conditionMap);
 		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
 
-		const outputName = compilation.getPath(
-			getChunkFilenameTemplate(chunk, compilation.outputOptions),
-			{
-				chunk,
-				contentHashType: "javascript"
-			}
-		);
-		const rootOutputDir = getUndoPath(
-			outputName,
-			compilation.outputOptions.path,
-			false
-		);
+		const rootOutputDir = runtimeTemplate.chunkRootOutputDir(chunk, false);
 
 		const stateExpression = withHmr
 			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_readFileVm`
@@ -108,18 +93,30 @@ class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 			)
 		)}\n}`;
 
+		// Every part below that reads the table. A chunk asking only for `.b` gets this
+		// module for the base uri alone, and then has nothing to look up.
+		const withInstalledChunks =
+			withOnChunkLoad || withLoading || withExternalInstallChunk || withHmr;
+
 		return Template.asString([
 			withBaseURI
 				? this._generateBaseUri(chunk, rootOutputDir, runtimeTemplate)
 				: "// no baseURI",
 			"",
-			"// object to store loaded chunks",
-			'// "0" means "already loaded", Promise means loading',
-			`var installedChunks = ${
-				stateExpression
-					? runtimeTemplate.assignOr(stateExpression, installedChunksObject)
-					: installedChunksObject
-			};`,
+			withInstalledChunks
+				? Template.asString([
+						"// object to store loaded chunks",
+						'// "0" means "already loaded", Promise means loading',
+						`var installedChunks = ${
+							stateExpression
+								? runtimeTemplate.assignOr(
+										stateExpression,
+										installedChunksObject
+									)
+								: installedChunksObject
+						};`
+					])
+				: "// no installed chunks",
 			"",
 			withOnChunkLoad
 				? `${

package/lib/node/ReadFileCompileAsyncWasmPlugin.js

@@ -8,20 +8,14 @@
 const { WEBASSEMBLY_MODULE_TYPE_ASYNC } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
-const { getPresentKinds } = require("../TemplatedPathPlugin");
+const { usesFullHashDigest } = require("../TemplatedPathPlugin");
+const { needsRuntimeFullHash } = require("../wasm/wasmModuleFilename");
 const AsyncWasmCompileRuntimeModule = require("../wasm-async/AsyncWasmCompileRuntimeModule");
 const AsyncWasmLoadingRuntimeModule = require("../wasm-async/AsyncWasmLoadingRuntimeModule");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
-
-/**
- * The wasm runtime inlines `[fullhash]` as a runtime `getFullHash()` call, so
- * that runtime module must be requested (`[hash]` is the per-module hash here).
- * @param {string} filename `output.webassemblyModuleFilename`
- * @returns {boolean} whether it references the compilation `[fullhash]`
- */
-const usesFullHash = (filename) => getPresentKinds(filename).has("fullhash");
+/** @import Chunk from "../Chunk" */
+/** @import Compiler from "../Compiler" */
+/** @import { RuntimeSpec } from "../util/runtime" */
 
 /**
  * Defines the read file compile async wasm plugin options type used by this module.
@@ -63,21 +57,42 @@ class ReadFileCompileAsyncWasmPlugin {
 				return wasmLoading === "async-node";
 			};
 
+			// The call site already passes a complete `URL` when it bakes one, and `readFile`
+			// takes one as-is. Read that per call: it depends on parse results, so it is not
+			// settled while the plugin is being applied.
+			/**
+			 * @param {string} path rendered path to the wasm file
+			 * @param {RuntimeSpec} runtime the runtime this loader serves
+			 * @returns {string} the argument to hand the reader
+			 */
+			const wasmUrlArg = (path, runtime) =>
+				compilation.runtimeTemplate.supportsAnalyzable(
+					"wasm",
+					undefined,
+					undefined,
+					runtime
+				)
+					? path
+					: compilation.runtimeTemplate.importMetaUrl(path);
 			/**
-			 * @type {(path: string) => string} callback to generate code to load the wasm file
+			 * @type {(path: string, runtime: RuntimeSpec) => string} callback to generate code to load the wasm file
 			 */
 			const generateLoadBinaryCode = this._import
-				? (path) =>
+				? (path, runtime) =>
 						Template.asString([
 							"Promise.all([import('fs'), import('url')]).then(([{ readFile }, { URL }]) => new Promise((resolve, reject) => {",
 							Template.indent([
-								`readFile(new URL(${path}, ${compilation.outputOptions.importMetaName}.url), (err, buffer) => {`,
+								`readFile(${wasmUrlArg(path, runtime)}, (err, buffer) => {`,
 								Template.indent([
 									"if (err) return reject(err);",
 									"",
 									"// Fake fetch response",
 									"resolve({",
-									Template.indent(["arrayBuffer() { return buffer; }"]),
+									Template.indent([
+										// Return a real ArrayBuffer: some runtimes (e.g. Deno)
+										// reject a Node Buffer view here as "not a buffer source".
+										"arrayBuffer() { return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength); }"
+									]),
 									"});"
 								]),
 								"});"
@@ -90,8 +105,14 @@ class ReadFileCompileAsyncWasmPlugin {
 							Template.indent([
 								"try {",
 								Template.indent([
-									`var { readFile } = require(${compilation.runtimeTemplate.renderNodePrefixForCoreModule("fs")});`,
-									`var { join } = require(${compilation.runtimeTemplate.renderNodePrefixForCoreModule("path")});`,
+									compilation.runtimeTemplate.destructureObject(
+										["readFile"],
+										`require(${compilation.runtimeTemplate.renderNodePrefixForCoreModule("fs")})`
+									),
+									compilation.runtimeTemplate.destructureObject(
+										["join"],
+										`require(${compilation.runtimeTemplate.renderNodePrefixForCoreModule("path")})`
+									),
 									"",
 									`readFile(join(__dirname, ${path}), function(err, buffer){`,
 									Template.indent([
@@ -99,7 +120,15 @@ class ReadFileCompileAsyncWasmPlugin {
 										"",
 										"// Fake fetch response",
 										"resolve({",
-										Template.indent(["arrayBuffer() { return buffer; }"]),
+										Template.indent([
+											// Return a real ArrayBuffer: some runtimes (e.g. Deno)
+											// reject a Node Buffer view here as "not a buffer source".
+											compilation.runtimeTemplate.method(
+												"arrayBuffer",
+												"",
+												"return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);"
+											)
+										]),
 										"});"
 									]),
 									"});"
@@ -121,14 +150,30 @@ class ReadFileCompileAsyncWasmPlugin {
 					) {
 						return;
 					}
+					// A baked URL is already a literal, so nothing interpolates the name.
 					if (
-						usesFullHash(compilation.outputOptions.webassemblyModuleFilename)
+						!compilation.runtimeTemplate.supportsAnalyzable(
+							"wasm",
+							undefined,
+							undefined,
+							chunk.runtime
+						) &&
+						needsRuntimeFullHash(
+							/** @type {string} */ (
+								compilation.outputOptions.webassemblyModuleFilename
+							)
+						)
 					) {
 						set.add(RuntimeGlobals.getFullHash);
 					}
 					compilation.addRuntimeModule(
 						chunk,
 						new AsyncWasmLoadingRuntimeModule({
+							fullHashDigest: usesFullHashDigest(
+								/** @type {string} */ (
+									compilation.outputOptions.webassemblyModuleFilename
+								)
+							),
 							generateLoadBinaryCode,
 							supportsStreaming: false
 						})
@@ -147,14 +192,30 @@ class ReadFileCompileAsyncWasmPlugin {
 					) {
 						return;
 					}
+					// A baked URL is already a literal, so nothing interpolates the name.
 					if (
-						usesFullHash(compilation.outputOptions.webassemblyModuleFilename)
+						!compilation.runtimeTemplate.supportsAnalyzable(
+							"wasm",
+							undefined,
+							undefined,
+							chunk.runtime
+						) &&
+						needsRuntimeFullHash(
+							/** @type {string} */ (
+								compilation.outputOptions.webassemblyModuleFilename
+							)
+						)
 					) {
 						set.add(RuntimeGlobals.getFullHash);
 					}
 					compilation.addRuntimeModule(
 						chunk,
 						new AsyncWasmCompileRuntimeModule({
+							fullHashDigest: usesFullHashDigest(
+								/** @type {string} */ (
+									compilation.outputOptions.webassemblyModuleFilename
+								)
+							),
 							generateLoadBinaryCode,
 							supportsStreaming: false
 						})