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

package/lib/dependencies/importOptionsCheck.js

@@ -0,0 +1,47 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const Template = require("../Template");
+
+/** @import RuntimeTemplate from "../RuntimeTemplate" */
+
+/**
+ * Wraps an import so its arguments evaluate in source order and the options are
+ * checked, rejecting rather than throwing. The last parameter holds them.
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @param {string[]} parameters parameter names, the options one last
+ * @param {string} content the import expression to return once the check passes
+ * @returns {string} the wrapping function
+ */
+const importOptionsCheck = (runtimeTemplate, parameters, content) => {
+	const options = parameters[parameters.length - 1];
+	return runtimeTemplate.basicFunction(parameters.join(", "), [
+		"try {",
+		Template.indent([
+			`if (${options} !== undefined) {`,
+			Template.indent([
+				`if ((typeof ${options} !== "object" && typeof ${options} !== "function") || ${options} === null) throw new TypeError("The second argument to import() must be an object");`,
+				`var a = ${options}["with"];`,
+				"if (a !== undefined) {",
+				Template.indent([
+					'if ((typeof a !== "object" && typeof a !== "function") || a === null) throw new TypeError("The \'with\' option must be an object");',
+					"for (var k = Object.keys(a), i = 0; i < k.length; i++) {",
+					Template.indent([
+						'if (typeof a[k[i]] !== "string") throw new TypeError("Import attribute values must be strings");'
+					]),
+					"}"
+				]),
+				"}"
+			]),
+			"}"
+		]),
+		"} catch (e) { return Promise.reject(e); }",
+		`return ${content};`
+	]);
+};
+
+module.exports = importOptionsCheck;

package/lib/dll/DelegatedModule.js

