@oclif/core 2.0.1 → 2.0.2-beta.1

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,50 @@ 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);
+        });
+        // @ts-expect-error because the AbortSignal interface is missing addEventListener
+        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 +106,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 +120,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 +134,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 +183,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 +214,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 +232,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 +291,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 +311,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,6 @@
+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 +10,9 @@ 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;
 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.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,35 @@ 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', 'TRUE', '1', 'yes', 'YES', 'y', 'Y'].includes(input);
+}
+exports.isTruthy = isTruthy;
+function isNotFalsy(input) {
+    return !['false', 'FALSE', '0', 'no', 'NO', 'n', 'N'].includes(input);
+}
+exports.isNotFalsy = isNotFalsy;
+function requireJson(...pathParts) {
+    return JSON.parse(fs.readFileSync((0, path_1.join)(...pathParts), 'utf8'));
+}
+exports.requireJson = requireJson;

package/package.json

@@ -1,12 +1,10 @@
 {
   "name": "@oclif/core",
   "description": "base library for oclif CLIs",
-  "version": "2.0.1",
+  "version": "2.0.2-beta.1",
   "author": "Salesforce",
   "bugs": "https://github.com/oclif/core/issues",
   "dependencies": {
-    "@oclif/linewrap": "^1.0.0",
-    "@oclif/screen": "^3.0.4",
     "ansi-escapes": "^4.3.2",
     "ansi-styles": "^4.3.0",
     "cardinal": "^2.1.1",
@@ -32,6 +30,7 @@
     "supports-hyperlinks": "^2.2.0",
     "tslib": "^2.4.1",
     "widest-line": "^3.1.0",
+    "wordwrap": "^1.0.0",
     "wrap-ansi": "^7.0.0"
   },
   "devDependencies": {
@@ -57,6 +56,7 @@
     "@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",
@@ -109,7 +109,7 @@
     "lint": "eslint . --ext .ts --config .eslintrc",
     "posttest": "yarn lint",
     "prepack": "yarn run build",
-    "test": "mocha --forbid-only \"test/**/*.test.ts\"",
+    "test": "mocha \"test/**/*.test.ts\"",
     "test:e2e": "mocha \"test/**/*.e2e.ts\" --timeout 1200000",
     "pretest": "yarn build --noEmit && tsc -p test --noEmit --skipLibCheck"
   },

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;
-    },
-};

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

@@ -1,6 +0,0 @@
-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

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// this code is largely taken from opn
-const childProcess = require("child_process");
-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 (Number.isInteger(code) && code > 0) {
-                reject(new Error('Exited with code ' + code));
-                return;
-            }
-            resolve(cp);
-        });
-    });
-}
-exports.default = open;

package/lib/help/_test-help-class.d.ts

@@ -1,6 +0,0 @@
-import { HelpBase } from '.';
-export default class extends HelpBase {
-    showHelp(): Promise<void>;
-    showCommandHelp(): Promise<void>;
-    getCommandHelpForReadme(): string;
-}

package/lib/help/_test-help-class.js

@@ -1,19 +0,0 @@
-"use strict";
-// `loadHelpClass` tests require an oclif project for testing so
-// it is re-using the setup here to be able to do a lookup for
-// this sample help class file in tests, although it is not needed
-// for ../help itself.
-Object.defineProperty(exports, "__esModule", { value: true });
-const _1 = require(".");
-class default_1 extends _1.HelpBase {
-    async showHelp() {
-        console.log('help');
-    }
-    async showCommandHelp() {
-        console.log('command help');
-    }
-    getCommandHelpForReadme() {
-        return 'help for readme';
-    }
-}
-exports.default = default_1;