@depup/webpack 5.111.1-depup.2 → 5.112.0-depup.0

package/lib/{BannerPlugin.js → output/BannerPlugin.js}

@@ -6,22 +6,89 @@
 "use strict";
 
 const { ConcatSource } = require("webpack-sources");
-const Compilation = require("./Compilation");
-const ModuleFilenameHelpers = require("./ModuleFilenameHelpers");
-const Template = require("./Template");
+const Compilation = require("../Compilation");
+const ModuleFilenameHelpers = require("../devtool/ModuleFilenameHelpers");
+const Template = require("../template/Template");
 
 /** @import { Source } from "webpack-sources" */
+/** @import { PathDataChunk } from "../Compilation" */
+/** @import Compiler from "../Compiler" */
+/** @import Chunk from "../graph/Chunk" */
+/** @import { MatcherFn } from "../devtool/ModuleFilenameHelpers" */
+
+/**
+ * The banner as function, it will be wrapped in a comment.
+ * @tsType import('./BannerPlugin').BannerFunction
+ * @typedef {(data: { hash?: string, chunk: Chunk, filename: string }) => string} BannerFunction
+ */
+
+/**
+ * @inline
+ * @minLength 1
+ * @typedef {string} NonEmptyString
+ */
+
+/**
+ * A glob pattern.
+ * @inline
+ * @minLength 1
+ * @typedef {string} RuleGlobPattern
+ */
+
+/**
+ * @minItems 1
+ * @inline
+ * @typedef {RuleGlobPattern[]} RuleGlobList
+ */
+
+/**
+ * Glob patterns matched against the file name, `!` in front of a pattern excludes it, and a relative pattern matches at any depth.
+ * @since 5.112.0
+ * @inline
+ * @typedef {object} RuleGlob
+ * @property {RuleGlobList | NonEmptyString} glob Glob patterns to match.
+ */
+
+/**
+ * Filtering rule as regex or string.
+ * @typedef {RegExp | NonEmptyString | RuleGlob | import("../devtool/ModuleFilenameHelpers").MatcherFn} Rule
+ */
+
 /**
- * @import {
- * 	BannerPluginArgument,
- * 	BannerPluginOptions
- * } from "../declarations/plugins/BannerPlugin"
+ * A rule condition.
+ * @inline
+ * @typedef {Rule} RuleCondition
  */
-/** @import { PathDataChunk } from "./Compilation" */
-/** @import Compiler from "./Compiler" */
-/** @import Chunk from "./Chunk" */
 
-/** @typedef {(data: { hash?: string, chunk: Chunk, filename: string }) => string} BannerFunction */
+/**
+ * Filtering rules.
+ * @typedef {RuleCondition[] | Rule} Rules
+ */
+
+/**
+ * @inline
+ * @title BannerPluginOptions
+ * @typedef {object} BannerPluginOptions
+ * @property {string | BannerFunction} banner Specifies the banner.
+ * @property {boolean=} entryOnly If true, the banner will only be added to the entry chunks.
+ * @property {Rules=} exclude Exclude all modules matching any of these conditions.
+ * @property {boolean=} footer If true, banner will be placed at the end of the output.
+ * @property {Rules=} include Include all modules matching any of these conditions.
+ * @property {boolean=} raw If true, banner will not be wrapped in a comment.
+ * @property {number=} stage Specifies the stage when add a banner.
+ * @property {Rules=} test Include all modules that pass test assertion.
+ */
+
+/**
+ * The banner as string, it will be wrapped in a comment.
+ * @inline
+ * @typedef {NonEmptyString} BannerString
+ */
+
+/**
+ * @schema plugins/BannerPlugin
+ * @typedef {BannerString | BannerPluginOptions | BannerFunction} BannerPluginArgument
+ */
 
 /**
  * Wraps banner text in a JavaScript block comment, preserving multi-line
@@ -88,13 +155,14 @@ class BannerPlugin {
 	apply(compiler) {
 		compiler.hooks.validate.tap(PLUGIN_NAME, () => {
 			compiler.validate(
-				() => require("../schemas/plugins/BannerPlugin.json"),
+				() => require("../../schemas/plugins/BannerPlugin.json"),
 				this.options,
 				{
 					name: "Banner Plugin",
 					baseDataPath: "options"
 				},
-				(options) => require("../schemas/plugins/BannerPlugin.check")(options)
+				(options) =>
+					require("../../schemas/plugins/BannerPlugin.check")(options)
 			);
 		});
 		const options = this.options;
@@ -124,7 +192,7 @@ class BannerPlugin {
 						const data = { chunk, filename: file };
 
 						const comment = compilation.getPath(
-							/** @type {string | import("./TemplatedPathPlugin").TemplatePathFn<PathDataChunk>} */
+							/** @type {string | import("../template/TemplatedPathPlugin").TemplatePathFn<PathDataChunk>} */
 							(banner),
 							data
 						);

