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

package/lib/errors/ModuleDependencyWarning.js

@@ -7,10 +7,11 @@
 
 const makeSerializable = require("../util/makeSerializable");
 const WebpackError = require("./WebpackError");
+const deriveStackFromNestedError = require("./deriveStackFromNestedError");
 
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("./ModuleDependencyError").ErrorWithHideStack} ErrorWithHideStack */
+/** @import { DependencyLocation } from "../Dependency" */
+/** @import Module from "../Module" */
+/** @import { ErrorWithHideStack } from "./ModuleBuildError" */
 
 class ModuleDependencyWarning extends WebpackError {
 	/**
@@ -24,11 +25,6 @@ class ModuleDependencyWarning extends WebpackError {
 
 		/** @type {string} */
 		this.name = "ModuleDependencyWarning";
-		/** @type {string | undefined} */
-		this.details =
-			err && !err.hideStack
-				? /** @type {string} */ (err.stack).split("\n").slice(1).join("\n")
-				: undefined;
 		/** @type {Module} */
 		this.module = module;
 		/** @type {DependencyLocation} */
@@ -39,13 +35,7 @@ class ModuleDependencyWarning extends WebpackError {
 		 */
 		this.error = err;
 
-		if (err && err.hideStack && err.stack) {
-			/** @type {string | undefined} */
-			this.stack = /** @type {string} */ `${err.stack
-				.split("\n")
-				.slice(1)
-				.join("\n")}\n\n${this.stack}`;
-		}
+		deriveStackFromNestedError(this, err);
 	}
 }
 

package/lib/errors/ModuleHashingError.js

@@ -7,7 +7,7 @@
 
 const WebpackError = require("./WebpackError");
 
-/** @typedef {import("../Module")} Module */
+/** @import Module from "../Module" */
 
 class ModuleHashingError extends WebpackError {
 	/**

package/lib/errors/ModuleNotFoundError.js

@@ -7,8 +7,8 @@
 
 const WebpackError = require("./WebpackError");
 
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../Module")} Module */
+/** @import { DependencyLocation } from "../Dependency" */
+/** @import Module from "../Module" */
 
 const previouslyPolyfilledBuiltinModules = {
 	assert: "assert/",

package/lib/errors/ModuleParseError.js

@@ -8,8 +8,7 @@
 const makeSerializable = require("../util/makeSerializable");
 const WebpackError = require("./WebpackError");
 
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../Dependency").SourcePosition} SourcePosition */
+/** @import { DependencyLocation, SourcePosition } from "../Dependency" */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Error]>} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Error]>} ObjectSerializerContext */
 

package/lib/errors/ModuleRestoreError.js

@@ -7,7 +7,7 @@
 
 const WebpackError = require("./WebpackError");
 
