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

package/lib/electron/ElectronTargetPlugin.js

@@ -7,14 +7,49 @@
 
 const ExternalsPlugin = require("../ExternalsPlugin");
 
-/** @typedef {import("../../declarations/WebpackOptions").ExternalsType} ExternalsType */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Dependency")} Dependency */
+/** @import { ExternalsType } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/** @import Dependency from "../Dependency" */
 /** @typedef {"main" | "preload" | "renderer"} ElectronContext */
 
+const SHARED_MODULES = [
+	"clipboard",
+	"crash-reporter",
+	"electron",
+	"ipc",
+	"native-image",
+	"original-fs",
+	"screen",
+	"shell"
+];
+
+const MAIN_MODULES = [
+	"app",
+	"auto-updater",
+	"browser-window",
+	"content-tracing",
+	"dialog",
+	"global-shortcut",
+	"ipc-main",
+	"menu",
+	"menu-item",
+	"power-monitor",
+	"power-save-blocker",
+	"protocol",
+	"session",
+	"tray",
+	"web-contents"
+];
+
+const RENDERER_MODULES = [
+	"desktop-capturer",
+	"ipc-renderer",
+	"remote",
+	"web-frame"
+];
+
 class ElectronTargetPlugin {
 	/**
-	 * Creates an instance of ElectronTargetPlugin.
 	 * @param {ElectronContext=} context in main, preload or renderer context?
 	 * @param {ExternalsType=} type default external type
 	 */
@@ -23,6 +58,15 @@ class ElectronTargetPlugin {
 		this._context = context;
 		/** @type {ExternalsType} */
 		this.type = type;
+
+		/**
+		 * @param {Dependency} dependency the dependency
+		 * @returns {ExternalsType} the external type
+		 */
+		this._externalType = (dependency) =>
+			// When `require`-ing electron built-in modules with module output
+			// we should still emit `node-commonjs` for compatibility
+			dependency.category === "commonjs" ? "node-commonjs" : this.type;
 	}
 
 	/**
@@ -31,59 +75,19 @@ class ElectronTargetPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		/**
-		 * @param {Dependency} dependency the dependency
-		 * @returns {ExternalsType} the external type
-		 */
-		const externalType = (dependency) => {
-			// When `require` electron built-in modules with module output
-			// we should still emit `node-commonjs` for compatibility
-			if (dependency.category === "commonjs") {
-				return "node-commonjs";
-			}
+		const externals = [...SHARED_MODULES];
 
-			return this.type;
-		};
-		new ExternalsPlugin(externalType, [
-			"clipboard",
-			"crash-reporter",
-			"electron",
-			"ipc",
-			"native-image",
-			"original-fs",
-			"screen",
-			"shell"
-		]).apply(compiler);
 		switch (this._context) {
 			case "main":
-				new ExternalsPlugin(externalType, [
-					"app",
-					"auto-updater",
-					"browser-window",
-					"content-tracing",
-					"dialog",
-					"global-shortcut",
-					"ipc-main",
-					"menu",
-					"menu-item",
-					"power-monitor",
-					"power-save-blocker",
-					"protocol",
-					"session",
-					"tray",
-					"web-contents"
-				]).apply(compiler);
+				externals.push(...MAIN_MODULES);
 				break;
 			case "preload":
 			case "renderer":
-				new ExternalsPlugin(externalType, [
-					"desktop-capturer",
-					"ipc-renderer",
-					"remote",
-					"web-frame"
-				]).apply(compiler);
+				externals.push(...RENDERER_MODULES);
 				break;
 		}
+
+		new ExternalsPlugin(this._externalType, externals).apply(compiler);
 	}
 }
 

package/lib/errors/AsyncChunkWaterfallWarning.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} WaterfallDetails
+ * @property {string[]} chain the chunk groups making up the chain, outermost first
+ * @property {number} size the bytes the chain loads in total
+ */
+
+class AsyncChunkWaterfallWarning extends WebpackError {
+	/**
+	 * Creates an instance of AsyncChunkWaterfallWarning.
+	 * @param {WaterfallDetails[]} waterfalls the chains that are too deep
+	 * @param {number} depth the depth the deepest of them reaches
+	 */
+	constructor(waterfalls, depth) {
+		const list = waterfalls
+			.map((it) => `\n  ${it.chain.join(" → ")} (${it.size} bytes)`)
+			.join("");
+
+		super(
+			`async chunk waterfall: ${waterfalls.length} ${waterfalls.length === 1 ? "chain loads" : "chains load"} ${depth} levels deep:${list}\nA chunk cannot be requested until the one importing it has arrived and run, so each level costs a round trip before anything below it starts. Importing the deeper modules from the entry, or giving them one 'webpackPrefetch' hint, lets them be fetched together.\nFor more info visit https://webpack.js.org/api/module-methods/#magic-comments`
+		);
+
+		/** @type {string} */
+		this.name = "AsyncChunkWaterfallWarning";
+	}
+}
+
+module.exports = AsyncChunkWaterfallWarning;

