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

package/lib/performance/LegacyJavascriptPlugin.js

@@ -0,0 +1,139 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const LegacyJavascriptWarning = require("../errors/LegacyJavascriptWarning");
+const { compareStrings } = require("../util/comparators");
+const { WINDOWS_PATH_SEPARATOR_REGEXP } = require("../util/identifier");
+const getModuleSize = require("./getModuleSize");
+const getSourceModules = require("./getSourceModules");
+
+/** @import { Environment, PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/** @import { LegacyPackageDetails } from "../errors/LegacyJavascriptWarning" */
+
+const PLUGIN_NAME = "LegacyJavascriptPlugin";
+
+// Packages that exist to emulate syntax. `core-js` is absent on purpose: it
+// polyfills APIs, which `output.environment` says nothing about.
+const EMULATING_PACKAGES = ["regenerator-runtime", "@babel/runtime"];
+
+// The syntax the report leans on: each is what one of those packages exists to
+// lower, so a target with all of them needs none of the lowering.
+/** @type {(keyof Environment)[]} */
+const NATIVE_FEATURES = [
+	"arrowFunction",
+	"asyncFunction",
+	"const",
+	"destructuring",
+	"forOf",
+	"generator",
+	"templateLiteral"
+];
+
+/**
+ * The emulating package a module belongs to, if it is in one.
+ * @param {string} resource the module's path
+ * @returns {string | undefined} the package, or undefined when it is not one
+ */
+const emulatingPackage = (resource) => {
+	// Separators normalized so one check serves both platforms, and matched
+	// against the path so an alias or re-export is still recognized.
+	const path = resource.replace(WINDOWS_PATH_SEPARATOR_REGEXP, "/");
+
+	for (const name of EMULATING_PACKAGES) {
+		if (path.includes(`node_modules/${name}/`)) return name;
+	}
+
+	return undefined;
+};
+
+class LegacyJavascriptPlugin {
+	/**
+	 * Creates an instance of LegacyJavascriptPlugin.
+	 * @param {PerformanceOptions} options the plugin options
+	 */
+	constructor(options) {
+		/** @type {PerformanceOptions["hints"]} */
+		this.hints = options.hints;
+	}
+
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const hints = this.hints;
+
+		if (!hints) return;
+
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			// `afterSeal` is past the hash, which folds every message into it — a
+			// hint reported earlier would change the build's identity.
+			compilation.hooks.afterSeal.tap(PLUGIN_NAME, () => {
+				const environment = compilation.outputOptions.environment;
+
+				// Reported only when the target has every one of them: emulating a
+				// feature the target is missing is the polyfill doing its job.
+				for (const feature of NATIVE_FEATURES) {
+					if (!environment[feature]) return;
+				}
+
+				/** @type {Map<string, LegacyPackageDetails>} */
+				const found = new Map();
+				let totalSize = 0;
+
+				for (const module of compilation.modules) {
+					for (const inner of getSourceModules(module)) {
+						const resource = inner.nameForCondition();
+
+						if (!resource) continue;
+
+						const name = emulatingPackage(resource);
+
+						if (!name) continue;
+
+						const size = getModuleSize(inner);
+						const details = found.get(name);
+
+						totalSize += size;
+
+						if (details === undefined) {
+							found.set(name, { name, modules: 1, size });
+						} else {
+							details.modules++;
+							details.size += size;
+						}
+					}
+				}
+
+				if (found.size === 0) return;
+
+				// Ties break by name: module order is not stable across runs.
+				const packages = [...found.values()].sort(
+					(a, b) => b.size - a.size || compareStrings(a.name, b.name)
+				);
+
+				const warning = new LegacyJavascriptWarning(
+					packages,
+					totalSize,
+					NATIVE_FEATURES
+				);
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = LegacyJavascriptPlugin;

package/lib/performance/MissingSideEffectsPlugin.js

@@ -0,0 +1,138 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const NormalModule = require("../NormalModule");
+const MissingSideEffectsWarning = require("../errors/MissingSideEffectsWarning");
+const { compareStrings } = require("../util/comparators");
+const getModuleSize = require("./getModuleSize");
+const hasOnlyUnusedExports = require("./hasOnlyUnusedExports");
+
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/** @import Module from "../Module" */
+/**
+ * @import {
+ * 	MissingSideEffectsDetails
+ * } from "../errors/MissingSideEffectsWarning"
+ */
+
+const PLUGIN_NAME = "MissingSideEffectsPlugin";
+
+// Enough to name the costliest without listing the whole dependency tree.
+const MAX_REPORTED_PACKAGES = 5;
+
+/**
+ * The package a module belongs to, when its package.json leaves 'sideEffects'
+ * unsaid. Nearly every package does, so only the costly ones are worth naming.
+ * @param {Module} module the module to look up
+ * @returns {string | undefined} the package name, or undefined
+ */
+const getUndeclaredPackage = (module) => {
+	if (!(module instanceof NormalModule)) return undefined;
+
+	const resolveData = module.resourceResolveData;
+	const description = resolveData && resolveData.descriptionFileData;
+
+	if (!description || typeof description.name !== "string") return undefined;
+	if ("sideEffects" in description) return undefined;
+
+	return description.name;
+};
+
+class MissingSideEffectsPlugin {
+	/**
+	 * Creates an instance of MissingSideEffectsPlugin.
+	 * @param {PerformanceOptions} options the plugin options
+	 */
+	constructor(options) {
+		/** @type {PerformanceOptions["hints"]} */
+		this.hints = options.hints;
+	}
+
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const hints = this.hints;
+
+		if (!hints) return;
+
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			/** @type {MissingSideEffectsWarning | undefined} */
+			let warning;
+
+			// Usage is final here, and concatenation has not merged the modules
+			// away yet, so each one can still be measured and attributed.
+			compilation.hooks.optimizeModules.tap(PLUGIN_NAME, (modules) => {
+				const { chunkGraph, moduleGraph } = compilation;
+				/** @type {Map<string, { modules: number, size: number }>} */
+				const byPackage = new Map();
+				let wasted = 0;
+
+				for (const module of modules) {
+					// One webpack already left out costs nothing.
+					if (chunkGraph.getNumberOfModuleChunks(module) === 0) continue;
+					if (!hasOnlyUnusedExports(module, moduleGraph, chunkGraph)) continue;
+
+					const name = getUndeclaredPackage(module);
+
+					if (name === undefined) continue;
+
+					const size = getModuleSize(module);
+					const entry = byPackage.get(name);
+
+					wasted += size;
+
+					if (entry === undefined) {
+						byPackage.set(name, { modules: 1, size });
+					} else {
+						entry.modules++;
+						entry.size += size;
+					}
+				}
+
+				if (byPackage.size === 0) return;
+
+				/** @type {MissingSideEffectsDetails[]} */
+				const packages = [];
+
+				for (const [name, { modules: count, size }] of byPackage) {
+					packages.push({ name, modules: count, size });
+				}
+
+				// Ties break by name: module order is not stable across runtimes.
+				packages.sort(
+					(a, b) => b.size - a.size || compareStrings(a.name, b.name)
+				);
+
+				warning = new MissingSideEffectsWarning(
+					packages.slice(0, MAX_REPORTED_PACKAGES),
+					packages.length,
+					wasted
+				);
+			});
+
+			// Reported past the hash: `createHash` folds every message into it, so
+			// a hint pushed earlier would change the build's identity.
+			compilation.hooks.afterSeal.tap(PLUGIN_NAME, () => {
+				if (warning === undefined) return;
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = MissingSideEffectsPlugin;

package/lib/performance/MixedExportsPlugin.js

@@ -0,0 +1,136 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const MixedExportsWarning = require("../errors/MixedExportsWarning");
+const { compareStrings } = require("../util/comparators");
+
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/** @import { MixedExportsDetails } from "../errors/MixedExportsWarning" */
+
+const PLUGIN_NAME = "MixedExportsPlugin";
+
+// Enough to name the offenders without listing every entry.
+const MAX_REPORTED_ENTRIES = 5;
+
+// Only these hand the namespace object straight to `require()`, so only here
+// does a default sitting beside named exports change what a consumer receives.
+const AMBIGUOUS_LIBRARY_TYPES = new Set([
+	"commonjs",
+	"commonjs2",
+	"commonjs-module",
+	"commonjs-static"
+]);
+
+class MixedExportsPlugin {
+	/**
+	 * Creates an instance of MixedExportsPlugin.
+	 * @param {PerformanceOptions} options the plugin options
+	 */
+	constructor(options) {
+		/** @type {PerformanceOptions["hints"]} */
+		this.hints = options.hints;
+	}
+
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const hints = this.hints;
+
+		if (!hints) return;
+
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			// `afterSeal` is past the hash, which folds every message into it — a
+			// hint reported earlier would change the build's identity.
+			compilation.hooks.afterSeal.tap(PLUGIN_NAME, () => {
+				const { moduleGraph, outputOptions } = compilation;
+
+				/** @type {Map<string, MixedExportsDetails[]>} */
+				const byType = new Map();
+
+				for (const [name, entry] of compilation.entries) {
+					// An entry can carry its own library, which wins over the output one.
+					const library = entry.options.library || outputOptions.library;
+					const type = library && library.type;
+
+					if (!type || !AMBIGUOUS_LIBRARY_TYPES.has(type)) continue;
+
+					// Naming one export already resolves it, whichever it is.
+					if (library.export) continue;
+
+					// Only the last module of an entry reaches the consumer: every chunk
+					// format renders the startup with `entries[entries.length - 1]`.
+					const { dependencies } = entry;
+					const exported = dependencies[dependencies.length - 1];
+
+					if (!exported) continue;
+
+					const module = moduleGraph.getModule(exported);
+
+					if (!module) continue;
+
+					const provided = moduleGraph
+						.getExportsInfo(module)
+						.getProvidedExports();
+
+					// `true` means "everything", which says nothing about a default.
+					if (!Array.isArray(provided)) continue;
+
+					/** @type {string[]} */
+					const named = [];
+					let hasDefault = false;
+
+					for (const it of provided) {
+						if (it === "default") {
+							hasDefault = true;
+						} else {
+							named.push(it);
+						}
+					}
+
+					if (!hasDefault || named.length === 0) continue;
+
+					const mixed = byType.get(type);
+					const details = { name, named: named.sort(compareStrings) };
+
+					if (mixed) {
+						mixed.push(details);
+					} else {
+						byType.set(type, [details]);
+					}
+				}
+
+				if (byType.size === 0) return;
+
+				// One report per library type, sorted so a rename cannot reorder them.
+				for (const type of [...byType.keys()].sort(compareStrings)) {
+					const mixed = /** @type {MixedExportsDetails[]} */ (byType.get(type));
+
+					mixed.sort((a, b) => compareStrings(a.name, b.name));
+
+					const warning = new MixedExportsWarning(
+						mixed.slice(0, MAX_REPORTED_ENTRIES),
+						type
+					);
+
+					if (hints === "error") {
+						compilation.errors.push(warning);
+					} else if (hints === "stats") {
+						compilation.hints.push(warning);
+					} else {
+						compilation.warnings.push(warning);
+					}
+				}
+			});
+		});
+	}
+}
+
+module.exports = MixedExportsPlugin;

package/lib/performance/OsDependentRuleWarningPlugin.js

@@ -0,0 +1,178 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const OsDependentRuleWarning = require("../errors/OsDependentRuleWarning");
+
+/**
+ * @import {
+ * 	Falsy,
+ * 	PerformanceOptions,
+ * 	RuleSetCondition,
+ * 	RuleSetRule
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import Compiler from "../Compiler" */
+
+const PLUGIN_NAME = "OsDependentRuleWarningPlugin";
+
+// Only these carry a path. `resourceQuery`, `resourceFragment`, `mimetype` and
+// `scheme` legitimately contain a `/`.
+const PATH_PROPERTIES = [
+	"test",
+	"include",
+	"exclude",
+	"resource",
+	"realResource",
+	"issuer"
+];
+
+/** @typedef {"posix" | "windows" | undefined} Separator */
+
+/**
+ * Which separator a pattern can match, walking its source so an escape is never
+ * mistaken for the separator after it (`\.` is not `\\`); both means portable.
+ * @param {RegExp} regExp the condition
+ * @returns {Separator} the only separator it matches, or `undefined` when it is portable
+ */
+const onlyMatchedSeparator = (regExp) => {
+	const { source } = regExp;
+	let posix = false;
+	let windows = false;
+
+	for (let i = 0; i < source.length; i++) {
+		const character = source[i];
+
+		if (character === "\\") {
+			const escaped = source[i + 1];
+
+			if (escaped === "\\") {
+				windows = true;
+			} else if (escaped === "/") {
+				posix = true;
+			}
+
+			i++;
+		} else if (character === "/") {
+			posix = true;
+		}
+	}
+
+	if (posix === windows) return undefined;
+
+	return posix ? "posix" : "windows";
+};
+
+/**
+ * @param {RuleSetCondition} condition the condition to walk
+ * @param {(regExp: RegExp) => void} callback called for every regexp within
+ * @returns {void}
+ */
+const forEachRegExp = (condition, callback) => {
+	if (condition instanceof RegExp) {
+		callback(condition);
+	} else if (Array.isArray(condition)) {
+		for (const item of condition) forEachRegExp(item, callback);
+	} else if (condition && typeof condition === "object") {
+		// `not` is skipped: negated, a separator says which paths are *excluded*,
+		// so the condition still matches the other OS.
+		for (const key of ["and", "or"]) {
+			const nested = condition[/** @type {keyof typeof condition} */ (key)];
+
+			if (nested !== undefined) {
+				forEachRegExp(/** @type {RuleSetCondition} */ (nested), callback);
+			}
+		}
+	}
+};
+
+class OsDependentRuleWarningPlugin {
+	/**
+	 * Creates an instance of OsDependentRuleWarningPlugin.
+	 * @param {PerformanceOptions} options the plugin options
+	 */
+	constructor(options) {
+		/** @type {PerformanceOptions["hints"]} */
+		this.hints = options.hints;
+	}
+
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const hints = this.hints;
+		const rules =
+			compiler.options.module && compiler.options.module.rules
+				? compiler.options.module.rules
+				: [];
+
+		/** @type {string[]} */
+		const descriptions = [];
+
+		/**
+		 * @param {(RuleSetRule | Falsy)[]} ruleSet rules to walk
+		 * @param {string} path where `ruleSet` sits in the configuration
+		 * @returns {void}
+		 */
+		const walk = (ruleSet, path) => {
+			for (let i = 0; i < ruleSet.length; i++) {
+				const rule = ruleSet[i];
+
+				if (!rule || typeof rule !== "object") continue;
+
+				const rulePath = `${path}[${i}]`;
+
+				for (const property of PATH_PROPERTIES) {
+					const condition = rule[/** @type {keyof RuleSetRule} */ (property)];
+
+					if (condition === undefined) continue;
+
+					forEachRegExp(
+						/** @type {RuleSetCondition} */ (condition),
+						(regExp) => {
+							const separator = onlyMatchedSeparator(regExp);
+
+							if (separator === undefined) return;
+
+							descriptions.push(
+								`${rulePath}.${property} (${regExp}) only matches ${
+									separator === "posix" ? "'/'" : "'\\'"
+								} paths`
+							);
+						}
+					);
+				}
+
+				if (Array.isArray(rule.oneOf)) walk(rule.oneOf, `${rulePath}.oneOf`);
+				if (Array.isArray(rule.rules)) walk(rule.rules, `${rulePath}.rules`);
+			}
+		};
+
+		walk(/** @type {RuleSetRule[]} */ (rules), "module.rules");
+
+		if (descriptions.length === 0) return;
+
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			// Reported past the hash: `createHash` folds every message into it, so
+			// a hint pushed earlier would change the build's identity.
+			compilation.hooks.afterSeal.tap(PLUGIN_NAME, () => {
+				const warning = new OsDependentRuleWarning(descriptions);
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = OsDependentRuleWarningPlugin;