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

package/lib/errors/TinyChunksWarning.js

@@ -0,0 +1,40 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const formatSize = require("../util/formatSize");
+const WebpackError = require("./WebpackError");
+
+/**
+ * @typedef {object} TinyChunkDetails
+ * @property {string} name the chunk, by name or by id
+ * @property {number} size bytes it carries
+ */
+
+class TinyChunksWarning extends WebpackError {
+	/**
+	 * Creates an instance of TinyChunksWarning.
+	 * @param {TinyChunkDetails[]} chunks the smallest of them
+	 * @param {number} total how many fall under the floor in all
+	 * @param {number} totalSize bytes they carry between them
+	 */
+	constructor(chunks, total, totalSize) {
+		const list = chunks
+			.map((chunk) => `\n  ${chunk.name} (${formatSize(chunk.size)})`)
+			.join("");
+
+		super(
+			`tiny chunks: ${total} chunks are loaded on demand but carry less than 'optimization.splitChunks.minSize', ${formatSize(
+				totalSize
+			)} between them:${list}\nEach costs a request of its own, and that option is already the size below which webpack itself declines to make a chunk. Giving several 'import()' calls one 'webpackChunkName' groups them into a single chunk.\nFor more info visit https://webpack.js.org/api/module-methods/#magic-comments`
+		);
+
+		/** @type {string} */
+		this.name = "TinyChunksWarning";
+	}
+}
+
+module.exports = TinyChunksWarning;

package/lib/errors/TopLevelThisWarning.js

@@ -0,0 +1,34 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/**
+ * @typedef {object} TopLevelThisDetails
+ * @property {string} name the module, by request
+ * @property {number} count how many times it reads `this` at the top level
+ */
+
+class TopLevelThisWarning extends WebpackError {
+	/**
+	 * Creates an instance of TopLevelThisWarning.
+	 * @param {TopLevelThisDetails[]} modules the modules that do it
+	 * @param {number} total how many such reads there are in all
+	 */
+	constructor(modules, total) {
+		const list = modules.map((it) => `\n  ${it.name} (${it.count})`).join("");
+
+		super(
+			`top-level this: ${total} ${total === 1 ? "read" : "reads"} of 'this' at the top level of an ES module:${list}\nwebpack is treating these as ES modules, where 'this' is 'undefined' at the top level rather than 'module.exports' — so a file that worked as CommonJS reads nothing once it is bundled this way. A single 'import' or 'export' is enough to make 'javascript/auto' decide a file is an ES module. Use 'globalThis' where the global object was meant, 'import.meta' for anything about the module, or give the file a '.cjs' extension to keep it CommonJS.\nFor more info visit https://webpack.js.org/api/module-variables/#importmeta`
+		);
+
+		/** @type {string} */
+		this.name = "TopLevelThisWarning";
+	}
+}
+
+module.exports = TopLevelThisWarning;

package/lib/errors/UnsplitVendorsWarning.js

@@ -0,0 +1,42 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const formatSize = require("../util/formatSize");
+const WebpackError = require("./WebpackError");
+
+/**
+ * @typedef {object} UnsplitVendorChunkDetails
+ * @property {string} name
+ * @property {number} vendorModules how many of its modules come from node_modules
+ * @property {number} vendorSize bytes those modules contribute
+ */
+
+class UnsplitVendorsWarning extends WebpackError {
+	/**
+	 * Creates an instance of UnsplitVendorsWarning.
+	 * @param {UnsplitVendorChunkDetails[]} chunks the worst offenders, largest vendor size first
+	 */
+	constructor(chunks) {
+		const list = chunks
+			.map(
+				(chunk) =>
+					`\n  ${chunk.name} (${chunk.vendorModules} modules from node_modules, ${formatSize(
+						chunk.vendorSize
+					)})`
+			)
+			.join("");
+
+		super(
+			`unsplit vendors: initial chunks carry node_modules code next to application code:${list}\nThe dependencies then get a new hash on every application change, so returning visitors download them again. 'optimization.splitChunks' can move them into a chunk of their own.\nFor more info visit https://webpack.js.org/plugins/split-chunks-plugin/`
+		);
+
+		/** @type {string} */
+		this.name = "UnsplitVendorsWarning";
+	}
+}
+
+module.exports = UnsplitVendorsWarning;

package/lib/errors/UnsupportedFeatureWarning.js