package/lib/errors/AsyncDependencyToInitialChunkError.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" */
 
 /**
  * Error raised when webpack detects an attempt to lazy-load a chunk name that

package/lib/errors/BroadContextsWarning.js

@@ -0,0 +1,43 @@
+/*
+	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} BroadContextDetails
+ * @property {string} name the context as written, shortened for the report
+ * @property {number} modules how many distinct modules it matched
+ * @property {number} size bytes those modules contribute
+ */
+
+class BroadContextsWarning extends WebpackError {
+	/**
+	 * Creates an instance of BroadContextsWarning.
+	 * @param {BroadContextDetails[]} contexts the worst offenders, largest first
+	 * @param {number} total how many broad contexts there are in all
+	 */
+	constructor(contexts, total) {
+		const list = contexts
+			.map(
+				(context) =>
+					`\n  ${context.name} (${context.modules} modules, ${formatSize(
+						context.size
+					)})`
+			)
+			.join("");
+
+		super(
+			`broad contexts: ${total} ${total === 1 ? "context matches" : "contexts match"} every file under a directory:${list}\nA pattern opening with a bare wildcard takes whatever the directory holds, including files nothing ever requests — a sync context bundles them all, a lazy one gives each its own chunk. Narrowing the pattern, or 'ContextReplacementPlugin', limits it to what is reachable.\nFor more info visit https://webpack.js.org/plugins/context-replacement-plugin/`
+		);
+
+		/** @type {string} */
+		this.name = "BroadContextsWarning";
+	}
+}
+
+module.exports = BroadContextsWarning;

package/lib/errors/BuildCycleError.js

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

package/lib/errors/CacheEffectivenessWarning.js

@@ -0,0 +1,55 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/**
+ * @typedef {object} CacheEffectiveness
+ * @property {number} total how many modules the compilation holds
+ * @property {number} rebuilt how many of them were built rather than reused
+ * @property {number} uncacheable how many can never be reused
+ * @property {string[]} reasons why they cannot, most frequent first
+ */
+
+class CacheEffectivenessWarning extends WebpackError {
+	/**
+	 * Creates an instance of CacheEffectivenessWarning.
+	 * @param {CacheEffectiveness} effectiveness what the compilation reused
+	 */
+	constructor({ total, rebuilt, uncacheable, reasons }) {
+		const lines = [];
+
+		// Only stated when something was reused, which is what proves the cache was
+		// warm — a cold build rebuilds everything by design.
+		if (rebuilt < total) {
+			lines.push(
+				`${rebuilt} of ${total} modules were rebuilt although the cache was warm.`
+			);
+		}
+
+		if (uncacheable > 0) {
+			lines.push(
+				`${uncacheable} ${
+					uncacheable === 1 ? "module is" : "modules are"
+				} not cacheable, so ${
+					uncacheable === 1 ? "it rebuilds" : "they rebuild"
+				} on every build: ${reasons.join(", ")}.`
+			);
+		}
+
+		super(
+			`module caching: ${lines.join(
+				" "
+			)}\nA loader calling 'this.cacheable(false)', or a value that changes every build, prevents reuse. Stats list the modules individually as '[not cacheable]'.\nFor more info visit https://webpack.js.org/configuration/cache/`
+		);
+
+		/** @type {string} */
+		this.name = "CacheEffectivenessWarning";
+	}
+}
+
+module.exports = CacheEffectivenessWarning;

package/lib/errors/ChunkRenderError.js

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

package/lib/errors/CircularDependenciesWarning.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} CircularDependencyDetails
+ * @property {number} size how many modules can all reach each other
+ * @property {string} cycle the shortest cycle through one of them
+ */
+
+class CircularDependenciesWarning extends WebpackError {
+	/**
+	 * Creates an instance of CircularDependenciesWarning.
+	 * @param {CircularDependencyDetails[]} groups the largest groups, biggest first
+	 * @param {number} total how many groups of modules import each other
+	 */
+	constructor(groups, total) {
+		const list = groups
+			.map((group) => `\n  ${group.size} modules: ${group.cycle}`)
+			.join("");
+
+		super(
+			`circular dependencies: ${total} ${
+				total === 1 ? "group of modules imports" : "groups of modules import"
+			} each other synchronously, shortest cycle of each shown:${list}\nOne module of a cycle runs before the others finished, so it reads their exports as 'undefined' — or throws for a 'const' or 'class' export. Moving the shared part into a module both sides import breaks the cycle.`
+		);
+
+		/** @type {string} */
+		this.name = "CircularDependenciesWarning";
+	}
+}
+
+module.exports = CircularDependenciesWarning;

