225 lines
11 KiB
JavaScript
225 lines
11 KiB
JavaScript
'use strict';
|
|
|
|
Object.defineProperty(exports, '__esModule', { value: true });
|
|
|
|
var Table = require('cli-table3');
|
|
var terser = require('terser');
|
|
var filesize = require('filesize');
|
|
var gzipSize = require('gzip-size');
|
|
var brotli = require('brotli-size');
|
|
|
|
/******************************************************************************
|
|
Copyright (c) Microsoft Corporation.
|
|
|
|
Permission to use, copy, modify, and/or distribute this software for any
|
|
purpose with or without fee is hereby granted.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
|
|
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
|
|
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
|
|
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
|
|
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
|
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
PERFORMANCE OF THIS SOFTWARE.
|
|
***************************************************************************** */
|
|
|
|
function __awaiter(thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
}
|
|
|
|
function getFileSize(input) {
|
|
const length = typeof input === "string" ? Buffer.byteLength(input) : input;
|
|
return filesize.filesize(length);
|
|
}
|
|
function getMinifiedSize(text) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
const minified = yield terser.minify(text);
|
|
return Buffer.byteLength(minified.code || "");
|
|
});
|
|
}
|
|
function getGzippedSize(text) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return yield gzipSize.gzipSize(text);
|
|
});
|
|
}
|
|
function getBrotliSize(text) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
const brotliSize = brotli.default || brotli;
|
|
return brotliSize(text);
|
|
});
|
|
}
|
|
const color = {
|
|
black: str => `\x1b[30m${str}\x1b[0m`,
|
|
red: str => `\x1b[31m${str}\x1b[0m`,
|
|
green: str => `\x1b[32m${str}\x1b[0m`,
|
|
yellow: str => `\x1b[33m${str}\x1b[0m`,
|
|
blue: str => `\x1b[34m${str}\x1b[0m`,
|
|
magenta: str => `\x1b[35m${str}\x1b[0m`,
|
|
cyan: str => `\x1b[36m${str}\x1b[0m`,
|
|
white: str => `\x1b[37m${str}\x1b[0m`,
|
|
gray: str => `\x1b[90m${str}\x1b[0m`,
|
|
};
|
|
function reportWarning(descriptor, warnLow, warnHigh) {
|
|
switch (true) {
|
|
case descriptor.value > warnHigh:
|
|
return color.red(descriptor.displayValue);
|
|
case descriptor.value > warnLow:
|
|
return color.yellow(descriptor.displayValue);
|
|
default:
|
|
return color.green(descriptor.displayValue);
|
|
}
|
|
}
|
|
function generateSeparator(list) {
|
|
const numOfColumns = list[0].length;
|
|
const output = Array(numOfColumns).fill("-");
|
|
list.forEach(row => {
|
|
row.forEach((str, i) => {
|
|
if (str.length > output[i].length) {
|
|
output[i] = "-".repeat(str.length);
|
|
}
|
|
});
|
|
});
|
|
return output.map(i => color.gray(i));
|
|
}
|
|
function uuid() {
|
|
return Date.now().toString(36) + Math.random().toString(36).substring(2);
|
|
}
|
|
|
|
/** Prints out a summary of the rollup build */
|
|
function summary({ warnLow = 5e3, warnHigh = 1e4, totalLow = 2e5, totalHigh = 3e5, showBrotliSize = false, showGzippedSize = false, showMinifiedSize = false, } = {}) {
|
|
const info = new Map();
|
|
return {
|
|
name: "rollup-plugin-summary",
|
|
generateBundle: function (options, bundle) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
const identifierList = [];
|
|
options.dir && identifierList.push(options.dir);
|
|
options.file && identifierList.push(options.file);
|
|
options.format && identifierList.push(options.format);
|
|
const identifier = identifierList.length ? identifierList.join(" - ") : uuid();
|
|
if (!info.has(identifier)) {
|
|
info.set(identifier, []);
|
|
}
|
|
const defaultDescriptor = () => ({
|
|
value: 0,
|
|
displayValue: "0 B",
|
|
coloredValue: "0 B",
|
|
});
|
|
const totals = { fileName: "Totals", size: defaultDescriptor() };
|
|
for (const fileName in bundle) {
|
|
if (bundle[fileName].type === "chunk") {
|
|
const chunk = bundle[fileName];
|
|
// TODO: Investigate this
|
|
const code = chunk.code;
|
|
const warn = [warnLow || 0, warnHigh || 0];
|
|
const totalWarn = [totalLow || 0, totalHigh || 0];
|
|
/** @type {SummaryChunkInfo} */
|
|
const chunkInfo = { fileName, size: defaultDescriptor() };
|
|
chunkInfo.size.value = Buffer.byteLength(code);
|
|
chunkInfo.size.displayValue = getFileSize(chunkInfo.size.value);
|
|
chunkInfo.size.coloredValue = reportWarning(chunkInfo.size, ...warn);
|
|
totals.size.value += chunkInfo.size.value;
|
|
totals.size.displayValue = getFileSize(totals.size.value);
|
|
totals.size.coloredValue = reportWarning(totals.size, ...totalWarn);
|
|
if (showMinifiedSize) {
|
|
if (!chunkInfo.minified) {
|
|
chunkInfo.minified = defaultDescriptor();
|
|
}
|
|
if (!totals.minified) {
|
|
totals.minified = defaultDescriptor();
|
|
}
|
|
chunkInfo.minified.value = yield getMinifiedSize(code);
|
|
chunkInfo.minified.displayValue = getFileSize(chunkInfo.minified.value);
|
|
chunkInfo.minified.coloredValue = reportWarning(chunkInfo.minified, ...warn);
|
|
totals.minified.value += chunkInfo.minified.value;
|
|
totals.minified.displayValue = getFileSize(totals.minified.value);
|
|
totals.minified.coloredValue = reportWarning(totals.minified, ...totalWarn);
|
|
}
|
|
if (showGzippedSize) {
|
|
if (!chunkInfo.gzipped) {
|
|
chunkInfo.gzipped = defaultDescriptor();
|
|
}
|
|
if (!totals.gzipped) {
|
|
totals.gzipped = defaultDescriptor();
|
|
}
|
|
chunkInfo.gzipped.value = yield getGzippedSize(code);
|
|
chunkInfo.gzipped.displayValue = getFileSize(chunkInfo.gzipped.value);
|
|
chunkInfo.gzipped.coloredValue = reportWarning(chunkInfo.gzipped, ...warn);
|
|
totals.gzipped.value += chunkInfo.gzipped.value;
|
|
totals.gzipped.displayValue = getFileSize(totals.gzipped.value);
|
|
totals.gzipped.coloredValue = reportWarning(totals.gzipped, ...totalWarn);
|
|
}
|
|
if (showBrotliSize) {
|
|
if (!chunkInfo.brotli) {
|
|
chunkInfo.brotli = defaultDescriptor();
|
|
}
|
|
if (!totals.brotli) {
|
|
totals.brotli = defaultDescriptor();
|
|
}
|
|
chunkInfo.brotli.value = yield getBrotliSize(code);
|
|
chunkInfo.brotli.displayValue = getFileSize(chunkInfo.brotli.value);
|
|
chunkInfo.brotli.coloredValue = reportWarning(chunkInfo.brotli, ...warn);
|
|
totals.brotli.value += chunkInfo.brotli.value;
|
|
totals.brotli.displayValue = getFileSize(totals.brotli.value);
|
|
totals.brotli.coloredValue = reportWarning(totals.brotli, ...totalWarn);
|
|
}
|
|
info.get(identifier).push(chunkInfo);
|
|
}
|
|
}
|
|
info.get(identifier).push(totals);
|
|
});
|
|
},
|
|
closeBundle: function () {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
info.forEach((output, dir) => {
|
|
/** @type {string[]} */
|
|
const headers = ["File name", "Size"];
|
|
showMinifiedSize && headers.push("Minified");
|
|
showGzippedSize && headers.push("Gzipped");
|
|
showBrotliSize && headers.push("Brotli");
|
|
const table = new Table({
|
|
head: headers,
|
|
chars: { mid: "", "left-mid": "", "mid-mid": "", "right-mid": "" },
|
|
style: { head: ["blue"] },
|
|
});
|
|
const printable = output.map(file => {
|
|
const output = [file.fileName, file.size.coloredValue];
|
|
showMinifiedSize && output.push(file.minified.coloredValue);
|
|
showGzippedSize && output.push(file.gzipped.coloredValue);
|
|
showBrotliSize && output.push(file.brotli.coloredValue);
|
|
return output;
|
|
});
|
|
const totalsRow = printable.pop();
|
|
const separator = generateSeparator([
|
|
headers,
|
|
...output.map(file => {
|
|
const output = [file.fileName, file.size.displayValue];
|
|
showMinifiedSize && output.push(file.minified.displayValue);
|
|
showGzippedSize && output.push(file.gzipped.displayValue);
|
|
showBrotliSize && output.push(file.brotli.displayValue);
|
|
return output;
|
|
}),
|
|
]);
|
|
table.push(separator);
|
|
table.push(...printable);
|
|
table.push(separator);
|
|
table.push(totalsRow);
|
|
console.log("Build summary for", color.cyan(dir));
|
|
console.log(table.toString());
|
|
});
|
|
});
|
|
},
|
|
};
|
|
}
|
|
|
|
exports.default = summary;
|
|
exports.summary = summary;
|
|
module.exports = Object.assign(exports.default, exports);
|
|
//# sourceMappingURL=index.js.map
|