@@ -242,6 +242,7 @@ class DelegatedModule extends Module {
 	updateHash(hash, context) {
 		hash.update(this.delegationType);
 		hash.update(JSON.stringify(this.request));
+		hash.update(JSON.stringify(this.delegateData));
 		super.updateHash(hash, context);
 	}
 
@@ -299,7 +300,23 @@ class DelegatedModule extends Module {
 		this.delegationType = m.delegationType;
 		this.userRequest = m.userRequest;
 		this.originalRequest = m.originalRequest;
-		this.delegateData = m.delegateData;
+		const next = m.delegateData;
+		// cleanupForCache clears delegateData; compare surviving build products instead.
+		if (this.buildMeta) {
+			const nextMeta = { ...next.buildMeta };
+			const exportsDependency = this.dependencies[1];
+			const builtExports =
+				exportsDependency instanceof StaticExportsDependency
+					? exportsDependency.exports
+					: undefined;
+			if (
+				JSON.stringify(this.buildMeta) !== JSON.stringify(nextMeta) ||
+				JSON.stringify(builtExports) !== JSON.stringify(next.exports || true)
+			) {
+				this.buildMeta = undefined;
+			}
+		}
+		this.delegateData = next;
 	}
 
 	/**

package/lib/dll/DllReferencePlugin.js

@@ -8,7 +8,7 @@
 const ExternalModuleFactoryPlugin = require("../ExternalModuleFactoryPlugin");
 const DelegatedSourceDependency = require("../dependencies/DelegatedSourceDependency");
 const WebpackError = require("../errors/WebpackError");
-const { makePathsRelative } = require("../util/identifier");
+const { fileUrlToPath, makePathsRelative } = require("../util/identifier");
 const parseJson = require("../util/parseJson");
 const DelegatedModuleFactoryPlugin = require("./DelegatedModuleFactoryPlugin");
 
@@ -72,12 +72,13 @@ class DllReferencePlugin {
 			if ("manifest" in this.options) {
 				const manifest = this.options.manifest;
 				if (typeof manifest === "string") {
+					const manifestPath = fileUrlToPath(manifest);
 					/** @type {InputFileSystem} */
-					(compiler.inputFileSystem).readFile(manifest, (err, result) => {
+					(compiler.inputFileSystem).readFile(manifestPath, (err, result) => {
 						if (err) return callback(err);
 						/** @type {CompilationDataItem} */
 						const data = {
-							path: manifest,
+							path: manifestPath,
 							data: undefined,
 							error: undefined
 						};
@@ -93,13 +94,13 @@ class DllReferencePlugin {
 						} catch (parseErr) {
 							// Store the error in the params so that it can
 							// be added as a compilation error later on.
-							const manifestPath = makePathsRelative(
+							const relativePath = makePathsRelative(
 								compiler.context,
-								manifest,
+								manifestPath,
 								compiler.root
 							);
 							data.error = new DllManifestError(
-								manifestPath,
+								relativePath,
 								/** @type {Error} */ (parseErr).message
 							);
 						}
@@ -153,7 +154,9 @@ class DllReferencePlugin {
 				source,
 				type: this.options.type,
 				scope: this.options.scope,
-				context: this.options.context || compiler.context,
+				context: this.options.context
+					? fileUrlToPath(this.options.context)
+					: compiler.context,
 				content:
 					/** @type {DllReferencePluginOptionsContent} */
 					(resolvedContent),
@@ -176,7 +179,7 @@ class DllReferencePlugin {
 							/** @type {DllManifestError} */ (data.error)
 						);
 					}
-					compilation.fileDependencies.add(manifest);
+					compilation.fileDependencies.add(fileUrlToPath(manifest));
 				}
 			}
 		});

package/lib/dll/LibManifestPlugin.js

@@ -5,9 +5,9 @@
 
 "use strict";
 
-const asyncLib = require("neo-async");
 const EntryDependency = require("../dependencies/EntryDependency");
 const { someInIterable } = require("../util/IterableHelpers");
+const asyncLib = require("../util/async");
 const { compareModulesById } = require("../util/comparators");
 const { dirname, mkdirp } = require("../util/fs");
 

package/lib/errors/AnalyzableBailoutsWarning.js

@@ -0,0 +1,41 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/**
+ * @typedef {object} BailoutDetails
+ * @property {string} reason what keeps the runtime form, as the code generation recorded it
+ * @property {string[]} modules the modules it was recorded on, as many as are printed
+ * @property {number} count how many modules it was recorded on in all
+ */
+
+class AnalyzableBailoutsWarning extends WebpackError {
+	/**
+	 * Creates an instance of AnalyzableBailoutsWarning.
+	 * @param {BailoutDetails[]} bailouts the reasons found, the most frequent first
+	 * @param {number} references how many module and reason pairs there are
+	 */
+	constructor(bailouts, references) {
+		const list = bailouts
+			.map((it) => {
+				const more = it.count - it.modules.length;
+				const names = `${it.modules.join(", ")}${more > 0 ? `, and ${more} more` : ""}`;
+				return `\n  ${it.reason}\n    ${names}`;
+			})
+			.join("");
+
+		super(
+			`analyzable ESM output: ${references} ${references === 1 ? "reference keeps" : "references keep"} the runtime form:${list}\nA bundler reading this output cannot follow such a reference without running webpack's runtime. Each reason names the setting that keeps it; changing that setting lets the reference be written as a literal import() or new URL().\nFor more info visit https://webpack.js.org/configuration/output/#outputmodule`
+		);
+
+		/** @type {string} */
+		this.name = "AnalyzableBailoutsWarning";
+	}
+}
+
+module.exports = AnalyzableBailoutsWarning;

package/lib/errors/DotenvFileError.js

@@ -0,0 +1,29 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/**
+ * Error for a dotenv file that exists but could not be read. An absent file is
+ * normal and reported through `missingDependencies` instead.
+ */
+class DotenvFileError extends WebpackError {
+	/**
+	 * @param {string} file path of the dotenv file
+	 * @param {Error} error underlying file system error
+	 */
+	constructor(file, error) {
+		super(`Unable to read the dotenv file ${file}\n${error.message}`);
+
+		this.name = "DotenvFileError";
+		/** @type {string} */
+		this.file = file;
+		this.error = error;
+	}
+}
+
+module.exports = DotenvFileError;

package/lib/errors/DuplicateModulesWarning.js

@@ -12,6 +12,7 @@ const WebpackError = require("./WebpackError");
  * @typedef {object} DuplicateModuleDetails
  * @property {string} name
  * @property {number} chunks how many chunks carry a copy
+ * @property {string[]} entrypoints the entrypoints those chunks belong to, when more than one
  * @property {number} wasted bytes the extra copies cost
  */
 
@@ -23,18 +24,22 @@ class DuplicateModulesWarning extends WebpackError {
 	 */
 	constructor(modules, wasted) {
 		const list = modules
-			.map(
-				(module) =>
-					`\n  ${module.name} (in ${module.chunks} chunks, ${formatSize(
-						module.wasted
-					)} extra)`
-			)
+			.map((module) => {
+				// Which entrypoints pay for it is the actionable part, so it leads
+				// where the copies are spread across more than one.
+				const where =
+					module.entrypoints.length > 1
+						? `in ${module.entrypoints.join(", ")}, ${module.chunks} chunks`
+						: `in ${module.chunks} chunks`;
+
+				return `\n  ${module.name} (${where}, ${formatSize(module.wasted)} extra)`;
+			})
 			.join("");
 
 		super(
 			`duplicate modules: copies of the same module across chunks add ${formatSize(
 				wasted
-			)}:${list}\nA module reached from several chunks is emitted into each of them unless a shared chunk holds it. 'optimization.splitChunks' can pull it into one.\nFor more info visit https://webpack.js.org/plugins/split-chunks-plugin/`
+			)}:${list}\nA module reached from several chunks is emitted into each of them unless a shared chunk holds it. 'optimization.splitChunks' can pull it into one, with 'chunks: "all"' where the copies are in different entrypoints.\nFor more info visit https://webpack.js.org/plugins/split-chunks-plugin/`
 		);
 
 		/** @type {string} */

package/lib/errors/EmptyCopyPatternWarning.js

@@ -0,0 +1,26 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+class EmptyCopyPatternWarning extends WebpackError {
+	/**
+	 * Creates an instance of EmptyCopyPatternWarning.
+	 * @param {string} from the `from` of the pattern as written in the configuration
+	 * @param {string} glob the glob `from` was resolved to
+	 */
+	constructor(from, glob) {
+		super(
+			`The '${from}' pattern of 'output.copy' copied no file.\nIt resolved to '${glob}', which matches nothing on disk — usually a typo, a path relative to the wrong directory, or a directory a previous build step was supposed to create.\nSilence it with 'ignoreWarnings' when the pattern is optional.`
+		);
+
+		/** @type {string} */
+		this.name = "EmptyCopyPatternWarning";
+	}
+}
+
+module.exports = EmptyCopyPatternWarning;

package/lib/errors/ExternalStarReexportError.js

@@ -0,0 +1,44 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/** @import ExternalModule from "../ExternalModule" */
+/** @import Module from "../Module" */
+
+/**
+ * Error raised when a `module` library reexports everything from an external
+ * whose request names a property path instead of a module.
+ */
+class ExternalStarReexportError extends WebpackError {
+	/**
+	 * Captures the external and the library entry reexporting from it.
+	 * @param {ExternalModule} externalModule the reexported external
+	 * @param {Module} module the library entry module
+	 */
+	constructor(externalModule, module) {
+		const request = /** @type {string[]} */ (
+			externalModule.getResolvedRequest()
+		);
+		super(
+			`Can't 'export * from ${JSON.stringify(
+				externalModule.userRequest
+			)}': the external is configured as ${JSON.stringify(
+				request
+			)}, which is a property of ${JSON.stringify(
+				request[0]
+			)} and has no module specifier to reexport. Reexport the names explicitly or configure the external without a property path.`
+		);
+
+		/** @type {string} */
+		this.name = "ExternalStarReexportError";
+		/** @type {Module} */
+		this.module = module;
+	}
+}
+
+module.exports = ExternalStarReexportError;

package/lib/errors/HookWebpackError.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const { toError } = require("../ErrorHelpers");
 const makeSerializable = require("../util/makeSerializable");
 const WebpackError = require("./WebpackError");
 
@@ -67,13 +68,13 @@ makeSerializable(HookWebpackError, "webpack/lib/errors/HookWebpackError");
 
 /**
  * Creates webpack error.
- * @param {Error} error an error
+ * @param {EXPECTED_ANY} error what a plugin failed with
  * @param {string} hook name of the hook
  * @returns {WebpackError} a webpack error
  */
 const makeWebpackError = (error, hook) => {
 	if (error instanceof WebpackError) return error;
-	return new HookWebpackError(error, hook);
+	return new HookWebpackError(toError(error), hook);
 };
 
 HookWebpackError.makeWebpackError = makeWebpackError;

package/lib/errors/ImportedBindingAssignmentError.js

@@ -0,0 +1,30 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const WebpackError = require("./WebpackError");
+
+class ImportedBindingAssignmentError extends WebpackError {
+	/**
+	 * Creates an instance of ImportedBindingAssignmentError.
+	 * @param {string} name the local name of the namespace binding
+	 */
+	constructor(name) {
+		super(
+			`Assignment to the imported binding '${name}'. A namespace import is immutable, so this throws a TypeError where the module is a real ES module.`
+		);
+
+		this.name = "ImportedBindingAssignmentError";
+	}
+}
+
+makeSerializable(
+	ImportedBindingAssignmentError,
+	"webpack/lib/errors/ImportedBindingAssignmentError"
+);
+
+module.exports = ImportedBindingAssignmentError;

package/lib/errors/MissingSourceMapsWarning.js

@@ -0,0 +1,36 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/**
+ * @typedef {object} MissingSourceMapDetails
+ * @property {string} name the module, by request
+ * @property {string[]} loaders the loaders that ran on it
+ */
+
+class MissingSourceMapsWarning extends WebpackError {
+	/**
+	 * Creates an instance of MissingSourceMapsWarning.
+	 * @param {MissingSourceMapDetails[]} modules the modules whose map was lost
+	 * @param {number} total how many such modules there are
+	 */
+	constructor(modules, total) {
+		const list = modules
+			.map((it) => `\n  ${it.name} (${it.loaders.join(", ")})`)
+			.join("");
+
+		super(
+			`missing source maps: ${total} ${total === 1 ? "module was" : "modules were"} transformed by a loader that returned no source map:${list}\nA loader that rewrites code without returning a map leaves webpack mapping positions to the loader's output as though it were the file on disk, so every line the map names below that point is likely to be wrong. Have the loader pass its map to 'this.callback(null, code, map)', or take the loader out of the chain for this build.\nFor more info visit https://webpack.js.org/api/loaders/#thiscallback`
+		);
+
+		/** @type {string} */
+		this.name = "MissingSourceMapsWarning";
+	}
+}
+
+module.exports = MissingSourceMapsWarning;

package/lib/errors/ModuleParseError.js

@@ -101,7 +101,8 @@ class ModuleParseError extends WebpackError {
 				}
 			}
 
-			loc = { start: err.loc };
+			// a plain copy: a parser's own position class must not reach the cache
+			loc = { start: { line: lineNumber, column: err.loc.column } };
 		} else if (err && err.stack) {
 			message += `\n${err.stack}`;
 		}