package/lib/errors/CodeGenerationError.js

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

package/lib/errors/CommentCompilationWarning.js

@@ -8,7 +8,7 @@
 const makeSerializable = require("../util/makeSerializable");
 const WebpackError = require("./WebpackError");
 
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @import { DependencyLocation } from "../Dependency" */
 
 /**
  * Warning used for comment-related compilation issues, such as malformed magic

package/lib/errors/ConflictingResourceHintsWarning.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} ConflictingResourceHintDetails
+ * @property {string} parent the chunk group the directives were written in
+ * @property {string} child the chunk group they point at
+ */
+
+class ConflictingResourceHintsWarning extends WebpackError {
+	/**
+	 * Creates an instance of ConflictingResourceHintsWarning.
+	 * @param {ConflictingResourceHintDetails[]} links the conflicting links, parent name first
+	 */
+	constructor(links) {
+		const list = links
+			.map((link) => `\n  ${link.parent} -> ${link.child}`)
+			.join("");
+
+		super(
+			`conflicting resource hints: these chunks are asked for as both prefetch and preload from the same place:${list}\nThe two say opposite things: a preload fetches the chunk at high priority right away, while a prefetch asks for it at idle priority in case it is needed later. Keep 'webpackPreload' for what the page needs now and 'webpackPrefetch' for what it may need later, not both.\nFor more info visit https://webpack.js.org/guides/code-splitting/#prefetchingpreloading-modules`
+		);
+
+		/** @type {string} */
+		this.name = "ConflictingResourceHintsWarning";
+	}
+}
+
+module.exports = ConflictingResourceHintsWarning;

package/lib/errors/DuplicateModulesWarning.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} DuplicateModuleDetails
+ * @property {string} name
+ * @property {number} chunks how many chunks carry a copy
+ * @property {number} wasted bytes the extra copies cost
+ */
+
+class DuplicateModulesWarning extends WebpackError {
+	/**
+	 * Creates an instance of DuplicateModulesWarning.
+	 * @param {DuplicateModuleDetails[]} modules the worst offenders, largest waste first
+	 * @param {number} wasted bytes all duplicated copies cost together
+	 */
+	constructor(modules, wasted) {
+		const list = modules
+			.map(
+				(module) =>
+					`\n  ${module.name} (in ${module.chunks} chunks, ${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/`
+		);
+
+		/** @type {string} */
+		this.name = "DuplicateModulesWarning";
+	}
+}
+
+module.exports = DuplicateModulesWarning;

package/lib/errors/DynamicExportsWarning.js

@@ -0,0 +1,30 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("../WebpackError");
+
+/** @typedef {{ name: string, size: number }} DynamicExportsDetails */
+
+class DynamicExportsWarning extends WebpackError {
+	/**
+	 * Creates an instance of DynamicExportsWarning.
+	 * @param {DynamicExportsDetails[]} modules the modules to name, largest first
+	 * @param {number} total how many were found
+	 */
+	constructor(modules, total) {
+		super(
+			`dynamic exports: webpack cannot tell what ${total} ${total === 1 ? "module exports" : "modules export"}, so nothing importing ${total === 1 ? "it" : "them"} can be tree-shaken:
+${modules.map(({ name, size }) => `  ${name} (${size} bytes)`).join("\n")}
+
+Exports assigned under a condition or through a computed key cannot be read statically. For more info visit https://webpack.js.org/guides/tree-shaking/`
+		);
+
+		this.name = "DynamicExportsWarning";
+	}
+}
+
+module.exports = DynamicExportsWarning;

package/lib/errors/EmbeddedSourceMapsWarning.js

@@ -0,0 +1,25 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+class EmbeddedSourceMapsWarning extends WebpackError {
+	/**
+	 * Creates an instance of EmbeddedSourceMapsWarning.
+	 * @param {string} devtool the devtool that embeds them
+	 */
+	constructor(devtool) {
+		super(
+			`embedded source maps: 'devtool: "${devtool}"' writes the source map into the JavaScript itself, and this is a production build.\nThe map is then downloaded by everyone who loads the page, several times the size of the code it describes. A separate '.map' file is fetched only by whoever opens the devtools, and 'hidden-source-map' keeps it off the client entirely while still uploading to an error reporter.\nFor more info visit https://webpack.js.org/configuration/devtool/#production`
+		);
+
+		/** @type {string} */
+		this.name = "EmbeddedSourceMapsWarning";
+	}
+}
+
+module.exports = EmbeddedSourceMapsWarning;

