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

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;

package/lib/performance/PureAnnotationsPlugin.js

@@ -0,0 +1,219 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../ModuleTypeConstants");
+const PureAnnotationsWarning = require("../errors/PureAnnotationsWarning");
+const { compareStrings } = require("../util/comparators");
+const { CompilerHintNotationRegExp } = require("../util/magicComment");
+
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/** @import { Program } from "estree" */
+/** @import { BuildInfo } from "../Module" */
+/** @import JavascriptParser from "../javascript/JavascriptParser" */
+/** @import { PureAnnotationDetails } from "../errors/PureAnnotationsWarning" */
+
+const PLUGIN_NAME = "PureAnnotationsPlugin";
+
+// Enough to name the offenders without listing every module.
+const MAX_REPORTED_MODULES = 5;
+
+// The only three the parser reads the annotation for; before anything else it
+// is just a comment. Kept in step with `JavascriptParser.isPure`.
+const ANNOTATED_TYPES = new Set([
+	"CallExpression",
+	"NewExpression",
+	"TaggedTemplateExpression"
+]);
+
+/**
+ * Collects where every node starts, and which of those starts carry a node the
+ * annotation is read for.
+ * @param {Program} ast the program
+ * @returns {{ starts: number[], annotated: Set<number> }} the two of them
+ */
+const collectStarts = (ast) => {
+	/** @type {number[]} */
+	const starts = [];
+	/** @type {Set<number>} */
+	const annotated = new Set();
+	/** @type {unknown[]} */
+	const queue = [ast];
+
+	while (queue.length > 0) {
+		const node = queue.pop();
+
+		if (!node || typeof node !== "object") continue;
+
+		if (Array.isArray(node)) {
+			for (const item of /** @type {unknown[]} */ (node)) queue.push(item);
+			continue;
+		}
+
+		// Walked structurally rather than per node type, so a node the estree
+		// types do not name is still reached.
+		const fields = /** @type {Record<string, unknown>} */ (node);
+		const { type, range } = fields;
+
+		const start = Array.isArray(range)
+			? /** @type {unknown[]} */ (range)[0]
+			: undefined;
+
+		if (typeof type === "string" && typeof start === "number") {
+			starts.push(start);
+
+			if (ANNOTATED_TYPES.has(type)) annotated.add(start);
+		}
+
+		for (const key of Object.keys(fields)) {
+			if (key !== "range" && key !== "loc") queue.push(fields[key]);
+		}
+	}
+
+	// Sorted so each annotation can binary-search for the node after it rather
+	// than walking every start, which is quadratic on a generated file.
+	starts.sort((a, b) => a - b);
+
+	return { starts, annotated };
+};
+
+class PureAnnotationsPlugin {
+	/**
+	 * Creates an instance of PureAnnotationsPlugin.
+	 * @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, { normalModuleFactory }) => {
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 */
+				const handler = (parser) => {
+					parser.hooks.program.tap(PLUGIN_NAME, (ast, comments) => {
+						const pure = comments.filter((comment) =>
+							CompilerHintNotationRegExp.Pure.test(comment.value)
+						);
+
+						if (pure.length === 0) return;
+
+						const { starts, annotated } = collectStarts(ast);
+						let wasted = 0;
+
+						for (const comment of pure) {
+							const range = /** @type {[number, number]} */ (comment.range);
+							const after = range[1];
+
+							// Comments are outside every node's range, so the node the
+							// annotation applies to is whichever starts first after it.
+							let low = 0;
+							let high = starts.length;
+
+							while (low < high) {
+								const middle = (low + high) >> 1;
+
+								if (starts[middle] < after) {
+									low = middle + 1;
+								} else {
+									high = middle;
+								}
+							}
+
+							if (low === starts.length || !annotated.has(starts[low])) {
+								wasted++;
+							}
+						}
+
+						if (wasted === 0) return;
+
+						// Kept on the module rather than in a map here, so a module the
+						// filesystem cache restores rather than parses still reports.
+						const buildInfo = /** @type {BuildInfo} */ (
+							parser.state.module.buildInfo
+						);
+
+						buildInfo.ineffectivePureAnnotations = wasted;
+					});
+				};
+
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, handler);
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, handler);
+
+				// `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 { requestShortener } = compilation;
+					/** @type {PureAnnotationDetails[]} */
+					const wasteful = [];
+					let total = 0;
+
+					for (const module of compilation.modules) {
+						// Every built module carries one, so only the field is in question.
+						const buildInfo = /** @type {BuildInfo} */ (module.buildInfo);
+
+						if (!buildInfo.ineffectivePureAnnotations) continue;
+
+						const count = buildInfo.ineffectivePureAnnotations;
+
+						total += count;
+						wasteful.push({
+							name: module.readableIdentifier(requestShortener),
+							count
+						});
+					}
+
+					if (wasteful.length === 0) return;
+
+					// Ties break by name: module order is not stable across runs.
+					wasteful.sort(
+						(a, b) => b.count - a.count || compareStrings(a.name, b.name)
+					);
+
+					const warning = new PureAnnotationsWarning(
+						wasteful.slice(0, MAX_REPORTED_MODULES),
+						total
+					);
+
+					if (hints === "error") {
+						compilation.errors.push(warning);
+					} else if (hints === "stats") {
+						compilation.hints.push(warning);
+					} else {
+						compilation.warnings.push(warning);
+					}
+				});
+			}
+		);
+	}
+}
+
+module.exports = PureAnnotationsPlugin;