@oclif/core 1.1.1 → 1.3.0

package/lib/cli-ux/index.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Table = exports.ExitError = exports.Config = exports.ActionBase = exports.config = exports.ux = void 0;
+const Errors = require("../errors");
+const util = require("util");
+const base_1 = require("./action/base");
+Object.defineProperty(exports, "ActionBase", { enumerable: true, get: function () { return base_1.ActionBase; } });
+const config_1 = require("./config");
+Object.defineProperty(exports, "config", { enumerable: true, get: function () { return config_1.config; } });
+Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return config_1.Config; } });
+const deps_1 = require("./deps");
+const exit_1 = require("./exit");
+Object.defineProperty(exports, "ExitError", { enumerable: true, get: function () { return exit_1.ExitError; } });
+const Table = require("./styled/table");
+exports.Table = Table;
+const hyperlinker = require('hyperlinker');
+function timeout(p, ms) {
+    function wait(ms, unref = false) {
+        return new Promise(resolve => {
+            const t = setTimeout(() => resolve(null), ms);
+            if (unref)
+                t.unref();
+        });
+    }
+    return Promise.race([p, wait(ms, true).then(() => exports.ux.error('timed out'))]);
+}
+async function flush() {
+    const p = new Promise(resolve => {
+        process.stdout.once('drain', () => resolve(null));
+    });
+    process.stdout.write('');
+    return p;
+}
+exports.ux = {
+    config: config_1.config,
+    warn: Errors.warn,
+    error: Errors.error,
+    exit: Errors.exit,
+    get prompt() {
+        return deps_1.default.prompt.prompt;
+    },
+    /**
+     * "press anykey to continue"
+     */
+    get anykey() {
+        return deps_1.default.prompt.anykey;
+    },
+    get confirm() {
+        return deps_1.default.prompt.confirm;
+    },
+    get action() {
+        return config_1.config.action;
+    },
+    get prideAction() {
+        return config_1.config.prideAction;
+    },
+    styledObject(obj, keys) {
+        exports.ux.info(deps_1.default.styledObject(obj, keys));
+    },
+    get styledHeader() {
+        return deps_1.default.styledHeader;
+    },
+    get styledJSON() {
+        return deps_1.default.styledJSON;
+    },
+    get table() {
+        return deps_1.default.table;
+    },
+    get tree() {
+        return deps_1.default.tree;
+    },
+    get open() {
+        return deps_1.default.open;
+    },
+    get wait() {
+        return deps_1.default.wait;
+    },
+    get progress() {
+        return deps_1.default.progress;
+    },
+    async done() {
+        config_1.config.action.stop();
+        // await flushStdout()
+    },
+    trace(format, ...args) {
+        if (this.config.outputLevel === 'trace') {
+            process.stdout.write(util.format(format, ...args) + '\n');
+        }
+    },
+    debug(format, ...args) {
+        if (['trace', 'debug'].includes(this.config.outputLevel)) {
+            process.stdout.write(util.format(format, ...args) + '\n');
+        }
+    },
+    info(format, ...args) {
+        process.stdout.write(util.format(format, ...args) + '\n');
+    },
+    log(format, ...args) {
+        this.info(format || '', ...args);
+    },
+    url(text, uri, params = {}) {
+        const supports = require('supports-hyperlinks');
+        if (supports.stdout) {
+            this.log(hyperlinker(text, uri, params));
+        }
+        else {
+            this.log(uri);
+        }
+    },
+    annotation(text, annotation) {
+        const supports = require('supports-hyperlinks');
+        if (supports.stdout) {
+            // \u001b]8;;https://google.com\u0007sometext\u001b]8;;\u0007
+            this.log(`\u001B]1337;AddAnnotation=${text.length}|${annotation}\u0007${text}`);
+        }
+        else {
+            this.log(text);
+        }
+    },
+    async flush() {
+        await timeout(flush(), 10000);
+    },
+};
+const cliuxProcessExitHandler = async () => {
+    try {
+        await exports.ux.done();
+    }
+    catch (error) {
+        // tslint:disable no-console
+        console.error(error);
+        process.exitCode = 1;
+    }
+};
+// to avoid MaxListenersExceededWarning
+// only attach named listener once
+const cliuxListener = process.listeners('exit').find(fn => fn.name === cliuxProcessExitHandler.name);
+if (!cliuxListener) {
+    process.once('exit', cliuxProcessExitHandler);
+}

