@oclif/core 2.0.1 → 2.0.2-beta.10

package/lib/parser/index.js

@@ -1,43 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.custom = exports.option = exports.build = exports.string = exports.file = exports.directory = exports.url = exports.integer = exports.boolean = exports.parse = exports.flagUsages = exports.flags = exports.args = void 0;
-const args = require("./args");
-exports.args = args;
-const deps_1 = require("./deps");
-const flags = require("./flags");
-exports.flags = flags;
+exports.parse = exports.flagUsages = void 0;
 const parse_1 = require("./parse");
+const validate_1 = require("./validate");
 var help_1 = require("./help");
 Object.defineProperty(exports, "flagUsages", { enumerable: true, get: function () { return help_1.flagUsages; } });
-// eslint-disable-next-line new-cap
-const m = (0, deps_1.default)()
-    // eslint-disable-next-line node/no-missing-require
-    .add('validate', () => require('./validate').validate);
 async function parse(argv, options) {
     const input = {
         argv,
         context: options.context,
-        args: (options.args || []).map((a) => args.newArg(a)),
         '--': options['--'],
-        flags: {
-            color: flags.defaultFlags.color,
-            ...options.flags,
-        },
+        flags: (options.flags ?? {}),
+        args: (options.args ?? {}),
         strict: options.strict !== false,
     };
     const parser = new parse_1.Parser(input);
     const output = await parser.parse();
-    await m.validate({ input, output });
+    await (0, validate_1.validate)({ input, output });
     return output;
 }
 exports.parse = parse;
-var flags_1 = require("./flags");
-Object.defineProperty(exports, "boolean", { enumerable: true, get: function () { return flags_1.boolean; } });
-Object.defineProperty(exports, "integer", { enumerable: true, get: function () { return flags_1.integer; } });
-Object.defineProperty(exports, "url", { enumerable: true, get: function () { return flags_1.url; } });
-Object.defineProperty(exports, "directory", { enumerable: true, get: function () { return flags_1.directory; } });
-Object.defineProperty(exports, "file", { enumerable: true, get: function () { return flags_1.file; } });
-Object.defineProperty(exports, "string", { enumerable: true, get: function () { return flags_1.string; } });
-Object.defineProperty(exports, "build", { enumerable: true, get: function () { return flags_1.build; } });
-Object.defineProperty(exports, "option", { enumerable: true, get: function () { return flags_1.option; } });
-Object.defineProperty(exports, "custom", { enumerable: true, get: function () { return flags_1.custom; } });

package/lib/parser/parse.d.ts