@@ -8,7 +8,7 @@
 const makeSerializable = require("../util/makeSerializable");
 const WebpackError = require("./WebpackError");
 
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @import { DependencyLocation } from "../Dependency" */
 
 class UnsupportedFeatureWarning extends WebpackError {
 	/**

package/lib/errors/UnusedAliasesWarning.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");
+
+class UnusedAliasesWarning extends WebpackError {
+	/**
+	 * Creates an instance of UnusedAliasesWarning.
+	 * @param {string[]} names the alias names no request matched
+	 */
+	constructor(names) {
+		super(
+			`webpack alias recommendations: \nThe following 'resolve.alias' ${
+				names.length === 1 ? "entry was" : "entries were"
+			} never applied to a request: ${names.join(
+				", "
+			)}.\nAn alias nothing matches is usually a typo in the name, or a leftover from a package that is now imported directly. Note that an alias is matched against the request as written, so renaming the request without renaming the alias leaves the alias dead and the original request resolved as-is.\nFor more info visit https://webpack.js.org/configuration/resolve/#resolvealias`
+		);
+
+		/** @type {string} */
+		this.name = "UnusedAliasesWarning";
+	}
+}
+
+module.exports = UnusedAliasesWarning;

package/lib/errors/UnusedDefinesWarning.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");
+
+class UnusedDefinesWarning extends WebpackError {
+	/**
+	 * Creates an instance of UnusedDefinesWarning.
+	 * @param {string[]} keys the define keys nothing referenced
+	 */
+	constructor(keys) {
+		super(
+			`webpack define recommendations: \nThe following ${
+				keys.length === 1 ? "key was" : "keys were"
+			} defined but never referenced by any module: ${keys.join(
+				", "
+			)}.\nA key that substitutes nothing is usually a typo, or a leftover from code that no longer reads it. Every key still costs a parser hook on each module, and changing its value invalidates the build for nothing.\nFor more info visit https://webpack.js.org/plugins/define-plugin/`
+		);
+
+		/** @type {string} */
+		this.name = "UnusedDefinesWarning";
+	}
+}
+
+module.exports = UnusedDefinesWarning;

package/lib/errors/UnusedExternalsWarning.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");
+
+class UnusedExternalsWarning extends WebpackError {
+	/**
+	 * Creates an instance of UnusedExternalsWarning.
+	 * @param {string[]} requests the external requests nothing imported
+	 */
+	constructor(requests) {
+		super(
+			`webpack externals recommendations: \nThe following ${
+				requests.length === 1 ? "external was" : "externals were"
+			} declared but never imported: ${requests.join(
+				", "
+			)}.\nAn external that nothing requests is usually a typo in the request, or a leftover from a dependency that is now bundled. It also hides a real import behind the wrong name, which then gets bundled instead of staying external.\nFor more info visit https://webpack.js.org/configuration/externals/`
+		);
+
+		/** @type {string} */
+		this.name = "UnusedExternalsWarning";
+	}
+}
+
+module.exports = UnusedExternalsWarning;

package/lib/errors/UnusedReexportsWarning.js

@@ -0,0 +1,42 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const formatSize = require("../util/formatSize");
+const WebpackError = require("./WebpackError");
+
+/**
+ * @typedef {object} UnusedReexportDetails
+ * @property {string} name
+ * @property {number} size bytes the module costs
+ */
+
+class UnusedReexportsWarning extends WebpackError {
+	/**
+	 * Creates an instance of UnusedReexportsWarning.
+	 * @param {UnusedReexportDetails[]} modules the worst offenders, largest first
+	 * @param {number} total how many modules are bundled unused
+	 * @param {number} wasted bytes they cost together
+	 */
+	constructor(modules, total, wasted) {
+		const list = modules
+			.map((module) => `\n  ${module.name} (${formatSize(module.size)})`)
+			.join("");
+
+		super(
+			`unused re-exports: ${total} ${
+				total === 1 ? "module is" : "modules are"
+			} bundled although nothing uses what they export, adding ${formatSize(
+				wasted
+			)}:${list}\nA module you import re-exports them, and their top-level code has side effects webpack is not allowed to drop. Setting '"sideEffects": false' in the package.json that owns them lets webpack leave them out.\nFor more info visit https://webpack.js.org/guides/tree-shaking/`
+		);
+
+		/** @type {string} */
+		this.name = "UnusedReexportsWarning";
+	}
+}
+
+module.exports = UnusedReexportsWarning;