-/** @typedef {import("../Module")} Module */
+/** @import Module from "../Module" */
 
 class ModuleRestoreError extends WebpackError {
 	/**

package/lib/errors/ModuleStoreError.js

@@ -7,7 +7,7 @@
 
 const WebpackError = require("./WebpackError");
 
-/** @typedef {import("../Module")} Module */
+/** @import Module from "../Module" */
 
 class ModuleStoreError extends WebpackError {
 	/**

package/lib/errors/NodeStuffInWebError.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @import { DependencyLocation } from "../Dependency" */
 
 const makeSerializable = require("../util/makeSerializable");
 const WebpackError = require("./WebpackError");

package/lib/errors/OsDependentRuleWarning.js

@@ -0,0 +1,31 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+class OsDependentRuleWarning extends WebpackError {
+	/**
+	 * Creates an instance of OsDependentRuleWarning.
+	 * @param {string[]} rules descriptions of the rules whose paths only match on one operating system
+	 */
+	constructor(rules) {
+		super(
+			`webpack rule recommendations: \nThe following ${
+				rules.length === 1
+					? "condition hardcodes a path separator, so it"
+					: "conditions hardcode a path separator, so they"
+			} only match on one operating system: ${rules.join(
+				", "
+			)}.\nConditions are matched against native paths, which use '\\' on Windows and '/' elsewhere, so such a rule silently stops matching on the other one. Write '[\\\\/]' to accept both.\nFor more info visit https://webpack.js.org/configuration/module/#condition`
+		);
+
+		/** @type {string} */
+		this.name = "OsDependentRuleWarning";
+	}
+}
+
+module.exports = OsDependentRuleWarning;

package/lib/errors/PureAnnotationsWarning.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} PureAnnotationDetails
+ * @property {string} name the module, shortened for the report
+ * @property {number} count how many of its annotations do nothing
+ */
+
+class PureAnnotationsWarning extends WebpackError {
+	/**
+	 * Creates an instance of PureAnnotationsWarning.
+	 * @param {PureAnnotationDetails[]} modules the worst offenders, most first
+	 * @param {number} total how many annotations do nothing in all
+	 */
+	constructor(modules, total) {
+		const list = modules
+			.map((module) => `\n  ${module.name} (${module.count})`)
+			.join("");
+
+		super(
+			`pure annotations: ${total} '/*#__PURE__*/' ${total === 1 ? "annotation does" : "annotations do"} nothing:${list}\nThe annotation is read only where it sits directly before a call, a 'new', or a tagged template — anywhere else it is a comment, and the code it was meant to make droppable is kept.\nFor more info visit https://webpack.js.org/guides/tree-shaking/`
+		);
+
+		/** @type {string} */
+		this.name = "PureAnnotationsWarning";
+	}
+}
+
+module.exports = PureAnnotationsWarning;

package/lib/errors/RedundantDynamicImportWarning.js

@@ -0,0 +1,31 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+class RedundantDynamicImportWarning extends WebpackError {
+	/**
+	 * Creates an instance of RedundantDynamicImportWarning.
+	 * @param {string[]} imports descriptions of the `import()` calls that split nothing
+	 */
+	constructor(imports) {
+		const list = imports.map((description) => `\n  ${description}`).join("");
+
+		super(
+			`dynamic imports: ${
+				imports.length === 1
+					? "an 'import()' targets a module already loaded where it runs"
+					: "these 'import()' calls target modules already loaded where they run"
+			}, so nothing is deferred:${list}\n'import()' only splits a module out when nothing already loaded pulls it in — a static 'import' of it in the same entrypoint cancels the split.\nFor more info visit https://webpack.js.org/guides/code-splitting/`
+		);
+
+		/** @type {string} */
+		this.name = "RedundantDynamicImportWarning";
+	}
+}
+
+module.exports = RedundantDynamicImportWarning;

package/lib/errors/ScopeHoistingBailoutsWarning.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 {{ reason: string, count: number, names: string[] }} ScopeHoistingBailoutGroup */
+
+/**
+ * @param {ScopeHoistingBailoutGroup} group one reason and what it applied to
+ * @returns {string} one printed line
+ */
+const formatGroup = ({ reason, count, names }) => {
+	const shown = names.join(", ");
+	const rest = count - names.length;
+
+	return `  ${count} × ${reason}\n     ${shown}${rest > 0 ? ` and ${rest} more` : ""}`;
+};
+
+class ScopeHoistingBailoutsWarning extends WebpackError {
+	/**
+	 * Creates an instance of ScopeHoistingBailoutsWarning.
+	 * @param {ScopeHoistingBailoutGroup[]} groups the reasons, most modules first
+	 * @param {number} total how many modules were left out
+	 */
+	constructor(groups, total) {
+		super(
+			`scope hoisting: ${total} ${total === 1 ? "module was" : "modules were"} not merged into the scope of ${total === 1 ? "its importer" : "their importers"}, so each keeps its own wrapper:
+${groups.map(formatGroup).join("\n")}
+
+Concatenation needs a module to be ESM and statically analyzable. For more info visit https://webpack.js.org/plugins/module-concatenation-plugin/`
+		);
+
+		this.name = "ScopeHoistingBailoutsWarning";
+	}
+}
+
+module.exports = ScopeHoistingBailoutsWarning;

package/lib/errors/SplitChunksCappedWarning.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} CappedSplitDetails
+ * @property {string} cacheGroup the cache group whose split was refused
+ * @property {string} chunk the chunk it would have been taken out of
+ * @property {string} limit the option that refused it
+ * @property {number} maxRequests the value that option had
+ * @property {number} modules how many modules the split would have moved
+ */
+
+class SplitChunksCappedWarning extends WebpackError {
+	/**
+	 * Creates an instance of SplitChunksCappedWarning.
+	 * @param {CappedSplitDetails[]} splits the refused splits, most modules first
+	 */
+	constructor(splits) {
+		const list = splits
+			.map(
+				(split) =>
+					`\n  cacheGroup '${split.cacheGroup}' out of ${split.chunk} (${split.modules} modules, ${split.limit} is ${split.maxRequests})`
+			)
+			.join("");
+
+		super(
+			`split chunks capped: 'optimization.splitChunks' refused these splits because the chunk already had as many requests as it is allowed:${list}\nThe modules stayed where they were, so the cache group did not take effect. Raising the limit lets the split happen, at the cost of more parallel requests.\nFor more info visit https://webpack.js.org/plugins/split-chunks-plugin/`
+		);
+
+		/** @type {string} */
+		this.name = "SplitChunksCappedWarning";
+	}
+}
+
+module.exports = SplitChunksCappedWarning;

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 {
 	/**