rtolms-cli/lib/status-renderer.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const chalk_1 = require("chalk");
const cliTruncate = require("cli-truncate");
const elegantSpinner = require("elegant-spinner");
const figures = require("figures");
const indentString = require("indent-string");
const logSymbols = require("log-symbols");
const logUpdate = require("log-update");
const stringWidth = require("string-width");
const stripAnsi = require("strip-ansi");
const pointer = chalk_1.default.yellow(figures.pointer);
const skipped = chalk_1.default.yellow(figures.arrowDown);
const isDefined = x => x !== null && x !== undefined;
function getSymbol(task, options) {
    if (!task.spinner) {
        task.spinner = elegantSpinner();
    }
    if (task.isPending()) {
        return options.showSubtasks !== false && task.subtasks.length > 0 ? pointer : chalk_1.default.yellow(task.spinner());
    }
    if (task.isCompleted()) {
        return logSymbols.success;
    }
    if (task.hasFailed()) {
        return task.subtasks.length > 0 ? pointer : logSymbols.error;
    }
    if (task.isSkipped()) {
        return skipped;
    }
    return '';
}
function getBranchStatus(porcelainLines) {
    const ret = {
        currentBranch: 'Unknown',
    };
    const branchLine = porcelainLines.find(str => str.startsWith('##'));
    const currentBranchRE = /## (.+?)\.\.\./gi;
    const upstreamRE = /\[(.+)\]$/gi;
    const currentBranchMatch = currentBranchRE.exec(branchLine);
    const upstreamMatch = upstreamRE.exec(branchLine);
    if (currentBranchMatch) {
        let currentBranch = currentBranchMatch[1];
        if (currentBranch === 'master') {
            currentBranch = chalk_1.default.red(currentBranch);
        }
        ret.currentBranch = currentBranch;
    }
    if (upstreamMatch) {
        ret.upstreamStatus = upstreamMatch[1];
    }
    return ret;
}
function getModifications(porcelainLines) {
    const modificationLines = porcelainLines.filter(str => !str.startsWith('##'));
    if (modificationLines.length === 0) {
        return '';
    }
    return modificationLines.reduce((acc, str) => {
        const symb = str.charAt(0);
        if (!acc.includes(symb)) {
            acc += symb;
        }
        return acc;
    }, '');
}
function getGitStatus(task) {
    if (!task.output) {
        return;
    }
    const porcelainLines = `${task.output}`.replace('git status:', '')
        .split('\u0000')
        .map(str => str.trim())
        .filter(str => str.length !== 0);
    if (porcelainLines.length === 0) {
        return;
    }
    return {
        branchStatus: getBranchStatus(porcelainLines),
        modifications: getModifications(porcelainLines),
    };
}
function stripHyperlinkANSI(str) {
    const OSC = '\u001B]';
    const BEL = '\u0007';
    const stripper1 = new RegExp(`${OSC}8;;.+?${BEL}(.+)${OSC}8;;${BEL}`, 'i');
    return str.replace(stripper1, '$1');
}
function padANSI(str, length, char, dir = 'start') {
    const stripped = stripHyperlinkANSI(str);
    const widthPad = (str.length - stringWidth(stripped)) + length;
    if (dir === 'end') {
        return str.padEnd(widthPad, char);
    }
    return str.padStart(widthPad, char);
}
const renderHelper = (tasks, options, level = 0, isFinal) => {
    let output = [];
    for (const task of tasks) {
        if (task.isEnabled()) {
            const { showSubtasks, collapse, padTitleLength, } = options;
            const skipped = task.isSkipped() ? ` ${chalk_1.default.dim('[skipped]')}` : '';
            const gitStatus = getGitStatus(task);
            let currentBranch = '';
            let upstreamStatus = '';
            if (gitStatus) {
                currentBranch = chalk_1.default.gray(gitStatus.branchStatus.currentBranch);
                if (gitStatus.branchStatus.upstreamStatus) {
                    upstreamStatus = chalk_1.default.yellow(gitStatus.branchStatus.upstreamStatus)
                        .replace('behind', figures.arrowDown)
                        .replace('ahead', figures.arrowUp);
                }
            }
            let title = task.title;
            if (!isFinal) {
                title = stripHyperlinkANSI(title);
            }
            if (gitStatus) {
                title = gitStatus.modifications.length ? chalk_1.default.yellow(title) : chalk_1.default.gray(title);
            }
            if (padTitleLength) {
                title = padANSI(title, padTitleLength, ' ', 'end');
            }
            let lineSymbol;
            if (gitStatus && gitStatus.modifications.length) {
                lineSymbol = chalk_1.default `{yellow ${figures.warning}} {red ${gitStatus.modifications}}`;
            }
            else {
                lineSymbol = getSymbol(task, options);
            }
            lineSymbol = padANSI(lineSymbol, 4);
            output.push(indentString(`${lineSymbol} ${title}${skipped} ${currentBranch} ${upstreamStatus}`, level, '  '));
            if ((task.isPending() || task.isSkipped() || task.hasFailed()) && isDefined(task.output)) {
                let data = task.output;
                if (typeof data === 'string') {
                    data = stripAnsi(data.trim().split('\n').filter(Boolean).pop());
                    if (data === '') {
                        data = undefined;
                    }
                }
                if (isDefined(data)) {
                    const out = indentString(`${figures.arrowRight} ${data}`, level, '  ');
                    output.push(`   ${chalk_1.default.gray(cliTruncate(out, process.stdout.columns - 3))}`);
                }
            }
            if ((task.isPending() || task.hasFailed() || collapse === false) && (task.hasFailed() || showSubtasks !== false) && task.subtasks.length > 0) {
                output = output.concat(renderHelper(task.subtasks, options, level + 1, isFinal));
            }
        }
    }
    return output.join('\n');
};
const render = (tasks, options, level, isFinal) => {
    logUpdate(renderHelper(tasks, options, level, isFinal));
};
class StatusRenderer {
    constructor(tasks, options) {
        this.nonTTY = false;
        this._tasks = tasks;
        this._options = Object.assign({ showSubtasks: true, collapse: true, clearOutput: false, padTitleLength: undefined, updateInterval: 100 }, options);
    }
    render() {
        if (this._id) {
            // Do not render if we are already rendering
            return;
        }
        this._id = setInterval(() => {
            render(this._tasks, this._options);
        }, this._options.updateInterval);
    }
    end(err) {
        if (this._id) {
            clearInterval(this._id);
            this._id = undefined;
        }
        render(this._tasks, this._options, 0, true);
        if (this._options.clearOutput && err === undefined) {
            logUpdate.clear();
        }
        else {
            logUpdate.done();
        }
    }
}
StatusRenderer.nonTTY = false; //static members to shut tsc up
StatusRenderer.render = () => { }; //static members to shut tsc up
StatusRenderer.end = () => { }; //static members to shut tsc up
exports.default = StatusRenderer;