@bevry/testen/edition-es2022/version.js

"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 (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __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.Version = void 0;
// external
const ansi = __importStar(require("@bevry/ansi"));
const figures_1 = __importDefault(require("@bevry/figures"));
const version_clean_1 = __importDefault(require("version-clean"));
// local
const util_js_1 = require("./util.js");
function getTime() {
    return Date.now();
}
/** Version */
class Version {
    /** The precise version number, or at least the WIP version number/alias until it is resolved further. */
    version;
    /** The list of listeners we will call when updates happen. */
    listeners = [];
    /** An array of aliases for this version if any were used. */
    aliases = [];
    /** The current status of this version, initially it is `pending`. */
    status = 'pending';
    /**
     * The version resolution that was successfully loaded.
     * For instance, if a nvm alias is used such as "current" which resolves to 18.18.2 which is the system Node.js version, but is not installed via nvm itself, then trying to resolve "18.18.2" will fail with [version "v18.18.2" is not yet installed] but the original "current" resolution will work.
     */
    loadedVersion = null;
    /** Whether or not this version has been successful. */
    success = null;
    /** Any error that occurred against this version.  */
    error = null;
    /** The last stdout value that occurred against this version. */
    stdout = null;
    /** The last stderr value that occurred against this version. */
    stderr = null;
    /** The time the run started. */
    started = null;
    /** The time the run finished. */
    finished = null;
    /** Cache of the message. */
    messageCache = null;
    /** Create our Version instance */
    constructor(version, listeners = []) {
        this.listeners.push(...listeners);
        this.version = String(version);
        // If it fails to pass, then it is an alias, not a version
        if (!(0, version_clean_1.default)(this.version)) {
            // this uses a setter to add to this.aliases
            this.alias = this.version;
        }
    }
    /** The alias for this version if any were provided. E.g. `system` or `current` */
    get alias() {
        return this.aliases[0];
    }
    set alias(alias) {
        if (alias) {
            const aliases = this.aliases.concat(alias);
            this.aliases = (0, util_js_1.uniq)(aliases);
        }
    }
    /** Reset the version state. */
    reset() {
        this.success = null;
        this.error = null;
        this.stdout = null;
        this.stderr = null;
        this.started = null;
        this.finished = null;
        this.messageCache = null;
        return this;
    }
    /** Notify that an update has occurred.
     * @param {string?} status
     * @returns {this}
     * @private
     */
    async update(status) {
        if (status)
            this.status = status;
        await Promise.all(this.listeners.map((listener) => listener(this)));
        return this;
    }
    /** Load the version, which resolves the precise version number and determines if it is available or not. */
    async load() {
        this.status = 'loading';
        this.reset();
        await this.update();
        const result = await (0, util_js_1.loadVersion)(this.version);
        if (result.error) {
            if ((result.error || '').toString().includes('not yet installed')) {
                this.status = 'missing';
                this.success = false;
            }
            else {
                this.status = 'failed';
                this.success = false;
            }
            this.error = result.error;
            this.stdout = (result.stdout || '').toString();
            this.stderr = (result.stderr || '').toString();
        }
        else {
            const result = await (0, util_js_1.runVersion)(this.version);
            if (result.error) {
                this.status = 'failed';
                this.success = false;
                this.error = result.error;
                this.stdout = (result.stdout || '').toString();
                this.stderr = (result.stderr || '').toString();
            }
            else {
                this.loadedVersion = this.loadedVersion || this.version;
                this.version = (0, util_js_1.lastLine)(result.stdout); // resolve the version
                this.status = 'loaded';
            }
        }
        await this.update();
        return this;
    }
    /**
     * Install the version if it was missing.
     * Requires the current state to be `missing`.
     */
    async install() {
        if (this.status !== 'missing')
            return this;
        this.status = 'installing';
        this.reset();
        await this.update();
        const result = await (0, util_js_1.runInstall)(this.version);
        if (result.error) {
            this.error = result.error;
            this.status = 'missing';
            this.success = false;
            this.stdout = (result.stdout || '').toString();
            this.stderr = (result.stderr || '').toString();
        }
        else {
            await this.update('installed');
            await this.load();
        }
        return this;
    }
    /**
     * Run the command against the version.
     * Requires the current state to be `loaded`.
     */
    async test(command) {
        if (!command) {
            throw new Error('no command provided to the testen version runner');
        }
        if (this.status !== 'loaded')
            return this;
        this.status = 'running';
        this.reset();
        await this.update();
        this.started = getTime();
        const result = await (0, util_js_1.runCommand)(this.loadedVersion || this.version, command);
        this.finished = getTime();
        this.error = result.error;
        this.stdout = (result.stdout || '').toString();
        this.stderr = (result.stderr || '').toString();
        this.success = Boolean(result.error) === false;
        await this.update(this.success ? 'passed' : 'failed');
        return this;
    }
    /**
     * Converts the version properties into an array for use of displaying in a neat table.
     * Doesn't cache as we want to refresh timers.
     */
    get row() {
        const indicator = this.success === null
            ? ansi.dim(figures_1.default.circle)
            : this.success
                ? ansi.green(figures_1.default.tick)
                : ansi.red(figures_1.default.cross);
        const result = this.success === null
            ? ansi.dim(this.status)
            : this.success
                ? ansi.green(this.status)
                : ansi.red(this.status);
        // note that caching prevents realtime updates of duration time
        const ms = this.started ? (this.finished || getTime()) - this.started : 0;
        const duration = this.started
            ? ansi.dim(ms > 1000 ? `${Math.round(ms / 1000)}s` : `${ms}ms`)
            : '';
        const aliases = this.aliases.length
            ? ansi.dim(` [${this.aliases.join('|')}]`)
            : '';
        const row = [
            '  ' + indicator,
            this.version + aliases,
            result,
            duration,
        ];
        return row;
    }
    /**
     * Converts the version properties a detailed message of what has occurred with this version.
     * Caches for each status change.
     * @property {string} message
     * @public
     */
    get message() {
        // Cache
        if (this.messageCache && this.messageCache[0] === this.status) {
            return this.messageCache[1];
        }
        // Prepare
        const parts = [];
        // fetch heading
        const heading = `Node version ${ansi.underline(this.version)} ${this.status}`;
        if (this.status === 'missing') {
            parts.push(ansi.bold(ansi.red(heading)));
        }
        else if (this.success === true) {
            parts.push(ansi.bold(ansi.green(heading)));
        }
        else if (this.success === false) {
            parts.push(ansi.bold(ansi.red(heading)));
        }
        else {
            // running, loading, etc - shown in verbose mode
            parts.push(ansi.bold(ansi.dim(heading)));
        }
        // Output the command that was run
        if (this.error) {
            parts.push(ansi.red(this.error.message.split('\n')[0]));
        }
        // Output stdout and stderr
        if (this.status === 'missing') {
            parts.push(ansi.red(`You need to run: nvm install ${this.version}`));
        }
        else {
            const stdout = (0, util_js_1.trim)(this.stdout || '');
            const stderr = (0, util_js_1.trim)(this.stderr || '');
            if (!stdout && !stderr) {
                parts.push(ansi.dim('no output'));
            }
            else {
                if (stdout) {
                    parts.push(stdout);
                }
                if (stderr) {
                    parts.push(ansi.red(stderr));
                }
            }
        }
        // Join it all together
        const message = parts.join('\n');
        // Cache
        this.messageCache = [this.status, message];
        return message;
    }
}
exports.Version = Version;
exports.default = Version;