package/lib/errors/UnusedAssetsWarning.js

@@ -0,0 +1,36 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/**
+ * @typedef {object} UnusedAssetDetails
+ * @property {string} name the module, by request
+ * @property {number} size the bytes its file adds to the output
+ */
+
+class UnusedAssetsWarning extends WebpackError {
+	/**
+	 * Creates an instance of UnusedAssetsWarning.
+	 * @param {UnusedAssetDetails[]} assets the assets nothing reads
+	 * @param {number} total the bytes they add between them
+	 */
+	constructor(assets, total) {
+		const list = assets
+			.map((it) => `\n  ${it.name} (${it.size} bytes)`)
+			.join("");
+
+		super(
+			`unused assets: ${total} bytes are emitted for ${assets.length === 1 ? "an import whose binding" : "imports whose bindings"} nothing reads:${list}\nThe import brings the file into the output but its value is never used, so the bytes ship for nothing. Drop the import, or write it as 'import "./file"' with no binding where the file is wanted on disk regardless — 'experiments.futureDefaults' already leaves those alone and drops these.\nFor more info visit https://webpack.js.org/guides/asset-modules/`
+		);
+
+		/** @type {string} */
+		this.name = "UnusedAssetsWarning";
+	}
+}
+
+module.exports = UnusedAssetsWarning;

