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

package/lib/ProgressPlugin.js

@@ -9,33 +9,34 @@ const Compiler = require("./Compiler");
 const MultiCompiler = require("./MultiCompiler");
 const NormalModule = require("./NormalModule");
 const { contextify } = require("./util/identifier");
+const memoize = require("./util/memoize");
+
+const getColors = memoize(() => {
+	const cli = require("./cli");
+
+	return cli.createColors({ useColor: cli.isColorSupported() });
+});
+
+const BAR_LENGTH = 25;
+const BLOCK_CHAR = "━";
+const BULLET_ICON = "●";
 
 /** @typedef {import("tapable").Tap} Tap */
 /**
+ * Defines the hook type used by this module.
  * @template T, R, AdditionalOptions
  * @typedef {import("tapable").Hook<T, R, AdditionalOptions>} Hook
  */
 /** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginArgument} ProgressPluginArgument */
 /** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginOptions} ProgressPluginOptions */
-/** @typedef {import("./Compilation").FactorizeModuleOptions} FactorizeModuleOptions */
 /** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
 /** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
 /** @typedef {import("./logging/Logger").Logger} Logger */
+/** @typedef {import("./cli").Colors} Colors */
 
 /**
- * @template T, K, R
- * @typedef {import("./util/AsyncQueue")<T, K, R>} AsyncQueue
- */
-
-/**
- * @typedef {object} CountsData
- * @property {number} modulesCount modules count
- * @property {number} dependenciesCount dependencies count
- */
-
-/**
+ * Returns median.
  * @param {number} a a
  * @param {number} b b
  * @param {number} c c
@@ -46,82 +47,260 @@ const median3 = (a, b, c) => a + b + c - Math.max(a, b, c) - Math.min(a, b, c);
 /** @typedef {(percentage: number, msg: string, ...args: string[]) => void} HandlerFn */
 
 /**
+ * @param {Logger} logger logger
+ * @param {{ value: string | undefined, time: number }[]} lastStateInfo mutable state
+ * @param {number} percentage percentage
+ * @param {string} msg msg
+ * @param {string[]} args args
+ */
+const reportProfile = (logger, lastStateInfo, percentage, msg, args) => {
+	if (percentage === 0) {
+		lastStateInfo.length = 0;
+	}
+	const fullState = [msg, ...args];
+	const state = fullState.map((s) => s.replace(/\d+\/\d+ /g, ""));
+	const now = Date.now();
+	const len = Math.max(state.length, lastStateInfo.length);
+	for (let i = len; i >= 0; i--) {
+		const stateItem = i < state.length ? state[i] : undefined;
+		const lastStateItem =
+			i < lastStateInfo.length ? lastStateInfo[i] : undefined;
+		if (lastStateItem) {
+			if (stateItem !== lastStateItem.value) {
+				const diff = now - lastStateItem.time;
+				if (lastStateItem.value) {
+					let reportState = lastStateItem.value;
+					if (i > 0) {
+						reportState = `${lastStateInfo[i - 1].value} > ${reportState}`;
+					}
+					const stateMsg = `${" | ".repeat(i)}${diff} ms ${reportState}`;
+					const d = diff;
+					// This depends on timing so we ignore it for coverage
+					/* eslint-disable no-lone-blocks */
+					/* istanbul ignore next */
+					{
+						if (d > 10000) {
+							logger.error(stateMsg);
+						} else if (d > 1000) {
+							logger.warn(stateMsg);
+						} else if (d > 10) {
+							logger.info(stateMsg);
+						} else if (d > 5) {
+							logger.log(stateMsg);
+						} else {
+							logger.debug(stateMsg);
+						}
+					}
+					/* eslint-enable no-lone-blocks */
+				}
+				if (stateItem === undefined) {
+					lastStateInfo.length = i;
+				} else {
+					lastStateItem.value = stateItem;
+					lastStateItem.time = now;
+					lastStateInfo.length = i + 1;
+				}
+			}
+		} else {
+			lastStateInfo[i] = {
+				value: stateItem,
+				time: now
+			};
+		}
+	}
+};
+
+/**
+ * @param {number} ms milliseconds
+ * @returns {string} human readable duration
+ */
+const formatTime = (ms) => {
+	if (ms < 1000) return `${Math.round(ms)}ms`;
+	const seconds = Math.floor(ms / 1000);
+	if (seconds < 60) return `${seconds}s`;
+	const minutes = Math.floor(seconds / 60);
+	if (minutes < 60) return `${minutes}m ${seconds % 60}s`;
+	const hours = Math.floor(minutes / 60);
+	return `${hours}h ${minutes % 60}m`;
+};
+
+/**
+ * @param {string} name progress bar name
+ * @param {string} color progress bar color
+ * @param {number} width progress bar width in characters
+ * @returns {(percentage: number) => string} bar renderer
+ */
+const createReportBar = (name, color, width) => {
+	const c = getColors();
+	const colorFn = color in c ? c[/** @type {keyof Colors} */ (color)] : c.green;
+	// The bar only changes when the filled width does, so cache it between steps.
+	let lastFilled = -1;
+	let lastBar = "";
+
+	return (percentage) => {
+		const filled = Math.round(percentage * width);
+		if (filled === lastFilled) return lastBar;
+		lastFilled = filled;
+		const filledStr = BLOCK_CHAR.repeat(filled);
+		const emptyStr = BLOCK_CHAR.repeat(width - filled);
+		lastBar = `${[BULLET_ICON, name, filledStr].map(colorFn).join(" ")}${c.white(
+			emptyStr
+		)}`;
+		return lastBar;
+	};
+};
+
+/** @typedef {Required<Exclude<NonNullable<ProgressPluginOptions["progressBar"]>, boolean | "auto">>} ProgressBarOptions */
+
+/** @type {ProgressBarOptions} */
+const DEFAULT_PROGRESS_BAR = {
+	name: "Build",
+	color: "green",
+	width: BAR_LENGTH
+};
+
+/** @typedef {{ progressBar?: ProgressBarOptions | false, estimatedTime?: boolean, phaseTimings?: boolean }} DefaultHandlerOptions */
+
+/**
+ * Creates a default handler.
  * @param {boolean | null | undefined} profile need profile
  * @param {Logger} logger logger
+ * @param {DefaultHandlerOptions=} options display options
  * @returns {HandlerFn} default handler
  */
