@oclif/core 3.0.0-beta.9 → 3.0.1

package/README.md

@@ -11,14 +11,16 @@ base library for oclif CLIs
 Migrating
 =====
 
+See the [v3 migration guide](./guides/V3_MIGRATION.md) for an overview of breaking changes that occurred between v2 and v3.
+
 See the [v2 migration guide](./guides/V2_MIGRATION.md) for an overview of breaking changes that occurred between v1 and v2.
 
-See the [v3 migration guide](./guides/V3_MIGRATION.md) for an overview of breaking changes that occurred between v2 and v3.
+Migrating from `@oclif/config` and `@oclif/command`? See the [v1 migration guide](./guides/PRE_CORE_MIGRATION.md).
 
 CLI UX
 =====
 
-The [ux README](./src/ux/README.md) contains detailed usage examples of using the `ux` export.
+The [ux README](./src/cli-ux/README.md) contains detailed usage examples of using the `ux` export.
 
 Usage
 =====

package/flush.d.ts

@@ -0,0 +1,3 @@
+declare const flush: () => Promise<void>
+
+export = flush

package/flush.js

@@ -0,0 +1 @@
+module.exports = require('./lib/cli-ux/flush').flush

package/handle.js

@@ -0,0 +1 @@
+module.exports = async error => require('./lib/errors/handle').handle(error)