package/lib/errors/UnusedFederationWarning.js

@@ -0,0 +1,35 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/**
+ * @typedef {object} UnusedFederationDetails
+ * @property {string} name the share key or remote name, as declared
+ * @property {"shared" | "remote"} kind which list declared it
+ */
+
+class UnusedFederationWarning extends WebpackError {
+	/**
+	 * Creates an instance of UnusedFederationWarning.
+	 * @param {UnusedFederationDetails[]} entries the entries nothing used
+	 */
+	constructor(entries) {
+		const list = entries
+			.map((entry) => `\n  ${entry.name} (${entry.kind})`)
+			.join("");
+
+		super(
+			`unused federation config: ${entries.length} ${entries.length === 1 ? "entry was" : "entries were"} declared but never used:${list}\nA 'shared' key nothing imports is not shared at all — each side keeps its own copy, which for a package holding state breaks at runtime rather than only costing bytes. A 'remotes' name nothing imports is dead configuration, or names a remote the code spells differently.\nFor more info visit https://webpack.js.org/concepts/module-federation/`
+		);
+
+		/** @type {string} */
+		this.name = "UnusedFederationWarning";
+	}
+}
+
+module.exports = UnusedFederationWarning;

package/lib/errors/UnusedModulesWarning.js

@@ -0,0 +1,38 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/**
+ * @typedef {object} UnusedModuleDetails
+ * @property {string} name the module, by request
+ * @property {number} size the bytes it adds to the bundle
+ * @property {string} statement the statement that kept it, as `type at location`
+ */
+
+class UnusedModulesWarning extends WebpackError {
+	/**
+	 * Creates an instance of UnusedModulesWarning.
+	 * @param {UnusedModuleDetails[]} modules the modules nothing uses
+	 * @param {number} total how many such modules there are
+	 * @param {number} size the bytes they add between them
+	 */
+	constructor(modules, total, size) {
+		const list = modules
+			.map((it) => `\n  ${it.name} (${it.size} bytes) — ${it.statement}`)
+			.join("");
+
+		super(
+			`unused modules: ${total} ${total === 1 ? "module is" : "modules are"} bundled although nothing uses what they export, costing ${size} bytes:${list}\nEach is kept only by the statement named above, which runs for its effect rather than for anything the importer reads. Move that effect to where it is wanted, or drop the import — 'sideEffects' in the package's package.json says so for a whole package at once.\nFor more info visit https://webpack.js.org/guides/tree-shaking/#mark-the-file-as-side-effect-free`
+		);
+
+		/** @type {string} */
+		this.name = "UnusedModulesWarning";
+	}
+}
+
+module.exports = UnusedModulesWarning;

