@oclif/plugin-legacy/lib/index.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Config = require("@oclif/config");
const path = require("path");
const util_1 = require("util");
const util_2 = require("./util");
const debug = require('debug')('@oclif/plugin-legacy');
const pjson = require('../package.json');
function convertFlagsFromV5(Flags, flags) {
    if (!flags)
        return {};
    if (!Array.isArray(flags))
        return flags;
    return flags.reduce((flags, flag) => {
        const opts = {
            char: flag.char,
            description: flag.description,
            hidden: flag.hidden,
            required: flag.required || flag.optional === false,
            parse: flag.parse,
            completion: flag.completion,
            default: flag.default,
        };
        for (const [k, v] of Object.entries(opts)) {
            if (v === undefined)
                delete opts[k];
        }
        if (!opts.parse)
            delete opts.parse;
        flags[flag.name] = flag.hasValue ? Flags.string(opts) : Flags.boolean(opts);
        return flags;
    }, {});
}
class PluginLegacy extends Config.Plugin {
    constructor(config, base) {
        super(base);
        this.config = config;
        this.base = base;
        this._base = `${pjson.name}@${pjson.version}`;
        debug('loading legacy plugin', base.root);
    }
    get topics() {
        return super.topics
            .concat(this.moduleTopics);
    }
    get commandIDs() {
        return super.commandIDs
            .concat(this.moduleCommands.map(c => c.id));
    }
    findCommand(id, opts = {}) {
        let cmd = super.findCommand(id);
        if (cmd)
            return this.convertCommand(cmd);
        cmd = this.moduleCommands.find(c => c.id === id);
        if (cmd) {
            cmd.plugin = this;
            return this.convertCommand(cmd);
        }
        if (opts.must)
            throw new Error(`command ${id} not found`);
    }
    get moduleCommands() {
        if (this._moduleCommands)
            return this._moduleCommands;
        const main = this.pjson.main;
        if (!main)
            return [];
        const module = require(path.join(this.root, main));
        if (!module.commands)
            return [];
        debug('loading module commands', this.root);
        this._moduleCommands = module.commands
            .map((c) => this.convertCommand(c));
        return this._moduleCommands;
    }
    get moduleTopics() {
        if (this.pjson.oclif.topics)
            return [];
        if (this._moduleTopics)
            return this._moduleTopics;
        const main = this.pjson.main;
        if (!main)
            return [];
        const module = require(path.join(this.root, main));
        if (!module.commands)
            return [];
        debug('loading module topics', this.root);
        this._moduleTopics = module.topics;
        return this._moduleTopics;
    }
    convertCommand(c) {
        if (this.isICommand(c))
            return this.convertFromICommand(c);
        if (this.isV5Command(c))
            return this.convertFromV5(c);
        if (this.isFlowCommand(c))
            return this.convertFromFlow(c);
        debug(c);
        throw new Error(`Invalid command: ${util_1.inspect(c)}`);
    }
    convertFromICommand(c) {
        if (!c.id)
            c.id = util_2.compact([c.topic, c.command]).join(':');
        return c;
    }
    convertFromFlow(c) {
        if (!c.id)
            c.id = util_2.compact([c.topic, c.command]).join(':');
        c._version = c._version || '0.0.0';
        return c;
    }
    convertFromV5(c) {
        const { Command, flags: Flags, vars } = require('@heroku-cli/command');
        class V5 extends Command {
            async run() {
                const color = require('@oclif/color').default;
                const { flags, argv, args } = this.parse(this.constructor);
                const ctx = {
                    version: this.config.userAgent,
                    supportsColor: Boolean(color.supports.stdout),
                    auth: {},
                    debug: Boolean(this.config.debug),
                    debugHeaders: this.config.debug > 1 || ['1', 'true'].includes(process.env.HEROKU_DEBUG_HEADERS),
                    flags,
                    args: c.variableArgs ? argv : args,
                    app: flags.app,
                    org: flags.org,
                    team: flags.team,
                    config: this.config,
                    apiUrl: vars.apiUrl,
                    herokuDir: this.config.cacheDir,
                    apiToken: this.heroku.auth,
                    apiHost: vars.apiHost,
                    gitHost: vars.gitHost,
                    httpGitHost: vars.httpGitHost,
                    cwd: process.cwd(),
                };
                ctx.auth.password = ctx.apiToken;
                const ansi = require('ansi-escapes');
                process.once('exit', () => {
                    if (process.stderr.isTTY) {
                        process.stderr.write(ansi.cursorShow);
                    }
                });
                return c.run(ctx);
            }
        }
        V5.id = util_2.compact([c.topic, c.command]).join(':');
        V5.description = [c.description, c.help].join('\n');
        V5.hidden = Boolean(c.hidden);
        V5.args = (c.args || []).map((a) => (Object.assign(Object.assign({}, a), { required: a.required !== false && !a.optional })));
        V5.flags = convertFlagsFromV5(Flags, c.flags);
        V5.strict = c.strict || !c.variableArgs;
        V5.help = c.help;
        V5.aliases = c.aliases || [];
        V5.usage = c.usage;
        V5.examples = c.examples || c.example;
        if (c.needsApp || c.wantsApp) {
            V5.flags.app = Flags.app({ required: Boolean(c.needsApp) });
            V5.flags.remote = Flags.remote();
        }
        if (c.needsOrg || c.wantsOrg) {
            const opts = { required: Boolean(c.needsOrg), hidden: false, description: 'team to use' };
            V5.flags.team = Flags.team(opts);
            V5.flags.org = Flags.team({ char: 'o', hidden: true });
        }
        return V5;
    }
    isICommand(c) {
        const semver = require('semver');
        if (!c._version)
            return false;
        return semver.gte(c._version, '11.0.0');
    }
    isV5Command(command) {
        const c = command;
        return Boolean(typeof c === 'object');
    }
    isFlowCommand(command) {
        const c = command;
        return typeof c === 'function';
        // if (c._version && deps.semver.lt(c._version, '11.0.0')) return true
    }
}
exports.PluginLegacy = PluginLegacy;