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

package/lib/WebpackOptionsApply.js

@@ -74,13 +74,17 @@ const DefaultStatsPresetPlugin = require("./stats/DefaultStatsPresetPlugin");
 const DefaultStatsPrinterPlugin = require("./stats/DefaultStatsPrinterPlugin");
 
 const { cleverMerge } = require("./util/cleverMerge");
-
-/** @typedef {import("./webpack").WebpackPluginFunction} WebpackPluginFunction */
-/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
-/** @typedef {import("./config/normalization").WebpackOptionsInterception} WebpackOptionsInterception */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("./util/fs").IntermediateFileSystem} IntermediateFileSystem */
+const { NODE_MODULES_REGEXP } = require("./util/identifier");
+
+/** @import { WebpackPluginFunction } from "./webpack" */
+/**
+ * @import {
+ * 	WebpackOptionsNormalizedWithDefaults as WebpackOptions
+ * } from "./config/defaults"
+ */
+/** @import { WebpackOptionsInterception } from "./config/normalization" */
+/** @import Compiler from "./Compiler" */
+/** @import { InputFileSystem, IntermediateFileSystem } from "./util/fs" */
 
 const CLASS_NAME = "WebpackOptionsApply";
 
@@ -149,6 +153,90 @@ class WebpackOptionsApply extends OptionsApply {
 				).apply(compiler);
 			}
 		}