package/lib/cli-ux/list.d.ts

@@ -0,0 +1,3 @@
+export declare type IListItem = [string, string | undefined];
+export declare type IList = IListItem[];
+export declare function renderList(items: IListItem[]): string;

package/lib/cli-ux/list.js

@@ -0,0 +1,30 @@
+"use strict";
+// tslint:disable
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderList = void 0;
+const maxBy_1 = require("lodash/maxBy");
+const deps_1 = require("./deps");
+function linewrap(length, s) {
+    const lw = require('@oclif/linewrap');
+    return lw(length, deps_1.default.screen.stdtermwidth, {
+        skipScheme: 'ansi-color',
+    })(s).trim();
+}
+function renderList(items) {
+    if (items.length === 0) {
+        return '';
+    }
+    const maxLength = (0, maxBy_1.default)(items, '[0].length')[0].length;
+    const lines = items.map(i => {
+        let left = i[0];
+        let right = i[1];
+        if (!right) {
+            return left;
+        }
+        left = left.padEnd(maxLength);
+        right = linewrap(maxLength + 2, right);
+        return `${left}  ${right}`;
+    });
+    return lines.join('\n');
+}
+exports.renderList = renderList;

package/lib/cli-ux/open.d.ts

@@ -0,0 +1,6 @@
+export declare namespace open {
+    type Options = {
+        app?: string | string[];
+    };
+}
+export default function open(target: string, opts?: open.Options): Promise<unknown>;

package/lib/cli-ux/open.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// this code is largely taken from opn
+const childProcess = require("child_process");
+const lodash_1 = require("lodash");
+const isWsl = require('is-wsl');
+function open(target, opts = {}) {
+    // opts = {wait: true, ...opts}
+    let cmd;
+    let appArgs = [];
+    let args = [];
+    const cpOpts = {};
+    if (Array.isArray(opts.app)) {
+        appArgs = opts.app.slice(1);
+        opts.app = opts.app[0];
+    }
+    if (process.platform === 'darwin') {
+        cmd = 'open';
+        // if (opts.wait) {
+        //   args.push('-W')
+        // }
+        if (opts.app) {
+            args.push('-a', opts.app);
+        }
+    }
+    else if (process.platform === 'win32' || isWsl) {
+        cmd = 'cmd' + (isWsl ? '.exe' : '');
+        args.push('/c', 'start', '""', '/b');
+        target = target.replace(/&/g, '^&');
+        // if (opts.wait) {
+        //   args.push('/wait')
+        // }
+        if (opts.app) {
+            args.push(opts.app);
+        }
+        if (appArgs.length > 0) {
+            args = [...args, ...appArgs];
+        }
+    }
+    else {
+        cmd = opts.app ? opts.app : 'xdg-open';
+        if (appArgs.length > 0) {
+            args = [...args, ...appArgs];
+        }
+        // if (!opts.wait) {
+        // `xdg-open` will block the process unless
+        // stdio is ignored and it's detached from the parent
+        // even if it's unref'd
+        cpOpts.stdio = 'ignore';
+        cpOpts.detached = true;
+        // }
+    }
+    args.push(target);
+    if (process.platform === 'darwin' && appArgs.length > 0) {
+        args.push('--args');
+        args = [...args, ...appArgs];
+    }
+    const cp = childProcess.spawn(cmd, args, cpOpts);
+    return new Promise((resolve, reject) => {
+        cp.once('error', reject);
+        cp.once('close', code => {
+            if (lodash_1.default.isNumber(code) && code > 0) {
+                reject(new Error('Exited with code ' + code));
+                return;
+            }
+            resolve(cp);
+        });
+    });
+}
+exports.default = open;

