@oclif/core 3.0.2 → 3.0.4

package/lib/command.d.ts

@@ -117,13 +117,28 @@ export declare abstract class Command {
     abstract run(): Promise<any>;
 }
 export declare namespace Command {
+    /**
+     * The Command class exported by a command file.
+     */
     type Class = typeof Command & {
         id: string;
         run(argv?: string[], config?: LoadOptions): Promise<any>;
     };
-    interface Loadable extends Cached {
+    /**
+     * A cached command that's had a `load` method attached to it.
+     *
+     * The `Plugin` class loads the commands from the manifest (if it exists) or requires and caches
+     * the commands directly from the commands directory inside the plugin. At this point the plugin
+     * is working with `Command.Cached`. It then appends a `load` method to each one. If the a command
+     * is executed then the `load` method is used to require the command class.
+     */
+    type Loadable = Cached & {
         load(): Promise<Command.Class>;
-    }
+    };
+    /**
+     * A cached version of the command. This is created by the cachedCommand utility and
+     * stored in the oclif.manifest.json.
+     */
     type Cached = {
         [key: string]: unknown;
         aliasPermutations?: string[];
@@ -131,6 +146,7 @@ export declare namespace Command {
         args: {
             [name: string]: Arg.Cached;
         };
+        deprecateAliases?: boolean;
         deprecationOptions?: Deprecation;
         description?: string;
         examples?: Example[];

package/lib/execute.d.ts

@@ -8,19 +8,23 @@ import { LoadOptions } from './interfaces';
  * @example For ESM dev.js
  * ```
  * #!/usr/bin/env ts-node
- * void (async () => {
+ * async function main() {
  *   const oclif = await import('@oclif/core')
  *   await oclif.execute({development: true, dir: import.meta.url})
- * })()
+ * }
+ *
+ * await main()
  * ```
  *
  * @example For ESM run.js
  * ```
  * #!/usr/bin/env node
- * void (async () => {
+ * async function main() {
  *   const oclif = await import('@oclif/core')
  *   await oclif.execute({dir: import.meta.url})
- * })()
+ * }
+ *
+ * await main()
  * ```
  *
  * @example For CJS dev.js

package/lib/execute.js

@@ -14,19 +14,23 @@ const settings_1 = require("./settings");
  * @example For ESM dev.js
  * ```
  * #!/usr/bin/env ts-node
- * void (async () => {
+ * async function main() {
  *   const oclif = await import('@oclif/core')
  *   await oclif.execute({development: true, dir: import.meta.url})
- * })()
+ * }
+ *
+ * await main()
  * ```
  *
  * @example For ESM run.js
  * ```
  * #!/usr/bin/env node
- * void (async () => {
+ * async function main() {
  *   const oclif = await import('@oclif/core')
  *   await oclif.execute({dir: import.meta.url})
- * })()
+ * }
+ *
+ * await main()
  * ```
  *
  * @example For CJS dev.js

package/lib/flags.d.ts

@@ -76,31 +76,31 @@ export declare const string: FlagDefinition<string, CustomOptions, {
 }>;
 export declare const version: (opts?: Partial<BooleanFlag<boolean>>) => BooleanFlag<void>;
 export declare const help: (opts?: Partial<BooleanFlag<boolean>>) => BooleanFlag<void>;
-type ElementType<T extends ReadonlyArray<unknown>> = T[number];
-export declare function option<T extends readonly string[], P extends CustomOptions>(defaults: Partial<OptionFlag<ElementType<T>[], P>> & {
+type ReadonlyElementOf<T extends ReadonlyArray<unknown>> = T[number];
+export declare function option<T extends readonly string[], P extends CustomOptions>(defaults: Partial<OptionFlag<ReadonlyElementOf<T>[], P>> & {
     multiple: true;
     options: T;
 } & ({
-    default: OptionFlag<ElementType<T>[], P>['default'] | undefined;
+    default: OptionFlag<ReadonlyElementOf<T>[], P>['default'] | undefined;
 } | {
     required: true;
 })): FlagDefinition<(typeof defaults.options)[number], P, {
     multiple: true;
     requiredOrDefaulted: true;
 }>;
-export declare function option<T extends readonly string[], P extends CustomOptions>(defaults: Partial<OptionFlag<ElementType<T>, P>> & {
+export declare function option<T extends readonly string[], P extends CustomOptions>(defaults: Partial<OptionFlag<ReadonlyElementOf<T>, P>> & {
     multiple?: false | undefined;
     options: T;
 } & ({
-    default: OptionFlag<ElementType<T>, P>['default'];
+    default: OptionFlag<ReadonlyElementOf<T>, P>['default'];
 } | {
     required: true;
 })): FlagDefinition<(typeof defaults.options)[number], P, {
     multiple: false;
     requiredOrDefaulted: true;
 }>;
-export declare function option<T extends readonly string[], P extends CustomOptions>(defaults: Partial<OptionFlag<ElementType<T>, P>> & {
-    default?: OptionFlag<ElementType<T>, P>['default'] | undefined;
+export declare function option<T extends readonly string[], P extends CustomOptions>(defaults: Partial<OptionFlag<ReadonlyElementOf<T>, P>> & {
+    default?: OptionFlag<ReadonlyElementOf<T>, P>['default'] | undefined;
     multiple?: false | undefined;
     options: T;
     required?: false | undefined;
@@ -108,8 +108,8 @@ export declare function option<T extends readonly string[], P extends CustomOpti
     multiple: false;
     requiredOrDefaulted: false;
 }>;
-export declare function option<T extends readonly string[], P extends CustomOptions>(defaults: Partial<OptionFlag<ElementType<T>[], P>> & {
-    default?: OptionFlag<ElementType<T>[], P>['default'] | undefined;
+export declare function option<T extends readonly string[], P extends CustomOptions>(defaults: Partial<OptionFlag<ReadonlyElementOf<T>[], P>> & {
+    default?: OptionFlag<ReadonlyElementOf<T>[], P>['default'] | undefined;
     multiple: true;
     options: T;
     required?: false | undefined;

package/lib/help/command.d.ts

@@ -2,10 +2,10 @@ import { Command } from '../command';
 import * as Interfaces from '../interfaces';
 import { HelpFormatter, HelpSectionRenderer } from './formatter';
 export declare class CommandHelp extends HelpFormatter {
-    command: Command.Cached | Command.Class | Command.Loadable;
+    command: Command.Loadable;
     config: Interfaces.Config;
     opts: Interfaces.HelpOptions;
-    constructor(command: Command.Cached | Command.Class | Command.Loadable, config: Interfaces.Config, opts: Interfaces.HelpOptions);
+    constructor(command: Command.Loadable, config: Interfaces.Config, opts: Interfaces.HelpOptions);
     private formatIfCommand;
     private isCommand;
     protected aliases(aliases: string[] | undefined): string | undefined;

package/lib/help/formatter.d.ts

@@ -10,7 +10,7 @@ export type HelpSection = {
 } | undefined;
 export type HelpSectionRenderer = (data: {
     args: Command.Arg.Any[];
-    cmd: Command.Cached | Command.Class | Command.Loadable;
+    cmd: Command.Loadable;
     flags: Command.Flag.Any[];
 }, header: string) => HelpSection | HelpSection[] | string | undefined;
 export declare class HelpFormatter {

package/lib/help/index.d.ts

@@ -11,7 +11,7 @@ export declare abstract class HelpBase extends HelpFormatter {
      * @param command
      * @param topics
      */
-    abstract showCommandHelp(command: Command.Class, topics: Interfaces.Topic[]): Promise<void>;
+    abstract showCommandHelp(command: Command.Loadable, topics: Interfaces.Topic[]): Promise<void>;
     /**
      * Show help, used in multi-command CLIs
      * @param args passed into your command, useful for determining which type of help to display
@@ -22,20 +22,20 @@ export declare class Help extends HelpBase {
     protected CommandHelpClass: typeof CommandHelp;
     constructor(config: Interfaces.Config, opts?: Partial<Interfaces.HelpOptions>);
     private get _topics();
-    protected command(command: Command.Class): string;
-    protected description(c: Command.Cached | Command.Class | Command.Loadable): string;
-    protected formatCommand(command: Command.Cached | Command.Class | Command.Loadable): string;
-    protected formatCommands(commands: Array<Command.Cached | Command.Class | Command.Loadable>): string;
+    protected command(command: Command.Loadable): string;
+    protected description(c: Command.Loadable): string;
+    protected formatCommand(command: Command.Loadable): string;
+    protected formatCommands(commands: Array<Command.Loadable>): string;
     protected formatRoot(): string;
     protected formatTopic(topic: Interfaces.Topic): string;
     protected formatTopics(topics: Interfaces.Topic[]): string;
-    protected getCommandHelpClass(command: Command.Cached | Command.Class | Command.Loadable): CommandHelp;
+    protected getCommandHelpClass(command: Command.Loadable): CommandHelp;
     protected log(...args: string[]): void;
-    showCommandHelp(command: Command.Cached | Command.Class | Command.Loadable): Promise<void>;
+    showCommandHelp(command: Command.Loadable): Promise<void>;
     showHelp(argv: string[]): Promise<void>;
     protected showRootHelp(): Promise<void>;
     protected showTopicHelp(topic: Interfaces.Topic): Promise<void>;
-    protected summary(c: Command.Cached | Command.Class | Command.Loadable): string | undefined;
+    protected summary(c: Command.Loadable): string | undefined;
     protected get sortedCommands(): Command.Loadable[];
     protected get sortedTopics(): Interfaces.Topic[];
 }

package/lib/interfaces/parser.d.ts

@@ -210,7 +210,8 @@ export type OptionFlagProps = FlagProps & {
 export type FlagParserContext = Command & {
     token: FlagToken;
 };
-export type FlagParser<T, I extends string | boolean, P = CustomOptions> = (input: I, context: FlagParserContext, opts: P & OptionFlag<T, P>) => T extends Array<infer U> ? Promise<U | undefined> : Promise<T | undefined>;
+type NonNullableElementOf<T> = [NonNullable<T>] extends [Array<infer U>] ? U : T;
+export type FlagParser<T, I extends string | boolean, P = CustomOptions> = (input: I, context: FlagParserContext, opts: P & OptionFlag<T, P>) => Promise<NonNullableElementOf<T> | undefined>;
 export type ArgParserContext = Command & {
     token: ArgToken;
 };

package/lib/interfaces/pjson.d.ts

@@ -40,6 +40,11 @@ export declare namespace PJSON {
                 identifier?: string;
                 sign?: string;
             };
+            windows?: {
+                homepage?: string;
+                keypath?: string;
+                name?: string;
+            };
             plugins?: string[];
             repositoryPrefix?: string;
             schema?: number;
@@ -69,6 +74,7 @@ export declare namespace PJSON {
     interface S3 {
         acl?: string;
         bucket?: string;
+        folder?: string;
         gz?: boolean;
         host?: string;
         templates: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oclif/core",
   "description": "base library for oclif CLIs",
-  "version": "3.0.2",
+  "version": "3.0.4",
   "author": "Salesforce",
   "bugs": "https://github.com/oclif/core/issues",
   "dependencies": {