package/lib/esm/ExportWebpackRequireRuntimeModule.js

@@ -22,6 +22,15 @@ class ExportWebpackRequireRuntimeModule extends RuntimeModule {
 		return false;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/esm/ModuleChunkFormatPlugin.js

@@ -19,7 +19,10 @@ const {
 	getChunkFilenameTemplate,
 	getCompilationHooks
 } = require("../javascript/JavascriptModulesPlugin");
-const { entryModuleIdExpression } = require("../javascript/StartupHelpers");
+const {
+	entryModuleIdExpression,
+	renderAwaitedEntries
+} = require("../javascript/StartupHelpers");
 const { getUndoPath } = require("../util/identifier");
 
 /** @import { Source } from "webpack-sources" */
@@ -186,7 +189,8 @@ class ModuleChunkFormatPlugin {
 				}
 			);
 			hooks.renderChunk.tap(PLUGIN_NAME, (modules, renderContext) => {
-				const { chunk, chunkGraph, runtimeTemplate } = renderContext;
+				const { chunk, chunkGraph, moduleGraph, runtimeTemplate } =
+					renderContext;
 				const hotUpdateChunk = chunk instanceof HotUpdateChunk ? chunk : null;
 				const source = new ConcatSource();
 				const cst = runtimeTemplate.renderConst();
@@ -239,6 +243,17 @@ class ModuleChunkFormatPlugin {
 						);
 					}
 
+					const entryOptions = chunk.getEntryOptions();
+					const library =
+						entryOptions && entryOptions.library !== undefined
+							? entryOptions.library
+							: runtimeTemplate.outputOptions.library;
+					// A module library awaits the entry itself, in `ModuleLibraryPlugin`.
+					const canAwaitEntry =
+						runtimeTemplate.supportsTopLevelAwait() &&
+						!(library !== undefined && library.type === "module");
+					/** @type {string[]} */
+					const awaitedEntries = [];
 					/** @type {Set<Chunk>} */
 					const loadedChunks = new Set();
 					let ownInstalled = false;
@@ -296,13 +311,23 @@ class ModuleChunkFormatPlugin {
 							startupSource.add(inlinedEntrySource);
 							startupSource.add("\n");
 						} else {
+							// An async entry nobody awaits settles after the bundle did,
+							// which orphans its rejection.
+							const awaitEntry = canAwaitEntry && moduleGraph.isAsync(module);
+							const target = final
+								? RuntimeGlobals.exports
+								: `${RuntimeGlobals.exports}_${i}`;
 							startupSource.add(
 								`${
-									final ? `var ${RuntimeGlobals.exports} = ` : ""
+									final || awaitEntry ? `var ${target} = ` : ""
 								}__webpack_exec__(${JSON.stringify(moduleId)});\n`
 							);
+							if (awaitEntry) awaitedEntries.push(target);
 						}
 					}
+					for (const line of renderAwaitedEntries(awaitedEntries)) {
+						startupSource.add(`${line}\n`);
+					}
 
 					entrySource.add(
 						hooks.renderStartup.call(