@commercelayer/cli-ux 1.0.1

package/lib/index.d.mts

@@ -0,0 +1,469 @@
+import { Options as Options$1, SingleBar } from 'cli-progress';
+import { Interfaces, Errors } from '@oclif/core';
+
+declare const _default$2: {
+    arc: {
+        frames: string[];
+        interval: number;
+    };
+    arrow: {
+        frames: string[];
+        interval: number;
+    };
+    arrow2: {
+        frames: string[];
+        interval: number;
+    };
+    arrow3: {
+        frames: string[];
+        interval: number;
+    };
+    balloon: {
+        frames: string[];
+        interval: number;
+    };
+    balloon2: {
+        frames: string[];
+        interval: number;
+    };
+    bounce: {
+        frames: string[];
+        interval: number;
+    };
+    bouncingBall: {
+        frames: string[];
+        interval: number;
+    };
+    bouncingBar: {
+        frames: string[];
+        interval: number;
+    };
+    boxBounce: {
+        frames: string[];
+        interval: number;
+    };
+    boxBounce2: {
+        frames: string[];
+        interval: number;
+    };
+    circle: {
+        frames: string[];
+        interval: number;
+    };
+    circleHalves: {
+        frames: string[];
+        interval: number;
+    };
+    circleQuarters: {
+        frames: string[];
+        interval: number;
+    };
+    clock: {
+        frames: string[];
+        interval: number;
+    };
+    dots: {
+        frames: string[];
+        interval: number;
+    };
+    dots2: {
+        frames: string[];
+        interval: number;
+    };
+    dots3: {
+        frames: string[];
+        interval: number;
+    };
+    dots4: {
+        frames: string[];
+        interval: number;
+    };
+    dots5: {
+        frames: string[];
+        interval: number;
+    };
+    dots6: {
+        frames: string[];
+        interval: number;
+    };
+    dots7: {
+        frames: string[];
+        interval: number;
+    };
+    dots8: {
+        frames: string[];
+        interval: number;
+    };
+    dots9: {
+        frames: string[];
+        interval: number;
+    };
+    dots10: {
+        frames: string[];
+        interval: number;
+    };
+    dots11: {
+        frames: string[];
+        interval: number;
+    };
+    earth: {
+        frames: string[];
+        interval: number;
+    };
+    flip: {
+        frames: string[];
+        interval: number;
+    };
+    growHorizontal: {
+        frames: string[];
+        interval: number;
+    };
+    growVertical: {
+        frames: string[];
+        interval: number;
+    };
+    hamburger: {
+        frames: string[];
+        interval: number;
+    };
+    hearts: {
+        frames: string[];
+        interval: number;
+    };
+    hexagon: {
+        frames: string[];
+        interval: number;
+    };
+    line: {
+        frames: string[];
+        interval: number;
+    };
+    line2: {
+        frames: string[];
+        interval: number;
+    };
+    monkey: {
+        frames: string[];
+        interval: number;
+    };
+    moon: {
+        frames: string[];
+        interval: number;
+    };
+    noise: {
+        frames: string[];
+        interval: number;
+    };
+    pipe: {
+        frames: string[];
+        interval: number;
+    };
+    pong: {
+        frames: string[];
+        interval: number;
+    };
+    runner: {
+        frames: string[];
+        interval: number;
+    };
+    simpleDots: {
+        frames: string[];
+        interval: number;
+    };
+    simpleDotsScrolling: {
+        frames: string[];
+        interval: number;
+    };
+    smiley: {
+        frames: string[];
+        interval: number;
+    };
+    squareCorners: {
+        frames: string[];
+        interval: number;
+    };
+    squish: {
+        frames: string[];
+        interval: number;
+    };
+    star: {
+        frames: string[];
+        interval: number;
+    };
+    star2: {
+        frames: string[];
+        interval: number;
+    };
+    toggle: {
+        frames: string[];
+        interval: number;
+    };
+    toggle2: {
+        frames: string[];
+        interval: number;
+    };
+    toggle3: {
+        frames: string[];
+        interval: number;
+    };
+    toggle4: {
+        frames: string[];
+        interval: number;
+    };
+    toggle5: {
+        frames: string[];
+        interval: number;
+    };
+    toggle6: {
+        frames: string[];
+        interval: number;
+    };
+    toggle7: {
+        frames: string[];
+        interval: number;
+    };
+    toggle8: {
+        frames: string[];
+        interval: number;
+    };
+    toggle9: {
+        frames: string[];
+        interval: number;
+    };
+    toggle10: {
+        frames: string[];
+        interval: number;
+    };
+    toggle11: {
+        frames: string[];
+        interval: number;
+    };
+    toggle12: {
+        frames: string[];
+        interval: number;
+    };
+    toggle13: {
+        frames: string[];
+        interval: number;
+    };
+    triangle: {
+        frames: string[];
+        interval: number;
+    };
+};
+
+type Options = {
+    stdout?: boolean;
+    style?: keyof typeof _default$2;
+};
+
+interface ITask {
+    action: string;
+    active: boolean;
+    status: string | undefined;
+}
+type ActionType = 'debug' | 'simple' | 'spinner';
+declare class ActionBase {
+    std: 'stderr' | 'stdout';
+    protected stdmocks?: Array<['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;
+    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();
+}
+
+type Levels = 'debug' | 'error' | 'fatal' | 'info' | 'trace' | 'warn';
+declare class Config {
+    action: ActionBase;
+    errorsHandled: boolean;
+    outputLevel: Levels;
+    showStackTrace: boolean;
+    get context(): any;
+    set context(v: unknown);
+    get debug(): boolean;
+    set debug(v: boolean);
+}
+declare const config: Config;
+
+interface IPromptOptions {
+    default?: string;
+    prompt?: string;
+    /**
+     * Requires user input if true, otherwise allows empty input
+     */
+    required?: boolean;
+    timeout?: number;
+    type?: 'hide' | 'mask' | 'normal' | 'single';
+}
+/**
+ * prompt for input
+ * @param name - prompt text
+ * @param options - @see IPromptOptions
+ * @returns Promise<string>
+ */
+declare function prompt$1(name: string, options?: IPromptOptions): Promise<string>;
+/**
+ * confirmation prompt (yes/no)
+ * @param message - confirmation text
+ * @returns Promise<boolean>
+ */
+declare function confirm$1(message: string): Promise<boolean>;
+/**
+ * "press anykey to continue"
+ * @param message - optional message to display to user
+ * @returns Promise<string>
+ */
+declare function anykey$1(message?: string): Promise<string>;
+
+declare function progress$1(options?: Options$1): SingleBar;
+
+declare function table$1<T extends Record<string, unknown>>(data: T[], columns: table$1.Columns<T>, options?: table$1.Options): void;
+declare namespace table$1 {
+    export const Flags: {
+        columns: Interfaces.OptionFlag<string | undefined>;
+        csv: Interfaces.BooleanFlag<boolean>;
+        extended: Interfaces.BooleanFlag<boolean>;
+        filter: Interfaces.OptionFlag<string | undefined>;
+        'no-header': Interfaces.BooleanFlag<boolean>;
+        'no-truncate': Interfaces.BooleanFlag<boolean>;
+        output: Interfaces.OptionFlag<string | undefined>;
+        sort: Interfaces.OptionFlag<string | undefined>;
+    };
+    type IFlags = typeof Flags;
+    type ExcludeFlags<T, Z> = Pick<T, Exclude<keyof T, Z>>;
+    type IncludeFlags<T, K extends keyof T> = Pick<T, K>;
+    export function flags(): IFlags;
+    export function flags<Z extends keyof IFlags = keyof IFlags>(opts: {
+        except: Z | Z[];
+    }): ExcludeFlags<IFlags, Z>;
+    export function flags<K extends keyof IFlags = keyof IFlags>(opts: {
+        only: K | K[];
+    }): IncludeFlags<IFlags, K>;
+    export interface Column<T extends Record<string, unknown>> {
+        extended: boolean;
+        get(row: T): any;
+        header: string;
+        minWidth: number;
+    }
+    export type Columns<T extends Record<string, unknown>> = Record<string, Partial<Column<T>>>;
+    export interface Options {
+        [key: string]: any;
+        columns?: string;
+        extended?: boolean;
+        filter?: string;
+        'no-header'?: boolean;
+        'no-truncate'?: boolean;
+        output?: string;
+        printLine?(s: any): any;
+        sort?: string;
+    }
+    export {  };
+}
+
+declare namespace table$2 {
+  export { table$1 as table };
+}
+
+declare class Tree {
+    nodes: Record<string, Tree>;
+    display(logger?: any): void;
+    insert(child: string, value?: Tree): this;
+    search(key: string): Tree | undefined;
+}
+declare function tree$1(): Tree;
+
+declare const _default$1: (ms?: number) => Promise<void>;
+
+declare class ExitError extends Error {
+    code: 'EEXIT';
+    error?: Error;
+    ux: {
+        exit: number;
+    };
+    constructor(status: number, error?: Error);
+}
+
+declare const STANDARD_CHALK: readonly ["white", "black", "blue", "yellow", "green", "red", "magenta", "cyan", "gray", "blackBright", "redBright", "greenBright", "yellowBright", "blueBright", "magentaBright", "cyanBright", "whiteBright", "bgBlack", "bgRed", "bgGreen", "bgYellow", "bgBlue", "bgMagenta", "bgCyan", "bgWhite", "bgGray", "bgBlackBright", "bgRedBright", "bgGreenBright", "bgYellowBright", "bgBlueBright", "bgMagentaBright", "bgCyanBright", "bgWhiteBright", "bold", "underline", "dim", "italic", "strikethrough"];
+type StandardChalk = (typeof STANDARD_CHALK)[number];
+/**
+ * Add color to text.
+ * @param color color to use. Can be hex code (e.g. `#ff0000`), rgb (e.g. `rgb(255, 255, 255)`) or a chalk color (e.g. `red`)
+ * @param text string to colorize
+ * @returns colorized string
+ */
+declare function colorize(color: string | StandardChalk | undefined, text: string): string;
+
+declare const _default: {
+    stderr: (msg: string) => void;
+    stdout: (msg: string) => void;
+};
+
+declare class ux {
+    static config: Config;
+    static get action(): ActionBase;
+    static annotation(text: string, annotation: string): void;
+    /**
+     * "press anykey to continue"
+     */
+    static get anykey(): typeof anykey$1;
+    static get confirm(): typeof confirm$1;
+    static debug(format: string, ...args: string[]): void;
+    static done(): Promise<void>;
+    static flush(ms?: number): Promise<void>;
+    static info(format: string, ...args: string[]): void;
+    static log(format?: string, ...args: string[]): void;
+    static logToStderr(format?: string, ...args: string[]): void;
+    static get progress(): typeof progress$1;
+    static get prompt(): typeof prompt$1;
+    static styledHeader(header: string): void;
+    static styledJSON(obj: unknown): void;
+    static styledObject(obj: any, keys?: string[]): void;
+    static get table(): typeof table$1;
+    static trace(format: string, ...args: string[]): void;
+    static get tree(): typeof tree$1;
+    static url(text: string, uri: string, params?: {}): void;
+    static get wait(): typeof _default$1;
+}
+declare const action: ActionBase;
+declare const annotation: typeof ux.annotation;
+declare const anykey: typeof anykey$1;
+declare const confirm: typeof confirm$1;
+declare const debug: typeof ux.debug;
+declare const done: typeof ux.done;
+declare const flush: typeof ux.flush;
+declare const info: typeof ux.info;
+declare const log: typeof ux.log;
+declare const logToStderr: typeof ux.logToStderr;
+declare const progress: typeof progress$1;
+declare const prompt: typeof prompt$1;
+declare const styledHeader: typeof ux.styledHeader;
+declare const styledJSON: typeof ux.styledJSON;
+declare const styledObject: typeof ux.styledObject;
+declare const table: typeof table$1;
+declare const trace: typeof ux.trace;
+declare const tree: typeof tree$1;
+declare const url: typeof ux.url;
+declare const wait: (ms?: number) => Promise<void>;
+declare const error: typeof Errors.error;
+declare const exit: typeof Errors.exit;
+declare const warn: typeof Errors.warn;
+
+export { ActionBase, Config, ExitError, type IPromptOptions, table$2 as Table, action, annotation, anykey, colorize, config, confirm, debug, done, error, exit, flush, info, log, logToStderr, progress, prompt, styledHeader, styledJSON, styledObject, table, trace, tree, url, ux, wait, warn, _default as write };