@oclif/core 3.0.4 → 3.0.5

package/lib/cli-ux/action/base.d.ts

@@ -6,10 +6,21 @@ export interface ITask {
 }
 export type ActionType = 'debug' | 'simple' | 'spinner';
 export declare class ActionBase {
-    private stdmockOrigs;
     std: 'stderr' | 'stdout';
     protected stdmocks?: ['stderr' | 'stdout', string[]][];
     type: ActionType;
+    private stdmockOrigs;
+    protected get output(): string | undefined;
+    protected set output(output: string | undefined);
+    get running(): boolean;
+    get status(): string | undefined;
+    set status(status: string | undefined);
+    get task(): ITask | undefined;
+    set task(task: ITask | undefined);
+    pause(fn: () => any, icon?: string): Promise<any>;
+    pauseAsync<T>(fn: () => Promise<T>, icon?: string): Promise<T>;
+    start(action: string, status?: string, opts?: Options): void;
+    stop(msg?: string): void;
     protected _flushStdout(): void;
     protected _pause(_?: string): void;
     protected _resume(): void;
@@ -19,15 +30,4 @@ export declare class ActionBase {
     protected _updateStatus(_: string | undefined, __?: string): void;
     protected _write(std: 'stderr' | 'stdout', s: string | string[]): void;
     private get globals();
-    pause(fn: () => any, icon?: string): Promise<any>;
-    pauseAsync<T>(fn: () => Promise<T>, icon?: string): Promise<T>;
-    start(action: string, status?: string, opts?: Options): void;
-    stop(msg?: string): void;
-    protected get output(): string | undefined;
-    protected set output(output: string | undefined);
-    get running(): boolean;
-    get status(): string | undefined;
-    set status(status: string | undefined);
-    get task(): ITask | undefined;
-    set task(task: ITask | undefined);
 }

package/lib/cli-ux/action/base.js

@@ -5,13 +5,88 @@ const node_util_1 = require("node:util");
 const util_1 = require("../../util/util");
 const stream_1 = require("../stream");
 class ActionBase {
+    std = 'stderr';
+    stdmocks;
+    type;
     stdmockOrigs = {
         stderr: stream_1.stderr.write,
         stdout: stream_1.stdout.write,
     };
-    std = 'stderr';
-    stdmocks;
-    type;
+    get output() {
+        return this.globals.output;
+    }
+    set output(output) {
+        this.globals.output = output;
+    }
+    get running() {
+        return Boolean(this.task);
+    }
+    get status() {
+        return this.task ? this.task.status : undefined;
+    }
+    set status(status) {
+        const { task } = this;
+        if (!task) {
+            return;
+        }
+        if (task.status === status) {
+            return;
+        }
+        this._updateStatus(status, task.status);
+        task.status = status;
+    }
+    get task() {
+        return this.globals.action.task;
+    }
+    set task(task) {
+        this.globals.action.task = task;
+    }
+    pause(fn, icon) {
+        const { task } = this;
+        const active = task && task.active;
+        if (task && active) {
+            this._pause(icon);
+            this._stdout(false);
+            task.active = false;
+        }
+        const ret = fn();
+        if (task && active) {
+            this._resume();
+        }
+        return ret;
+    }
+    async pauseAsync(fn, icon) {
+        const { task } = this;
+        const active = task && task.active;
+        if (task && active) {
+            this._pause(icon);
+            this._stdout(false);
+            task.active = false;
+        }
+        const ret = await fn();
+        if (task && active) {
+            this._resume();
+        }
+        return ret;
+    }
+    start(action, status, opts = {}) {
+        this.std = opts.stdout ? 'stdout' : 'stderr';
+        const task = { action, active: Boolean(this.task && this.task.active), status };
+        this.task = task;
+        this._start(opts);
+        task.active = true;
+        this._stdout(true);
+    }
+    stop(msg = 'done') {
+        const { task } = this;
+        if (!task) {
+            return;
+        }
+        this._stop(msg);
+        task.active = false;
+        this.task = undefined;
+        this._stdout(false);
+    }
     // flush mocked stdout/stderr
     _flushStdout() {
         try {
@@ -105,80 +180,5 @@ class ActionBase {
         globals.action = globals.action || {};
         return globals;
     }
-    pause(fn, icon) {
-        const { task } = this;
-        const active = task && task.active;
-        if (task && active) {
-            this._pause(icon);
-            this._stdout(false);
-            task.active = false;
-        }
-        const ret = fn();
-        if (task && active) {
-            this._resume();
-        }
-        return ret;
-    }
-    async pauseAsync(fn, icon) {
-        const { task } = this;
-        const active = task && task.active;
-        if (task && active) {
-            this._pause(icon);
-            this._stdout(false);
-            task.active = false;
-        }
-        const ret = await fn();
-        if (task && active) {
-            this._resume();
-        }
-        return ret;
-    }
-    start(action, status, opts = {}) {
-        this.std = opts.stdout ? 'stdout' : 'stderr';
-        const task = { action, active: Boolean(this.task && this.task.active), status };
-        this.task = task;
-        this._start(opts);
-        task.active = true;
-        this._stdout(true);
-    }
-    stop(msg = 'done') {
-        const { task } = this;
-        if (!task) {
-            return;
-        }
-        this._stop(msg);
-        task.active = false;
-        this.task = undefined;
-        this._stdout(false);
-    }
-    get output() {
-        return this.globals.output;
-    }
-    set output(output) {
-        this.globals.output = output;
-    }
-    get running() {
-        return Boolean(this.task);
-    }
-    get status() {
-        return this.task ? this.task.status : undefined;
-    }
-    set status(status) {
-        const { task } = this;
-        if (!task) {
-            return;
-        }
-        if (task.status === status) {
-            return;
-        }
-        this._updateStatus(status, task.status);
-        task.status = status;
-    }
-    get task() {
-        return this.globals.action.task;
-    }
-    set task(task) {
-        this.globals.action.task = task;
-    }
 }
 exports.ActionBase = ActionBase;

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

@@ -4,13 +4,13 @@
 declare class Stream {
     channel: 'stderr' | 'stdout';
     constructor(channel: 'stderr' | 'stdout');
+    get isTTY(): boolean;
     emit(event: string, ...args: any[]): boolean;
     getWindowSize(): number[];
     on(event: string, listener: (...args: any[]) => void): Stream;
     once(event: string, listener: (...args: any[]) => void): Stream;
     read(): boolean;
     write(data: string): boolean;
-    get isTTY(): boolean;
 }
 export declare const stdout: Stream;
 export declare const stderr: Stream;

package/lib/cli-ux/stream.js

@@ -9,6 +9,9 @@ class Stream {
     constructor(channel) {
         this.channel = channel;
     }
+    get isTTY() {
+        return process[this.channel].isTTY;
+    }
     emit(event, ...args) {
         return process[this.channel].emit(event, ...args);
     }
@@ -29,9 +32,6 @@ class Stream {
     write(data) {
         return process[this.channel].write(data);
     }
-    get isTTY() {
-        return process[this.channel].isTTY;
-    }
 }
 exports.stdout = new Stream('stdout');
 exports.stderr = new Stream('stderr');

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

@@ -49,6 +49,70 @@ class Table {
             title,
         };
     }
+    display() {
+        // build table rows from input array data
+        let rows = this.data.map((d) => {
+            const row = {};
+            for (const col of this.columns) {
+                let val = col.get(d);
+                if (typeof val !== 'string')
+                    val = (0, node_util_1.inspect)(val, { breakLength: Number.POSITIVE_INFINITY });
+                row[col.key] = val;
+            }
+            return row;
+        });
+        // filter rows
+        if (this.options.filter) {
+            let [header, regex] = this.options.filter.split('=');
+            const isNot = header[0] === '-';
+            if (isNot)
+                header = header.slice(1);
+            const col = this.findColumnFromHeader(header);
+            if (!col || !regex)
+                throw new Error('Filter flag has an invalid value');
+            rows = rows.filter((d) => {
+                const re = new RegExp(regex);
+                const val = d[col.key];
+                const match = val.match(re);
+                return isNot ? !match : match;
+            });
+        }
+        // sort rows
+        if (this.options.sort) {
+            const sorters = this.options.sort.split(',');
+            const sortHeaders = sorters.map((k) => (k[0] === '-' ? k.slice(1) : k));
+            const sortKeys = this.filterColumnsFromHeaders(sortHeaders).map((c) => (v) => v[c.key]);
+            const sortKeysOrder = sorters.map((k) => (k[0] === '-' ? 'desc' : 'asc'));
+            rows = (0, natural_orderby_1.orderBy)(rows, sortKeys, sortKeysOrder);
+        }
+        // and filter columns
+        if (this.options.columns) {
+            const filters = this.options.columns.split(',');
+            this.columns = this.filterColumnsFromHeaders(filters);
+        }
+        else if (!this.options.extended) {
+            // show extented columns/properties
+            this.columns = this.columns.filter((c) => !c.extended);
+        }
+        this.data = rows;
+        switch (this.options.output) {
+            case 'csv': {
+                this.outputCSV();
+                break;
+            }
+            case 'json': {
+                this.outputJSON();
+                break;
+            }
+            case 'yaml': {
+                this.outputYAML();
+                break;
+            }
+            default: {
+                this.outputTable();
+            }
+        }
+    }
     filterColumnsFromHeaders(filters) {
         // unique
         filters = [...new Set(filters)];
@@ -207,70 +271,6 @@ class Table {
         const { columns, data } = this;
         return data.map((d) => Object.fromEntries(columns.map((col) => [col.key, d[col.key] ?? ''])));
     }
-    display() {
-        // build table rows from input array data
-        let rows = this.data.map((d) => {
-            const row = {};
-            for (const col of this.columns) {
-                let val = col.get(d);
-                if (typeof val !== 'string')
-                    val = (0, node_util_1.inspect)(val, { breakLength: Number.POSITIVE_INFINITY });
-                row[col.key] = val;
-            }
-            return row;
-        });
-        // filter rows
-        if (this.options.filter) {
-            let [header, regex] = this.options.filter.split('=');
-            const isNot = header[0] === '-';
-            if (isNot)
-                header = header.slice(1);
-            const col = this.findColumnFromHeader(header);
-            if (!col || !regex)
-                throw new Error('Filter flag has an invalid value');
-            rows = rows.filter((d) => {
-                const re = new RegExp(regex);
-                const val = d[col.key];
-                const match = val.match(re);
-                return isNot ? !match : match;
-            });
-        }
-        // sort rows
-        if (this.options.sort) {
-            const sorters = this.options.sort.split(',');
-            const sortHeaders = sorters.map((k) => (k[0] === '-' ? k.slice(1) : k));
-            const sortKeys = this.filterColumnsFromHeaders(sortHeaders).map((c) => (v) => v[c.key]);
-            const sortKeysOrder = sorters.map((k) => (k[0] === '-' ? 'desc' : 'asc'));
-            rows = (0, natural_orderby_1.orderBy)(rows, sortKeys, sortKeysOrder);
-        }
-        // and filter columns
-        if (this.options.columns) {
-            const filters = this.options.columns.split(',');
-            this.columns = this.filterColumnsFromHeaders(filters);
-        }
-        else if (!this.options.extended) {
-            // show extented columns/properties
-            this.columns = this.columns.filter((c) => !c.extended);
-        }
-        this.data = rows;
-        switch (this.options.output) {
-            case 'csv': {
-                this.outputCSV();
-                break;
-            }
-            case 'json': {
-                this.outputJSON();
-                break;
-            }
-            case 'yaml': {
-                this.outputYAML();
-                break;
-            }
-            default: {
-                this.outputTable();
-            }
-        }
-    }
 }
 function table(data, columns, options = {}) {
     new Table(data, columns, options).display();

package/lib/command.d.ts

@@ -68,10 +68,14 @@ export declare abstract class Command {
      * 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;
+    private static readonly _base;
     constructor(argv: string[], config: Config);
+    /**
+     * actual command run code goes here
+     */
+    abstract run(): Promise<any>;
     /**
      * instantiate and run the command
      *
@@ -81,8 +85,7 @@ 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 _run<T>(): Promise<T>;
-    private removeEnvVar;
+    protected get ctor(): typeof Command;
     protected catch(err: CommandError): Promise<any>;
     error(input: Error | string, options: {
         code?: string;
@@ -110,11 +113,8 @@ export declare abstract class Command {
     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 _run<T>(): Promise<T>;
+    private removeEnvVar;
 }
 export declare namespace Command {
     /**

package/lib/command.js

@@ -88,9 +88,9 @@ class Command {
      * An override string (or strings) for the default usage documentation.
      */
     static usage;
-    static _base = `${pjson.name}@${pjson.version}`;
     debug;
     id;
+    static _base = `${pjson.name}@${pjson.version}`;
     constructor(argv, config) {
         this.argv = argv;
         this.config = config;
@@ -128,35 +128,8 @@ class Command {
         }
         return cmd._run();
     }
-    async _run() {
-        let err;
-        let result;
-        try {
-            // remove redirected env var to allow subsessions to run autoupdated client
-            this.removeEnvVar('REDIRECTED');
-            await this.init();
-            result = await this.run();
-        }
-        catch (error) {
-            err = error;
-            await this.catch(error);
-        }
-        finally {
-            await this.finally(err);
-        }
-        if (result && this.jsonEnabled())
-            this.logJson(this.toSuccessJson(result));
-        return result;
-    }
-    removeEnvVar(envVar) {
-        const keys = [];
-        try {
-            keys.push(...this.config.scopedEnvVarKeys(envVar));
-        }
-        catch {
-            keys.push(this.config.scopedEnvVarKey(envVar));
-        }
-        keys.map((key) => delete process.env[key]);
+    get ctor() {
+        return this.constructor;
     }
     async catch(err) {
         process.exitCode = process.exitCode ?? err.exitCode ?? 1;
@@ -294,8 +267,35 @@ class Command {
             }
         }
     }
-    get ctor() {
-        return this.constructor;
+    async _run() {
+        let err;
+        let result;
+        try {
+            // remove redirected env var to allow subsessions to run autoupdated client
+            this.removeEnvVar('REDIRECTED');
+            await this.init();
+            result = await this.run();
+        }
+        catch (error) {
+            err = error;
+            await this.catch(error);
+        }
+        finally {
+            await this.finally(err);
+        }
+        if (result && this.jsonEnabled())
+            this.logJson(this.toSuccessJson(result));
+        return result;
+    }
+    removeEnvVar(envVar) {
+        const keys = [];
+        try {
+            keys.push(...this.config.scopedEnvVarKeys(envVar));
+        }
+        catch {
+            keys.push(this.config.scopedEnvVarKey(envVar));
+        }
+        keys.map((key) => delete process.env[key]);
     }
 }
 exports.Command = Command;

package/lib/config/config.d.ts

@@ -4,14 +4,6 @@ import { ArchTypes, Config as IConfig, LoadOptions, PlatformTypes, VersionDetail
 import { Plugin as IPlugin, Options } from '../interfaces/plugin';
 export declare class Config implements IConfig {
     options: Options;
-    private _base;
-    private _commandIDs;
-    private _commands;
-    private static _rootPlugin;
-    private _topics;
-    private commandPermutations;
-    private pluginLoader;
-    private topicPermutations;
     arch: ArchTypes;
     bin: string;
     binAliases?: string[];
@@ -40,46 +32,22 @@ export declare class Config implements IConfig {
     version: string;
     protected warned: boolean;
     windows: boolean;
+    private _base;
+    private _commandIDs;
+    private _commands;
+    private static _rootPlugin;
+    private _topics;
+    private commandPermutations;
+    private pluginLoader;
+    private topicPermutations;
     constructor(options: Options);
     static load(opts?: LoadOptions): Promise<Config>;
     static get rootPlugin(): IPlugin | undefined;
-    protected _debug(): number;
-    protected _shell(): string;
-    /**
-     * This method is responsible for locating the correct plugin to use for a named command id
-     * It searches the {Config} registered commands to match either the raw command id or the command alias
-     * It is possible that more than one command will be found. This is due the ability of two distinct plugins to
-     * create the same command or command alias.
-     *
-     * In the case of more than one found command, the function will select the command based on the order in which
-     * the plugin is included in the package.json `oclif.plugins` list. The command that occurs first in the list
-     * is selected as the command to run.
-     *
-     * Commands can also be present from either an install or a link. When a command is one of these and a core plugin
-     * is present, this function defers to the core plugin.
-     *
-     * If there is not a core plugin command present, this function will return the first
-     * plugin as discovered (will not change the order)
-     *
-     * @param commands commands to determine the priority of
-     * @returns command instance {Command.Loadable} or undefined
-     */
-    private determinePriority;
-    private getCmdLookupId;
-    private getTopicLookupId;
-    /**
-     * Insert legacy plugins
-     *
-     * Replace invalid CLI plugins (cli-engine plugins, mostly Heroku) loaded via `this.loadPlugins`
-     * with oclif-compatible ones returned by @oclif/plugin-legacy init hook.
-     *
-     * @param plugins array of oclif-compatible plugins
-     * @returns void
-     */
-    private insertLegacyPlugins;
-    private isJitPluginCommand;
-    private loadCommands;
-    private loadTopics;
+    get commandIDs(): string[];
+    get commands(): Command.Loadable[];
+    protected get isProd(): boolean;
+    get topics(): Topic[];
+    get versionDetails(): VersionDetails;
     protected dir(category: 'cache' | 'config' | 'data'): string;
     findCommand(id: string, opts: {
         must: true;
@@ -148,9 +116,41 @@ export declare class Config implements IConfig {
     protected windowsHome(): string | undefined;
     protected windowsHomedriveHome(): string | undefined;
     protected windowsUserprofileHome(): string | undefined;
-    get commandIDs(): string[];
-    get commands(): Command.Loadable[];
-    protected get isProd(): boolean;
-    get topics(): Topic[];
-    get versionDetails(): VersionDetails;
+    protected _debug(): number;
+    protected _shell(): string;
+    /**
+     * This method is responsible for locating the correct plugin to use for a named command id
+     * It searches the {Config} registered commands to match either the raw command id or the command alias
+     * It is possible that more than one command will be found. This is due the ability of two distinct plugins to
+     * create the same command or command alias.
+     *
+     * In the case of more than one found command, the function will select the command based on the order in which
+     * the plugin is included in the package.json `oclif.plugins` list. The command that occurs first in the list
+     * is selected as the command to run.
+     *
+     * Commands can also be present from either an install or a link. When a command is one of these and a core plugin
+     * is present, this function defers to the core plugin.
+     *
+     * If there is not a core plugin command present, this function will return the first
+     * plugin as discovered (will not change the order)
+     *
+     * @param commands commands to determine the priority of
+     * @returns command instance {Command.Loadable} or undefined
+     */
+    private determinePriority;
+    private getCmdLookupId;
+    private getTopicLookupId;
+    /**
+     * Insert legacy plugins
+     *
+     * Replace invalid CLI plugins (cli-engine plugins, mostly Heroku) loaded via `this.loadPlugins`
+     * with oclif-compatible ones returned by @oclif/plugin-legacy init hook.
+     *
+     * @param plugins array of oclif-compatible plugins
+     * @returns void
+     */
+    private insertLegacyPlugins;
+    private isJitPluginCommand;
+    private loadCommands;
+    private loadTopics;
 }