+		if (options.externalsPresets.nodeModules) {
+			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			const ExternalsPlugin = require("./ExternalsPlugin");
+
+			const type = options.output.module ? "module-import" : "node-commonjs";
+			const preset = options.externalsPresets.nodeModules;
+			const allowlist = preset === true ? undefined : preset.allowlist;
+			/**
+			 * @param {string} request the request
+			 * @returns {boolean} true when the request should stay bundled
+			 */
+			const isAllowed = (request) =>
+				allowlist !== undefined &&
+				allowlist.some((entry) =>
+					entry instanceof RegExp
+						? entry.test(request)
+						: typeof entry === "function"
+							? entry(request)
+							: entry === request
+				);
+			// Relative/absolute requests are never installed packages, and `#` subpath
+			// imports only resolve against the importing package's own `imports` field.
+			const NEVER_EXTERNAL = /^(?:\.\.?(?:\/|$)|\/|[A-Za-z]:[\\/]|#)/;
+			// Only JS-loadable resolutions are externalized; a package's CSS/asset
+			// imported from JS must stay bundled so webpack can process it.
+			const RUNTIME_LOADABLE = /\.(?:m|c)?js$|\.json$|\.node$/i;
+			/**
+			 * @param {string} request a request or a path below a `node_modules` directory
+			 * @returns {string} the package name it belongs to
+			 */
+			const getPackageName = (request) => {
+				const parts = request.split("/");
+				return request.startsWith("@") ? `${parts[0]}/${parts[1]}` : parts[0];
+			};
+			// `url()`/CSS `@import` references are handled by their own presets.
+			const NON_JS_DEPENDENCY_TYPES = new Set([
+				"url",
+				"css-import",
+				"css-import-local-module",
+				"css-import-global-module"
+			]);
+
+			new ExternalsPlugin(
+				// Keep `require()` semantics for CommonJS deps even with module output.
+				(dependency) =>
+					dependency.category === "commonjs" ? "node-commonjs" : type,
+				({ request, context, dependencyType, getResolve }, callback) => {
+					if (
+						NEVER_EXTERNAL.test(request) ||
+						NON_JS_DEPENDENCY_TYPES.has(dependencyType) ||
+						isAllowed(request)
+					) {
+						return callback();
+					}
+
+					const resolve =
+						/** @type {(context: string, request: string, callback: (err?: Error | null, result?: string | false) => void) => void} */
+						(getResolve());
+
+					// Externalize the package only when it resolves to a runtime-loadable
+					// file inside a node_modules directory.
+					resolve(context, request, (err, result) => {
+						if (
+							err ||
+							!result ||
+							!NODE_MODULES_REGEXP.test(result) ||
+							!RUNTIME_LOADABLE.test(result)
+						) {
+							return callback();
+						}
+						// The external keeps the original request, so requests that
+						// `resolve.alias` sends to another package must stay bundled.
+						const resolvedPath = result.split(NODE_MODULES_REGEXP).pop();
+						const resolvedPackageName = getPackageName(
+							/** @type {string} */ (resolvedPath).replace(/\\/g, "/")
+						);
+						callback(
+							null,
+							resolvedPackageName === getPackageName(request) ? true : undefined
+						);
+					});
+				}
+			).apply(compiler);
+		}
 		if (options.externalsPresets.deno) {
 			const DenoTargetPlugin = require("./deno/DenoTargetPlugin");
 
@@ -434,6 +522,13 @@ class WebpackOptionsApply extends OptionsApply {
 			}
 		}
 
+		if (options.output.module) {
+			// Analyzable output is ESM output, so this is every build that can reserve a name.
+			const RuntimeTemplate = require("./RuntimeTemplate");
+
+			RuntimeTemplate.fillReservedNames(compiler);
+		}
+
 		if (options.experiments.syncWebAssembly) {
 			const WebAssemblyModulesPlugin = require("./wasm-sync/WebAssemblyModulesPlugin");
 
@@ -639,10 +734,15 @@ class WebpackOptionsApply extends OptionsApply {
 			new InnerGraphPlugin().apply(compiler);
 		}
 
-		if (options.mode === "production") {
+		const circularHints =
+			options.performance && options.performance.circularDependencies
+				? options.performance.hints
+				: false;
+
+		if (options.mode === "production" || circularHints) {
 			const CircularModulesPlugin = require("./CircularModulesPlugin");
 
-			new CircularModulesPlugin().apply(compiler);
+			new CircularModulesPlugin({ hints: circularHints }).apply(compiler);
 		}
 
 		const ConstExportsPlugin = require("./optimize/ConstExportsPlugin");
@@ -806,15 +906,19 @@ class WebpackOptionsApply extends OptionsApply {
 					? publicPath
 					: "/";
 
-			new DefinePlugin({
-				"process.env.NODE_ENV": defValue,
-				"import.meta.env.NODE_ENV": defValue,
-				"import.meta.env.MODE": defValue,
-				"import.meta.env.DEV": JSON.stringify(development),
-				"import.meta.env.PROD": JSON.stringify(!development),
-				"import.meta.env.SSR": JSON.stringify(ssr),
-				"import.meta.env.BASE_URL": JSON.stringify(baseUrl)
-			}).apply(compiler);
+			// Marked internal: these keys are webpack's, so `performance.unusedDefines`
+			// must not report them against the user.
+			DefinePlugin.markInternal(
+				new DefinePlugin({
+					"process.env.NODE_ENV": defValue,
+					"import.meta.env.NODE_ENV": defValue,
+					"import.meta.env.MODE": defValue,
+					"import.meta.env.DEV": JSON.stringify(development),
+					"import.meta.env.PROD": JSON.stringify(!development),
+					"import.meta.env.SSR": JSON.stringify(ssr),
+					"import.meta.env.BASE_URL": JSON.stringify(baseUrl)
+				})
+			).apply(compiler);
 		}
 		if (options.optimization.minimize) {
 			for (const minimizer of options.optimization.minimizer) {
@@ -828,9 +932,195 @@ class WebpackOptionsApply extends OptionsApply {
 		}
 
 		if (options.performance) {
+			if (options.performance.hotspots) {
+				const HotspotsPlugin = require("./performance/HotspotsPlugin");
+
+				new HotspotsPlugin(options.performance).apply(compiler);
+			}
+
 			const SizeLimitsPlugin = require("./performance/SizeLimitsPlugin");
 
 			new SizeLimitsPlugin(options.performance).apply(compiler);
+
+			if (options.performance.duplicatePackages) {
+				const DuplicatePackagesPlugin = require("./performance/DuplicatePackagesPlugin");
+
+				new DuplicatePackagesPlugin(options.performance).apply(compiler);
+			}
+
+			if (options.performance.cacheEffectiveness) {
+				const CacheEffectivenessPlugin = require("./performance/CacheEffectivenessPlugin");
+
+				new CacheEffectivenessPlugin(options.performance).apply(compiler);
+			}
+
+			if (options.performance.duplicateModules) {
+				const DuplicateModulesPlugin = require("./performance/DuplicateModulesPlugin");
+
+				new DuplicateModulesPlugin(options.performance).apply(compiler);
+			}
+
+			if (options.performance.redundantDynamicImports) {
+				const RedundantDynamicImportsPlugin = require("./performance/RedundantDynamicImportsPlugin");
+
+				new RedundantDynamicImportsPlugin(options.performance).apply(compiler);
+			}
+
+			if (options.performance.entrypointOverlap) {
+				const EntrypointOverlapPlugin = require("./performance/EntrypointOverlapPlugin");
+
+				new EntrypointOverlapPlugin(options.performance).apply(compiler);
+			}
+
+			if (options.performance.largeModules) {
+				const LargeModulesPlugin = require("./performance/LargeModulesPlugin");
+
+				new LargeModulesPlugin(options.performance).apply(compiler);
+			}
+
+			if (options.performance.asyncChunkWaterfalls) {
+				const AsyncChunkWaterfallsPlugin = require("./performance/AsyncChunkWaterfallsPlugin");
+
+				new AsyncChunkWaterfallsPlugin(options.performance).apply(compiler);
+			}
+
+			if (options.performance.broadContexts) {
+				const BroadContextsPlugin = require("./performance/BroadContextsPlugin");
+
+				new BroadContextsPlugin(options.performance).apply(compiler);
+			}
+
+			if (options.performance.legacyJavascript) {
+				const LegacyJavascriptPlugin = require("./performance/LegacyJavascriptPlugin");
+
+				new LegacyJavascriptPlugin(options.performance).apply(compiler);
+			}
+
+			if (options.performance.mixedExports) {
+				const MixedExportsPlugin = require("./performance/MixedExportsPlugin");
+
+				new MixedExportsPlugin(options.performance).apply(compiler);
+			}
+
+			if (options.performance.pureAnnotations) {
+				const PureAnnotationsPlugin = require("./performance/PureAnnotationsPlugin");
+
+				new PureAnnotationsPlugin(options.performance).apply(compiler);
+			}
+
+			if (options.performance.evalUsage) {
+				const EvalUsagePlugin = require("./performance/EvalUsagePlugin");
+
+				new EvalUsagePlugin(options.performance).apply(compiler);
+			}
+
+			if (options.performance.tinyChunks) {
+				const TinyChunksPlugin = require("./performance/TinyChunksPlugin");
+
+				new TinyChunksPlugin(options.performance).apply(compiler);
+			}
+
+			if (options.performance.topLevelThis) {
+				const TopLevelThisPlugin = require("./performance/TopLevelThisPlugin");
+
+				new TopLevelThisPlugin(options.performance).apply(compiler);
+			}
+
+			if (options.performance.unsplitVendors) {
+				const UnsplitVendorsPlugin = require("./performance/UnsplitVendorsPlugin");
+
+				new UnsplitVendorsPlugin(options.performance).apply(compiler);
+			}
+
+			if (options.performance.splitChunksCapped) {
+				const SplitChunksCappedPlugin = require("./performance/SplitChunksCappedPlugin");
+
+				new SplitChunksCappedPlugin(options.performance).apply(compiler);
+			}
+
+			if (options.performance.dynamicExports) {
+				const DynamicExportsPlugin = require("./performance/DynamicExportsPlugin");
+
+				new DynamicExportsPlugin(options.performance).apply(compiler);
+			}
+
+			if (options.performance.embeddedSourceMaps) {
+				const EmbeddedSourceMapsPlugin = require("./performance/EmbeddedSourceMapsPlugin");
+
+				new EmbeddedSourceMapsPlugin(options.performance).apply(compiler);
+			}
+
+			if (options.performance.inlinedAssets) {
+				const InlinedAssetsPlugin = require("./performance/InlinedAssetsPlugin");
+
+				new InlinedAssetsPlugin(options.performance).apply(compiler);
+			}
+
+			if (options.performance.missingSideEffects) {
+				const MissingSideEffectsPlugin = require("./performance/MissingSideEffectsPlugin");
+
+				new MissingSideEffectsPlugin(options.performance).apply(compiler);
+			}
+
+			if (options.performance.scopeHoistingBailouts) {
+				const ScopeHoistingBailoutsPlugin = require("./performance/ScopeHoistingBailoutsPlugin");
+
+				new ScopeHoistingBailoutsPlugin(options.performance).apply(compiler);
+			}
+
+			if (options.performance.unusedReexports) {
+				const UnusedReexportsPlugin = require("./performance/UnusedReexportsPlugin");
+
+				new UnusedReexportsPlugin(options.performance).apply(compiler);
+			}
+
+			// Deliberately not gated on `hints`, like `unusedRules` below: a rule
+			// that only matches on one OS is a configuration mistake, not a size.
+			if (options.performance.osDependentRules) {
+				const OsDependentRuleWarningPlugin = require("./performance/OsDependentRuleWarningPlugin");
+
+				new OsDependentRuleWarningPlugin(options.performance).apply(compiler);
+			}
+
+			// Deliberately not gated on `hints`: an alias nothing matches is a
+			// configuration mistake, not a size.
+			if (options.performance.unusedAliases) {
+				const UnusedAliasesPlugin = require("./performance/UnusedAliasesPlugin");
+
+				new UnusedAliasesPlugin(options.performance).apply(compiler);
+			}
+
+			// Deliberately not gated on `hints`: a key nothing reads is a
+			// configuration mistake, not a size.
+			if (options.performance.unusedDefines) {
+				const UnusedDefinesPlugin = require("./performance/UnusedDefinesPlugin");
+
+				new UnusedDefinesPlugin(options.performance).apply(compiler);
+			}
+
+			// Deliberately not gated on `hints`: a misspelled external gets bundled
+			// instead, which no size limit would explain.
+			if (options.performance.unusedExternals) {
+				const UnusedExternalsPlugin = require("./performance/UnusedExternalsPlugin");
+
+				new UnusedExternalsPlugin(options.performance).apply(compiler);
+			}
+
+			// Deliberately not gated on `hints`: asking for both directives on one
+			// import is a configuration mistake, not a size.
+			if (options.performance.conflictingResourceHints) {
+				const ConflictingResourceHintsPlugin = require("./performance/ConflictingResourceHintsPlugin");
+
+				new ConflictingResourceHintsPlugin(options.performance).apply(compiler);
+			}
+
+			// Deliberately not gated on `hints`: a dead rule is a configuration
+			// mistake worth reporting even where size hints are off.
+			if (options.performance.unusedRules) {
+				const UnusedRuleWarningPlugin = require("./performance/UnusedRuleWarningPlugin");
+
+				new UnusedRuleWarningPlugin(options.performance).apply(compiler);
+			}
 		}
 
 		new TemplatedPathPlugin().apply(compiler);

package/lib/WebpackOptionsDefaulter.js

@@ -8,8 +8,12 @@
 const { applyWebpackOptionsDefaults } = require("./config/defaults");
 const { getNormalizedWebpackOptions } = require("./config/normalization");
 
-/** @typedef {import("./config/normalization").WebpackOptions} WebpackOptions */
-/** @typedef {import("./config/normalization").WebpackOptionsNormalized} WebpackOptionsNormalized */
+/**
+ * @import {
+ * 	WebpackOptions,
+ * 	WebpackOptionsNormalized
+ * } from "../declarations/WebpackOptions"
+ */
 
 class WebpackOptionsDefaulter {
 	/**

package/lib/asset/AssetBytesGenerator.js

@@ -20,13 +20,17 @@ const {
 } = require("../ModuleSourceTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
-/** @typedef {import("../Module").SourceType} SourceType */
-/** @typedef {import("../Module").SourceTypes} SourceTypes */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../NormalModule")} NormalModule */
+/** @import { Source } from "webpack-sources" */
+/** @import { GenerateContext } from "../Generator" */
+/**
+ * @import {
+ * 	ConcatenationBailoutReasonContext,
+ * 	SourceType,
+ * 	SourceTypes
+ * } from "../Module"
+ */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import NormalModule from "../NormalModule" */
 
 class AssetBytesGenerator extends Generator {
 	/**
@@ -110,9 +114,7 @@ class AssetBytesGenerator extends Generator {
 	generateError(error, module, generateContext) {
 		switch (generateContext.type) {
 			case JAVASCRIPT_TYPE: {
-				return new RawSource(
-					`throw new Error(${JSON.stringify(error.message)});`
-				);
+				return new RawSource(Generator.throwBuildErrorCode(error));
 			}
 			default:
 				return null;

package/lib/asset/AssetBytesParser.js

@@ -7,10 +7,8 @@
 
 const Parser = require("../Parser");
 
-/** @typedef {import("../Module").BuildInfo} BuildInfo */
-/** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+/** @import { BuildInfo, BuildMeta } from "../Module" */
+/** @import { ParserState, PreparsedAst } from "../Parser" */
 
 class AssetBytesParser extends Parser {
 	/**