nav tabs on admin dashboard

node_modules/webpack/lib/ProgressPlugin.js

@@ -4,189 +4,328 @@
 */
 "use strict";
 
-class ProgressPlugin {
+const validateOptions = require("schema-utils");
+const schema = require("../schemas/plugins/ProgressPlugin.json");
 
+/** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginArgument} ProgressPluginArgument */
+/** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginOptions} ProgressPluginOptions */
+
+const createDefaultHandler = profile => {
+	let lineCaretPosition = 0;
+	let lastMessage = "";
+	let lastState;
+	let lastStateTime;
+
+	const defaultHandler = (percentage, msg, ...args) => {
+		let state = msg;
+		const details = args;
+		if (percentage < 1) {
+			percentage = Math.floor(percentage * 100);
+			msg = `${percentage}% ${msg}`;
+			if (percentage < 100) {
+				msg = ` ${msg}`;
+			}
+			if (percentage < 10) {
+				msg = ` ${msg}`;
+			}
+			for (let detail of details) {
+				if (!detail) continue;
+				if (detail.length > 40) {
+					detail = `...${detail.substr(detail.length - 39)}`;
+				}
+				msg += ` ${detail}`;
+			}
+		}
+		if (profile) {
+			state = state.replace(/^\d+\/\d+\s+/, "");
+			if (percentage === 0) {
+				lastState = null;
+				lastStateTime = Date.now();
+			} else if (state !== lastState || percentage === 1) {
+				const now = Date.now();
+				if (lastState) {
+					const stateMsg = `${now - lastStateTime}ms ${lastState}`;
+					goToLineStart(stateMsg);
+					process.stderr.write(stateMsg + "\n");
+					lineCaretPosition = 0;
+				}
+				lastState = state;
+				lastStateTime = now;
+			}
+		}
+		if (lastMessage !== msg) {
+			goToLineStart(msg);
+			process.stderr.write(msg);
+			lastMessage = msg;
+		}
+	};
+
+	const goToLineStart = nextMessage => {
+		let str = "";
+		for (; lineCaretPosition > nextMessage.length; lineCaretPosition--) {
+			str += "\b \b";
+		}
+		for (var i = 0; i < lineCaretPosition; i++) {
+			str += "\b";
+		}
+		lineCaretPosition = nextMessage.length;
+		if (str) process.stderr.write(str);
+	};
+
+	return defaultHandler;
+};
+
+class ProgressPlugin {
+	/**
+	 * @param {ProgressPluginArgument} options options
+	 */
 	constructor(options) {
-		if(typeof options === "function") {
+		if (typeof options === "function") {
 			options = {
 				handler: options
 			};
 		}
+
 		options = options || {};
+		validateOptions(schema, options, "Progress Plugin");
+		options = Object.assign({}, ProgressPlugin.defaultOptions, options);
+
 		this.profile = options.profile;
 		this.handler = options.handler;
+		this.modulesCount = options.modulesCount;
+		this.showEntries = options.entries;
+		this.showModules = options.modules;
+		this.showActiveModules = options.activeModules;
 	}
 
 	apply(compiler) {
-		const handler = this.handler || defaultHandler;
-		const profile = this.profile;
-		if(compiler.compilers) {
+		const { modulesCount } = this;
+		const handler = this.handler || createDefaultHandler(this.profile);
+		const showEntries = this.showEntries;
+		const showModules = this.showModules;
+		const showActiveModules = this.showActiveModules;
+		if (compiler.compilers) {
 			const states = new Array(compiler.compilers.length);
-			compiler.compilers.forEach(function(compiler, idx) {
-				compiler.apply(new ProgressPlugin(function(p, msg) {
-					states[idx] = Array.prototype.slice.apply(arguments);
-					handler.apply(null, [
-						states.map(state => state && state[0] || 0).reduce((a, b) => a + b) / states.length,
-						`[${idx}] ${msg}`
-					].concat(Array.prototype.slice.call(arguments, 2)));
-				}));
+			compiler.compilers.forEach((compiler, idx) => {
+				new ProgressPlugin((p, msg, ...args) => {
+					states[idx] = [p, msg, ...args];
+					handler(
+						states
+							.map(state => (state && state[0]) || 0)
+							.reduce((a, b) => a + b) / states.length,
+						`[${idx}] ${msg}`,
+						...args
+					);
+				}).apply(compiler);
 			});
 		} else {
 			let lastModulesCount = 0;
-			let moduleCount = 500;
+			let lastEntriesCount = 0;
+			let moduleCount = modulesCount;
+			let entriesCount = 1;
 			let doneModules = 0;
-			const activeModules = [];
+			let doneEntries = 0;
+			const activeModules = new Set();
+			let lastActiveModule = "";
 
-			const update = function update(module) {
-				handler(
-					0.1 + (doneModules / Math.max(lastModulesCount, moduleCount)) * 0.6,
-					"building modules",
-					`${doneModules}/${moduleCount} modules`,
-					`${activeModules.length} active`,
-					activeModules[activeModules.length - 1]
-				);
+			const update = () => {
+				const percentByModules =
+					doneModules / Math.max(lastModulesCount, moduleCount);
+				const percentByEntries =
+					doneEntries / Math.max(lastEntriesCount, entriesCount);
+
+				const items = [
+					0.1 + Math.max(percentByModules, percentByEntries) * 0.6,
+					"building"
+				];
+				if (showEntries) {
+					items.push(`${doneEntries}/${entriesCount} entries`);
+				}
+				if (showModules) {
+					items.push(`${doneModules}/${moduleCount} modules`);
+				}
+				if (showActiveModules) {
+					items.push(`${activeModules.size} active`);
+					items.push(lastActiveModule);
+				}
+				handler(...items);
 			};
 
-			const moduleDone = function moduleDone(module) {
-				doneModules++;
-				const ident = module.identifier();
-				if(ident) {
-					const idx = activeModules.indexOf(ident);
-					if(idx >= 0) activeModules.splice(idx, 1);
+			const moduleAdd = module => {
+				moduleCount++;
+				if (showActiveModules) {
+					const ident = module.identifier();
+					if (ident) {
+						activeModules.add(ident);
+						lastActiveModule = ident;
+					}
 				}
 				update();
 			};
-			compiler.plugin("compilation", function(compilation) {
-				if(compilation.compiler.isChild()) return;
-				lastModulesCount = moduleCount;
-				moduleCount = 0;
-				doneModules = 0;
-				handler(0, "compiling");
-				compilation.plugin("build-module", function(module) {
-					moduleCount++;
+
+			const entryAdd = (entry, name) => {
+				entriesCount++;
+				update();
+			};
+
+			const moduleDone = module => {
+				doneModules++;
+				if (showActiveModules) {
 					const ident = module.identifier();
-					if(ident) {
-						activeModules.push(ident);
+					if (ident) {
+						activeModules.delete(ident);
+						if (lastActiveModule === ident) {
+							lastActiveModule = "";
+							for (const m of activeModules) {
+								lastActiveModule = m;
+							}
+						}
 					}
-					update();
-				});
-				compilation.plugin("failed-module", moduleDone);
-				compilation.plugin("succeed-module", moduleDone);
-				const syncHooks = {
-					"seal": [0.71, "sealing"],
-					"optimize": [0.72, "optimizing"],
-					"optimize-modules-basic": [0.73, "basic module optimization"],
-					"optimize-modules": [0.74, "module optimization"],
-					"optimize-modules-advanced": [0.75, "advanced module optimization"],
-					"optimize-chunks-basic": [0.76, "basic chunk optimization"],
-					"optimize-chunks": [0.77, "chunk optimization"],
-					"optimize-chunks-advanced": [0.78, "advanced chunk optimization"],
-					// optimize-tree
-					"optimize-chunk-modules": [0.80, "chunk modules optimization"],
-					"optimize-chunk-modules-advanced": [0.81, "advanced chunk modules optimization"],
-					"revive-modules": [0.82, "module reviving"],
-					"optimize-module-order": [0.83, "module order optimization"],
-					"optimize-module-ids": [0.84, "module id optimization"],
-					"revive-chunks": [0.85, "chunk reviving"],
-					"optimize-chunk-order": [0.86, "chunk order optimization"],
-					"optimize-chunk-ids": [0.87, "chunk id optimization"],
-					"before-hash": [0.88, "hashing"],
-					"before-module-assets": [0.89, "module assets processing"],
-					"before-chunk-assets": [0.90, "chunk assets processing"],
-					"additional-chunk-assets": [0.91, "additional chunk assets processing"],
-					"record": [0.92, "recording"]
+				}
+				update();
+			};
+
+			const entryDone = (entry, name) => {
+				doneEntries++;
+				update();
+			};
+
+			compiler.hooks.compilation.tap("ProgressPlugin", compilation => {
+				if (compilation.compiler.isChild()) return;
+				lastModulesCount = moduleCount;
+				lastEntriesCount = entriesCount;
+				moduleCount = entriesCount = 0;
+				doneModules = doneEntries = 0;
+				handler(0, "compiling");
+
+				compilation.hooks.buildModule.tap("ProgressPlugin", moduleAdd);
+				compilation.hooks.failedModule.tap("ProgressPlugin", moduleDone);
+				compilation.hooks.succeedModule.tap("ProgressPlugin", moduleDone);
+
+				compilation.hooks.addEntry.tap("ProgressPlugin", entryAdd);
+				compilation.hooks.failedEntry.tap("ProgressPlugin", entryDone);
+				compilation.hooks.succeedEntry.tap("ProgressPlugin", entryDone);
+
+				const hooks = {
+					finishModules: "finish module graph",
+					seal: "sealing",
+					beforeChunks: "chunk graph",
+					afterChunks: "after chunk graph",
+					optimizeDependenciesBasic: "basic dependencies optimization",
+					optimizeDependencies: "dependencies optimization",
+					optimizeDependenciesAdvanced: "advanced dependencies optimization",
+					afterOptimizeDependencies: "after dependencies optimization",
+					optimize: "optimizing",
+					optimizeModulesBasic: "basic module optimization",
+					optimizeModules: "module optimization",
+					optimizeModulesAdvanced: "advanced module optimization",
+					afterOptimizeModules: "after module optimization",
+					optimizeChunksBasic: "basic chunk optimization",
+					optimizeChunks: "chunk optimization",
+					optimizeChunksAdvanced: "advanced chunk optimization",
+					afterOptimizeChunks: "after chunk optimization",
+					optimizeTree: "module and chunk tree optimization",
+					afterOptimizeTree: "after module and chunk tree optimization",
+					optimizeChunkModulesBasic: "basic chunk modules optimization",
+					optimizeChunkModules: "chunk modules optimization",
+					optimizeChunkModulesAdvanced: "advanced chunk modules optimization",
+					afterOptimizeChunkModules: "after chunk modules optimization",
+					reviveModules: "module reviving",
+					optimizeModuleOrder: "module order optimization",
+					advancedOptimizeModuleOrder: "advanced module order optimization",
+					beforeModuleIds: "before module ids",
+					moduleIds: "module ids",
+					optimizeModuleIds: "module id optimization",
+					afterOptimizeModuleIds: "module id optimization",
+					reviveChunks: "chunk reviving",
+					optimizeChunkOrder: "chunk order optimization",
+					beforeChunkIds: "before chunk ids",
+					optimizeChunkIds: "chunk id optimization",
+					afterOptimizeChunkIds: "after chunk id optimization",
+					recordModules: "record modules",
+					recordChunks: "record chunks",
+					beforeHash: "hashing",
+					contentHash: "content hashing",
+					afterHash: "after hashing",
+					recordHash: "record hash",
+					beforeModuleAssets: "module assets processing",
+					beforeChunkAssets: "chunk assets processing",
+					additionalChunkAssets: "additional chunk assets processing",
+					record: "recording",
+					additionalAssets: "additional asset processing",
+					optimizeChunkAssets: "chunk asset optimization",
+					afterOptimizeChunkAssets: "after chunk asset optimization",
+					optimizeAssets: "asset optimization",
+					afterOptimizeAssets: "after asset optimization",
+					afterSeal: "after seal"
 				};
-				Object.keys(syncHooks).forEach(name => {
-					let pass = 0;
-					const settings = syncHooks[name];
-					compilation.plugin(name, () => {
-						if(pass++ > 0)
-							handler(settings[0], settings[1], `pass ${pass}`);
-						else
-							handler(settings[0], settings[1]);
+				const numberOfHooks = Object.keys(hooks).length;
+				Object.keys(hooks).forEach((name, idx) => {
+					const title = hooks[name];
+					const percentage = (idx / numberOfHooks) * 0.25 + 0.7;
+					compilation.hooks[name].intercept({
+						name: "ProgressPlugin",
+						context: true,
+						call: () => {
+							handler(percentage, title);
+						},
+						tap: (context, tap) => {
+							if (context) {
+								// p is percentage from 0 to 1
+								// args is any number of messages in a hierarchical matter
+								context.reportProgress = (p, ...args) => {
+									handler(percentage, title, tap.name, ...args);
+								};
+							}
+							handler(percentage, title, tap.name);
+						}
 					});
 				});
-				compilation.plugin("optimize-tree", (chunks, modules, callback) => {
-					handler(0.79, "module and chunk tree optimization");
-					callback();
-				});
-				compilation.plugin("additional-assets", callback => {
-					handler(0.91, "additional asset processing");
-					callback();
-				});
-				compilation.plugin("optimize-chunk-assets", (chunks, callback) => {
-					handler(0.92, "chunk asset optimization");
-					callback();
-				});
-				compilation.plugin("optimize-assets", (assets, callback) => {
-					handler(0.94, "asset optimization");
-					callback();
-				});
 			});
-			compiler.plugin("emit", (compilation, callback) => {
-				handler(0.95, "emitting");
-				callback();
+			compiler.hooks.emit.intercept({
+				name: "ProgressPlugin",
+				context: true,
+				call: () => {
+					handler(0.95, "emitting");
+				},
+				tap: (context, tap) => {
+					if (context) {
+						context.reportProgress = (p, ...args) => {
+							handler(0.95, "emitting", tap.name, ...args);
+						};
+					}
+					handler(0.95, "emitting", tap.name);
+				}
 			});
-			compiler.plugin("done", () => {
+			compiler.hooks.afterEmit.intercept({
+				name: "ProgressPlugin",
+				context: true,
+				call: () => {
+					handler(0.98, "after emitting");
+				},
+				tap: (context, tap) => {
+					if (context) {
+						context.reportProgress = (p, ...args) => {
+							handler(0.98, "after emitting", tap.name, ...args);
+						};
+					}
+					handler(0.98, "after emitting", tap.name);
+				}
+			});
+			compiler.hooks.done.tap("ProgressPlugin", () => {
 				handler(1, "");
 			});
 		}
-
-		let lineCaretPosition = 0,
-			lastState, lastStateTime;
-
-		function defaultHandler(percentage, msg) {
-			let state = msg;
-			const details = Array.prototype.slice.call(arguments, 2);
-			if(percentage < 1) {
-				percentage = Math.floor(percentage * 100);
-				msg = `${percentage}% ${msg}`;
-				if(percentage < 100) {
-					msg = ` ${msg}`;
-				}
-				if(percentage < 10) {
-					msg = ` ${msg}`;
-				}
-				details.forEach(detail => {
-					if(!detail) return;
-					if(detail.length > 40) {
-						detail = `...${detail.substr(detail.length - 37)}`;
-					}
-					msg += ` ${detail}`;
-				});
-			}
-			if(profile) {
-				state = state.replace(/^\d+\/\d+\s+/, "");
-				if(percentage === 0) {
-					lastState = null;
-					lastStateTime = Date.now();
-				} else if(state !== lastState || percentage === 1) {
-					const now = Date.now();
-					if(lastState) {
-						const stateMsg = `${now - lastStateTime}ms ${lastState}`;
-						goToLineStart(stateMsg);
-						process.stderr.write(stateMsg + "\n");
-						lineCaretPosition = 0;
-					}
-					lastState = state;
-					lastStateTime = now;
-				}
-			}
-			goToLineStart(msg);
-			process.stderr.write(msg);
-		}
-
-		function goToLineStart(nextMessage) {
-			let str = "";
-			for(; lineCaretPosition > nextMessage.length; lineCaretPosition--) {
-				str += "\b \b";
-			}
-			for(var i = 0; i < lineCaretPosition; i++) {
-				str += "\b";
-			}
-			lineCaretPosition = nextMessage.length;
-			if(str) process.stderr.write(str);
-		}
 	}
 }
+
+ProgressPlugin.defaultOptions = {
+	profile: false,
+	modulesCount: 500,
+	modules: true,
+	activeModules: true,
+	// TODO webpack 5 default this to true
+	entries: false
+};
+
 module.exports = ProgressPlugin;