@oclif/core 3.0.0-beta.9 → 3.0.0

package/lib/command.d.ts

@@ -1,9 +1,9 @@
 import { Config } from './config';
 import { PrettyPrintableError } from './errors';
-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';
+import { ArgInput, ArgOutput, ArgProps, BooleanFlagProps, Deprecation, FlagInput, FlagOutput, Arg as IArg, Flag as IFlag, Input, OptionFlagProps, ParserOutput } from './interfaces/parser';
+import { Plugin } from './interfaces/plugin';
 /**
  * An abstract class which acts as the base for each command
  * in your project.
@@ -11,44 +11,23 @@ import { CommandError } from './interfaces/errors';
 export declare abstract class Command {
     argv: string[];
     config: Config;
-    private static readonly _base;
-    /** A command ID, used mostly in error or verbose reporting. */
-    static id: string;
+    /** An array of aliases for this command. */
+    static aliases: string[];
+    /** An order-dependent object of arguments for the command */
+    static args: ArgInput;
+    static baseFlags: FlagInput;
     /**
-     * The tweet-sized description for your class, used in a parent-commands
-     * sub-command listing and as the header for the command help.
+     * Emit deprecation warning when a command alias is used
      */
-    static summary?: string;
+    static deprecateAliases?: boolean;
+    static deprecationOptions?: Deprecation;
     /**
      * A full description of how to use the command.
      *
      * If no summary, the first line of the description will be used as the summary.
      */
     static description: string | undefined;
-    /** Hide the command from help */
-    static hidden: boolean;
-    /** Mark the command as a given state (e.g. beta or deprecated) in help */
-    static state?: 'beta' | 'deprecated' | string;
-    static deprecationOptions?: Deprecation;
-    /**
-     * Emit deprecation warning when a command alias is used
-     */
-    static deprecateAliases?: boolean;
-    /**
-     * An override string (or strings) for the default usage documentation.
-     */
-    static usage: string | string[] | undefined;
-    static help: string | undefined;
-    /** An array of aliases for this command. */
-    static aliases: string[];
-    /** When set to false, allows a variable amount of arguments */
-    static strict: boolean;
-    /** 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;
+    static enableJsonFlag: boolean;
     /**
      * An array of examples to show at the end of the command's help.
      *
@@ -64,14 +43,35 @@ export declare abstract class Command {
      * ```
      */
     static examples: Command.Example[];
+    /** A hash of flags for the command */
+    static flags: FlagInput;
     static hasDynamicHelp: boolean;
-    protected static '_--': boolean;
-    protected static _enableJsonFlag: boolean;
-    static get enableJsonFlag(): boolean;
-    static set enableJsonFlag(value: boolean);
-    static get '--'(): boolean;
-    static set '--'(value: boolean);
-    get passThroughEnabled(): boolean;
+    static help: string | undefined;
+    /** Hide the command from help */
+    static hidden: boolean;
+    /** A command ID, used mostly in error or verbose reporting. */
+    static id: string;
+    static plugin: Plugin | undefined;
+    static readonly pluginAlias?: string;
+    static readonly pluginName?: string;
+    static readonly pluginType?: string;
+    /** Mark the command as a given state (e.g. beta or deprecated) in help */
+    static state?: 'beta' | 'deprecated' | string;
+    /** When set to false, allows a variable amount of arguments */
+    static strict: boolean;
+    /**
+     * The tweet-sized description for your class, used in a parent-commands
+     * sub-command listing and as the header for the command help.
+     */
+    static summary?: string;
+    /**
+     * An override string (or strings) for the default usage documentation.
+     */
+    static usage: string | string[] | undefined;
+    private static readonly _base;
+    protected debug: (...args: any[]) => void;
+    id: string | undefined;
+    constructor(argv: string[], config: Config);
     /**
      * instantiate and run the command
      *
@@ -81,50 +81,40 @@ export declare abstract class Command {
      * @returns {Promise<unknown>} result
      */
     static run<T extends Command>(this: new (argv: string[], config: Config) => T, argv?: string[], opts?: LoadOptions): Promise<ReturnType<T['run']>>;