package/lib/args.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { URL } from 'url';
+import { URL } from 'node:url';
 import { Arg, ArgDefinition } from './interfaces/parser';
 /**
  * Create a custom arg.
@@ -21,8 +21,8 @@ import { Arg, ArgDefinition } from './interfaces/parser';
 export declare function custom<T = string, P = Record<string, unknown>>(defaults: Partial<Arg<T, P>>): ArgDefinition<T, P>;
 export declare const boolean: ArgDefinition<boolean, Record<string, unknown>>;
 export declare const integer: ArgDefinition<number, {
-    min?: number | undefined;
     max?: number | undefined;
+    min?: number | undefined;
 }>;
 export declare const directory: ArgDefinition<string, {
     exists?: boolean | undefined;

package/lib/args.js

@@ -1,25 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.string = exports.url = exports.file = exports.directory = exports.integer = exports.boolean = exports.custom = void 0;
-const url_1 = require("url");
-const util_1 = require("./util");
+const node_url_1 = require("node:url");
+const fs_1 = require("./util/fs");
+const util_1 = require("./util/util");
 function custom(defaults) {
-    return (options = {}) => {
-        return {
-            parse: async (i, _context, _opts) => i,
-            ...defaults,
-            ...options,
-            input: [],
-            type: 'option',
-        };
-    };
+    return (options = {}) => ({
+        parse: async (i, _context, _opts) => i,
+        ...defaults,
+        ...options,
+        input: [],
+        type: 'option',
+    });
 }
 exports.custom = custom;
 exports.boolean = custom({
     parse: async (b) => Boolean(b) && (0, util_1.isNotFalsy)(b),
 });
 exports.integer = custom({
-    parse: async (input, _, opts) => {
+    async parse(input, _, opts) {
         if (!/^-?\d+$/.test(input))
             throw new Error(`Expected an integer but received: ${input}`);
         const num = Number.parseInt(input, 10);
@@ -31,16 +30,16 @@ exports.integer = custom({
     },
 });
 exports.directory = custom({
-    parse: async (input, _, opts) => {
+    async parse(input, _, opts) {
         if (opts.exists)
-            return (0, util_1.dirExists)(input);
+            return (0, fs_1.dirExists)(input);
         return input;
     },
 });
 exports.file = custom({
-    parse: async (input, _, opts) => {
+    async parse(input, _, opts) {
         if (opts.exists)
-            return (0, util_1.fileExists)(input);
+            return (0, fs_1.fileExists)(input);
         return input;
     },
 });
@@ -49,9 +48,9 @@ exports.file = custom({
  * if the string is not a valid URL.
  */
 exports.url = custom({
-    parse: async (input) => {
+    async parse(input) {
         try {
-            return new url_1.URL(input);
+            return new node_url_1.URL(input);
         }
         catch {
             throw new Error(`Expected a valid url but received: ${input}`);

package/lib/{ux → cli-ux}/action/base.d.ts

@@ -1,35 +1,33 @@
+import { Options } from './types';
 export interface ITask {
     action: string;
-    status: string | undefined;
     active: boolean;
+    status: string | undefined;
 }
-export type ActionType = 'spinner' | 'simple' | 'debug';
-export interface Options {
-    stdout?: boolean;
-}
+export type ActionType = 'debug' | 'simple' | 'spinner';
 export declare class ActionBase {
-    type: ActionType;
-    std: 'stdout' | 'stderr';
-    protected stdmocks?: ['stdout' | 'stderr', string[]][];
     private stdmockOrigs;
+    std: 'stderr' | 'stdout';
+    protected stdmocks?: ['stderr' | 'stdout', string[]][];
+    type: ActionType;
+    protected _flushStdout(): void;
+    protected _pause(_?: string): void;
+    protected _resume(): void;
+    protected _start(_opts: Options): void;
+    protected _stdout(toggle: boolean): void;
+    protected _stop(_: string): void;
+    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;
-    private get globals();
-    get task(): ITask | undefined;
-    set task(task: ITask | undefined);
     protected get output(): string | undefined;
     protected set output(output: string | undefined);
     get running(): boolean;
     get status(): string | undefined;
     set status(status: string | undefined);
-    pauseAsync<T extends any>(fn: () => Promise<T>, icon?: string): Promise<T>;
-    pause(fn: () => any, icon?: string): Promise<any>;
-    protected _start(): void;
-    protected _stop(_: string): void;
-    protected _resume(): void;
-    protected _pause(_?: string): void;
-    protected _updateStatus(_: string | undefined, __?: string): void;
-    protected _stdout(toggle: boolean): void;
-    protected _flushStdout(): void;
-    protected _write(std: 'stdout' | 'stderr', s: string | string[]): void;
+    get task(): ITask | undefined;
+    set task(task: ITask | undefined);
 }

package/lib/{ux → cli-ux}/action/base.js

@@ -1,112 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ActionBase = void 0;
-const util_1 = require("util");
-const util_2 = require("../../util");
+const node_util_1 = require("node:util");
+const util_1 = require("../../util/util");
 const stream_1 = require("../stream");
 class ActionBase {
-    constructor() {
-        this.std = 'stderr';
-        this.stdmockOrigs = {
-            stdout: stream_1.stdout.write,
-            stderr: stream_1.stderr.write,
-        };
-    }
-    start(action, status, opts = {}) {
-        this.std = opts.stdout ? 'stdout' : 'stderr';
-        const task = { action, status, active: Boolean(this.task && this.task.active) };
-        this.task = task;
-        this._start();
-        task.active = true;
-        this._stdout(true);
-    }
-    stop(msg = 'done') {
-        const task = this.task;
-        if (!task) {
-            return;
-        }
-        this._stop(msg);
-        task.active = false;
-        this.task = undefined;
-        this._stdout(false);
-    }
-    get globals() {
-        global.ux = global.ux || {};
-        const globals = global.ux;
-        globals.action = globals.action || {};
-        return globals;
-    }
-    get task() {
-        return this.globals.action.task;
-    }
-    set task(task) {
-        this.globals.action.task = task;
-    }
-    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.task;
-        if (!task) {
-            return;
-        }
-        if (task.status === status) {
-            return;
-        }
-        this._updateStatus(status, task.status);
-        task.status = status;
-    }
-    async pauseAsync(fn, icon) {
-        const task = this.task;
-        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;
-    }
-    pause(fn, icon) {
-        const task = this.task;
-        const active = task && task.active;
-        if (task && active) {
-            this._pause(icon);
-            this._stdout(false);
-            task.active = false;
+    stdmockOrigs = {
+        stderr: stream_1.stderr.write,
+        stdout: stream_1.stdout.write,
+    };
+    std = 'stderr';
+    stdmocks;
+    type;
+    // flush mocked stdout/stderr
+    _flushStdout() {
+        try {
+            let output = '';
+            let std;
+            while (this.stdmocks && this.stdmocks.length > 0) {
+                const cur = this.stdmocks.shift();
+                std = cur[0];
+                this._write(std, cur[1]);
+                output += cur[1][0].toString('utf8');
+            }
+            // add newline if there isn't one already
+            // otherwise we'll just overwrite it when we render
+            if (output && std && output.at(-1) !== '\n') {
+                this._write(std, '\n');
+            }
         }
-        const ret = fn();
-        if (task && active) {
-            this._resume();
+        catch (error) {
+            this._write('stderr', (0, node_util_1.inspect)(error));
         }
-        return ret;
     }
-    _start() {
-        throw new Error('not implemented');
-    }
-    _stop(_) {
+    _pause(_) {
         throw new Error('not implemented');
     }
     _resume() {
         if (this.task)
             this.start(this.task.action, this.task.status);
     }
-    _pause(_) {
+    _start(_opts) {
         throw new Error('not implemented');
     }
-    _updateStatus(_, __) { }
     // mock out stdout/stderr so it doesn't screw up the rendering
     _stdout(toggle) {
         try {
@@ -114,8 +50,8 @@ class ActionBase {
                 if (this.stdmocks)
                     return;
                 this.stdmockOrigs = {
-                    stdout: stream_1.stdout.write,
                     stderr: stream_1.stderr.write,
+                    stdout: stream_1.stdout.write,
                 };
                 this.stdmocks = [];
                 stream_1.stdout.write = (...args) => {
@@ -137,42 +73,112 @@ class ActionBase {
             }
         }
         catch (error) {
-            this._write('stderr', (0, util_1.inspect)(error));
+            this._write('stderr', (0, node_util_1.inspect)(error));
         }
     }
-    // flush mocked stdout/stderr
-    _flushStdout() {
-        try {
-            let output = '';
-            let std;
-            while (this.stdmocks && this.stdmocks.length > 0) {
-                const cur = this.stdmocks.shift();
-                std = cur[0];
-                this._write(std, cur[1]);
-                output += cur[1][0].toString('utf8');
-            }
-            // add newline if there isn't one already
-            // otherwise we'll just overwrite it when we render
-            if (output && std && output[output.length - 1] !== '\n') {
-                this._write(std, '\n');
-            }
-        }
-        catch (error) {
-            this._write('stderr', (0, util_1.inspect)(error));
-        }
+    _stop(_) {
+        throw new Error('not implemented');
+    }
+    _updateStatus(_, __) {
+        // Not implemented
     }
     // write to the real stdout/stderr
     _write(std, s) {
         switch (std) {
-            case 'stdout':
-                this.stdmockOrigs.stdout.apply(stream_1.stdout, (0, util_2.castArray)(s));
+            case 'stdout': {
+                this.stdmockOrigs.stdout.apply(stream_1.stdout, (0, util_1.castArray)(s));
                 break;
-            case 'stderr':
-                this.stdmockOrigs.stderr.apply(stream_1.stderr, (0, util_2.castArray)(s));
+            }
+            case 'stderr': {
+                this.stdmockOrigs.stderr.apply(stream_1.stderr, (0, util_1.castArray)(s));
                 break;
-            default:
+            }
+            default: {
                 throw new Error(`invalid std: ${std}`);
+            }
+        }
+    }
+    get globals() {
+        ;
+        global.ux = global.ux || {};
+        const globals = global.ux;
+        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/{ux → cli-ux}/action/simple.js

@@ -2,15 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const base_1 = require("./base");
 class SimpleAction extends base_1.ActionBase {
-    constructor() {
-        super(...arguments);
-        this.type = 'simple';
-    }
-    _start() {
-        const task = this.task;
-        if (!task)
-            return;
-        this._render(task.action, task.status);
+    type = 'simple';
+    _flush() {
+        this._write(this.std, '\n');
+        this._flushStdout();
     }
     _pause(icon) {
         if (icon)
@@ -18,35 +13,35 @@ class SimpleAction extends base_1.ActionBase {
         else
             this._flush();
     }
-    _resume() { }
-    _updateStatus(status, prevStatus, newline = false) {
-        const task = this.task;
-        if (!task)
+    _render(action, status) {
+        if (!this.task)
             return;
-        if (task.active && !prevStatus)
-            this._write(this.std, ` ${status}`);
-        else
-            this._write(this.std, `${task.action}... ${status}`);
-        if (newline || !prevStatus)
+        if (this.task.active)
             this._flush();
+        this._write(this.std, status ? `${action}... ${status}` : `${action}...`);
+    }
+    _resume() {
+        // Not implemented
+    }
+    _start() {
+        if (!this.task)
+            return;
+        this._render(this.task.action, this.task.status);
     }
     _stop(status) {
-        const task = this.task;
-        if (!task)
+        if (!this.task)
             return;
-        this._updateStatus(status, task.status, true);
+        this._updateStatus(status, this.task.status, true);
     }
-    _render(action, status) {
-        const task = this.task;
-        if (!task)
+    _updateStatus(status, prevStatus, newline = false) {
+        if (!this.task)
             return;
-        if (task.active)
+        if (this.task.active && !prevStatus)
+            this._write(this.std, ` ${status}`);
+        else
+            this._write(this.std, `${this.task.action}... ${status}`);
+        if (newline || !prevStatus)
             this._flush();
-        this._write(this.std, status ? `${action}... ${status}` : `${action}...`);
-    }
-    _flush() {
-        this._write(this.std, '\n');
-        this._flushStdout();
     }
 }
 exports.default = SimpleAction;

package/lib/{ux → cli-ux}/action/spinner.d.ts

@@ -1,16 +1,18 @@
 /// <reference types="node" />
 import { ActionBase, ActionType } from './base';
+import { Options } from './types';
 export default class SpinnerAction extends ActionBase {
-    type: ActionType;
-    spinner?: NodeJS.Timeout;
-    frames: any;
     frameIndex: number;
+    frames: string[];
+    spinner?: NodeJS.Timeout;
+    type: ActionType;
     constructor();
-    protected _start(): void;
-    protected _stop(status: string): void;
-    protected _pause(icon?: string): void;
     protected _frame(): string;
+    private _lines;
+    protected _pause(icon?: string): void;
     private _render;
     private _reset;
-    private _lines;
+    protected _start(opts: Options): void;
+    protected _stop(status: string): void;
+    private getFrames;
 }