package/lib/cli-ux/prompt.d.ts

@@ -0,0 +1,29 @@
+export interface IPromptOptions {
+    prompt?: string;
+    type?: 'normal' | 'mask' | 'hide' | 'single';
+    timeout?: number;
+    /**
+     * Requires user input if true, otherwise allows empty input
+     */
+    required?: boolean;
+    default?: string;
+}
+/**
+ * prompt for input
+ * @param name - prompt text
+ * @param options - @see IPromptOptions
+ * @returns void
+ */
+export declare function prompt(name: string, options?: IPromptOptions): Promise<any>;
+/**
+ * confirmation prompt (yes/no)
+ * @param message - confirmation text
+ * @returns Promise<boolean>
+ */
+export declare function confirm(message: string): Promise<boolean>;
+/**
+ * "press anykey to continue"
+ * @param message - optional message to display to user
+ * @returns Promise<void>
+ */
+export declare function anykey(message?: string): Promise<void>;

package/lib/cli-ux/prompt.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anykey = exports.confirm = exports.prompt = void 0;
+const Errors = require("../errors");
+const chalk = require("chalk");
+const config_1 = require("./config");
+const deps_1 = require("./deps");
+function normal(options, retries = 100) {
+    if (retries < 0)
+        throw new Error('no input');
+    return new Promise((resolve, reject) => {
+        let timer;
+        if (options.timeout) {
+            timer = setTimeout(() => {
+                process.stdin.pause();
+                reject(new Error('Prompt timeout'));
+            }, options.timeout);
+            timer.unref();
+        }
+        process.stdin.setEncoding('utf8');
+        process.stderr.write(options.prompt);
+        process.stdin.resume();
+        process.stdin.once('data', b => {
+            if (timer)
+                clearTimeout(timer);
+            process.stdin.pause();
+            const data = (typeof b === 'string' ? b : b.toString()).trim();
+            if (!options.default && options.required && data === '') {
+                resolve(normal(options, retries - 1));
+            }
+            else {
+                resolve(data || options.default);
+            }
+        });
+    });
+}
+function getPrompt(name, type, defaultValue) {
+    let prompt = '> ';
+    if (defaultValue && type === 'hide') {
+        defaultValue = '*'.repeat(defaultValue.length);
+    }
+    if (name && defaultValue)
+        prompt = name + ' ' + chalk.yellow('[' + defaultValue + ']') + ': ';
+    else if (name)
+        prompt = `${name}: `;
+    return prompt;
+}
+async function single(options) {
+    var _a;
+    const raw = process.stdin.isRaw;
+    if (process.stdin.setRawMode)
+        process.stdin.setRawMode(true);
+    options.required = (_a = options.required) !== null && _a !== void 0 ? _a : false;
+    const response = await normal(options);
+    if (process.stdin.setRawMode)
+        process.stdin.setRawMode(Boolean(raw));
+    return response;
+}
+function replacePrompt(prompt) {
+    process.stderr.write(deps_1.default.ansiEscapes.cursorHide + deps_1.default.ansiEscapes.cursorUp(1) + deps_1.default.ansiEscapes.cursorLeft + prompt +
+        deps_1.default.ansiEscapes.cursorDown(1) + deps_1.default.ansiEscapes.cursorLeft + deps_1.default.ansiEscapes.cursorShow);
+}
+function _prompt(name, inputOptions = {}) {
+    const prompt = getPrompt(name, inputOptions.type, inputOptions.default);
+    const options = {
+        isTTY: Boolean(process.env.TERM !== 'dumb' && process.stdin.isTTY),
+        name,
+        prompt,
+        type: 'normal',
+        required: true,
+        default: '',
+        ...inputOptions,
+    };
+    switch (options.type) {
+        case 'normal':
+            return normal(options);
+        case 'single':
+            return single(options);
+        case 'mask':
+            return deps_1.default.passwordPrompt(options.prompt, {
+                method: options.type,
+                required: options.required,
+                default: options.default,
+            }).then((value) => {
+                replacePrompt(getPrompt(name, 'hide', inputOptions.default));
+                return value;
+            });
+        case 'hide':
+            return deps_1.default.passwordPrompt(options.prompt, {
+                method: options.type,
+                required: options.required,
+                default: options.default,
+            });
+        default:
+            throw new Error(`unexpected type ${options.type}`);
+    }
+}
+/**
+ * prompt for input
+ * @param name - prompt text
+ * @param options - @see IPromptOptions
+ * @returns void
+ */
+function prompt(name, options = {}) {
+    return config_1.default.action.pauseAsync(() => {
+        return _prompt(name, options);
+    }, chalk.cyan('?'));
+}
+exports.prompt = prompt;
+/**
+ * confirmation prompt (yes/no)
+ * @param message - confirmation text
+ * @returns Promise<boolean>
+ */
+function confirm(message) {
+    return config_1.default.action.pauseAsync(async () => {
+        const confirm = async () => {
+            const response = (await _prompt(message)).toLowerCase();
+            if (['n', 'no'].includes(response))
+                return false;
+            if (['y', 'yes'].includes(response))
+                return true;
+            return confirm();
+        };
+        return confirm();
+    }, chalk.cyan('?'));
+}
+exports.confirm = confirm;
+/**
+ * "press anykey to continue"
+ * @param message - optional message to display to user
+ * @returns Promise<void>
+ */
+async function anykey(message) {
+    const tty = Boolean(process.stdin.setRawMode);
+    if (!message) {
+        message = tty ?
+            `Press any key to continue or ${chalk.yellow('q')} to exit` :
+            `Press enter to continue or ${chalk.yellow('q')} to exit`;
+    }
+    const char = await prompt(message, { type: 'single', required: false });
+    if (tty)
+        process.stderr.write('\n');
+    if (char === 'q')
+        Errors.error('quit');
+    if (char === '\u0003')
+        Errors.error('ctrl-c');
+    return char;
+}
+exports.anykey = anykey;