-    protected static _baseFlags: FlagInput;
-    static get baseFlags(): FlagInput;
-    static set baseFlags(flags: FlagInput);
-    /** A hash of flags for the command */
-    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);
-    protected get ctor(): typeof Command;
     protected _run<T>(): Promise<T>;
-    exit(code?: number): never;
-    warn(input: string | Error): string | Error;
-    error(input: string | Error, options: {
+    private removeEnvVar;
+    protected catch(err: CommandError): Promise<any>;
+    error(input: Error | string, options: {
         code?: string;
         exit: false;
     } & PrettyPrintableError): void;
-    error(input: string | Error, options?: {
+    error(input: Error | string, options?: {
         code?: string;
         exit?: number;
     } & PrettyPrintableError): never;
-    log(message?: string, ...args: any[]): void;
-    logToStderr(message?: string, ...args: any[]): void;
+    exit(code?: number): never;
+    protected finally(_: Error | undefined): Promise<any>;
+    protected init(): Promise<any>;
     /**
      * Determine if the command is being run with the --json flag in a command that supports it.
      *
      * @returns {boolean} true if the command supports json and the --json flag is present
      */
     jsonEnabled(): boolean;
+    log(message?: string, ...args: any[]): void;
+    protected logJson(json: unknown): void;
+    logToStderr(message?: string, ...args: any[]): void;
+    protected parse<F extends FlagOutput, B extends FlagOutput, A extends ArgOutput>(options?: Input<F, B, A>, argv?: string[]): Promise<ParserOutput<F, B, A>>;
+    protected toErrorJson(err: unknown): any;
+    protected toSuccessJson(result: unknown): any;
+    warn(input: Error | string): Error | string;
+    protected warnIfCommandDeprecated(): void;
+    protected warnIfFlagDeprecated(flags: Record<string, unknown>): void;
+    protected get ctor(): typeof Command;
     /**
      * actual command run code goes here
      */
     abstract run(): Promise<any>;
-    protected init(): Promise<any>;
-    protected warnIfFlagDeprecated(flags: Record<string, unknown>): void;
-    protected warnIfCommandDeprecated(): void;
-    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;
-    protected logJson(json: unknown): void;
-    private removeEnvVar;
 }
 export declare namespace Command {
     type Class = typeof Command & {
@@ -136,42 +126,46 @@ export declare namespace Command {
     }
     type Cached = {
         [key: string]: unknown;
-        id: string;
-        hidden: boolean;
-        state?: 'beta' | 'deprecated' | string;
-        deprecationOptions?: Deprecation;
+        aliasPermutations?: string[];
         aliases: string[];
-        summary?: string;
+        args: {
+            [name: string]: Arg.Cached;
+        };
+        deprecationOptions?: Deprecation;
         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;
+        hidden: boolean;
+        id: string;
+        isESM?: boolean;
         permutations?: string[];
-        aliasPermutations?: string[];
+        pluginAlias?: string;
+        pluginName?: string;
+        pluginType?: string;
+        relativePath?: string[];
+        state?: 'beta' | 'deprecated' | string;
+        strict?: boolean;
+        summary?: string;
+        type?: string;
+        usage?: string | string[];
     };
-    type Flag = CompletableFlag<any>;
+    type Flag = IFlag<any>;
     namespace Flag {
-        type Cached = Omit<Flag, 'parse' | 'input'> & (BooleanFlagProps | OptionFlagProps);
-        type Any = Flag | Cached;
+        type Cached = Omit<Flag, 'input' | 'parse'> & (BooleanFlagProps | OptionFlagProps) & {
+            hasDynamicHelp?: boolean;
+        };
+        type Any = Cached | Flag;
     }
     type Arg = IArg<any>;
     namespace Arg {
-        type Cached = Omit<Arg, 'parse' | 'input'> & ArgProps;
+        type Cached = Omit<Arg, 'input' | 'parse'> & ArgProps;
         type Any = Arg | Cached;
     }
-    type Example = string | {
-        description: string;
+    type Example = {
         command: string;
-    };
+        description: string;
+    } | string;
 }