@atlaspack/reporter-cli 2.15.1-canary.35 → 2.15.1-canary.351

package/dist/bundleReport.js

@@ -0,0 +1,117 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = bundleReport;
+const utils_1 = require("@atlaspack/utils");
+const filesize_1 = __importDefault(require("filesize"));
+const chalk_1 = __importDefault(require("chalk"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const emoji = __importStar(require("./emoji"));
+const render_1 = require("./render");
+const utils_2 = require("./utils");
+const LARGE_BUNDLE_SIZE = 1024 * 1024;
+const COLUMNS = [
+    { align: 'left' }, // name
+    { align: 'right' }, // size
+    { align: 'right' }, // time
+];
+async function bundleReport(bundleGraph, fs, projectRoot, assetCount = 0) {
+    let bundleList = bundleGraph.getBundles();
+    // Get a list of bundles sorted by size
+    let { bundles } = assetCount > 0
+        ? await (0, utils_1.generateBuildMetrics)(bundleList, fs, projectRoot)
+        : {
+            bundles: bundleList.map((b) => {
+                return {
+                    filePath: (0, nullthrows_1.default)(b.filePath),
+                    size: b.stats.size,
+                    time: b.stats.time,
+                    assets: [],
+                };
+            }),
+        };
+    let rows = [];
+    for (let bundle of bundles) {
+        // Add a row for the bundle
+        rows.push([
+            (0, utils_2.formatFilename)(bundle.filePath || '', chalk_1.default.cyan.bold),
+            chalk_1.default.bold(prettifySize(bundle.size, bundle.size > LARGE_BUNDLE_SIZE)),
+            chalk_1.default.green.bold((0, utils_1.prettifyTime)(bundle.time)),
+        ]);
+        if (assetCount > 0) {
+            let largestAssets = bundle.assets.slice(0, assetCount);
+            for (let asset of largestAssets) {
+                let columns = [
+                    asset == largestAssets[largestAssets.length - 1] ? '└── ' : '├── ',
+                    // @ts-expect-error TS2554
+                    chalk_1.default.dim(prettifySize(asset.size)),
+                    chalk_1.default.dim(chalk_1.default.green((0, utils_1.prettifyTime)(asset.time))),
+                ];
+                if (asset.filePath !== '') {
+                    columns[0] += (0, utils_2.formatFilename)(asset.filePath, chalk_1.default.reset);
+                }
+                else {
+                    columns[0] += 'Code from unknown sourcefiles';
+                }
+                // Add a row for the asset.
+                rows.push(columns);
+            }
+            if (bundle.assets.length > largestAssets.length) {
+                rows.push([
+                    '└── ' +
+                        chalk_1.default.dim(`+ ${bundle.assets.length - largestAssets.length} more assets`),
+                ]);
+            }
+            // If this isn't the last bundle, add an empty row before the next one
+            if (bundle !== bundles[bundles.length - 1]) {
+                rows.push([]);
+            }
+        }
+    }
+    // Render table
+    (0, render_1.writeOut)('');
+    // @ts-expect-error TS2345
+    (0, render_1.table)(COLUMNS, rows);
+}
+function prettifySize(size, isLarge) {
+    let res = (0, filesize_1.default)(size);
+    if (isLarge) {
+        return chalk_1.default.yellow(emoji.warning + '  ' + res);
+    }
+    return chalk_1.default.magenta(res);
+}

package/dist/emoji.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.docs = exports.hint = exports.info = exports.warning = exports.error = exports.success = exports.progress = void 0;
+// From https://github.com/sindresorhus/is-unicode-supported/blob/8f123916d5c25a87c4f966dcc248b7ca5df2b4ca/index.js
+// This package is ESM-only so it has to be vendored
+function isUnicodeSupported() {
+    if (process.platform !== 'win32') {
+        return process.env.TERM !== 'linux'; // Linux console (kernel)
+    }
+    return (Boolean(process.env.CI) ||
+        Boolean(process.env.WT_SESSION) || // Windows Terminal
+        process.env.ConEmuTask === '{cmd::Cmder}' || // ConEmu and cmder
+        process.env.TERM_PROGRAM === 'vscode' ||
+        process.env.TERM === 'xterm-256color' ||
+        process.env.TERM === 'alacritty');
+}
+const supportsEmoji = isUnicodeSupported();
+// Fallback symbols for Windows from https://en.wikipedia.org/wiki/Code_page_437
+exports.progress = supportsEmoji ? '⏳' : '∞';
+exports.success = supportsEmoji ? '✨' : '√';
+exports.error = supportsEmoji ? '🚨' : '×';
+exports.warning = supportsEmoji ? '⚠️' : '‼';
+exports.info = supportsEmoji ? 'ℹ️' : 'ℹ';
+exports.hint = supportsEmoji ? '💡' : 'ℹ';
+exports.docs = supportsEmoji ? '📝' : 'ℹ';

package/dist/logLevels.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logLevels = {
+    none: 0,
+    error: 1,
+    warn: 2,
+    info: 3,
+    progress: 3,
+    success: 3,
+    verbose: 4,
+};
+exports.default = logLevels;

package/dist/phaseReport.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = phaseReport;
+const utils_1 = require("@atlaspack/utils");
+const chalk_1 = __importDefault(require("chalk"));
+const render_1 = require("./render");
+const assert_1 = __importDefault(require("assert"));
+function phaseReport(phaseStartTimes) {
+    let phaseTimes = {};
+    if (phaseStartTimes['transforming'] && phaseStartTimes['bundling']) {
+        phaseTimes['Transforming'] =
+            phaseStartTimes['bundling'] - phaseStartTimes['transforming'];
+    }
+    let packagingAndOptimizing = phaseStartTimes['packaging'] && phaseStartTimes['optimizing']
+        ? Math.min(phaseStartTimes['packaging'], phaseStartTimes['optimizing'])
+        : phaseStartTimes['packaging'] || phaseStartTimes['optimizing'];
+    if (phaseStartTimes['bundling'] && packagingAndOptimizing) {
+        phaseTimes['Bundling'] =
+            packagingAndOptimizing - phaseStartTimes['bundling'];
+    }
+    if (packagingAndOptimizing && phaseStartTimes['buildSuccess']) {
+        phaseTimes['Packaging & Optimizing'] =
+            phaseStartTimes['buildSuccess'] - packagingAndOptimizing;
+    }
+    for (let [phase, time] of Object.entries(phaseTimes)) {
+        (0, assert_1.default)(typeof time === 'number');
+        (0, render_1.writeOut)(chalk_1.default.green.bold(`${phase} finished in ${(0, utils_1.prettifyTime)(time)}`));
+    }
+}

package/dist/render.js

@@ -0,0 +1,166 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTTY = void 0;
+exports._setStdio = _setStdio;
+exports.writeOut = writeOut;
+exports.persistMessage = persistMessage;
+exports.updateSpinner = updateSpinner;
+exports.persistSpinner = persistSpinner;
+exports.resetWindow = resetWindow;
+exports.table = table;
+const readline_1 = __importDefault(require("readline"));
+const ora_1 = __importDefault(require("ora"));
+const string_width_1 = __importDefault(require("string-width"));
+const utils_1 = require("./utils");
+const emoji = __importStar(require("./emoji"));
+exports.isTTY = process.env.NODE_ENV !== 'test' && process.stdout.isTTY;
+let stdout = process.stdout;
+let stderr = process.stderr;
+// We pipe worker output to the process. If you
+// have more than 10 threads then Nodejs will
+// print warnings indicating you exceed the max
+// listener count.
+stdout.setMaxListeners(100);
+stderr.setMaxListeners(100);
+// Some state so we clear the output properly
+let lineCount = 0;
+let errorLineCount = 0;
+let statusPersisted = false;
+function _setStdio(stdoutLike, stderrLike) {
+    // @ts-expect-error TS2322
+    stdout = stdoutLike;
+    // @ts-expect-error TS2322
+    stderr = stderrLike;
+}
+let spinner = (0, ora_1.default)({
+    color: 'green',
+    stream: stdout,
+    discardStdin: false,
+});
+let persistedMessages = [];
+function writeOut(message, isError = false) {
+    let processedMessage = message + '\n';
+    let hasSpinner = spinner.isSpinning;
+    // Stop spinner so we don't duplicate it
+    if (hasSpinner) {
+        spinner.stop();
+    }
+    let lines = (0, utils_1.countLines)(message);
+    if (isError) {
+        stderr.write(processedMessage);
+        errorLineCount += lines;
+    }
+    else {
+        stdout.write(processedMessage);
+        lineCount += lines;
+    }
+    // Restart the spinner
+    if (hasSpinner) {
+        spinner.start();
+    }
+}
+function persistMessage(message) {
+    if (persistedMessages.includes(message))
+        return;
+    persistedMessages.push(message);
+    writeOut(message);
+}
+function updateSpinner(message) {
+    // This helps the spinner play well with the tests
+    if (!exports.isTTY) {
+        writeOut(message);
+        return;
+    }
+    spinner.text = message + '\n';
+    if (!spinner.isSpinning) {
+        spinner.start();
+    }
+}
+function persistSpinner(name, status, message) {
+    spinner.stopAndPersist({
+        symbol: emoji[status],
+        text: message,
+    });
+    statusPersisted = true;
+}
+function clearStream(stream, lines) {
+    if (!exports.isTTY)
+        return;
+    readline_1.default.moveCursor(stream, 0, -lines);
+    readline_1.default.clearScreenDown(stream);
+}
+// Reset the window's state
+function resetWindow() {
+    if (!exports.isTTY)
+        return;
+    // If status has been persisted we add a line
+    // Otherwise final states would remain in the terminal for rebuilds
+    if (statusPersisted) {
+        lineCount++;
+        statusPersisted = false;
+    }
+    clearStream(stderr, errorLineCount);
+    errorLineCount = 0;
+    clearStream(stdout, lineCount);
+    lineCount = 0;
+    for (let m of persistedMessages) {
+        writeOut(m);
+    }
+}
+function table(columns, table) {
+    // Measure column widths
+    let colWidths = [];
+    for (let row of table) {
+        let i = 0;
+        for (let item of row) {
+            colWidths[i] = Math.max(colWidths[i] || 0, (0, string_width_1.default)(item));
+            i++;
+        }
+    }
+    // Render rows
+    for (let row of table) {
+        let items = row.map((item, i) => {
+            // Add padding between columns unless the alignment is the opposite to the
+            // next column and pad to the column width.
+            let padding = !columns[i + 1] || columns[i + 1].align === columns[i].align ? 4 : 0;
+            return (0, utils_1.pad)(item, colWidths[i] + padding, columns[i].align);
+        });
+        writeOut(items.join(''));
+    }
+}

package/dist/utils.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTerminalWidth = getTerminalWidth;
+exports.pad = pad;
+exports.formatFilename = formatFilename;
+exports.countLines = countLines;
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const string_width_1 = __importDefault(require("string-width"));
+const term_size_1 = __importDefault(require("term-size"));
+const utils_1 = require("@atlaspack/utils");
+let terminalSize = (0, term_size_1.default)();
+process.stdout.on('resize', function () {
+    terminalSize = (0, term_size_1.default)();
+});
+function getTerminalWidth() {
+    return terminalSize;
+}
+// Pad a string with spaces on either side
+function pad(text, length, align = 'left') {
+    let pad = ' '.repeat(length - (0, string_width_1.default)(text));
+    if (align === 'right') {
+        return pad + text;
+    }
+    return text + pad;
+}
+function formatFilename(filename, color = chalk_1.default.reset) {
+    let dir = path_1.default.relative(process.cwd(), path_1.default.dirname(filename));
+    return (chalk_1.default.dim(dir + (dir ? path_1.default.sep : '')) + color(path_1.default.basename(filename)));
+}
+function countLines(message) {
+    let { columns } = terminalSize;
+    return (0, utils_1.stripAnsi)(message)
+        .split('\n')
+        .reduce((p, line) => p + Math.ceil(((0, string_width_1.default)(line) || 1) / columns), 0);
+}