package/lib/cli-ux/styled/header.d.ts

@@ -0,0 +1 @@
+export default function styledHeader(header: string): void;

package/lib/cli-ux/styled/header.js

@@ -0,0 +1,8 @@
+"use strict";
+// tslint:disable restrict-plus-operands
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk = require("chalk");
+function styledHeader(header) {
+    process.stdout.write(chalk.dim('=== ') + chalk.bold(header) + '\n');
+}
+exports.default = styledHeader;

package/lib/cli-ux/styled/json.d.ts

@@ -0,0 +1 @@
+export default function styledJSON(obj: any): void;

package/lib/cli-ux/styled/json.js

@@ -0,0 +1,16 @@
+"use strict";
+// tslint:disable restrict-plus-operands
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk = require("chalk");
+const index_1 = require("../../index");
+function styledJSON(obj) {
+    const json = JSON.stringify(obj, null, 2);
+    if (!chalk.level) {
+        index_1.CliUx.ux.info(json);
+        return;
+    }
+    const cardinal = require('cardinal');
+    const theme = require('cardinal/themes/jq');
+    index_1.CliUx.ux.info(cardinal.highlight(json, { json: true, theme }));
+}
+exports.default = styledJSON;

package/lib/cli-ux/styled/object.d.ts

@@ -0,0 +1 @@
+export default function styledObject(obj: any, keys?: string[]): string;

package/lib/cli-ux/styled/object.js