package/lib/errors/EntrypointOverlapWarning.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} EntrypointOverlapDetails
+ * @property {string} name
+ * @property {string[]} entrypoints the entrypoints that each ship a copy
+ * @property {number} wasted bytes the copies past the first cost
+ */
+
+class EntrypointOverlapWarning extends WebpackError {
+	/**
+	 * Creates an instance of EntrypointOverlapWarning.
+	 * @param {EntrypointOverlapDetails[]} modules the worst offenders, largest waste first
+	 * @param {number} wasted bytes all overlapping copies cost together
+	 */
+	constructor(modules, wasted) {
+		const list = modules
+			.map(
+				(module) =>
+					`\n  ${module.name} (in ${module.entrypoints.join(", ")}, ${formatSize(
+						module.wasted
+					)} extra)`
+			)
+			.join("");
+
+		super(
+			`entrypoint overlap: modules shipped by more than one entrypoint add ${formatSize(
+				wasted
+			)}:${list}\nEach entrypoint downloads its own copy. 'optimization.splitChunks' with 'chunks: "all"' can move them into a chunk every entrypoint shares.\nFor more info visit https://webpack.js.org/plugins/split-chunks-plugin/`
+		);
+
+		/** @type {string} */
+		this.name = "EntrypointOverlapWarning";
+	}
+}
+
+module.exports = EntrypointOverlapWarning;

package/lib/errors/EnvironmentNotSupportAsyncWarning.js

@@ -8,8 +8,8 @@
 const makeSerializable = require("../util/makeSerializable");
 const WebpackError = require("./WebpackError");
 
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @import Module from "../Module" */
+/** @import RuntimeTemplate from "../RuntimeTemplate" */
 /** @typedef {"asyncWebAssembly" | "topLevelAwait" | "external promise" | "external script" | "external import" | "external module" | "external amd-async"} Feature */
 
 class EnvironmentNotSupportAsyncWarning extends WebpackError {

package/lib/errors/EvalUsageWarning.js

@@ -0,0 +1,28 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+class EvalUsageWarning extends WebpackError {
+	/**
+	 * Creates an instance of EvalUsageWarning.
+	 * @param {string[]} modules the modules calling it, named for the report
+	 * @param {number} total how many call it in all
+	 */
+	constructor(modules, total) {
+		const list = modules.map((module) => `\n  ${module}`).join("");
+
+		super(
+			`eval usage: ${total} ${total === 1 ? "module calls" : "modules call"} 'eval' directly:${list}\nA direct eval reads and writes any name in scope, so nothing the module declares can be renamed or dropped: minification, scope hoisting and tree shaking all stop at it. 'new Function' takes no local scope and does not.\nFor more info visit https://webpack.js.org/configuration/optimization/#optimizationconcatenatemodules`
+		);
+
+		/** @type {string} */
+		this.name = "EvalUsageWarning";
+	}
+}
+
+module.exports = EvalUsageWarning;

package/lib/errors/HookWebpackError.js

@@ -65,8 +65,6 @@ class HookWebpackError extends WebpackError {
 
 makeSerializable(HookWebpackError, "webpack/lib/errors/HookWebpackError");
 
-module.exports = HookWebpackError;
-
 /**
  * Creates webpack error.
  * @param {Error} error an error
@@ -78,7 +76,7 @@ const makeWebpackError = (error, hook) => {
 	return new HookWebpackError(error, hook);
 };
 
-module.exports.makeWebpackError = makeWebpackError;
+HookWebpackError.makeWebpackError = makeWebpackError;
 
 /**
  * Creates webpack error callback.
@@ -99,7 +97,7 @@ const makeWebpackErrorCallback = (callback, hook) => (err, result) => {
 	callback(null, result);
 };
 
-module.exports.makeWebpackErrorCallback = makeWebpackErrorCallback;
+HookWebpackError.makeWebpackErrorCallback = makeWebpackErrorCallback;
 
 /**
  * Try run or webpack error.
@@ -122,4 +120,6 @@ const tryRunOrWebpackError = (fn, hook) => {
 	return r;
 };
 
-module.exports.tryRunOrWebpackError = tryRunOrWebpackError;
+HookWebpackError.tryRunOrWebpackError = tryRunOrWebpackError;
+
+module.exports = HookWebpackError;