@@ -1,5 +1,5 @@
-import { ParserInput, OutputFlags, ParsingToken, OutputArgs } from '../interfaces';
-export declare class Parser<T extends ParserInput, TFlags extends OutputFlags<T['flags']>, TArgs extends OutputArgs> {
+import { OutputArgs, OutputFlags, ParserInput, ParserOutput } from '../interfaces/parser';
+export declare class Parser<T extends ParserInput, TFlags extends OutputFlags<T['flags']>, BFlags extends OutputFlags<T['flags']>, TArgs extends OutputArgs<T['args']>> {
     private readonly input;
     private readonly argv;
     private readonly raw;
@@ -9,17 +9,10 @@ export declare class Parser<T extends ParserInput, TFlags extends OutputFlags<T[
     private readonly metaData;
     private currentFlag?;
     constructor(input: T);
-    parse(): Promise<{
-        args: TArgs;
-        argv: any[];
-        flags: TFlags;
-        raw: ParsingToken[];
-        metadata: any;
-    }>;
-    private _args;
+    parse(): Promise<ParserOutput<TFlags, BFlags, TArgs>>;
     private _flags;
     private _validateOptions;
-    private _argv;
+    private _args;
     private _debugOutput;
     private _debugInput;
     private get _argTokens();

package/lib/parser/parse.js

@@ -1,14 +1,10 @@
 "use strict";
-// tslint:disable interface-over-type-literal
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Parser = void 0;
-const deps_1 = require("./deps");
-// eslint-disable-next-line new-cap
-const m = (0, deps_1.default)()
-    // eslint-disable-next-line node/no-missing-require
-    .add('errors', () => require('./errors'))
-    // eslint-disable-next-line node/no-missing-require
-    .add('util', () => require('./util'));
+/* eslint-disable no-await-in-loop */
+const errors_1 = require("./errors");
+const readline = require("readline");
+const util_1 = require("../util");
 let debug;
 try {
     // eslint-disable-next-line no-negated-condition
@@ -18,26 +14,49 @@ catch {
     debug = () => { };
 }
 const readStdin = async () => {
-    const { stdin } = process;
-    let result;
-    if (stdin.isTTY || stdin.isTTY === undefined)
-        return result;
-    result = '';
-    stdin.setEncoding('utf8');
-    for await (const chunk of stdin) {
-        result += chunk;
-    }
-    return result;
+    const { stdin, stdout } = process;
+    debug('stdin.isTTY', stdin.isTTY);
+    if (stdin.isTTY)
+        return null;
+    // process.stdin.isTTY is true whenever it's running in a terminal.
+    // process.stdin.isTTY is undefined when it's running in a pipe, e.g. echo 'foo' | my-cli command
+    // process.stdin.isTTY is undefined when it's running in a spawned process, even if there's no pipe.
+    // This means that reading from stdin could hang indefinitely while waiting for a non-existent pipe.
+    // Because of this, we have to set a timeout to prevent the process from hanging.
+    return new Promise(resolve => {
+        let result = '';
+        const ac = new AbortController();
+        const signal = ac.signal;
+        const timeout = setTimeout(() => ac.abort(), 100);
+        const rl = readline.createInterface({
+            input: stdin,
+            output: stdout,
+            terminal: false,
+        });
+        rl.on('line', line => {
+            result += line;
+        });
+        rl.once('close', () => {
+            clearTimeout(timeout);
+            debug('resolved from stdin', result);
+            resolve(result);
+        });
+        signal.addEventListener('abort', () => {
+            debug('stdin aborted');
+            clearTimeout(timeout);
+            rl.close();
+            resolve(null);
+        }, { once: true });
+    });
 };
 class Parser {
     constructor(input) {
         this.input = input;
         this.raw = [];
-        const { pickBy } = m.util;
         this.context = input.context || {};
         this.argv = [...input.argv];
         this._setNames();
-        this.booleanFlags = pickBy(input.flags, f => f.type === 'boolean');
+        this.booleanFlags = (0, util_1.pickBy)(input.flags, f => f.type === 'boolean');
         this.flagAliases = Object.fromEntries(Object.values(input.flags).flatMap(flag => {
             return (flag.aliases ?? []).map(a => [a, flag]);
         }));
@@ -86,7 +105,7 @@ class Parser {
                 this.currentFlag = flag;
                 const input = long || arg.length < 3 ? this.argv.shift() : arg.slice(arg[2] === '=' ? 3 : 2);
                 if (typeof input !== 'string') {
-                    throw new m.errors.CLIError(`Flag --${name} expects a value`);
+                    throw new errors_1.CLIError(`Flag --${name} expects a value`);
                 }
                 this.raw.push({ type: 'flag', flag: flag.name, input });
             }
@@ -100,6 +119,9 @@ class Parser {
             return true;
         };
         let parsingFlags = true;
+        const nonExistentFlags = [];
+        let dashdash = false;
+        const originalArgv = [...this.argv];
         while (this.argv.length > 0) {
             const input = this.argv.shift();
             if (parsingFlags && input.startsWith('-') && input !== '-') {
@@ -111,45 +133,48 @@ class Parser {
                 if (parseFlag(input)) {
                     continue;
                 }
-                // not actually a flag if it reaches here so parse as an arg
+                if (input === '--') {
+                    dashdash = true;
+                    continue;
+                }
+                if (this.input['--'] !== false) {
+                    // At this point we have a value that begins with '-' or '--'
+                    // but doesn't match up to a flag definition. So we assume that
+                    // this is a misspelled flag or a non-existent flag,
+                    // e.g. --hekp instead of --help
+                    nonExistentFlags.push(input);
+                    continue;
+                }
             }
             if (parsingFlags && this.currentFlag && this.currentFlag.multiple) {
                 this.raw.push({ type: 'flag', flag: this.currentFlag.name, input });
                 continue;
             }
             // not a flag, parse as arg
-            const arg = this.input.args[this._argTokens.length];
-            if (arg)
-                arg.input = input;
-            this.raw.push({ type: 'arg', input });
+            const arg = Object.keys(this.input.args)[this._argTokens.length];
+            this.raw.push({ type: 'arg', arg, input });
         }
-        const argv = await this._argv();
-        const args = this._args(argv);
+        const { argv, args } = await this._args();
         const flags = await this._flags();
         this._debugOutput(argv, args, flags);
+        const unsortedArgv = (dashdash ? [...argv, ...nonExistentFlags, '--'] : [...argv, ...nonExistentFlags]);
         return {
-            args,
-            argv,
+            argv: unsortedArgv.sort((a, b) => originalArgv.indexOf(a) - originalArgv.indexOf(b)),
             flags,
+            args: args,
             raw: this.raw,
             metadata: this.metaData,
+            nonExistentFlags,
         };
     }
-    _args(argv) {
-        const args = {};
-        for (let i = 0; i < this.input.args.length; i++) {
-            const arg = this.input.args[i];
-            args[arg.name] = argv[i];
-        }
-        return args;
-    }
+    // eslint-disable-next-line complexity
     async _flags() {
         const flags = {};
         this.metaData.flags = {};
         for (const token of this._flagTokens) {
             const flag = this.input.flags[token.flag];
             if (!flag)
-                throw new m.errors.CLIError(`Unexpected flag ${token.flag}`);
+                throw new errors_1.CLIError(`Unexpected flag ${token.flag}`);
             if (flag.type === 'boolean') {
                 if (token.input === `--no-${flag.name}`) {
                     flags[token.flag] = false;
@@ -157,20 +182,25 @@ class Parser {
                 else {
                     flags[token.flag] = true;
                 }
-                // eslint-disable-next-line no-await-in-loop
                 flags[token.flag] = await flag.parse(flags[token.flag], this.context, flag);
             }
             else {
                 const input = token.input;
                 this._validateOptions(flag, input);
-                // eslint-disable-next-line no-await-in-loop
-                const value = flag.parse ? await flag.parse(input, this.context, flag) : input;
-                if (flag.multiple) {
+                if (flag.delimiter && flag.multiple) {
+                    const values = await Promise.all(input.split(flag.delimiter).map(async (v) => flag.parse ? flag.parse(v.trim(), this.context, flag) : v.trim()));
                     flags[token.flag] = flags[token.flag] || [];
-                    flags[token.flag].push(...(Array.isArray(value) ? value : [value]));
+                    flags[token.flag].push(...values);
                 }
                 else {
-                    flags[token.flag] = value;
+                    const value = flag.parse ? await flag.parse(input, this.context, flag) : input;
+                    if (flag.multiple) {
+                        flags[token.flag] = flags[token.flag] || [];
+                        flags[token.flag].push(value);
+                    }
+                    else {
+                        flags[token.flag] = value;
+                    }
                 }
             }
         }
@@ -183,18 +213,16 @@ class Parser {
                 if (flag.type === 'option') {
                     if (input) {
                         this._validateOptions(flag, input);
-                        // eslint-disable-next-line no-await-in-loop
                         flags[k] = await flag.parse(input, this.context, flag);
                     }
                 }
                 else if (flag.type === 'boolean') {
                     // eslint-disable-next-line no-negated-condition
-                    flags[k] = input !== undefined ? ['true', 'TRUE', '1', 'yes', 'YES', 'y', 'Y'].includes(input) : false;
+                    flags[k] = input !== undefined ? (0, util_1.isTruthy)(input) : false;
                 }
             }
             if (!(k in flags) && flag.default !== undefined) {
                 this.metaData.flags[k] = { setFromDefault: true };
-                // eslint-disable-next-line no-await-in-loop
                 const defaultValue = (typeof flag.default === 'function' ? await flag.default({ options: flag, flags, ...this.context }) : flag.default);
                 flags[k] = defaultValue;
             }
@@ -203,48 +231,51 @@ class Parser {
     }
     _validateOptions(flag, input) {
         if (flag.options && !flag.options.includes(input))
-            throw new m.errors.FlagInvalidOptionError(flag, input);
+            throw new errors_1.FlagInvalidOptionError(flag, input);
     }
-    async _argv() {
-        const args = [];
+    async _args() {
+        const argv = [];
+        const args = {};
         const tokens = this._argTokens;
         let stdinRead = false;
-        for (let i = 0; i < Math.max(this.input.args.length, tokens.length); i++) {
-            const token = tokens[i];
-            const arg = this.input.args[i];
+        for (const [name, arg] of Object.entries(this.input.args)) {
+            const token = tokens.find(t => t.arg === name);
             if (token) {
-                if (arg) {
-                    if (arg.options && !arg.options.includes(token.input)) {
-                        throw new m.errors.ArgInvalidOptionError(arg, token.input);
-                    }
-                    // eslint-disable-next-line no-await-in-loop
-                    args[i] = await arg.parse(token.input);
-                }
-                else {
-                    args[i] = token.input;
+                if (arg.options && !arg.options.includes(token.input)) {
+                    throw new errors_1.ArgInvalidOptionError(arg, token.input);
                 }
+                const parsed = await arg.parse(token.input, this.context, arg);
+                argv.push(parsed);
+                args[token.arg] = parsed;
             }
             else if (!arg.ignoreStdin && !stdinRead) {
-                // eslint-disable-next-line no-await-in-loop
                 let stdin = await readStdin();
                 if (stdin) {
                     stdin = stdin.trim();
-                    args[i] = stdin;
+                    const parsed = await arg.parse(stdin, this.context, arg);
+                    argv.push(parsed);
+                    args[name] = parsed;
                 }
                 stdinRead = true;
             }
-            if (!args[i] && arg?.default !== undefined) {
+            if (!args[name] && (arg.default || arg.default === false)) {
                 if (typeof arg.default === 'function') {
-                    // eslint-disable-next-line no-await-in-loop
                     const f = await arg.default();
-                    args[i] = f;
+                    argv.push(f);
+                    args[name] = f;
                 }
                 else {
-                    args[i] = arg.default;
+                    argv.push(arg.default);
+                    args[name] = arg.default;
                 }
             }
         }
-        return args;
+        for (const token of tokens) {
+            if (args[token.arg])
+                continue;
+            argv.push(token.input);
+        }
+        return { argv, args: args };
     }
     _debugOutput(args, flags, argv) {
         if (argv.length > 0) {
@@ -259,8 +290,9 @@ class Parser {
     }
     _debugInput() {
         debug('input: %s', this.argv.join(' '));
-        if (this.input.args.length > 0) {
-            debug('available args: %s', this.input.args.map(a => a.name).join(' '));
+        const args = Object.keys(this.input.args);
+        if (args.length > 0) {
+            debug('available args: %s', args.join(' '));
         }
         if (Object.keys(this.input.flags).length === 0)
             return;
@@ -278,6 +310,9 @@ class Parser {
         for (const k of Object.keys(this.input.flags)) {
             this.input.flags[k].name = k;
         }
+        for (const k of Object.keys(this.input.args)) {
+            this.input.args[k].name = k;
+        }
     }
 }
 exports.Parser = Parser;

package/lib/parser/validate.d.ts

@@ -1,4 +1,4 @@
-import { ParserInput, ParserOutput } from '../interfaces';
+import { ParserInput, ParserOutput } from '../interfaces/parser';
 export declare function validate(parse: {
     input: ParserInput;
     output: ParserOutput;

package/lib/parser/validate.js

@@ -5,14 +5,17 @@ const errors_1 = require("./errors");
 const util_1 = require("../config/util");
 async function validate(parse) {
     function validateArgs() {
-        const maxArgs = parse.input.args.length;
+        if (parse.output.nonExistentFlags?.length > 0) {
+            throw new errors_1.NonExistentFlagsError({ parse, flags: parse.output.nonExistentFlags });
+        }
+        const maxArgs = Object.keys(parse.input.args).length;
         if (parse.input.strict && parse.output.argv.length > maxArgs) {
             const extras = parse.output.argv.slice(maxArgs);
             throw new errors_1.UnexpectedArgsError({ parse, args: extras });
         }
         const missingRequiredArgs = [];
         let hasOptional = false;
-        for (const [index, arg] of parse.input.args.entries()) {
+        for (const [name, arg] of Object.entries(parse.input.args)) {
             if (!arg.required) {
                 hasOptional = true;
             }
@@ -21,7 +24,7 @@ async function validate(parse) {
                 // optionals should follow required, not before
                 throw new errors_1.InvalidArgsSpecError({ parse, args: parse.input.args });
             }
-            if (arg.required && !parse.output.argv[index] && parse.output.argv[index] !== 0) {
+            if (arg.required && !parse.output.args[name] && parse.output.args[name] !== 0) {
                 missingRequiredArgs.push(arg);
             }
         }

package/lib/util.d.ts

@@ -1,3 +1,8 @@
+import { Command } from './command';
+import { ArgInput } from './interfaces/parser';
+export declare function pickBy<T extends {
+    [s: string]: T[keyof T];
+} | ArrayLike<T[keyof T]>>(obj: T, fn: (i: T[keyof T]) => boolean): Partial<T>;
 export declare function compact<T>(a: (T | undefined)[]): T[];
 export declare function uniqBy<T>(arr: T[], fn: (cur: T) => any): T[];
 type SortTypes = string | number | undefined | boolean;
@@ -7,4 +12,19 @@ export declare function isProd(): boolean;
 export declare function maxBy<T>(arr: T[], fn: (i: T) => number): T | undefined;
 export declare function sumBy<T>(arr: T[], fn: (i: T) => number): number;
 export declare function capitalize(s: string): string;
+export declare const dirExists: (input: string) => Promise<string>;
+export declare const fileExists: (input: string) => Promise<string>;
+export declare function isTruthy(input: string): boolean;
+export declare function isNotFalsy(input: string): boolean;
+export declare function requireJson<T>(...pathParts: string[]): T;
+/**
+ * Ensure that the provided args are an object. This is for backwards compatibility with v1 commands which
+ * defined args as an array.
+ *
+ * @param args Either an array of args or an object of args
+ * @returns ArgInput
+ */
+export declare function ensureArgObject(args?: any[] | ArgInput | {
+    [name: string]: Command.Arg.Cached;
+}): ArgInput;
 export {};

package/lib/util.js

@@ -1,6 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.capitalize = exports.sumBy = exports.maxBy = exports.isProd = exports.castArray = exports.sortBy = exports.uniqBy = exports.compact = void 0;
+exports.ensureArgObject = exports.requireJson = exports.isNotFalsy = exports.isTruthy = exports.fileExists = exports.dirExists = exports.capitalize = exports.sumBy = exports.maxBy = exports.isProd = exports.castArray = exports.sortBy = exports.uniqBy = exports.compact = exports.pickBy = void 0;
+const fs = require("fs");
+const path_1 = require("path");
+function pickBy(obj, fn) {
+    return Object.entries(obj)
+        .reduce((o, [k, v]) => {
+        if (fn(v))
+            o[k] = v;
+        return o;
+    }, {});
+}
+exports.pickBy = pickBy;
 function compact(a) {
     return a.filter((a) => Boolean(a));
 }
@@ -62,3 +73,48 @@ function capitalize(s) {
     return s ? s.charAt(0).toUpperCase() + s.slice(1).toLowerCase() : '';
 }
 exports.capitalize = capitalize;
+const dirExists = async (input) => {
+    if (!fs.existsSync(input)) {
+        throw new Error(`No directory found at ${input}`);
+    }
+    if (!(await fs.promises.stat(input)).isDirectory()) {
+        throw new Error(`${input} exists but is not a directory`);
+    }
+    return input;
+};
+exports.dirExists = dirExists;
+const fileExists = async (input) => {
+    if (!fs.existsSync(input)) {
+        throw new Error(`No file found at ${input}`);
+    }
+    if (!(await fs.promises.stat(input)).isFile()) {
+        throw new Error(`${input} exists but is not a file`);
+    }
+    return input;
+};
+exports.fileExists = fileExists;
+function isTruthy(input) {
+    return ['true', '1', 'yes', 'y'].includes(input.toLowerCase());
+}
+exports.isTruthy = isTruthy;
+function isNotFalsy(input) {
+    return !['false', '0', 'no', 'n'].includes(input.toLowerCase());
+}
+exports.isNotFalsy = isNotFalsy;
+function requireJson(...pathParts) {
+    return JSON.parse(fs.readFileSync((0, path_1.join)(...pathParts), 'utf8'));
+}
+exports.requireJson = requireJson;
+/**
+ * Ensure that the provided args are an object. This is for backwards compatibility with v1 commands which
+ * defined args as an array.
+ *
+ * @param args Either an array of args or an object of args
+ * @returns ArgInput
+ */
+function ensureArgObject(args) {
+    return (Array.isArray(args) ? (args ?? []).reduce((x, y) => {
+        return { ...x, [y.name]: y };
+    }, {}) : args ?? {});
+}
+exports.ensureArgObject = ensureArgObject;

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "@oclif/core",
   "description": "base library for oclif CLIs",
-  "version": "2.0.1",
+  "version": "2.0.2-beta.10",
   "author": "Salesforce",
   "bugs": "https://github.com/oclif/core/issues",
   "dependencies": {
-    "@oclif/linewrap": "^1.0.0",
-    "@oclif/screen": "^3.0.4",
+    "@types/cli-progress": "^3.11.0",
     "ansi-escapes": "^4.3.2",
     "ansi-styles": "^4.3.0",
     "cardinal": "^2.1.1",
@@ -32,31 +31,32 @@
     "supports-hyperlinks": "^2.2.0",
     "tslib": "^2.4.1",
     "widest-line": "^3.1.0",
+    "wordwrap": "^1.0.0",
     "wrap-ansi": "^7.0.0"
   },
   "devDependencies": {
     "@commitlint/config-conventional": "^12.1.4",
     "@oclif/plugin-help": "^5.1.22",
     "@oclif/plugin-plugins": "^2.1.12",
-    "@oclif/test": "^2.2.19",
+    "@oclif/test": "^2.2.20",
     "@types/ansi-styles": "^3.2.1",
     "@types/chai": "^4.3.4",
     "@types/chai-as-promised": "^7.1.5",
     "@types/clean-stack": "^2.1.1",
-    "@types/cli-progress": "^3.9.2",
     "@types/ejs": "^3.1.0",
     "@types/fs-extra": "^9.0.13",
     "@types/indent-string": "^4.0.1",
     "@types/js-yaml": "^3.12.7",
     "@types/mocha": "^8.2.3",
     "@types/nock": "^11.1.0",
-    "@types/node": "^15.14.9",
+    "@types/node": "^16",
     "@types/node-notifier": "^8.0.2",
     "@types/proxyquire": "^1.3.28",
     "@types/semver": "^7.3.13",
     "@types/shelljs": "^0.8.11",
     "@types/strip-ansi": "^5.2.1",
     "@types/supports-color": "^8.1.1",
+    "@types/wordwrap": "^1.0.1",
     "@types/wrap-ansi": "^3.0.0",
     "chai": "^4.3.7",
     "chai-as-promised": "^7.1.1",
@@ -64,11 +64,11 @@
     "eslint": "^7.32.0",
     "eslint-config-oclif": "^4.0.0",
     "eslint-config-oclif-typescript": "^1.0.2",
-    "fancy-test": "^1.4.10",
+    "fancy-test": "^2.0.12",
     "globby": "^11.1.0",
     "husky": "6",
     "mocha": "^8.4.0",
-    "nock": "^13.2.4",
+    "nock": "^13.3.0",
     "proxyquire": "^2.1.3",
     "shelljs": "^0.8.5",
     "shx": "^0.3.4",

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

@@ -1,22 +0,0 @@
-declare const _default: {
-    readonly stripAnsi: (string: string) => string;
-    readonly ansiStyles: {
-        readonly modifier: import("ansi-styles").Modifier;
-        readonly color: import("ansi-styles").ForegroundColor & import("ansi-styles").ColorBase;
-        readonly bgColor: import("ansi-styles").BackgroundColor & import("ansi-styles").ColorBase;
-        readonly codes: ReadonlyMap<number, number>;
-    } & import("ansi-styles").BackgroundColor & import("ansi-styles").ForegroundColor & import("ansi-styles").Modifier;
-    readonly ansiEscapes: any;
-    readonly passwordPrompt: any;
-    readonly screen: typeof import("@oclif/screen");
-    readonly open: typeof import("./open").default;
-    readonly prompt: typeof import("./prompt");
-    readonly styledObject: typeof import("./styled/object").default;
-    readonly styledHeader: typeof import("./styled/header").default;
-    readonly styledJSON: typeof import("./styled/json").default;
-    readonly table: typeof import("./styled/table").table;
-    readonly tree: typeof import("./styled/tree").default;
-    readonly wait: (ms?: number) => Promise<unknown>;
-    readonly progress: typeof import("./styled/progress").default;
-};
-export default _default;

package/lib/cli-ux/deps.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable node/no-missing-require */
-exports.default = {
-    get stripAnsi() {
-        return require('strip-ansi');
-    },
-    get ansiStyles() {
-        return require('ansi-styles');
-    },
-    get ansiEscapes() {
-        return require('ansi-escapes');
-    },
-    get passwordPrompt() {
-        return require('password-prompt');
-    },
-    get screen() {
-        return require('@oclif/screen');
-    },
-    get open() {
-        return require('./open').default;
-    },
-    get prompt() {
-        return require('./prompt');
-    },
-    get styledObject() {
-        return require('./styled/object').default;
-    },
-    get styledHeader() {
-        return require('./styled/header').default;
-    },
-    get styledJSON() {
-        return require('./styled/json').default;
-    },
-    get table() {
-        return require('./styled/table').table;
-    },
-    get tree() {
-        return require('./styled/tree').default;
-    },
-    get wait() {
-        return require('./wait').default;
-    },
-    get progress() {
-        return require('./styled/progress').default;
-    },
-};