@@ -0,0 +1,39 @@
+"use strict";
+// tslint:disable
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk = require("chalk");
+const util = require("util");
+function styledObject(obj, keys) {
+    const output = [];
+    const keyLengths = Object.keys(obj).map(key => key.toString().length);
+    const maxKeyLength = Math.max(...keyLengths) + 2;
+    function pp(obj) {
+        if (typeof obj === 'string' || typeof obj === 'number')
+            return obj;
+        if (typeof obj === 'object') {
+            return Object.keys(obj)
+                .map(k => k + ': ' + util.inspect(obj[k]))
+                .join(', ');
+        }
+        return util.inspect(obj);
+    }
+    const logKeyValue = (key, value) => {
+        return `${chalk.blue(key)}:` + ' '.repeat(maxKeyLength - key.length - 1) + pp(value);
+    };
+    for (const key of keys || Object.keys(obj).sort()) {
+        const value = obj[key];
+        if (Array.isArray(value)) {
+            if (value.length > 0) {
+                output.push(logKeyValue(key, value[0]));
+                for (const e of value.slice(1)) {
+                    output.push(' '.repeat(maxKeyLength) + pp(e));
+                }
+            }
+        }
+        else if (value !== null && value !== undefined) {
+            output.push(logKeyValue(key, value));
+        }
+    }
+    return output.join('\n');
+}
+exports.default = styledObject;

package/lib/cli-ux/styled/progress.d.ts

@@ -0,0 +1 @@
+export default function progress(options?: any): any;

package/lib/cli-ux/styled/progress.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// 3pp
+const cliProgress = require("cli-progress");
+function progress(options) {
+    // if no options passed, create empty options
+    if (!options) {
+        options = {};
+    }
+    // set noTTYOutput for options
+    options.noTTYOutput = Boolean(process.env.TERM === 'dumb' || !process.stdin.isTTY);
+    return new cliProgress.SingleBar(options);
+}
+exports.default = progress;

package/lib/cli-ux/styled/table.d.ts

@@ -0,0 +1,45 @@
+import * as Interfaces from '../../interfaces';
+export declare function table<T extends Record<string, unknown>>(data: T[], columns: table.Columns<T>, options?: table.Options): void;
+export declare namespace table {
+    export const Flags: {
+        columns: Interfaces.OptionFlag<string | undefined>;
+        sort: Interfaces.OptionFlag<string | undefined>;
+        filter: Interfaces.OptionFlag<string | undefined>;
+        csv: Interfaces.Flag<boolean>;
+        output: Interfaces.OptionFlag<string | undefined>;
+        extended: Interfaces.Flag<boolean>;
+        'no-truncate': Interfaces.Flag<boolean>;
+        'no-header': Interfaces.Flag<boolean>;
+    };
+    type IFlags = typeof Flags;
+    type ExcludeFlags<T, Z> = Pick<T, Exclude<keyof T, Z>>;
+    type IncludeFlags<T, K extends keyof T> = Pick<T, K>;
+    export function flags(): IFlags;
+    export function flags<Z extends keyof IFlags = keyof IFlags>(opts: {
+        except: Z | Z[];
+    }): ExcludeFlags<IFlags, Z>;
+    export function flags<K extends keyof IFlags = keyof IFlags>(opts: {
+        only: K | K[];
+    }): IncludeFlags<IFlags, K>;
+    export interface Column<T extends Record<string, unknown>> {
+        header: string;
+        extended: boolean;
+        minWidth: number;
+        get(row: T): any;
+    }
+    export type Columns<T extends Record<string, unknown>> = {
+        [key: string]: Partial<Column<T>>;
+    };
+    export interface Options {
+        [key: string]: any;
+        sort?: string;
+        filter?: string;
+        columns?: string;
+        extended?: boolean;
+        'no-truncate'?: boolean;
+        output?: string;
+        'no-header'?: boolean;
+        printLine?(s: any): any;
+    }
+    export {};
+}