-const createDefaultHandler = (profile, logger) => {
+const createDefaultHandler = (profile, logger, options = {}) => {
+	const {
+		progressBar = false,
+		estimatedTime = false,
+		phaseTimings = false
+	} = options;
+	const trackTime = estimatedTime || phaseTimings;
+
 	/** @type {{ value: string | undefined, time: number }[]} */
 	const lastStateInfo = [];
+	let buildStart = 0;
+	// Exponential moving average of the estimated total build time (0 = unset).
+	let smoothedTotal = 0;
+	/** @type {Map<string, number>} accumulated ms per phase (msg) */
+	const phaseTimes = new Map();
+	/** @type {string | undefined} */
+	let currentPhase;
+	let currentPhaseStart = 0;
+	let summaryReported = false;
+	/** @type {((percentage: number) => string) | undefined} */
+	let reportBar;
+
+	/**
+	 * @param {number} now current timestamp
+	 * @returns {void}
+	 */
+	const reportPhaseSummary = (now) => {
+		if (!phaseTimings || summaryReported || phaseTimes.size === 0) return;
+		summaryReported = true;
+		// Flush the phase still running at completion.
+		if (currentPhase !== undefined) {
+			phaseTimes.set(
+				currentPhase,
+				(phaseTimes.get(currentPhase) || 0) + (now - currentPhaseStart)
+			);
+		}
+		const total = now - buildStart;
+		logger.info(`Build completed in ${formatTime(total)}`);
+		logger.info("Phase breakdown:");
+		for (const [phase, duration] of phaseTimes) {
+			if (duration > 0) {
+				const percent = total > 0 ? Math.round((duration / total) * 100) : 0;
+				logger.info(`  ${phase}: ${formatTime(duration)} (${percent}%)`);
+			}
+		}
+	};
 
 	/** @type {HandlerFn} */
 	const defaultHandler = (percentage, msg, ...args) => {
 		if (profile) {
-			if (percentage === 0) {
-				lastStateInfo.length = 0;
+			reportProfile(logger, lastStateInfo, percentage, msg, args);
+		}
+
+		const now = trackTime ? Date.now() : 0;
+
+		if (trackTime && percentage === 0) {
+			buildStart = now;
+			smoothedTotal = 0;
+			summaryReported = false;
+			phaseTimes.clear();
+			currentPhase = undefined;
+			currentPhaseStart = now;
+		}
+
+		// Accumulate time under the previous phase whenever the top-level message changes.
+		if (phaseTimings && msg && msg !== currentPhase) {
+			if (currentPhase !== undefined) {
+				phaseTimes.set(
+					currentPhase,
+					(phaseTimes.get(currentPhase) || 0) + (now - currentPhaseStart)
+				);
 			}
-			const fullState = [msg, ...args];
-			const state = fullState.map((s) => s.replace(/\d+\/\d+ /g, ""));
-			const now = Date.now();
-			const len = Math.max(state.length, lastStateInfo.length);
-			for (let i = len; i >= 0; i--) {
-				const stateItem = i < state.length ? state[i] : undefined;
-				const lastStateItem =
-					i < lastStateInfo.length ? lastStateInfo[i] : undefined;
-				if (lastStateItem) {
-					if (stateItem !== lastStateItem.value) {
-						const diff = now - lastStateItem.time;
-						if (lastStateItem.value) {
-							let reportState = lastStateItem.value;
-							if (i > 0) {
-								reportState = `${lastStateInfo[i - 1].value} > ${reportState}`;
-							}
-							const stateMsg = `${" | ".repeat(i)}${diff} ms ${reportState}`;
-							const d = diff;
-							// This depends on timing so we ignore it for coverage
-							/* eslint-disable no-lone-blocks */
-							/* istanbul ignore next */
-							{
-								if (d > 10000) {
-									logger.error(stateMsg);
-								} else if (d > 1000) {
-									logger.warn(stateMsg);
-								} else if (d > 10) {
-									logger.info(stateMsg);
-								} else if (d > 5) {
-									logger.log(stateMsg);
-								} else {
-									logger.debug(stateMsg);
-								}
-							}
-							/* eslint-enable no-lone-blocks */
-						}
-						if (stateItem === undefined) {
-							lastStateInfo.length = i;
-						} else {
-							lastStateItem.value = stateItem;
-							lastStateItem.time = now;
-							lastStateInfo.length = i + 1;
-						}
-					}
-				} else {
-					lastStateInfo[i] = {
-						value: stateItem,
-						time: now
-					};
-				}
+			currentPhase = msg;
+			currentPhaseStart = now;
+		}
+
+		/** @type {string | undefined} */
+		let eta;
+		if (estimatedTime && percentage > 0.05 && percentage < 1) {
+			const elapsed = now - buildStart;
+			const rawTotal = elapsed / percentage;
+			smoothedTotal =
+				smoothedTotal > 0 ? smoothedTotal * 0.7 + rawTotal * 0.3 : rawTotal;
+			const remaining = smoothedTotal - elapsed;
+			if (remaining > 0) eta = `ETA: ${formatTime(remaining)}`;
+		}
+
+		if (progressBar) {
+			// Build the bar renderer once, then reuse it across every step.
+			if (reportBar === undefined) {
+				reportBar = createReportBar(
+					progressBar.name,
+					progressBar.color,
+					progressBar.width
+				);
+			}
+			const c = getColors();
+			/** @type {string} */
+			const currentBar = reportBar(percentage);
+			const suffix = eta ? ` ${eta}` : "";
+
+			if (percentage === 1) {
+				logger.status();
+				reportPhaseSummary(now);
+			} else if (msg) {
+				logger.status(
+					`${currentBar} (${Math.floor(percentage * 100)}%)${suffix}`,
+					`\n${[msg, ...args].map(c.gray).join(" ")}`
+				);
+			} else {
+				logger.status(
+					`${currentBar} (${Math.floor(percentage * 100)}%)${suffix}`
+				);
 			}
+			return;
+		}
+
+		if (eta) {
+			logger.status(`${Math.floor(percentage * 100)}%`, msg, ...args, eta);
+		} else {
+			logger.status(`${Math.floor(percentage * 100)}%`, msg, ...args);
+		}
+		if (percentage === 1 || (!msg && args.length === 0)) {
+			if (percentage === 1) reportPhaseSummary(now);
+			logger.status();
 		}
-		logger.status(`${Math.floor(percentage * 100)}%`, msg, ...args);
-		if (percentage === 1 || (!msg && args.length === 0)) logger.status();
 	};
 
 	return defaultHandler;
 };
 
-const SKIPPED_QUEUE_CONTEXTS = ["import-module", "load-module"];
-
 /**
+ * Defines the report progress callback.
  * @callback ReportProgress
  * @param {number} p percentage
  * @param {...string} args additional arguments
@@ -142,11 +321,40 @@ const DEFAULT_OPTIONS = {
 	dependencies: true,
 	activeModules: false,
 	entries: true,
-	percentBy: null
+	percentBy: null,
+	progressBar: false,
+	estimatedTime: false,
+	phaseTimings: false
+};
+
+/**
+ * Whether progress can be rendered in place (interactive TTY). The bar is only
+ * useful here; in append-only output every update becomes a new line.
+ * @param {Compiler | MultiCompiler} compiler compiler
+ * @returns {boolean} true when output is an interactive terminal
+ */
+const isInteractive = (compiler) => {
+	const c =
+		compiler instanceof MultiCompiler ? compiler.compilers[0] : compiler;
+	const infrastructureLogging =
+		c && c.options && c.options.infrastructureLogging;
+	if (
+		infrastructureLogging &&
+		typeof infrastructureLogging.appendOnly === "boolean"
+	) {
+		return !infrastructureLogging.appendOnly;
+	}
+	const stream =
+		(infrastructureLogging && infrastructureLogging.stream) || process.stderr;
+	return (
+		Boolean(/** @type {NodeJS.WriteStream} */ (stream).isTTY) &&
+		process.env.TERM !== "dumb"
+	);
 };
 
 class ProgressPlugin {
 	/**
+	 * Returns a progress reporter, if any.
 	 * @param {Compiler} compiler the current compiler
 	 * @returns {ReportProgress | undefined} a progress reporter, if any
 	 */
@@ -155,6 +363,7 @@ class ProgressPlugin {
 	}
 
 	/**
+	 * Creates an instance of ProgressPlugin.
 	 * @param {ProgressPluginArgument} options options
 	 */
 	constructor(options = {}) {
@@ -167,30 +376,73 @@ class ProgressPlugin {
 		/** @type {ProgressPluginOptions} */
 		this.options = options;
 
-		this.profile = options.profile || DEFAULT_OPTIONS.profile;
-		this.handler = options.handler;
-		this.modulesCount = options.modulesCount || DEFAULT_OPTIONS.modulesCount;
-		this.dependenciesCount =
-			options.dependenciesCount || DEFAULT_OPTIONS.dependenciesCount;
-		this.showEntries = options.entries || DEFAULT_OPTIONS.entries;
-		this.showModules = options.modules || DEFAULT_OPTIONS.modules;
-		this.showDependencies =
-			options.dependencies || DEFAULT_OPTIONS.dependencies;
-		this.showActiveModules =
-			options.activeModules || DEFAULT_OPTIONS.activeModules;
-		this.percentBy = options.percentBy || DEFAULT_OPTIONS.percentBy;
+		const merged = { ...DEFAULT_OPTIONS, ...options };
+		/** @type {boolean | null} */
+		this.profile = merged.profile;
+		/** @type {HandlerFn | undefined} */
+		this.handler = merged.handler;
+		/** @type {number} */
+		this.modulesCount = merged.modulesCount;
+		/** @type {number} */
+		this.dependenciesCount = merged.dependenciesCount;
+		/** @type {boolean} */
+		this.showEntries = merged.entries;
+		/** @type {boolean} */
+		this.showModules = merged.modules;
+		/** @type {boolean} */
+		this.showDependencies = merged.dependencies;
+		/** @type {boolean} */
+		this.showActiveModules = merged.activeModules;
+		this.percentBy = merged.percentBy;
+
+		const progressBar = merged.progressBar;
+		/** @type {ProgressBarOptions | false | "auto"} */
+		this.progressBar =
+			progressBar === "auto"
+				? "auto"
+				: progressBar
+					? {
+							...DEFAULT_PROGRESS_BAR,
+							...(progressBar === true ? {} : progressBar)
+						}
+					: false;
+		/** @type {boolean} */
+		this.estimatedTime = merged.estimatedTime;
+		/** @type {boolean} */
+		this.phaseTimings = merged.phaseTimings;
 	}
 
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler | MultiCompiler} compiler webpack compiler
 	 * @returns {void}
 	 */
 	apply(compiler) {
+		let progressBar = this.progressBar;
+		// webpack@6 (opt-in today via `experiments.futureDefaults`) turns an unset
+		// progressBar into the auto bar; an explicit `false` is still respected.
+		if (progressBar === false && this.options.progressBar === undefined) {
+			const c =
+				compiler instanceof MultiCompiler ? compiler.compilers[0] : compiler;
+			if (c && c.options && c.options.experiments.futureDefaults) {
+				progressBar = "auto";
+			}
+		}
+		if (progressBar === "auto") {
+			progressBar = isInteractive(compiler)
+				? { ...DEFAULT_PROGRESS_BAR }
+				: false;
+		}
 		const handler =
 			this.handler ||
 			createDefaultHandler(
 				this.profile,
-				compiler.getInfrastructureLogger("webpack.Progress")
+				compiler.getInfrastructureLogger("webpack.Progress"),
+				{
+					progressBar,
+					estimatedTime: this.estimatedTime,
+					phaseTimings: this.phaseTimings
+				}
 			);
 		if (compiler instanceof MultiCompiler) {
 			this._applyOnMultiCompiler(compiler, handler);
@@ -200,6 +452,7 @@ class ProgressPlugin {
 	}
 
 	/**
+	 * Apply on multi compiler.
 	 * @param {MultiCompiler} compiler webpack multi-compiler
 	 * @param {HandlerFn} handler function that executes for every progress step
 	 * @returns {void}
@@ -219,6 +472,7 @@ class ProgressPlugin {
 	}
 
 	/**
+	 * Processes the provided compiler.
 	 * @param {Compiler} compiler webpack compiler
 	 * @param {HandlerFn} handler function that executes for every progress step
 	 * @returns {void}
@@ -246,9 +500,7 @@ class ProgressPlugin {
 		let lastDependenciesCount = 0;
 		let lastEntriesCount = 0;
 		let modulesCount = 0;
-		let skippedModulesCount = 0;
 		let dependenciesCount = 0;
-		let skippedDependenciesCount = 0;
 		let entriesCount = 1;
 		let doneModules = 0;
 		let doneDependencies = 0;
@@ -332,15 +584,7 @@ class ProgressPlugin {
 			lastUpdate = Date.now();
 		};
 
-		/**
-		 * @template T
-		 * @param {AsyncQueue<FactorizeModuleOptions, string, Module | ModuleFactoryResult>} factorizeQueue async queue
-		 * @param {T} _item item
-		 */
-		const factorizeAdd = (factorizeQueue, _item) => {
-			if (SKIPPED_QUEUE_CONTEXTS.includes(factorizeQueue.getContext())) {
-				skippedDependenciesCount++;
-			}
+		const factorizeAdd = () => {
 			dependenciesCount++;
 			if (dependenciesCount < 50 || dependenciesCount % 100 === 0) {
 				updateThrottled();
@@ -354,21 +598,14 @@ class ProgressPlugin {
 			}
 		};
 
-		/**
-		 * @template T
-		 * @param {AsyncQueue<Module, string, Module>} addModuleQueue async queue
-		 * @param {T} _item item
-		 */
-		const moduleAdd = (addModuleQueue, _item) => {
-			if (SKIPPED_QUEUE_CONTEXTS.includes(addModuleQueue.getContext())) {
-				skippedModulesCount++;
-			}
+		const moduleAdd = () => {
 			modulesCount++;
 			if (modulesCount < 50 || modulesCount % 100 === 0) updateThrottled();
 		};
 
 		// only used when showActiveModules is set
 		/**
+		 * Processes the provided module.
 		 * @param {Module} module the module
 		 */
 		const moduleBuild = (module) => {
@@ -381,6 +618,7 @@ class ProgressPlugin {
 		};
 
 		/**
+		 * Processes the provided entry.
 		 * @param {Dependency} entry entry dependency
 		 * @param {EntryOptions} options options object
 		 */
@@ -390,6 +628,7 @@ class ProgressPlugin {
 		};
 
 		/**
+		 * Processes the provided module.
 		 * @param {Module} module the module
 		 */
 		const moduleDone = (module) => {
@@ -412,6 +651,7 @@ class ProgressPlugin {
 		};
 
 		/**
+		 * Processes the provided entry.
 		 * @param {Dependency} entry entry dependency
 		 * @param {EntryOptions} options options object
 		 */
@@ -420,72 +660,20 @@ class ProgressPlugin {
 			update();
 		};
 
-		const cache = compiler.getCache(PLUGIN_NAME).getItemCache("counts", null);
-
-		/** @type {Promise<CountsData> | undefined} */
-		let cacheGetPromise;
-
-		compiler.hooks.beforeCompile.tap(PLUGIN_NAME, () => {
-			if (!cacheGetPromise) {
-				cacheGetPromise = cache.getPromise().then(
-					(data) => {
-						if (data) {
-							lastModulesCount = lastModulesCount || data.modulesCount;
-							lastDependenciesCount =
-								lastDependenciesCount || data.dependenciesCount;
-						}
-						return data;
-					},
-					(_err) => {
-						// Ignore error
-					}
-				);
-			}
-		});
-
-		compiler.hooks.afterCompile.tapPromise(PLUGIN_NAME, (compilation) => {
-			if (compilation.compiler.isChild()) return Promise.resolve();
-			return /** @type {Promise<CountsData>} */ (cacheGetPromise).then(
-				async (oldData) => {
-					const realModulesCount = modulesCount - skippedModulesCount;
-					const realDependenciesCount =
-						dependenciesCount - skippedDependenciesCount;
-
-					if (
-						!oldData ||
-						oldData.modulesCount !== realModulesCount ||
-						oldData.dependenciesCount !== realDependenciesCount
-					) {
-						await cache.storePromise({
-							modulesCount: realModulesCount,
-							dependenciesCount: realDependenciesCount
-						});
-					}
-				}
-			);
-		});
-
 		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			if (compilation.compiler.isChild()) return;
+			// Carry the previous compilation's counts into the next as an estimate
+			// (helps watch rebuilds); not persisted, to avoid cache invalidation.
 			lastModulesCount = modulesCount;
 			lastEntriesCount = entriesCount;
 			lastDependenciesCount = dependenciesCount;
-			modulesCount =
-				skippedModulesCount =
-				dependenciesCount =
-				skippedDependenciesCount =
-				entriesCount =
-					0;
+			modulesCount = dependenciesCount = entriesCount = 0;
 			doneModules = doneDependencies = doneEntries = 0;
 
-			compilation.factorizeQueue.hooks.added.tap(PLUGIN_NAME, (item) =>
-				factorizeAdd(compilation.factorizeQueue, item)
-			);
+			compilation.factorizeQueue.hooks.added.tap(PLUGIN_NAME, factorizeAdd);
 			compilation.factorizeQueue.hooks.result.tap(PLUGIN_NAME, factorizeDone);
 
-			compilation.addModuleQueue.hooks.added.tap(PLUGIN_NAME, (item) =>
-				moduleAdd(compilation.addModuleQueue, item)
-			);
+			compilation.addModuleQueue.hooks.added.tap(PLUGIN_NAME, moduleAdd);
 			compilation.processDependenciesQueue.hooks.result.tap(
 				PLUGIN_NAME,
 				moduleDone
@@ -606,6 +794,7 @@ class ProgressPlugin {
 			}
 		});
 		/**
+		 * Processes the provided hook.
 		 * @template {Hook<EXPECTED_ANY, EXPECTED_ANY, EXPECTED_ANY>} T
 		 * @param {T} hook hook
 		 * @param {number} progress progress from 0 to 1
@@ -629,6 +818,7 @@ class ProgressPlugin {
 					handler(progress, category, name);
 				},
 				/**
+				 * Processes the provided tap.
 				 * @param {Tap} tap tap
 				 */
 				tap(tap) {