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

package/lib/errors/HotspotsWarning.js

@@ -0,0 +1,57 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/**
+ * @typedef {object} HotspotDetails
+ * @property {"loader" | "plugin"} kind what the name refers to
+ * @property {string} name the loader or plugin, as it identified itself
+ * @property {number} ms milliseconds it held the main thread
+ * @property {number} runs how many times it ran
+ */
+
+/**
+ * @typedef {object} HookDetails
+ * @property {string} name the hook
+ * @property {number} ms milliseconds its taps held the main thread
+ */
+
+class HotspotsWarning extends WebpackError {
+	/**
+	 * Creates an instance of HotspotsWarning.
+	 * @param {HotspotDetails[]} hotspots the worst offenders, slowest first
+	 * @param {number} total how many are over the threshold in all
+	 * @param {HookDetails[]} hooks the same time grouped by hook instead
+	 */
+	constructor(hotspots, total, hooks) {
+		const list = hotspots
+			.map(
+				(hotspot) =>
+					`\n  ${hotspot.kind} ${hotspot.name} (${Math.round(hotspot.ms)} ms over ${
+						hotspot.runs
+					} ${hotspot.runs === 1 ? "run" : "runs"})`
+			)
+			.join("");
+
+		const byHook =
+			hooks.length > 0
+				? `\nThe same time, grouped by the hook it ran under:${hooks
+						.map((hook) => `\n  ${hook.name} (${Math.round(hook.ms)} ms)`)
+						.join("")}`
+				: "";
+
+		super(
+			`hotspots: ${total} ${total === 1 ? "thing holds" : "things hold"} the main thread long enough to be worth looking at:${list}${byHook}\nThis is the time each one held the main thread itself, with anything it called out to charged to that instead — so it is what the loader or plugin costs, not what it waited for. Only synchronous stretches count, so work resumed after an await is missing from it. 'ProfilingPlugin' records the same work as a trace when the ordering matters.\nFor more info visit https://webpack.js.org/plugins/profiling-plugin/`
+		);
+
+		/** @type {string} */
+		this.name = "HotspotsWarning";
+	}
+}
+
+module.exports = HotspotsWarning;

package/lib/errors/IgnoreErrorModuleFactory.js

@@ -7,9 +7,13 @@
 
 const ModuleFactory = require("../ModuleFactory");
 
-/** @typedef {import("../ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */
-/** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("../NormalModuleFactory")} NormalModuleFactory */
+/**
+ * @import {
+ * 	ModuleFactoryCallback,
+ * 	ModuleFactoryCreateData
+ * } from "../ModuleFactory"
+ */
+/** @import NormalModuleFactory from "../NormalModuleFactory" */
 
 /**
  * Ignores error when module is unresolved

package/lib/errors/InlinedAssetsWarning.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} InlinedAssetDetails
+ * @property {string} name the asset, by path
+ * @property {number} size the bytes it adds to the JavaScript
+ */
+
+class InlinedAssetsWarning extends WebpackError {
+	/**
+	 * Creates an instance of InlinedAssetsWarning.
+	 * @param {InlinedAssetDetails[]} assets the assets inlined as data urls
+	 * @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(
+			`inlined assets: ${total} bytes of asset data are embedded in the JavaScript:${list}\nA data url is base64, so it costs about a third more than the file it replaces, cannot be cached on its own, and is downloaded again whenever the code around it changes. 'Rule.parser.dataUrlCondition.maxSize' decides which files are small enough to be worth that.\nFor more info visit https://webpack.js.org/guides/asset-modules/#general-asset-type`
+		);
+
+		/** @type {string} */
+		this.name = "InlinedAssetsWarning";
+	}
+}
+
+module.exports = InlinedAssetsWarning;

package/lib/errors/InvalidDependenciesModuleWarning.js

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

package/lib/errors/LargeModulesWarning.js

@@ -0,0 +1,45 @@
+/*
+	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} LargeModuleDetails
+ * @property {string} name the module, shortened for the report
+ * @property {string} chunk the chunk it weighs down
+ * @property {number} size bytes the module contributes
+ * @property {number} chunkSize bytes the whole chunk contributes
+ */
+
+class LargeModulesWarning extends WebpackError {
+	/**
+	 * Creates an instance of LargeModulesWarning.
+	 * @param {LargeModuleDetails[]} modules the worst offenders, largest first
+	 * @param {number} total how many dominating modules there are in all
+	 */
+	constructor(modules, total) {
+		const list = modules
+			.map((module) => {
+				const share = Math.round((module.size / module.chunkSize) * 100);
+
+				return `\n  ${module.name} is ${share}% of '${module.chunk}' (${formatSize(
+					module.size
+				)} of ${formatSize(module.chunkSize)})`;
+			})
+			.join("");
+
+		super(
+			`large modules: ${total} ${total === 1 ? "module carries" : "modules carry"} most of the chunk ${total === 1 ? "it is" : "they are"} in:${list}\nEverything else in the chunk together weighs less than this one module, so splitting it out with 'optimization.splitChunks', loading it on demand, or replacing it is what changes the size.\nFor more info visit https://webpack.js.org/guides/code-splitting/`
+		);
+
+		/** @type {string} */
+		this.name = "LargeModulesWarning";
+	}
+}
+
+module.exports = LargeModulesWarning;

package/lib/errors/LegacyJavascriptWarning.js