package/lib/{CleanPlugin.js → output/CleanPlugin.js}

@@ -7,16 +7,21 @@
 
 const path = require("path");
 const { SyncBailHook } = require("tapable");
-const asyncLib = require("./util/async");
-const createHooksRegistry = require("./util/createHooksRegistry");
-const { join } = require("./util/fs");
-const { ABSOLUTE_PATH_REGEXP } = require("./util/identifier");
-const processAsyncTree = require("./util/processAsyncTree");
-
-/** @import { CleanOptions } from "../declarations/WebpackOptions" */
-/** @import Compiler from "./Compiler" */
-/** @import { Logger } from "./logging/Logger" */
-/** @import { IStats, OutputFileSystem, StatsCallback } from "./util/fs" */
+const { join } = require("../fs/fs");
+const asyncLib = require("../util/async");
+const createHooksRegistry = require("../util/createHooksRegistry");
+const { ABSOLUTE_PATH_REGEXP } = require("../util/identifier");
+const memoize = require("../util/memoize");
+const processAsyncTree = require("../util/processAsyncTree");
+
+const getMatchGlobCondition = memoize(
+	() => require("../util/globUtils").matchGlobCondition
+);
+
+/** @import { CleanOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/** @import { Logger } from "../logging/Logger" */
+/** @import { IStats, OutputFileSystem, StatsCallback } from "../fs/fs" */
 
 /** @typedef {Map<string, number>} Assets */
 