package/lib/errors/UnusedRuleWarning.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");
+
+class UnusedRuleWarning extends WebpackError {
+	/**
+	 * Creates an instance of UnusedRuleWarning.
+	 * @param {string[]} rules descriptions of the rules that never matched
+	 */
+	constructor(rules) {
+		super(
+			`webpack rule recommendations: \nThe following ${
+				rules.length === 1 ? "rule was" : "rules were"
+			} never applied to a module: ${rules.join(
+				", "
+			)}.\nA rule that matches nothing is usually a typo in 'test', 'include' or 'exclude', or a leftover from a removed file type. Plugins add rules as well, so a rule listed here may come from a plugin rather than from your configuration.\nFor more info visit https://webpack.js.org/configuration/module/#modulerules`
+		);
+
+		/** @type {string} */
+		this.name = "UnusedRuleWarning";
+	}
+}
+
+module.exports = UnusedRuleWarning;

package/lib/errors/WebpackError.js

@@ -8,11 +8,15 @@
 const inspect = require("util").inspect.custom;
 const makeSerializable = require("../util/makeSerializable");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @import Chunk from "../Chunk" */
+/** @import { DependencyLocation } from "../Dependency" */
+/** @import Module from "../Module" */
+/**
+ * @import {
+ * 	ObjectDeserializerContext,
+ * 	ObjectSerializerContext
+ * } from "../serialization/ObjectMiddleware"
+ */
 
 class WebpackError extends Error {
 	/**

package/lib/errors/deriveStackFromNestedError.js

@@ -0,0 +1,90 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/** @import { ErrorWithHideStack } from "./ModuleBuildError" */
+/** @import WebpackError from "./WebpackError" */
+
+/**
+ * Returns the nested error's stack without its leading "Name: message" line.
+ * @param {ErrorWithHideStack} nestedError the wrapped error
+ * @returns {string | undefined} frames of the nested stack
+ */
+const getNestedFrames = (nestedError) => {
+	const stack = nestedError.stack;
+	if (!stack) return undefined;
+	const firstLineEnd = stack.indexOf("\n");
+	return firstLineEnd === -1 ? "" : stack.slice(firstLineEnd + 1);
+};
+
+/**
+ * Derives `details` — or, for a `hideStack` error, `stack` — of a diagnostic
+ * that wraps `nestedError`. V8 formats a stack trace only when it is read, and
+ * a diagnostic is normally printed without one (stats needs `errorDetails` or
+ * `errorStack` for that), so the derived string is materialized on first
+ * access: a build with thousands of dependency warnings would otherwise spend a
+ * large share of its time formatting stacks that nothing ever reads.
+ * @param {WebpackError} error the wrapping diagnostic
+ * @param {ErrorWithHideStack | undefined} nestedError the wrapped error
+ * @returns {void}
+ */
+const deriveStackFromNestedError = (error, nestedError) => {
+	if (!nestedError) return;
+	if (nestedError.hideStack) {
+		// the frames are hidden, but they are still prepended to the own stack
+		const ownStack =
+			/** @type {PropertyDescriptor} */
+			(Object.getOwnPropertyDescriptor(error, "stack"));
+		/** @type {string | undefined} */
+		let stack;
+		let computed = false;
+		Object.defineProperty(error, "stack", {
+			configurable: true,
+			enumerable: false,
+			get() {
+				if (!computed) {
+					computed = true;
+					const own = ownStack.get ? ownStack.get.call(error) : ownStack.value;
+					const frames = getNestedFrames(nestedError);
+					stack = frames === undefined ? own : `${frames}\n\n${own}`;
+					// older V8 replaces the own `stack` accessor when it is first read
+					Object.defineProperty(error, "stack", {
+						configurable: true,
+						enumerable: false,
+						writable: true,
+						value: stack
+					});
+				}
+				return stack;
+			},
+			set(value) {
+				computed = true;
+				stack = value;
+			}
+		});
+		return;
+	}
+	/** @type {string | undefined} */
+	let details;
+	let computed = false;
+	Object.defineProperty(error, "details", {
+		configurable: true,
+		enumerable: true,
+		get() {
+			if (!computed) {
+				computed = true;
+				details = getNestedFrames(nestedError);
+			}
+			return details;
+		},
+		set(value) {
+			computed = true;
+			details = value;
+		}
+	});
+};
+
+module.exports = deriveStackFromNestedError;

package/lib/esm/ExportWebpackRequireRuntimeModule.js

@@ -14,6 +14,8 @@ class ExportWebpackRequireRuntimeModule extends RuntimeModule {
 
 	/**
 	 * Returns true, if the runtime module should get it's own scope.
+	 * When false, `generate()` must emit complete statements ending with `;`
+	 * so a following runtime IIFE is not parsed as a call (ASI).
 	 * @returns {boolean} true, if the runtime module should get it's own scope
 	 */
 	shouldIsolate() {

package/lib/esm/ModuleChunkFormatPlugin.js

@@ -19,16 +19,20 @@ const {
 	getChunkFilenameTemplate,
 	getCompilationHooks
 } = require("../javascript/JavascriptModulesPlugin");
+const { entryModuleIdExpression } = require("../javascript/StartupHelpers");
 const { getUndoPath } = require("../util/identifier");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Entrypoint")} Entrypoint */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
+/** @import { Source } from "webpack-sources" */
+/** @import Chunk from "../Chunk" */
+/** @import ChunkGraph from "../ChunkGraph" */
+/** @import Compilation from "../Compilation" */
+/** @import Compiler from "../Compiler" */
+/** @import Entrypoint from "../Entrypoint" */
+/**
+ * @import {
+ * 	ChunkRenderContext
+ * } from "../javascript/JavascriptModulesPlugin"
+ */
 
 /**
  * Gets relative path.
@@ -185,22 +189,18 @@ class ModuleChunkFormatPlugin {
 				const { chunk, chunkGraph, runtimeTemplate } = renderContext;
 				const hotUpdateChunk = chunk instanceof HotUpdateChunk ? chunk : null;
 				const source = new ConcatSource();
+				const cst = runtimeTemplate.renderConst();
 				source.add(
-					`export const ${RuntimeGlobals.esmId} = ${JSON.stringify(
-						chunk.id
-					)};\n`
-				);
-				source.add(
-					`export const ${RuntimeGlobals.esmIds} = ${JSON.stringify(
+					`export ${cst} ${RuntimeGlobals.esmIds} = ${JSON.stringify(
 						chunk.ids
 					)};\n`
 				);
-				source.add(`export const ${RuntimeGlobals.esmModules} = `);
+				source.add(`export ${cst} ${RuntimeGlobals.esmModules} = `);
 				source.add(modules);
 				source.add(";\n");
 				const runtimeModules = chunkGraph.getChunkRuntimeModulesInOrder(chunk);
 				if (runtimeModules.length > 0) {
-					source.add(`export const ${RuntimeGlobals.esmRuntime} =\n`);
+					source.add(`export ${cst} ${RuntimeGlobals.esmRuntime} =\n`);
 					source.add(
 						Template.renderChunkRuntimeModules(runtimeModules, renderContext)
 					);
@@ -229,7 +229,11 @@ class ModuleChunkFormatPlugin {
 					if (needExec) {
 						startupSource.add(
 							`var __webpack_exec__ = ${runtimeTemplate.returningFunction(
-								`${RuntimeGlobals.require}(${RuntimeGlobals.entryModuleId} = moduleId)`,
+								`${RuntimeGlobals.require}(${entryModuleIdExpression(
+									chunkGraph,
+									chunk,
+									"moduleId"
+								)})`,
 								"moduleId"
 							)}\n`
 						);
@@ -237,6 +241,7 @@ class ModuleChunkFormatPlugin {
 
 					/** @type {Set<Chunk>} */
 					const loadedChunks = new Set();
+					let ownInstalled = false;
 					for (let i = 0; i < entries.length; i++) {
 						const [module, entrypoint] = entries[i];
 						if (!chunkGraph.getModuleSourceTypes(module).has(JAVASCRIPT_TYPE)) {
@@ -246,8 +251,8 @@ class ModuleChunkFormatPlugin {
 						const moduleId = chunkGraph.getModuleId(module);
 						const chunks = getAllChunks(
 							/** @type {Entrypoint} */ (entrypoint),
-							/** @type {Chunk} */ (runtimeChunk),
-							undefined
+							chunk,
+							/** @type {Chunk} */ (runtimeChunk)
 						);
 						/** @type {Set<Chunk>} */
 						const processChunks = new Set();
@@ -267,6 +272,19 @@ class ModuleChunkFormatPlugin {
 							startupSource.add("\n");
 							startupSource.add(sourceWithDependentChunks);
 						}
+						if (!ownInstalled) {
+							ownInstalled = true;
+							// Own chunk data comes from the `export const` bindings above.
+							startupSource.add(
+								`${RuntimeGlobals.externalInstallChunk}({ ${
+									RuntimeGlobals.esmIds
+								}, ${RuntimeGlobals.esmModules}${
+									runtimeModules.length > 0
+										? `, ${RuntimeGlobals.esmRuntime}`
+										: ""
+								} });\n`
+							);
+						}
 						if (module === inlinedEntryModule && inlinedEntrySource) {
 							// Inline the entry at the top level so its declarations stay
 							// live ESM bindings (exports appended by `renderStartup`).