@oclif/core 1.1.1 → 1.3.0

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [1.3.0](https://github.com/oclif/core/compare/v1.2.1...v1.3.0) (2022-02-01)
+
+
+### Features
+
+* add S3Manifest ([#354](https://github.com/oclif/core/issues/354)) ([ea5585d](https://github.com/oclif/core/commit/ea5585db6361f12c3c0608b05d1e33e16bc0b4b6))
+
+### [1.2.1](https://github.com/oclif/core/compare/v1.2.0...v1.2.1) (2022-01-28)
+
+
+### Bug Fixes
+
+* module resolution of linked plugins ([#352](https://github.com/oclif/core/issues/352)) ([c7f5d34](https://github.com/oclif/core/commit/c7f5d3439e7e60b6562362c87fe0d16a99a42a08))
+
+## [1.2.0](https://github.com/oclif/core/compare/v1.1.2...v1.2.0) (2022-01-26)
+
+
+### Features
+
+* merge cli-ux library with oclif/core ([#345](https://github.com/oclif/core/issues/345)) ([27175d6](https://github.com/oclif/core/commit/27175d6f0693533b7cfbf57de65da626168d872f)), closes [npm/cli#4234](https://github.com/npm/cli/issues/4234)
+
+### [1.1.2](https://github.com/oclif/core/compare/v1.1.1...v1.1.2) (2022-01-10)
+
 ### [1.1.1](https://github.com/oclif/core/compare/v1.1.0...v1.1.1) (2022-01-06)
 
 

package/README.md

@@ -14,6 +14,10 @@ Migrating
 
 If you're migrating from the old oclif libraries (`@oclif/config`, `@oclif/command`, `@oclif/error`, `@oclif/parser`), see the [migration guide](./MIGRATION.md).
 
+The `@oclif/core` module now also includes the `cli-ux` module. Merging `cli-ux` into `@oclif/core` resolves a circular dependency between the two modules.
+See the [cli-ux README](./src/cli-ux/README.md) for instructions on how to replace the `cli-ux` module with `@oclif/core`.
+The [cli-ux README](./src/cli-ux/README.md) also contains detailed usage examples.
+
 Usage
 =====
 
@@ -24,14 +28,14 @@ Without the generator, you can create a simple CLI like this:
 #!/usr/bin/env ts-node
 
 import * as fs from 'fs'
-import {Command, flags} from '@oclif/core'
+import {Command, Flags} from '@oclif/core'
 
 class LS extends Command {
   static flags = {
-    version: flags.version(),
-    help: flags.help(),
+    version: Flags.version(),
+    help: Flags.help(),
     // run with --dir= or -d=
-    dir: flags.string({
+    dir: Flags.string({
       char: 'd',
       default: process.cwd(),
     }),

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

@@ -0,0 +1,35 @@
+export interface ITask {
+    action: string;
+    status: string | undefined;
+    active: boolean;
+}
+export declare type ActionType = 'spinner' | 'simple' | 'debug';
+export interface Options {
+    stdout?: boolean;
+}
+export declare class ActionBase {
+    type: ActionType;
+    std: 'stdout' | 'stderr';
+    protected stdmocks?: ['stdout' | 'stderr', string[]][];
+    private stdmockOrigs;
+    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(fn: () => Promise<any>, icon?: string): Promise<any>;
+    pause(fn: () => any, icon?: string): 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;
+}

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

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionBase = void 0;
+const util_1 = require("util");
+const util_2 = require("../../util");
+class ActionBase {
+    constructor() {
+        this.std = 'stderr';
+        this.stdmockOrigs = {
+            stdout: process.stdout.write,
+            stderr: process.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['cli-ux'] = global['cli-ux'] || {};
+        const globals = global['cli-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;
+        }
+        const ret = fn();
+        if (task && active) {
+            this._resume();
+        }
+        return ret;
+    }
+    _start() {
+        throw new Error('not implemented');
+    }
+    _stop(_) {
+        throw new Error('not implemented');
+    }
+    _resume() {
+        if (this.task)
+            this.start(this.task.action, this.task.status);
+    }
+    _pause(_) {
+        throw new Error('not implemented');
+    }
+    _updateStatus(_, __) { }
+    // mock out stdout/stderr so it doesn't screw up the rendering
+    _stdout(toggle) {
+        try {
+            const outputs = ['stdout', 'stderr'];
+            if (toggle) {
+                if (this.stdmocks)
+                    return;
+                this.stdmockOrigs = {
+                    stdout: process.stdout.write,
+                    stderr: process.stderr.write,
+                };
+                this.stdmocks = [];
+                for (const std of outputs) {
+                    process[std].write = (...args) => {
+                        this.stdmocks.push([std, args]);
+                    };
+                }
+            }
+            else {
+                if (!this.stdmocks)
+                    return;
+                // this._write('stderr', '\nresetstdmock\n\n\n')
+                delete this.stdmocks;
+                for (const std of outputs)
+                    process[std].write = this.stdmockOrigs[std];
+            }
+        }
+        catch (error) {
+            this._write('stderr', (0, 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));
+        }
+    }
+    // write to the real stdout/stderr
+    _write(std, s) {
+        this.stdmockOrigs[std].apply(process[std], (0, util_2.castArray)(s));
+    }
+}
+exports.ActionBase = ActionBase;

package/lib/cli-ux/action/pride-spinner.d.ts

@@ -0,0 +1,4 @@
+import SpinnerAction from './spinner';
+export default class PrideSpinnerAction extends SpinnerAction {
+    protected _frame(): string;
+}

package/lib/cli-ux/action/pride-spinner.js

@@ -0,0 +1,31 @@
+"use strict";
+// tslint:disable restrict-plus-operands
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk = require("chalk");
+const supportsColor = require("supports-color");
+const spinner_1 = require("./spinner");
+function color(s, frameIndex) {
+    const prideColors = [
+        chalk.keyword('pink'),
+        chalk.red,
+        chalk.keyword('orange'),
+        chalk.yellow,
+        chalk.green,
+        chalk.cyan,
+        chalk.blue,
+        chalk.magenta,
+    ];
+    if (!supportsColor)
+        return s;
+    const has256 = supportsColor.stdout ? supportsColor.stdout.has256 : (process.env.TERM || '').includes('256');
+    const prideColor = prideColors[frameIndex] || prideColors[0];
+    return has256 ? prideColor(s) : chalk.magenta(s);
+}
+class PrideSpinnerAction extends spinner_1.default {
+    _frame() {
+        const frame = this.frames[this.frameIndex];
+        this.frameIndex = ++this.frameIndex % this.frames.length;
+        return color(frame, this.frameIndex);
+    }
+}
+exports.default = PrideSpinnerAction;

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

@@ -0,0 +1,11 @@
+import { ActionBase, ActionType } from './base';
+export default class SimpleAction extends ActionBase {
+    type: ActionType;
+    protected _start(): void;
+    protected _pause(icon?: string): void;
+    protected _resume(): void;
+    protected _updateStatus(status: string, prevStatus?: string, newline?: boolean): void;
+    protected _stop(status: string): void;
+    private _render;
+    private _flush;
+}

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

@@ -0,0 +1,52 @@
+"use strict";
+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);
+    }
+    _pause(icon) {
+        if (icon)
+            this._updateStatus(icon);
+        else
+            this._flush();
+    }
+    _resume() { }
+    _updateStatus(status, prevStatus, newline = false) {
+        const task = this.task;
+        if (!task)
+            return;
+        if (task.active && !prevStatus)
+            this._write(this.std, ` ${status}`);
+        else
+            this._write(this.std, `${task.action}... ${status}`);
+        if (newline || !prevStatus)
+            this._flush();
+    }
+    _stop(status) {
+        const task = this.task;
+        if (!task)
+            return;
+        this._updateStatus(status, task.status, true);
+    }
+    _render(action, status) {
+        const task = this.task;
+        if (!task)
+            return;
+        if (task.active)
+            this._flush();
+        this._write(this.std, status ? `${action}... ${status}` : `${action}...`);
+    }
+    _flush() {
+        this._write(this.std, '\n');
+        this._flushStdout();
+    }
+}
+exports.default = SimpleAction;

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

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

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

@@ -0,0 +1,79 @@
+"use strict";
+// tslint:disable restrict-plus-operands
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk = require("chalk");
+const supportsColor = require("supports-color");
+const deps_1 = require("../deps");
+const base_1 = require("./base");
+/* eslint-disable-next-line node/no-missing-require */
+const spinners = require('./spinners');
+function color(s) {
+    if (!supportsColor)
+        return s;
+    const has256 = supportsColor.stdout ? supportsColor.stdout.has256 : (process.env.TERM || '').includes('256');
+    return has256 ? `\u001B[38;5;104m${s}${deps_1.default.ansiStyles.reset.open}` : chalk.magenta(s);
+}
+class SpinnerAction extends base_1.ActionBase {
+    constructor() {
+        super();
+        this.type = 'spinner';
+        this.frames = spinners[process.platform === 'win32' ? 'line' : 'dots2'].frames;
+        this.frameIndex = 0;
+    }
+    _start() {
+        this._reset();
+        if (this.spinner)
+            clearInterval(this.spinner);
+        this._render();
+        this.spinner = setInterval(icon => this._render.bind(this)(icon), process.platform === 'win32' ? 500 : 100, 'spinner');
+        const interval = this.spinner;
+        interval.unref();
+    }
+    _stop(status) {
+        if (this.task)
+            this.task.status = status;
+        if (this.spinner)
+            clearInterval(this.spinner);
+        this._render();
+        this.output = undefined;
+    }
+    _pause(icon) {
+        if (this.spinner)
+            clearInterval(this.spinner);
+        this._reset();
+        if (icon)
+            this._render(` ${icon}`);
+        this.output = undefined;
+    }
+    _frame() {
+        const frame = this.frames[this.frameIndex];
+        this.frameIndex = ++this.frameIndex % this.frames.length;
+        return color(frame);
+    }
+    _render(icon) {
+        const task = this.task;
+        if (!task)
+            return;
+        this._reset();
+        this._flushStdout();
+        const frame = icon === 'spinner' ? ` ${this._frame()}` : icon || '';
+        const status = task.status ? ` ${task.status}` : '';
+        this.output = `${task.action}...${frame}${status}\n`;
+        this._write(this.std, this.output);
+    }
+    _reset() {
+        if (!this.output)
+            return;
+        const lines = this._lines(this.output);
+        this._write(this.std, deps_1.default.ansiEscapes.cursorLeft + deps_1.default.ansiEscapes.cursorUp(lines) + deps_1.default.ansiEscapes.eraseDown);
+        this.output = undefined;
+    }
+    _lines(s) {
+        return deps_1.default
+            .stripAnsi(s)
+            .split('\n')
+            .map(l => Math.ceil(l.length / deps_1.default.screen.errtermwidth))
+            .reduce((c, i) => c + i, 0);
+    }
+}
+exports.default = SpinnerAction;