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

#!/usr/bin/env node
"use strict";
/* eslint no-sync:0, no-inner-declarations:0 */
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
// local
const index_js_1 = require("./index.js");
const util_js_1 = require("./util.js");
// external
const version_range_1 = __importDefault(require("version-range"));
const minimist_1 = __importDefault(require("minimist"));
const text_table_1 = __importDefault(require("text-table"));
const string_width_1 = __importDefault(require("string-width"));
const logger_clearable_1 = __importDefault(require("logger-clearable"));
const spinner_title_1 = __importDefault(require("spinner-title"));
const fs_readable_1 = require("@bevry/fs-readable");
const wait_1 = __importDefault(require("@bevry/wait"));
const json_1 = require("@bevry/json");
const nodejs_versions_1 = require("@bevry/nodejs-versions");
const filedirname_1 = __importDefault(require("filedirname"));
const [file, dir] = (0, filedirname_1.default)();
// builtin
const node_process_1 = __importDefault(require("node:process"));
const node_path_1 = require("node:path");
// prepare
const spinner = null;
async function parse() {
    // parse the cli flags/arguments
    const cli = (0, minimist_1.default)(node_process_1.default.argv.slice(2), {
        '--': true,
        alias: {
            h: 'help',
            j: 'json',
            n: 'node',
            s: 'serial',
        },
        string: ['node', 'spinner'],
        // boolean: ['json', 'serial', 'verbose'], <-- this defaults to false instead of null, preventing accurate fallbacks
    });
    if (cli.help) {
        // output help and exit
        node_process_1.default.stdout.write([
            'Usage:',
            '',
            '  -n/--node [version]:   Add a Node.js version to test',
            '  -s/--serial:           Run tests serially, one after the other',
            '  -j/--json:             Output the test results as JSON',
            '  --spinner [spinner]    Which spinner to use in the title bar',
            '  --verbose:             Report details about all statuses, not just failures',
            '  --version:             Output the version of Testen',
            '  --help:                Output this help',
            '  -- [command]:          The test command you expect',
            '',
        ].join('\n'));
        return null;
    }
    if (cli.version) {
        // output version and exit
        const testenPackage = await (0, json_1.readJSON)((0, node_path_1.join)(dir, 'package.json'));
        node_process_1.default.stdout.write(testenPackage.version + '\n');
        return null;
    }
    // return configuration from cli
    const cliTestenConfig = {};
    if (cli.node)
        cliTestenConfig.node =
            Array.isArray(cli.node) && cli.node.length === 1 ? cli.node[0] : cli.node;
    if (cli['--'] && cli['--'].join(''))
        cliTestenConfig.command = cli['--'].join(' ');
    if (cli.spinner != null)
        cliTestenConfig.spinner = cli.spinner;
    if (cli.serial != null)
        cliTestenConfig.serial = cli.serial;
    if (cli.json != null)
        cliTestenConfig.json = cli.json;
    if (cli.verbose != null)
        cliTestenConfig.verbose = cli.verbose;
    return cliTestenConfig;
}
async function testen(customTestenConfig = {}) {
    // fetch the user package configuration
    const cwd = node_process_1.default.cwd();
    const userPackagePath = `${cwd}/package.json`;
    const userPackage = (await (0, fs_readable_1.isReadable)(userPackagePath))
        ? await (0, json_1.readJSON)(userPackagePath)
        : {};
    // merge the default, package, and custom configuration
    const testenConfig = Object.assign({
        node: (userPackage.engines && userPackage.engines.node) || '',
        command: 'npm test',
        spinner: 'monkey',
        serial: false,
        json: false,
        verbose: false,
    }, userPackage.testen || {}, customTestenConfig);
    // parse node versions
    const nodeVersions = [];
    if (Array.isArray(testenConfig.node) && testenConfig.node.length) {
        // specific versions
        nodeVersions.push(...testenConfig.node);
    }
    else if (testenConfig.node && /^[\d\w.-]+$/.test(testenConfig.node)) {
        // specific version
        nodeVersions.push(testenConfig.node);
    }
    else if (testenConfig.node) {
        // range
        await (0, nodejs_versions_1.preloadNodeVersions)();
        nodeVersions.push(...(0, nodejs_versions_1.filterSignificantNodeVersions)({
            maintainedOrLTS: true,
            released: true,
        }).filter((version) => (0, version_range_1.default)(version, testenConfig.node)));
    }
    else {
        nodeVersions.push('current', 'stable', 'system');
    }
    if (!nodeVersions || !nodeVersions.length) {
        throw new Error('No node versions specified');
    }
    // create the testen instance
    const listeners = [];
    let interval = null;
    let spinner = null;
    if (!testenConfig.json) {
        // create and start spinner
        spinner = new spinner_title_1.default({
            style: testenConfig.spinner,
            interval: 1000,
        });
        spinner.start();
        // prepare the logging, note that logger-clearable uses setImmediate, so requires a wait
        const logger = new logger_clearable_1.default();
        function table(result) {
            return (0, text_table_1.default)(result, { stringLength: string_width_1.default });
        }
        function refresh(versions) {
            const messages = [];
            versions.array.forEach(function (V) {
                if (V.success === false || testenConfig.verbose) {
                    messages.push(V.message);
                }
            });
            if (messages.length) {
                return ('\n' + messages.join('\n\n') + '\n\n' + table(versions.table) + '\n\n');
            }
            else {
                return '\n' + table(versions.table) + '\n\n';
            }
        }
        /* eslint-disable-next-line no-inner-declarations */
        function refresher() {
            /* eslint-disable-next-line no-use-before-define */
            logger.queue(() => refresh(versions));
        }
        interval = setInterval(refresher, 1000);
        listeners.push(refresher);
    }
    const versions = new index_js_1.Versions(nodeVersions, listeners);
    // run
    await versions.load();
    await versions.install();
    await versions.test(testenConfig.command, testenConfig.serial);
    // output and cleanup
    if (testenConfig.json) {
        // output json
        node_process_1.default.stdout.write(JSON.stringify(versions.json, null, '  '));
    }
    else {
        // output already occurred via listeners
        // cleanup our listeners
        if (interval) {
            clearInterval(interval); // stop the refresh interval
            interval = null;
        }
        spinner.stop(); // stop the spinner
        await (0, wait_1.default)(0); // wait for the logger to finish
    }
    // return versions instance
    return versions;
}
// start the cli
Promise.resolve()
    .then(parse)
    .then(async function (cliTestenConfig = null) {
    if (cliTestenConfig) {
        const versions = await testen(cliTestenConfig);
        node_process_1.default.exitCode = versions.success ? 0 : 1;
    }
})
    .catch(function (err) {
    if (spinner)
        spinner.stop();
    node_process_1.default.stderr.write((err.stack || err.message || err).toString());
    node_process_1.default.exitCode = (0, util_js_1.parseExitCode)(err.code) || 2;
});