@oclif/core 2.0.0-beta.3 → 2.0.0-beta.5

package/README.md

@@ -4,7 +4,6 @@
 base library for oclif CLIs
 
 [![Version](https://img.shields.io/npm/v/@oclif/core.svg)](https://npmjs.org/package/@oclif/core)
-[![CircleCI](https://circleci.com/gh/oclif/core/tree/main.svg?style=svg)](https://circleci.com/gh/oclif/core/tree/main)
 [![Downloads/week](https://img.shields.io/npm/dw/@oclif/core.svg)](https://npmjs.org/package/@oclif/core)
 [![License](https://img.shields.io/npm/l/@oclif/core.svg)](https://github.com/oclif/core/blob/main/package.json)
 
@@ -12,11 +11,12 @@ base library for oclif CLIs
 Migrating
 =====
 
-If you're migrating from the old oclif libraries (`@oclif/config`, `@oclif/command`, `@oclif/error`, `@oclif/parser`), see the [migration guide](./MIGRATION.md).
+See the [migration guide](./MIGRATION.md) for an overview of breaking changes that occurred between v1 and v2.
 
-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.
+CLI UX
+=====
+
+The [ux README](./src/cli-ux/README.md) contains detailed usage examples of using the `ux` export.
 
 Usage
 =====

package/lib/args.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="node" />
+import { URL } from 'url';
+import { Arg, ArgDefinition } from './interfaces/parser';
+/**
+ * Create a custom arg.
+ *
+ * @example
+ * type Id = string
+ * type IdOpts = { startsWith: string; length: number };
+ *
+ * export const myArg = custom<Id, IdOpts>({
+ *   parse: async (input, opts) => {
+ *     if (input.startsWith(opts.startsWith) && input.length === opts.length) {
+ *       return input
+ *     }
+ *
+ *     throw new Error('Invalid id')
+ *   },
+ * })
+ */
+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;
+}>;
+export declare const directory: ArgDefinition<string, {
+    exists?: boolean | undefined;
+}>;
+export declare const file: ArgDefinition<string, {
+    exists?: boolean | undefined;
+}>;
+/**
+ * Initializes a string as a URL. Throws an error
+ * if the string is not a valid URL.
+ */
+export declare const url: ArgDefinition<URL, Record<string, unknown>>;
+declare const stringArg: ArgDefinition<string, Record<string, unknown>>;
+export { stringArg as string };

package/lib/args.js

@@ -0,0 +1,62 @@
+"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");
+function custom(defaults) {
+    return (options = {}) => {
+        return {
+            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) => {
+        if (!/^-?\d+$/.test(input))
+            throw new Error(`Expected an integer but received: ${input}`);
+        const num = Number.parseInt(input, 10);
+        if (opts.min !== undefined && num < opts.min)
+            throw new Error(`Expected an integer greater than or equal to ${opts.min} but received: ${input}`);
+        if (opts.max !== undefined && num > opts.max)
+            throw new Error(`Expected an integer less than or equal to ${opts.max} but received: ${input}`);
+        return num;
+    },
+});
+exports.directory = custom({
+    parse: async (input, _, opts) => {
+        if (opts.exists)
+            return (0, util_1.dirExists)(input);
+        return input;
+    },
+});
+exports.file = custom({
+    parse: async (input, _, opts) => {
+        if (opts.exists)
+            return (0, util_1.fileExists)(input);
+        return input;
+    },
+});
+/**
+ * Initializes a string as a URL. Throws an error
+ * if the string is not a valid URL.
+ */
+exports.url = custom({
+    parse: async (input) => {
+        try {
+            return new url_1.URL(input);
+        }
+        catch {
+            throw new Error(`Expected a valid url but received: ${input}`);
+        }
+    },
+});
+const stringArg = custom({});
+exports.string = stringArg;

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

@@ -23,7 +23,7 @@ export declare class ActionBase {
     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): any;
+    pause(fn: () => any, icon?: string): Promise<any>;
     protected _start(): void;
     protected _stop(_: string): void;
     protected _resume(): void;

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

@@ -1,5 +1,4 @@
 "use strict";
-// tslint:disable restrict-plus-operands
 Object.defineProperty(exports, "__esModule", { value: true });
 const chalk = require("chalk");
 const supportsColor = require("supports-color");

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

@@ -1,23 +1,24 @@
 "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 stripAnsi = require('strip-ansi');
+const ansiStyles = require('ansi-styles');
+const ansiEscapes = require('ansi-escapes');
+const screen_1 = require("../../screen");
+const spinners_1 = require("./spinners");
 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);
+    return has256 ? `\u001B[38;5;104m${s}${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.frames = spinners_1.default[process.platform === 'win32' ? 'line' : 'dots2'].frames;
         this.frameIndex = 0;
     }
     _start() {
@@ -65,14 +66,12 @@ class SpinnerAction extends base_1.ActionBase {
         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._write(this.std, ansiEscapes.cursorLeft + ansiEscapes.cursorUp(lines) + 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))
+        return stripAnsi(s).split('\n')
+            .map(l => Math.ceil(l.length / screen_1.errtermwidth))
             .reduce((c, i) => c + i, 0);
     }
 }

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

@@ -0,0 +1,251 @@
+declare const _default: {
+    hexagon: {
+        interval: number;
+        frames: string[];
+    };
+    dots: {
+        interval: number;
+        frames: string[];
+    };
+    dots2: {
+        interval: number;
+        frames: string[];
+    };
+    dots3: {
+        interval: number;
+        frames: string[];
+    };
+    dots4: {
+        interval: number;
+        frames: string[];
+    };
+    dots5: {
+        interval: number;
+        frames: string[];
+    };
+    dots6: {
+        interval: number;
+        frames: string[];
+    };
+    dots7: {
+        interval: number;
+        frames: string[];
+    };
+    dots8: {
+        interval: number;
+        frames: string[];
+    };
+    dots9: {
+        interval: number;
+        frames: string[];
+    };
+    dots10: {
+        interval: number;
+        frames: string[];
+    };
+    dots11: {
+        interval: number;
+        frames: string[];
+    };
+    line: {
+        interval: number;
+        frames: string[];
+    };
+    line2: {
+        interval: number;
+        frames: string[];
+    };
+    pipe: {
+        interval: number;
+        frames: string[];
+    };
+    simpleDots: {
+        interval: number;
+        frames: string[];
+    };
+    simpleDotsScrolling: {
+        interval: number;
+        frames: string[];
+    };
+    star: {
+        interval: number;
+        frames: string[];
+    };
+    star2: {
+        interval: number;
+        frames: string[];
+    };
+    flip: {
+        interval: number;
+        frames: string[];
+    };
+    hamburger: {
+        interval: number;
+        frames: string[];
+    };
+    growVertical: {
+        interval: number;
+        frames: string[];
+    };
+    growHorizontal: {
+        interval: number;
+        frames: string[];
+    };
+    balloon: {
+        interval: number;
+        frames: string[];
+    };
+    balloon2: {
+        interval: number;
+        frames: string[];
+    };
+    noise: {
+        interval: number;
+        frames: string[];
+    };
+    bounce: {
+        interval: number;
+        frames: string[];
+    };
+    boxBounce: {
+        interval: number;
+        frames: string[];
+    };
+    boxBounce2: {
+        interval: number;
+        frames: string[];
+    };
+    triangle: {
+        interval: number;
+        frames: string[];
+    };
+    arc: {
+        interval: number;
+        frames: string[];
+    };
+    circle: {
+        interval: number;
+        frames: string[];
+    };
+    squareCorners: {
+        interval: number;
+        frames: string[];
+    };
+    circleQuarters: {
+        interval: number;
+        frames: string[];
+    };
+    circleHalves: {
+        interval: number;
+        frames: string[];
+    };
+    squish: {
+        interval: number;
+        frames: string[];
+    };
+    toggle: {
+        interval: number;
+        frames: string[];
+    };
+    toggle2: {
+        interval: number;
+        frames: string[];
+    };
+    toggle3: {
+        interval: number;
+        frames: string[];
+    };
+    toggle4: {
+        interval: number;
+        frames: string[];
+    };
+    toggle5: {
+        interval: number;
+        frames: string[];
+    };
+    toggle6: {
+        interval: number;
+        frames: string[];
+    };
+    toggle7: {
+        interval: number;
+        frames: string[];
+    };
+    toggle8: {
+        interval: number;
+        frames: string[];
+    };
+    toggle9: {
+        interval: number;
+        frames: string[];
+    };
+    toggle10: {
+        interval: number;
+        frames: string[];
+    };
+    toggle11: {
+        interval: number;
+        frames: string[];
+    };
+    toggle12: {
+        interval: number;
+        frames: string[];
+    };
+    toggle13: {
+        interval: number;
+        frames: string[];
+    };
+    arrow: {
+        interval: number;
+        frames: string[];
+    };
+    arrow2: {
+        interval: number;
+        frames: string[];
+    };
+    arrow3: {
+        interval: number;
+        frames: string[];
+    };
+    bouncingBar: {
+        interval: number;
+        frames: string[];
+    };
+    bouncingBall: {
+        interval: number;
+        frames: string[];
+    };
+    smiley: {
+        interval: number;
+        frames: string[];
+    };
+    monkey: {
+        interval: number;
+        frames: string[];
+    };
+    hearts: {
+        interval: number;
+        frames: string[];
+    };
+    clock: {
+        interval: number;
+        frames: string[];
+    };
+    earth: {
+        interval: number;
+        frames: string[];
+    };
+    moon: {
+        interval: number;
+        frames: string[];
+    };
+    runner: {
+        interval: number;
+        frames: string[];
+    };
+    pong: {
+        interval: number;
+        frames: string[];
+    };
+};
+export default _default;

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

@@ -1,5 +1,6 @@
 "use strict";
-module.exports = {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
     hexagon: {
         interval: 400,
         frames: ['⬡', '⬢'],

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

@@ -14,7 +14,7 @@ export declare class Config {
     get debug(): boolean;
     set debug(v: boolean);
     get context(): any;
-    set context(v: any);
+    set context(v: unknown);
 }
 export declare const config: Config;
 export default config;

package/lib/cli-ux/config.js

@@ -2,17 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.config = exports.Config = void 0;
 const semver = require("semver");
-const version = semver.parse(require('../../package.json').version);
+const util_1 = require("../util");
+const spinner_1 = require("./action/spinner");
+const spinner_2 = require("./action/spinner");
+const pride_spinner_1 = require("./action/pride-spinner");
+const version = semver.parse((0, util_1.requireJson)(__dirname, '..', '..', 'package.json').version);
 const g = global;
 const globals = g['cli-ux'] || (g['cli-ux'] = {});
 const actionType = (Boolean(process.stderr.isTTY) &&
     !process.env.CI &&
     !['dumb', 'emacs-color'].includes(process.env.TERM) &&
     'spinner') || 'simple';
-/* eslint-disable node/no-missing-require */
-const Action = actionType === 'spinner' ? require('./action/spinner').default : require('./action/simple').default;
-const PrideAction = actionType === 'spinner' ? require('./action/pride-spinner').default : require('./action/simple').default;
-/* eslint-enable node/no-missing-require */
+const Action = actionType === 'spinner' ? spinner_1.default : spinner_2.default;
+const PrideAction = actionType === 'spinner' ? pride_spinner_1.default : spinner_2.default;
 class Config {
     constructor() {
         this.outputLevel = 'info';

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

@@ -3,35 +3,57 @@ import { ActionBase } from './action/base';
 import { config, Config } from './config';
 import { ExitError } from './exit';
 import { IPromptOptions } from './prompt';
-import * as Table from './styled/table';
-export declare const ux: {
-    config: Config;
-    warn: typeof Errors.warn;
-    error: typeof Errors.error;
-    exit: typeof Errors.exit;
-    readonly prompt: typeof import("./prompt").prompt;
+import * as styled from './styled';
+import { Table } from './styled';
+import * as uxPrompt from './prompt';
+import uxWait from './wait';
+export declare class ux {
+    static config: Config;
+    static get prompt(): typeof uxPrompt.prompt;
     /**
      * "press anykey to continue"
      */
-    readonly anykey: typeof import("./prompt").anykey;
-    readonly confirm: typeof import("./prompt").confirm;
-    readonly action: ActionBase;
-    readonly prideAction: ActionBase;
-    styledObject(obj: any, keys?: string[]): void;
-    readonly styledHeader: typeof import("./styled/header").default;
-    readonly styledJSON: typeof import("./styled/json").default;
-    readonly table: typeof Table.table;
-    readonly tree: typeof import("./styled/tree").default;
-    readonly open: typeof import("./open").default;
-    readonly wait: (ms?: number) => Promise<unknown>;
-    readonly progress: typeof import("./styled/progress").default;
-    done(): Promise<void>;
-    trace(format: string, ...args: string[]): void;
-    debug(format: string, ...args: string[]): void;
-    info(format: string, ...args: string[]): void;
-    log(format?: string, ...args: string[]): void;
-    url(text: string, uri: string, params?: {}): void;
-    annotation(text: string, annotation: string): void;
-    flush(ms?: number): Promise<void>;
-};
-export { config, ActionBase, Config, ExitError, IPromptOptions, Table, };
+    static get anykey(): typeof uxPrompt.anykey;
+    static get confirm(): typeof uxPrompt.confirm;
+    static get action(): ActionBase;
+    static get prideAction(): ActionBase;
+    static styledObject(obj: any, keys?: string[]): void;
+    static get styledHeader(): typeof styled.styledHeader;
+    static get styledJSON(): typeof styled.styledJSON;
+    static get table(): typeof styled.Table.table;
+    static get tree(): typeof styled.tree;
+    static get wait(): typeof uxWait;
+    static get progress(): typeof styled.progress;
+    static done(): Promise<void>;
+    static trace(format: string, ...args: string[]): void;
+    static debug(format: string, ...args: string[]): void;
+    static info(format: string, ...args: string[]): void;
+    static log(format?: string, ...args: string[]): void;
+    static url(text: string, uri: string, params?: {}): void;
+    static annotation(text: string, annotation: string): void;
+    static flush(ms?: number): Promise<void>;
+}
+declare const action: ActionBase;
+declare const annotation: typeof ux.annotation;
+declare const anykey: typeof uxPrompt.anykey;
+declare const confirm: typeof uxPrompt.confirm;
+declare const debug: typeof ux.debug;
+declare const done: typeof ux.done;
+declare const error: typeof Errors.error;
+declare const exit: typeof Errors.exit;
+declare const flush: typeof ux.flush;
+declare const info: typeof ux.info;
+declare const log: typeof ux.log;
+declare const prideAction: ActionBase;
+declare const progress: typeof styled.progress;
+declare const prompt: typeof uxPrompt.prompt;
+declare const styledHeader: typeof styled.styledHeader;
+declare const styledJSON: typeof styled.styledJSON;
+declare const styledObject: typeof ux.styledObject;
+declare const table: typeof styled.Table.table;
+declare const trace: typeof ux.trace;
+declare const tree: typeof styled.tree;
+declare const url: typeof ux.url;
+declare const wait: (ms?: number) => Promise<void>;
+declare const warn: typeof Errors.warn;
+export { action, ActionBase, annotation, anykey, config, Config, confirm, debug, done, error, exit, ExitError, flush, info, IPromptOptions, log, prideAction, progress, prompt, styledHeader, styledJSON, styledObject, table, Table, trace, tree, url, wait, warn, };