@oclif/core 2.0.1 → 2.0.2-beta.10

package/lib/cli-ux/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Table = exports.ExitError = exports.Config = exports.ActionBase = exports.config = exports.ux = void 0;
+exports.warn = exports.wait = exports.url = exports.tree = exports.trace = exports.Table = exports.table = exports.styledObject = exports.styledJSON = exports.styledHeader = exports.prompt = exports.progress = exports.prideAction = exports.log = exports.info = exports.flush = exports.ExitError = exports.exit = exports.error = exports.done = exports.debug = exports.confirm = exports.Config = exports.config = exports.anykey = exports.annotation = exports.ActionBase = exports.action = exports.ux = void 0;
 const Errors = require("../errors");
 const util = require("util");
 const base_1 = require("./action/base");
@@ -8,11 +8,13 @@ Object.defineProperty(exports, "ActionBase", { enumerable: true, get: function (
 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 styled = require("./styled");
+const styled_1 = require("./styled");
+Object.defineProperty(exports, "Table", { enumerable: true, get: function () { return styled_1.Table; } });
+const uxPrompt = require("./prompt");
+const wait_1 = require("./wait");
 const hyperlinker = require('hyperlinker');
 function timeout(p, ms) {
     function wait(ms, unref = false) {
@@ -22,9 +24,9 @@ function timeout(p, ms) {
                 t.unref();
         });
     }
-    return Promise.race([p, wait(ms, true).then(() => exports.ux.error('timed out'))]);
+    return Promise.race([p, wait(ms, true).then(() => Errors.error('timed out'))]);
 }
-async function flush() {
+async function _flush() {
     const p = new Promise(resolve => {
         process.stdout.once('drain', () => resolve(null));
     });
@@ -34,74 +36,67 @@ async function flush() {
     }
     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;
-    },
+class ux {
+    static get prompt() {
+        return uxPrompt.prompt;
+    }
     /**
      * "press anykey to continue"
      */
-    get anykey() {
-        return deps_1.default.prompt.anykey;
-    },
-    get confirm() {
-        return deps_1.default.prompt.confirm;
-    },
-    get action() {
+    static get anykey() {
+        return uxPrompt.anykey;
+    }
+    static get confirm() {
+        return uxPrompt.confirm;
+    }
+    static get action() {
         return config_1.config.action;
-    },
-    get prideAction() {
+    }
+    static 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() {
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    static styledObject(obj, keys) {
+        this.info(styled.styledObject(obj, keys));
+    }
+    static get styledHeader() {
+        return styled.styledHeader;
+    }
+    static get styledJSON() {
+        return styled.styledJSON;
+    }
+    static get table() {
+        return styled.Table.table;
+    }
+    static get tree() {
+        return styled.tree;
+    }
+    static get wait() {
+        return wait_1.default;
+    }
+    static get progress() {
+        return styled.progress;
+    }
+    static async done() {
         config_1.config.action.stop();
-        // await flushStdout()
-    },
-    trace(format, ...args) {
+    }
+    static trace(format, ...args) {
         if (this.config.outputLevel === 'trace') {
             process.stdout.write(util.format(format, ...args) + '\n');
         }
-    },
-    debug(format, ...args) {
+    }
+    static debug(format, ...args) {
         if (['trace', 'debug'].includes(this.config.outputLevel)) {
             process.stdout.write(util.format(format, ...args) + '\n');
         }
-    },
-    info(format, ...args) {
+    }
+    static info(format, ...args) {
         process.stdout.write(util.format(format, ...args) + '\n');
-    },
-    log(format, ...args) {
+    }
+    static log(format, ...args) {
         this.info(format || '', ...args);
-    },
-    url(text, uri, params = {}) {
+    }
+    static url(text, uri, params = {}) {
         const supports = require('supports-hyperlinks');
         if (supports.stdout) {
             this.log(hyperlinker(text, uri, params));
@@ -109,8 +104,8 @@ exports.ux = {
         else {
             this.log(uri);
         }
-    },
-    annotation(text, annotation) {
+    }
+    static annotation(text, annotation) {
         const supports = require('supports-hyperlinks');
         if (supports.stdout) {
             // \u001b]8;;https://google.com\u0007sometext\u001b]8;;\u0007
@@ -119,17 +114,64 @@ exports.ux = {
         else {
             this.log(text);
         }
-    },
-    async flush(ms = 10000) {
-        await timeout(flush(), ms);
-    },
-};
+    }
+    static async flush(ms = 10000) {
+        await timeout(_flush(), ms);
+    }
+}
+exports.ux = ux;
+ux.config = config_1.config;
+const action = ux.action;
+exports.action = action;
+const annotation = ux.annotation;
+exports.annotation = annotation;
+const anykey = ux.anykey;
+exports.anykey = anykey;
+const confirm = ux.confirm;
+exports.confirm = confirm;
+const debug = ux.debug;
+exports.debug = debug;
+const done = ux.done;
+exports.done = done;
+const error = Errors.error;
+exports.error = error;
+const exit = Errors.exit;
+exports.exit = exit;
+const flush = ux.flush;
+exports.flush = flush;
+const info = ux.info;
+exports.info = info;
+const log = ux.log;
+exports.log = log;
+const prideAction = ux.prideAction;
+exports.prideAction = prideAction;
+const progress = ux.progress;
+exports.progress = progress;
+const prompt = ux.prompt;
+exports.prompt = prompt;
+const styledHeader = ux.styledHeader;
+exports.styledHeader = styledHeader;
+const styledJSON = ux.styledJSON;
+exports.styledJSON = styledJSON;
+const styledObject = ux.styledObject;
+exports.styledObject = styledObject;
+const table = ux.table;
+exports.table = table;
+const trace = ux.trace;
+exports.trace = trace;
+const tree = ux.tree;
+exports.tree = tree;
+const url = ux.url;
+exports.url = url;
+const wait = ux.wait;
+exports.wait = wait;
+const warn = Errors.warn;
+exports.warn = warn;
 const cliuxProcessExitHandler = async () => {
     try {
-        await exports.ux.done();
+        await ux.done();
     }
     catch (error) {
-        // tslint:disable no-console
         console.error(error);
         process.exitCode = 1;
     }

package/lib/cli-ux/list.js

@@ -1,12 +1,11 @@
 "use strict";
-// tslint:disable
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderList = void 0;
+const screen_1 = require("../screen");
 const util_1 = require("../util");
-const deps_1 = require("./deps");
+const wordwrap = require('wordwrap');
 function linewrap(length, s) {
-    const lw = require('@oclif/linewrap');
-    return lw(length, deps_1.default.screen.stdtermwidth, {
+    return wordwrap(length, screen_1.stdtermwidth, {
         skipScheme: 'ansi-color',
     })(s).trim();
 }

package/lib/cli-ux/prompt.js

@@ -2,9 +2,10 @@
 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");
+const chalk = require("chalk");
+const ansiEscapes = require('ansi-escapes');
+const passwordPrompt = require('password-prompt');
 function normal(options, retries = 100) {
     if (retries < 0)
         throw new Error('no input');
@@ -56,10 +57,10 @@ async function single(options) {
     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);
+    process.stderr.write(ansiEscapes.cursorHide + ansiEscapes.cursorUp(1) + ansiEscapes.cursorLeft + prompt +
+        ansiEscapes.cursorDown(1) + ansiEscapes.cursorLeft + ansiEscapes.cursorShow);
 }
-function _prompt(name, inputOptions = {}) {
+async function _prompt(name, inputOptions = {}) {
     const prompt = getPrompt(name, inputOptions.type, inputOptions.default);
     const options = {
         isTTY: Boolean(process.env.TERM !== 'dumb' && process.stdin.isTTY),
@@ -76,7 +77,7 @@ function _prompt(name, inputOptions = {}) {
         case 'single':
             return single(options);
         case 'mask':
-            return deps_1.default.passwordPrompt(options.prompt, {
+            return passwordPrompt(options.prompt, {
                 method: options.type,
                 required: options.required,
                 default: options.default,
@@ -85,7 +86,7 @@ function _prompt(name, inputOptions = {}) {
                 return value;
             });
         case 'hide':
-            return deps_1.default.passwordPrompt(options.prompt, {
+            return passwordPrompt(options.prompt, {
                 method: options.type,
                 required: options.required,
                 default: options.default,
@@ -100,7 +101,7 @@ function _prompt(name, inputOptions = {}) {
  * @param options - @see IPromptOptions
  * @returns Promise<string>
  */
-function prompt(name, options = {}) {
+async function prompt(name, options = {}) {
     return config_1.default.action.pauseAsync(() => {
         return _prompt(name, options);
     }, chalk.cyan('?'));

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

@@ -3,6 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const chalk = require("chalk");
 const index_1 = require("../../index");
 function styledHeader(header) {
-    index_1.CliUx.ux.info(chalk.dim('=== ') + chalk.bold(header) + '\n');
+    index_1.ux.info(chalk.dim('=== ') + chalk.bold(header) + '\n');
 }
 exports.default = styledHeader;

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

@@ -0,0 +1,7 @@
+import styledHeader from './header';
+import styledJSON from './json';
+import styledObject from './object';
+import * as Table from './table';
+import tree from './tree';
+import progress from './progress';
+export { styledHeader, styledJSON, styledObject, Table, tree, progress, };

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.progress = exports.tree = exports.Table = exports.styledObject = exports.styledJSON = exports.styledHeader = void 0;
+const header_1 = require("./header");
+exports.styledHeader = header_1.default;
+const json_1 = require("./json");
+exports.styledJSON = json_1.default;
+const object_1 = require("./object");
+exports.styledObject = object_1.default;
+const Table = require("./table");
+exports.Table = Table;
+const tree_1 = require("./tree");
+exports.tree = tree_1.default;
+const progress_1 = require("./progress");
+exports.progress = progress_1.default;

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

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

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

@@ -1,16 +1,15 @@
 "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);
+        index_1.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 }));
+    index_1.ux.info(cardinal.highlight(json, { json: true, theme }));
 }
 exports.default = styledJSON;

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

@@ -1,8 +1,8 @@
 "use strict";
-// tslint:disable
 Object.defineProperty(exports, "__esModule", { value: true });
 const chalk = require("chalk");
 const util = require("util");
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
 function styledObject(obj, keys) {
     const output = [];
     const keyLengths = Object.keys(obj).map(key => key.toString().length);

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

@@ -1 +1,2 @@
-export default function progress(options?: any): any;
+import { Options, SingleBar } from 'cli-progress';
+export default function progress(options?: Options): SingleBar;

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

@@ -1,14 +1,10 @@
 "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 = {};
-    }
+const cli_progress_1 = require("cli-progress");
+function progress(options = {}) {
     // set noTTYOutput for options
     options.noTTYOutput = Boolean(process.env.TERM === 'dumb' || !process.stdin.isTTY);
-    return new cliProgress.SingleBar(options);
+    return new cli_progress_1.SingleBar(options);
 }
 exports.default = progress;

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

@@ -126,7 +126,6 @@ class Table {
         return values.map(e => lineToBeEscaped ? `"${e.replace('"', '""')}"` : e);
     }
     resolveColumnsToObjectArray() {
-        // tslint:disable-next-line:no-this-assignment
         const { data, columns } = this;
         return data.map((d) => {
             // eslint-disable-next-line unicorn/prefer-object-from-entries
@@ -145,7 +144,6 @@ class Table {
         this.options.printLine((0, js_yaml_1.safeDump)(this.resolveColumnsToObjectArray()));
     }
     outputCSV() {
-        // tslint:disable-next-line:no-this-assignment
         const { data, columns, options } = this;
         if (!options['no-header']) {
             options.printLine(columns.map(c => c.header).join(','));
@@ -156,7 +154,6 @@ class Table {
         }
     }
     outputTable() {
-        // tslint:disable-next-line:no-this-assignment
         const { data, options } = this;
         // column truncation
         //
@@ -288,6 +285,7 @@ exports.table = table;
         'no-truncate': F.boolean({ exclusive: ['csv'], description: 'do not truncate output to fit screen' }),
         'no-header': F.boolean({ exclusive: ['csv'], description: 'hide table header from output' }),
     };
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
     function flags(opts) {
         if (opts) {
             const f = {};

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

@@ -20,7 +20,6 @@ class Tree {
                 return c;
         }
     }
-    // tslint:disable-next-line:no-console
     display(logger = console.log) {
         const addNodes = function (nodes) {
             const tree = {};

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

@@ -1,2 +1,2 @@
-declare const _default: (ms?: number) => Promise<unknown>;
+declare const _default: (ms?: number) => Promise<void>;
 export default _default;

package/lib/cli-ux/wait.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-// tslint:disable no-string-based-set-timeout
 exports.default = (ms = 1000) => {
     return new Promise(resolve => {
         setTimeout(resolve, ms);

package/lib/command.d.ts

@@ -1,15 +1,17 @@
 import { Config } from './config';
-import * as Interfaces from './interfaces';
 import { PrettyPrintableError } from './errors';
-import { Deprecation } from './interfaces/parser';
+import { BooleanFlagProps, CompletableFlag, Deprecation, Arg as IArg, ArgInput, FlagInput, FlagOutput, Input, ArgProps, OptionFlagProps, ParserOutput, ArgOutput } from './interfaces/parser';
+import { Plugin } from './interfaces/plugin';
+import { LoadOptions } from './interfaces/config';
+import { CommandError } from './interfaces/errors';
 /**
  * An abstract class which acts as the base for each command
  * in your project.
  */
-export default abstract class Command {
+export declare abstract class Command {
     argv: string[];
     config: Config;
-    static _base: string;
+    private static readonly _base;
     /** A command ID, used mostly in error or verbose reporting. */
     static id: string;
     /**
@@ -41,10 +43,12 @@ export default abstract class Command {
     static aliases: string[];
     /** When set to false, allows a variable amount of arguments */
     static strict: boolean;
-    static parse: boolean;
-    /** An order-dependent array of arguments for the command */
-    static args?: Interfaces.ArgInput;
-    static plugin: Interfaces.Plugin | undefined;
+    /** An order-dependent object of arguments for the command */
+    static args: ArgInput;
+    static plugin: Plugin | undefined;
+    static readonly pluginName?: string;
+    static readonly pluginType?: string;
+    static readonly pluginAlias?: string;
     /**
      * An array of examples to show at the end of the command's help.
      *
@@ -59,30 +63,32 @@ export default abstract class Command {
      *     $ <%= config.bin => command flags
      * ```
      */
-    static examples: Interfaces.Example[];
-    static parserOptions: {};
-    static _enableJsonFlag: boolean;
+    static examples: Command.Example[];
+    static hasDynamicHelp: boolean;
+    protected static _enableJsonFlag: boolean;
     static get enableJsonFlag(): boolean;
     static set enableJsonFlag(value: boolean);
     /**
      * instantiate and run the command
-     * @param {Interfaces.Command.Class} this Class
+     *
+     * @param {Command.Class} this - the command class
      * @param {string[]} argv argv
-     * @param {Interfaces.LoadOptions} opts options
+     * @param {LoadOptions} opts options
+     * @returns {Promise<unknown>} result
      */
-    static run: Interfaces.Command.Class['run'];
-    protected static _globalFlags: Interfaces.FlagInput;
-    static get globalFlags(): Interfaces.FlagInput;
-    static set globalFlags(flags: Interfaces.FlagInput);
+    static run<T extends Command>(this: new (argv: string[], config: Config) => T, argv?: string[], opts?: LoadOptions): Promise<unknown>;
+    protected static _baseFlags: FlagInput;
+    static get baseFlags(): FlagInput;
+    static set baseFlags(flags: FlagInput);
     /** A hash of flags for the command */
-    protected static _flags: Interfaces.FlagInput;
-    static get flags(): Interfaces.FlagInput;
-    static set flags(flags: Interfaces.FlagInput);
+    protected static _flags: FlagInput;
+    static get flags(): FlagInput;
+    static set flags(flags: FlagInput);
     id: string | undefined;
     protected debug: (...args: any[]) => void;
     constructor(argv: string[], config: Config);
-    get ctor(): typeof Command;
-    _run<T>(): Promise<T | undefined>;
+    protected get ctor(): typeof Command;
+    protected _run<T>(): Promise<T | undefined>;
     exit(code?: number): void;
     warn(input: string | Error): string | Error;
     error(input: string | Error, options: {
@@ -99,15 +105,60 @@ export default abstract class Command {
     /**
      * actual command run code goes here
      */
-    abstract run(): PromiseLike<any>;
+    abstract run(): Promise<any>;
     protected init(): Promise<any>;
     protected warnIfFlagDeprecated(flags: Record<string, unknown>): void;
     protected warnIfCommandDeprecated(): void;
-    protected parse<F extends Interfaces.FlagOutput, G extends Interfaces.FlagOutput, A extends {
-        [name: string]: any;
-    }>(options?: Interfaces.Input<F, G>, argv?: string[]): Promise<Interfaces.ParserOutput<F, G, A>>;
-    protected catch(err: Interfaces.CommandError): Promise<any>;
+    protected parse<F extends FlagOutput, B extends FlagOutput, A extends ArgOutput>(options?: Input<F, B, A>, argv?: string[]): Promise<ParserOutput<F, B, A>>;
+    protected catch(err: CommandError): Promise<any>;
     protected finally(_: Error | undefined): Promise<any>;
     protected toSuccessJson(result: unknown): any;
     protected toErrorJson(err: unknown): any;
 }
+export declare namespace Command {
+    type Class = typeof Command & {
+        id: string;
+        run(argv?: string[], config?: LoadOptions): Promise<any>;
+    };
+    interface Loadable extends Cached {
+        load(): Promise<Command.Class>;
+    }
+    type Cached = {
+        [key: string]: unknown;
+        id: string;
+        hidden: boolean;
+        state?: 'beta' | 'deprecated' | string;
+        deprecationOptions?: Deprecation;
+        aliases: string[];
+        summary?: string;
+        description?: string;
+        usage?: string | string[];
+        examples?: Example[];
+        strict?: boolean;
+        type?: string;
+        pluginName?: string;
+        pluginType?: string;
+        pluginAlias?: string;
+        flags: {
+            [name: string]: Flag.Cached;
+        };
+        args: {
+            [name: string]: Arg.Cached;
+        };
+        hasDynamicHelp?: boolean;
+    };
+    type Flag = CompletableFlag<any>;
+    namespace Flag {
+        type Cached = Omit<Flag, 'parse' | 'input'> & (BooleanFlagProps | OptionFlagProps);
+        type Any = Flag | Cached;
+    }
+    type Arg = IArg<any>;
+    namespace Arg {
+        type Cached = Omit<Arg, 'parse' | 'input'> & ArgProps;
+        type Any = Arg | Cached;
+    }
+    type Example = string | {
+        description: string;
+        command: string;
+    };
+}