@@ -358,7 +363,7 @@ class CleanPlugin {
 		compiler.hooks.validate.tap(PLUGIN_NAME, () => {
 			compiler.validate(
 				() => {
-					const { definitions } = require("../schemas/WebpackOptions.json");
+					const { definitions } = require("../../schemas/WebpackOptions.json");
 
 					return {
 						definitions,
@@ -383,15 +388,31 @@ class CleanPlugin {
 				? keep
 				: typeof keep === "string"
 					? (path) => path.startsWith(keep)
-					: typeof keep === "object" && keep.test
+					: keep instanceof RegExp
 						? (path) => keep.test(path)
-						: () => false;
+						: typeof keep === "object"
+							? (path) => getMatchGlobCondition()(keep, path)
+							: () => false;
 
 		// We assume that no external modification happens while the compiler is active
 		// So we can store the old assets and only diff to them to avoid fs access on
 		// incremental builds
 		/** @type {undefined | Assets} */
 		let oldAssets;
+		// a client may request the last hot update only after the next build,
+		// however long it takes, so it stays until a newer one is emitted
+		/** @type {Set<string>} */
+		let lastHotUpdateAssets = new Set();
+		// only a set that was written replaces it, see the afterEmit tap
+		/** @type {undefined | Set<string>} */
+		let pendingHotUpdateAssets;
+
+		compiler.hooks.afterEmit.tap(PLUGIN_NAME, () => {
+			if (pendingHotUpdateAssets) {
+				lastHotUpdateAssets = pendingHotUpdateAssets;
+				pendingHotUpdateAssets = undefined;
+			}
+		});
 
 		compiler.hooks.emit.tapAsync(
 			{
@@ -413,28 +434,39 @@ class CleanPlugin {
 
 				/** @type {Assets} */
 				const currentAssets = new Map();
+				/** @type {Set<string>} */
+				const hotUpdateAssets = new Set();
 				const now = Date.now();
 				for (const asset of Object.keys(compilation.assets)) {
 					if (ABSOLUTE_PATH_REGEXP.test(asset)) continue;
 					/** @type {string} */
-					let normalizedAsset;
-					let newNormalizedAsset = asset.replace(/\\/g, "/");
-					do {
-						normalizedAsset = newNormalizedAsset;
-						newNormalizedAsset = normalizedAsset.replace(
-							/(^|\/)(?!\.\.)[^/]+\/\.\.\//g,
-							"$1"
-						);
-					} while (newNormalizedAsset !== normalizedAsset);
+					let normalizedAsset = asset;
+					if (asset.includes("\\") || asset.includes("/../")) {
+						let newNormalizedAsset = asset.replace(/\\/g, "/");
+						do {
+							normalizedAsset = newNormalizedAsset;
+							newNormalizedAsset = normalizedAsset.replace(
+								/(^|\/)(?!\.\.)[^/]+\/\.\.\//g,
+								"$1"
+							);
+						} while (newNormalizedAsset !== normalizedAsset);
+					}
 					if (normalizedAsset.startsWith("../")) continue;
 					const assetInfo = compilation.assetsInfo.get(asset);
 					if (assetInfo && assetInfo.hotModuleReplacement) {
 						currentAssets.set(normalizedAsset, now + _10sec);
+						hotUpdateAssets.add(normalizedAsset);
 					} else {
 						currentAssets.set(normalizedAsset, 0);
 					}
 				}
 
+				// the retained set counts as emitted, so neither it nor its directory
+				// is removed; with timestamp 0 it goes once a newer set replaces it
+				for (const asset of lastHotUpdateAssets) {
+					if (!currentAssets.has(asset)) currentAssets.set(asset, 0);
+				}
+
 				const outputPath = compilation.getPath(compiler.outputPath, {});
 
 				/**
@@ -459,20 +491,30 @@ class CleanPlugin {
 						callback(err);
 						return;
 					}
+					const removed = /** @type {Diff} */ (diff);
 					applyDiff(
 						fs,
 						outputPath,
 						dry,
 						logger,
-						/** @type {Diff} */ (diff),
+						removed,
 						isKept,
 						(err, keptAssets) => {
 							if (err) {
 								oldAssets = undefined;
 							} else {
-								if (oldAssets) mergeAssets(currentAssets, oldAssets);
+								if (oldAssets) {
+									// a removed entry is gone for good; tracking it would
+									// stat it again on every later build
+									if (!dry) {
+										for (const asset of removed) oldAssets.delete(asset);
+									}
+									mergeAssets(currentAssets, oldAssets);
+								}
 								oldAssets = currentAssets;
 								if (keptAssets) mergeAssets(oldAssets, keptAssets);
+								pendingHotUpdateAssets =
+									hotUpdateAssets.size > 0 ? hotUpdateAssets : undefined;
 							}
 							callback(err);
 						}

package/lib/{CopyPlugin.js → output/CopyPlugin.js}

@@ -6,13 +6,15 @@
 "use strict";
 
 const path = require("path");
+const { SyncBailHook } = require("tapable");
 const { RawSource } = require("webpack-sources");
-const Compilation = require("./Compilation");
-const EmptyCopyPatternWarning = require("./errors/EmptyCopyPatternWarning");
-const WebpackError = require("./errors/WebpackError");
-const asyncLib = require("./util/async");
-const createHash = require("./util/createHash");
-const { PERMISSIONS_MASK, join } = require("./util/fs");
+const Compilation = require("../Compilation");
+const EmptyCopyPatternWarning = require("../errors/EmptyCopyPatternWarning");
+const WebpackError = require("../errors/WebpackError");
+const { PERMISSIONS_MASK, join } = require("../fs/fs");
+const asyncLib = require("../util/async");
+const createHash = require("../util/createHash");
+const createHooksRegistry = require("../util/createHooksRegistry");
 const {
 	escapeGlobPattern,
 	extractGlobBaseDir,
@@ -20,17 +22,30 @@ const {
 	normalizePathSeparators,
 	normalizePathSeparatorsForPath,
 	unescapeGlobPath
-} = require("./util/globUtils");
-const { ABSOLUTE_PATH_REGEXP } = require("./util/identifier");
-
-/** @import { CopyGlobOptions, CopyObjectPattern, CopyOptions, CopyPattern } from "../declarations/WebpackOptions" */
-/** @import Compiler from "./Compiler" */
-/** @import { AssetInfo, AssetSymlink, AssetTimestamps, PathData } from "./Compilation" */
-/** @import CacheFacade from "./CacheFacade" */
-/** @import { Snapshot } from "./FileSystemInfo" */
-/** @import { Logger } from "./logging/Logger" */
-/** @import { Dirent, InputFileSystem, IStats } from "./util/fs" */
-/** @import { GlobMatchOptions } from "./util/globUtils" */
+} = require("../util/globUtils");
+const { ABSOLUTE_PATH_REGEXP } = require("../util/identifier");
+
+const createCompilationHooks = () => ({
+	/**
+	 * Answers whether a path is copied, ahead of `globOptions.ignore`: true never copies it, false copies it whatever `globOptions.ignore` says, and nothing leaves the decision to webpack. A directory has to be answered as well as the files below it, because one that is ignored is never walked.
+	 * @type {SyncBailHook<[string], boolean | void>}
+	 * @since 5.112.0
+	 */
+	ignore: new SyncBailHook(["path"])
+});
+
+/**
+ * @typedef {ReturnType<typeof createCompilationHooks>} CopyPluginCompilationHooks
+ */
+
+/** @import { CopyGlobOptions, CopyObjectPattern, CopyOptions, CopyPattern } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/** @import { AssetInfo, AssetSymlink, AssetTimestamps, PathData } from "../Compilation" */
+/** @import CacheFacade from "../cache/CacheFacade" */
+/** @import { Snapshot } from "../fs/FileSystemInfo" */
+/** @import { Logger } from "../logging/Logger" */
+/** @import { Dirent, InputFileSystem, IStats } from "../fs/fs" */
+/** @import { GlobMatchOptions } from "../util/globUtils" */
 /** @import { Source } from "webpack-sources" */
 
 /**
@@ -183,6 +198,31 @@ const stat = (fs, filePath) =>
 		});
 	});
 
+/**
+ * Answers whether the path is a symbolic link itself rather than what one points at.
+ * @param {InputFileSystem} fs input file system
+ * @param {string} filePath path
+ * @returns {Promise<boolean>} true when it is a symbolic link
+ */
+const isSymbolicLink = (fs, filePath) =>
+	new Promise((resolve, reject) => {
+		// a file system without it reports what the link points at, which is the
+		// behavior this answer then leaves in place
+		if (!fs.lstat) {
+			resolve(false);
+			return;
+		}
+		fs.lstat(filePath, (err, stats) => {
+			if (err) {
+				if (err.code === "ENOENT" || err.code === "ENOTDIR") {
+					return resolve(false);
+				}
+				return reject(err);
+			}
+			resolve(/** @type {IStats} */ (stats).isSymbolicLink());
+		});
+	});
+
 /**
  * @param {InputFileSystem} fs input file system
  * @param {string} filePath path
@@ -260,11 +300,12 @@ const walkDirectory = async (options, directory, visited, maxDepth) => {
 		DIRECTORY_CONCURRENCY,
 		async (entry) => {
 			const filePath = join(fs, directory, entry.name);
+			const normalizedPath = normalizePathSeparatorsForPath(filePath);
 			const isSymlink = entry.isSymbolicLink();
 			// the link itself is what is copied, so neither its target nor what is
 			// below it is read
 			if (isSymlink && !followSymlinks) {
-				if (ignore.file(normalizePathSeparatorsForPath(filePath))) return [];
+				if (ignore.file(normalizedPath)) return [];
 				links.add(filePath);
 				return [filePath];
 			}
@@ -273,11 +314,13 @@ const walkDirectory = async (options, directory, visited, maxDepth) => {
 			const stats = isSymlink ? await stat(fs, filePath) : entry;
 			// the target is gone, or is neither a file nor a directory
 			if (stats === undefined) return [];
-			if (stats.isFile()) return [filePath];
+			if (stats.isFile()) {
+				return ignore.file(normalizedPath) ? [] : [filePath];
+			}
 			if (!stats.isDirectory() || maxDepth === 0) return [];
 			// an ignored directory is not listed at all, which is what makes an
 			// `ignore` naming one cheaper than dropping its files afterwards
-			if (ignore.directory(normalizePathSeparatorsForPath(filePath))) return [];
+			if (ignore.directory(normalizedPath)) return [];
 			if (isSymlink) {
 				const realPath = await realpath(fs, filePath);
 				if (visited.has(realPath)) return [];
@@ -301,16 +344,13 @@ const walkDirectory = async (options, directory, visited, maxDepth) => {
  * @returns {Promise<string[]>} absolute paths of the files below it, in a stable order
  */
 const walkBase = async (options, base, maxDepth) => {
-	// the base is a directory like any below it, so an `ignore` naming it skips
-	// what the whole pattern would have copied
-	if (options.ignore.directory(normalizePathSeparatorsForPath(base))) return [];
-	return walkDirectory(
-		options,
-		base,
-		// the base counts as walked, so a symlink pointing back at it ends there
-		new Set(options.followSymlinks ? [await realpath(options.fs, base)] : []),
-		maxDepth
-	);
+	/** @type {Set<string>} */
+	const visited = new Set();
+	// the base counts as walked, so a symlink pointing back at it ends there
+	if (options.followSymlinks) {
+		visited.add(await realpath(options.fs, base));
+	}
+	return walkDirectory(options, base, visited, maxDepth);
 };
 
 /**
@@ -321,6 +361,25 @@ const notIgnored = () => false;
 /** @type {IgnoreMatcher} */
 const NOTHING_IGNORED = { file: notIgnored, directory: notIgnored };
 
+/**
+ * Puts the `ignore` hook ahead of `globOptions.ignore`, so a plugin can overrule it either way.
+ * @param {CopyPluginCompilationHooks} hooks the compilation's copy hooks
+ * @param {IgnoreMatcher} ignore what `globOptions.ignore` does not copy
+ * @returns {IgnoreMatcher} the one answer for a path
+ */
+const createIgnoreMatcher = (hooks, ignore) => {
+	/**
+	 * @param {(normalizedPath: string) => boolean} byGlobOptions what `globOptions.ignore` says
+	 * @returns {(normalizedPath: string) => boolean} what the copy does
+	 */
+	const answer = (byGlobOptions) => (normalizedPath) => {
+		const decision = hooks.ignore.call(normalizedPath);
+		if (decision !== undefined) return decision;
+		return byGlobOptions(normalizedPath);
+	};
+	return { file: answer(ignore.file), directory: answer(ignore.directory) };
+};
+
 // the tail of a glob naming everything inside a directory, which names the
 // directory itself once it is gone
 const IGNORED_DIRECTORY_CONTENTS_REGEXP = /\/\*\*(?:\/\*)?$/;
@@ -330,7 +389,7 @@ const IGNORED_DIRECTORY_CONTENTS_REGEXP = /\/\*\*(?:\/\*)?$/;
  * @returns {WebpackError} the error as a webpack error
  */
 const toWebpackError = (error) => {
-	if (error instanceof WebpackError) return error;
+	if (WebpackError.isWebpackError(error)) return error;
 	const webpackError = new WebpackError(error.message);
 	webpackError.details = error.stack;
 	return webpackError;
@@ -474,10 +533,9 @@ class CopyPlugin {
 			caseSensitive: globOptions.caseSensitive,
 			requireLiteralLeadingDot: globOptions.dot === false
 		};
-		const ignore = this._createIgnoreMatcher(
-			context,
-			globOptions.ignore,
-			matchOptions
+		const ignore = createIgnoreMatcher(
+			CopyPlugin.getCompilationHooks(compilation),
+			this._createIgnoreMatcher(context, globOptions.ignore, matchOptions)
 		);
 		/** @type {Set<string>} */
 		const links = new Set();
@@ -538,7 +596,7 @@ class CopyPlugin {
 		/** @type {Set<string>} */
 		const filenames = new Set();
 		for (const result of results) {
-			if (result instanceof WebpackError) {
+			if (WebpackError.isWebpackError(result)) {
 				errors.push(result);
 				continue;
 			}
@@ -584,15 +642,22 @@ class CopyPlugin {
 		const absoluteFrom = path.isAbsolute(from)
 			? path.normalize(from)
 			: path.resolve(context, from);
+		// `stat` follows the link, so a `from` naming one is classified as what it
+		// points at — a directory to walk into, or a file whose bytes to read —
+		// where a `followSymlinks: false` copies the link itself instead
+		const namesLink =
+			!followSymlinks && (await isSymbolicLink(fs, absoluteFrom));
 		const stats = await stat(fs, absoluteFrom);
 		/** @type {TypeOfFrom} */
-		const typeOfFrom = !stats
-			? "glob"
-			: stats.isDirectory()
-				? "dir"
-				: stats.isFile()
-					? "file"
-					: "glob";
+		const typeOfFrom = namesLink
+			? "file"
+			: !stats
+				? "glob"
+				: stats.isDirectory()
+					? "dir"
+					: stats.isFile()
+						? "file"
+						: "glob";
 
 		/** @type {string} */
 		let glob;
@@ -634,39 +699,47 @@ class CopyPlugin {
 		// the glob is normalized already, and the base once here, so the match
 		// does not redo either for every entry
 		const normalizedBase = normalizePathSeparatorsForPath(base);
-		const entries =
+		// asked once for the whole pattern, so the walk and the watch agree on it
+		const ignored =
 			typeOfFrom === "file"
 				? ignore.file(normalizePathSeparatorsForPath(absoluteFrom))
-					? []
-					: [absoluteFrom]
+				: ignore.directory(normalizedBase);
+		const entries = ignored
+			? []
+			: typeOfFrom === "file"
+				? [absoluteFrom]
 				: (
 						await walkBase(
 							{ fs, followSymlinks, ignore, links },
 							base,
 							maxDepth
 						)
-					).filter((filePath) => {
-						const normalizedPath = normalizePathSeparatorsForPath(filePath);
-						return (
-							globMatchNormalizedWithExplicitDot(
-								glob,
-								normalizedPath,
-								normalizedBase,
-								matchOptions
-							) && !ignore.file(normalizedPath)
-						);
-					});
+					).filter((filePath) =>
+						globMatchNormalizedWithExplicitDot(
+							glob,
+							normalizePathSeparatorsForPath(filePath),
+							normalizedBase,
+							matchOptions
+						)
+					);
 
-		await this._addPatternDependency(
-			fs,
-			compilation,
-			typeOfFrom,
-			absoluteFrom,
-			base,
-			// only a glob can name a base which is not there — a directory `from`
-			// was stat'd above, and a file one watches itself
-			entries.length === 0 && typeOfFrom === "glob"
-		);
+		// what the link says is what is copied, the same as one the walk reaches
+		if (namesLink && entries.length > 0) links.add(absoluteFrom);
+
+		// a base which copies nothing is not watched either, or the compilation
+		// would rebuild on what it wrote there itself
+		if (!ignored) {
+			await this._addPatternDependency(
+				fs,
+				compilation,
+				typeOfFrom,
+				absoluteFrom,
+				base,
+				// only a glob can name a base which is not there — a directory `from`
+				// was stat'd above, and a file one watches itself
+				entries.length === 0 && typeOfFrom === "glob"
+			);
+		}
 
 		return { from, typeOfFrom, glob, base, entries };
 	}
@@ -1051,4 +1124,6 @@ class CopyPlugin {
 	}
 }
 
+CopyPlugin.getCompilationHooks = createHooksRegistry(createCompilationHooks);
+
 module.exports = CopyPlugin;