This repository has been archived on 2024-07-27. You can view files and clone it, but cannot push or open issues or pull requests.
keksAccountGUI/node_modulesOLD/webpack/lib/ProgressPlugin.js

349 lines
10 KiB
JavaScript
Raw Normal View History

2019-08-11 18:48:02 +00:00
/*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
"use strict";
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.filter(v => v.length);
const maxLineLength = process.stderr.columns || Infinity;
if (percentage < 1) {
percentage = Math.floor(percentage * 100);
msg = `${percentage}% ${msg}`;
if (percentage < 100) {
msg = ` ${msg}`;
}
if (percentage < 10) {
msg = ` ${msg}`;
}
if (details.length) {
const maxTotalDetailsLength = maxLineLength - msg.length;
const totalDetailsLength = details.reduce(
(a, b) => a + b.length,
details.length // account for added space before each detail text
);
const maxDetailLength =
totalDetailsLength < maxTotalDetailsLength
? Infinity
: Math.floor(maxTotalDetailsLength / details.length);
for (let detail of details) {
if (!detail) continue;
if (detail.length + 1 > maxDetailLength) {
const truncatePrefix = "...";
detail = `${truncatePrefix}${detail.substr(
-(maxDetailLength - truncatePrefix.length - 1)
)}`;
}
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);
msg = msg.substring(0, maxLineLength);
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") {
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 { 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((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 lastEntriesCount = 0;
let moduleCount = modulesCount;
let entriesCount = 1;
let doneModules = 0;
let doneEntries = 0;
const activeModules = new Set();
let lastActiveModule = "";
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 moduleAdd = module => {
moduleCount++;
if (showActiveModules) {
const ident = module.identifier();
if (ident) {
activeModules.add(ident);
lastActiveModule = ident;
}
}
update();
};
const entryAdd = (entry, name) => {
entriesCount++;
update();
};
const moduleDone = module => {
doneModules++;
if (showActiveModules) {
const ident = module.identifier();
if (ident) {
activeModules.delete(ident);
if (lastActiveModule === ident) {
lastActiveModule = "";
for (const m of activeModules) {
lastActiveModule = m;
}
}
}
}
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",
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"
};
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);
}
});
});
});
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.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, "");
});
}
}
}
ProgressPlugin.defaultOptions = {
profile: false,
modulesCount: 500,
modules: true,
activeModules: true,
// TODO webpack 5 default this to true
entries: false
};
module.exports = ProgressPlugin;