@@ -0,0 +1,48 @@
+/*
+	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} LegacyPackageDetails
+ * @property {string} name the package doing the emulating
+ * @property {number} modules how many of its modules are in the build
+ * @property {number} size bytes they contribute
+ */
+
+class LegacyJavascriptWarning extends WebpackError {
+	/**
+	 * Creates an instance of LegacyJavascriptWarning.
+	 * @param {LegacyPackageDetails[]} packages the ones found, largest first
+	 * @param {number} totalSize bytes they contribute between them
+	 * @param {string[]} features the ones the target already has
+	 */
+	constructor(packages, totalSize, features) {
+		const list = packages
+			.map(
+				(item) =>
+					`\n  ${item.name} (${item.modules} ${
+						item.modules === 1 ? "module" : "modules"
+					}, ${formatSize(item.size)})`
+			)
+			.join("");
+
+		super(
+			`legacy javascript: ${formatSize(
+				totalSize
+			)} of the build emulates syntax the target already has natively:${list}\n'output.environment' says this target supports ${features.join(
+				", "
+			)}, so whatever lowers the syntax — usually '@babel/preset-env' — is compiling for older browsers than webpack is. Lining its targets up with the browserslist webpack reads drops them.\nFor more info visit https://webpack.js.org/configuration/target/#browserslist`
+		);
+
+		/** @type {string} */
+		this.name = "LegacyJavascriptWarning";
+	}
+}
+
+module.exports = LegacyJavascriptWarning;

package/lib/errors/MissingSideEffectsWarning.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 {{ name: string, modules: number, size: number }} MissingSideEffectsDetails */
+
+class MissingSideEffectsWarning extends WebpackError {
+	/**
+	 * Creates an instance of MissingSideEffectsWarning.
+	 * @param {MissingSideEffectsDetails[]} packages the packages to name, costliest first
+	 * @param {number} total how many packages were found
+	 * @param {number} wasted the bytes they keep in the bundle
+	 */
+	constructor(packages, total, wasted) {
+		super(
+			`missing sideEffects: ${total} ${total === 1 ? "package keeps" : "packages keep"} ${wasted} bytes of unused code because ${total === 1 ? "its" : "their"} package.json does not declare 'sideEffects':
+${packages
+	.map(
+		({ name, modules, size }) =>
+			`  ${name} (${size} bytes in ${modules} ${modules === 1 ? "module" : "modules"})`
+	)
+	.join("\n")}
+
+Without the field webpack must assume every module runs code on import. For more info visit https://webpack.js.org/guides/tree-shaking/`
+		);
+
+		this.name = "MissingSideEffectsWarning";
+	}
+}
+
+module.exports = MissingSideEffectsWarning;

package/lib/errors/MixedExportsWarning.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} MixedExportsDetails
+ * @property {string} name the entry, by name
+ * @property {string[]} named the named exports sitting beside the default
+ */
+
+class MixedExportsWarning extends WebpackError {
+	/**
+	 * Creates an instance of MixedExportsWarning.
+	 * @param {MixedExportsDetails[]} entries the entries that mix them
+	 * @param {string} type the library type they are built for
+	 */
+	constructor(entries, type) {
+		const list = entries
+			.map(
+				(entry) =>
+					`\n  ${entry.name} (default and ${entry.named.length}: ${entry.named
+						.slice(0, 3)
+						.join(", ")}${entry.named.length > 3 ? ", …" : ""})`
+			)
+			.join("");
+
+		super(
+			`mixed exports: ${entries.length} ${entries.length === 1 ? "entry exports" : "entries export"} a default beside named exports for the '${type}' library:${list}\nA consumer calling 'require()' gets the namespace object, so the default arrives as '.default' rather than as the value itself. Exporting only a default, or only named exports, leaves no ambiguity — 'output.library.export' can also pick one.\nFor more info visit https://webpack.js.org/configuration/output/#outputlibraryexport`
+		);
+
+		/** @type {string} */
+		this.name = "MixedExportsWarning";
+	}
+}
+
+module.exports = MixedExportsWarning;

package/lib/errors/ModuleDependencyError.js

@@ -5,11 +5,13 @@
 
 "use strict";
 
+const makeSerializable = require("../util/makeSerializable");
 const WebpackError = require("./WebpackError");
+const deriveStackFromNestedError = require("./deriveStackFromNestedError");
 
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("./ModuleBuildError").ErrorWithHideStack} ErrorWithHideStack */
+/** @import { DependencyLocation } from "../Dependency" */
+/** @import Module from "../Module" */
+/** @import { ErrorWithHideStack } from "./ModuleBuildError" */
 
 class ModuleDependencyError extends WebpackError {
 	/**
@@ -19,15 +21,11 @@ class ModuleDependencyError extends WebpackError {
 	 * @param {DependencyLocation} loc location of dependency
 	 */
 	constructor(module, err, loc) {
-		super(err.message);
+		// Deserialization constructs with no arguments, so `err` is absent there.
+		super(err ? err.message : "");
 
 		/** @type {string} */
 		this.name = "ModuleDependencyError";
-		/** @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} */
@@ -38,14 +36,13 @@ class ModuleDependencyError 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);
 	}
 }
 
+makeSerializable(
+	ModuleDependencyError,
+	"webpack/lib/errors/ModuleDependencyError"
+);
+
 module.exports = ModuleDependencyError;

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;