q9

node_modules/listr2/dist/interfaces/index.d.ts

@@ -0,0 +1,4 @@
+export * from './listr.interface';
+export * from './listr-error.interface';
+export * from './task.interface';
+export * from './renderer.interface';

node_modules/listr2/dist/interfaces/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./listr.interface"), exports);
+__exportStar(require("./listr-error.interface"), exports);
+__exportStar(require("./task.interface"), exports);
+__exportStar(require("./renderer.interface"), exports);

node_modules/listr2/dist/interfaces/listr-error.interface.d.ts

@@ -0,0 +1,29 @@
+import { ListrRendererFactory } from './renderer.interface';
+import { Task } from '../lib/task';
+/** The internal error handling mechanism.. */
+export declare class ListrError<Ctx extends Record<PropertyKey, any> = Record<PropertyKey, any>> extends Error {
+    error: Error;
+    type?: ListrErrorTypes;
+    ctx?: Ctx;
+    task?: Task<Ctx, ListrRendererFactory>;
+    constructor(error: Error, type?: ListrErrorTypes, ctx?: Ctx, task?: Task<Ctx, ListrRendererFactory>);
+}
+/**
+ * The actual error type that is collected and to help identify where the error is triggered from.
+ */
+export declare enum ListrErrorTypes {
+    /** Task has failed and will try to retry. */
+    WILL_RETRY = "WILL_RETRY",
+    /** Task has failed and will try to rollback. */
+    WILL_ROLLBACK = "WILL_ROLLBACK",
+    /** Task has failed, ran the rollback action but the rollback action itself has failed. */
+    HAS_FAILED_TO_ROLLBACK = "HAS_FAILED_TO_ROLLBACK",
+    /** Task has failed. */
+    HAS_FAILED = "HAS_FAILED",
+    /** Task has failed, but exitOnError is set to false, so will ignore this error. */
+    HAS_FAILED_WITHOUT_ERROR = "HAS_FAILED_WITHOUT_ERROR"
+}
+/** The internal error handling mechanism for prompts only. */
+export declare class PromptError extends Error {
+    constructor(message: string);
+}

node_modules/listr2/dist/interfaces/listr-error.interface.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromptError = exports.ListrErrorTypes = exports.ListrError = void 0;
+/** The internal error handling mechanism.. */
+class ListrError extends Error {
+    constructor(error, type, ctx, task) {
+        super(error.message);
+        this.error = error;
+        this.type = type;
+        this.ctx = ctx;
+        this.task = task;
+        this.stack = error === null || error === void 0 ? void 0 : error.stack;
+        this.name = 'ListrError';
+    }
+}
+exports.ListrError = ListrError;
+/**
+ * The actual error type that is collected and to help identify where the error is triggered from.
+ */
+var ListrErrorTypes;
+(function (ListrErrorTypes) {
+    /** Task has failed and will try to retry. */
+    ListrErrorTypes["WILL_RETRY"] = "WILL_RETRY";
+    /** Task has failed and will try to rollback. */
+    ListrErrorTypes["WILL_ROLLBACK"] = "WILL_ROLLBACK";
+    /** Task has failed, ran the rollback action but the rollback action itself has failed. */
+    ListrErrorTypes["HAS_FAILED_TO_ROLLBACK"] = "HAS_FAILED_TO_ROLLBACK";
+    /** Task has failed. */
+    ListrErrorTypes["HAS_FAILED"] = "HAS_FAILED";
+    /** Task has failed, but exitOnError is set to false, so will ignore this error. */
+    ListrErrorTypes["HAS_FAILED_WITHOUT_ERROR"] = "HAS_FAILED_WITHOUT_ERROR";
+})(ListrErrorTypes = exports.ListrErrorTypes || (exports.ListrErrorTypes = {}));
+/** The internal error handling mechanism for prompts only. */
+class PromptError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PromptError';
+    }
+}
+exports.PromptError = PromptError;

node_modules/listr2/dist/interfaces/listr.interface.d.ts

@@ -0,0 +1,170 @@
+/// <reference types="node" />
+import type * as Enquirer from 'enquirer';
+import type { Observable } from 'rxjs';
+import { Readable } from 'stream';
+import { ListrDefaultNonTTYRendererOptions, ListrDefaultRendererOptions, ListrDefaultRendererValue, ListrFallbackRendererValue, ListrGetRendererTaskOptions, ListrRendererFactory, ListrRendererValue } from './renderer.interface';
+import { ListrEventType } from '../constants/event.constants';
+import { Task } from '../lib/task';
+import { TaskWrapper } from '../lib/task-wrapper';
+import { Listr } from '../listr';
+/** Listr Default Context */
+export declare type ListrContext = any | undefined;
+/**
+ * ListrTask.
+ *
+ * Defines the task, conditions and options to run a specific task in the listr.
+ */
+export interface ListrTask<Ctx = ListrContext, Renderer extends ListrRendererFactory = any> {
+    /**
+     * Title of the task.
+     *
+     * Give this task a title if you want to track it by name in the current renderer.
+     *
+     * Tasks without a title will hide in the default renderer and are useful for running a background instance.
+     * On verbose renderer, state changes from these tasks will log as 'Task without a title.'
+     */
+    title?: string;
+    /**
+     * The task itself.
+     *
+     * Task can be a sync or async function, an Observable, or a Stream.
+     * Task will be executed, if the certain criteria of the state are met and whenever the time for that specific task has come.
+     */
+    task: (ctx: Ctx, task: TaskWrapper<Ctx, Renderer>) => void | ListrTaskResult<Ctx>;
+    /**
+     * Skip this task depending on the context.
+     *
+     * The function that has been passed in will be evaluated at the runtime when the task tries to initially run.
+     */
+    skip?: boolean | string | ((ctx: Ctx) => boolean | string | Promise<boolean | string>);
+    /**
+     * Enable a task depending on the context.
+     *
+     * The function that has been passed in will be evaluated at the initial creation of the Listr class for rendering purposes,
+     * as well as re-evaluated when the time for that specific task has come.
+     */
+    enabled?: boolean | ((ctx: Ctx) => boolean | Promise<boolean>);
+    /**
+     * Adds the given number of retry attempts to the task if the task fails.
+     */
+    retry?: number;
+    /**
+     * Runs a specific event if the current task or any of the subtasks has failed.
+     *
+     * Mostly useful for rollback purposes for subtasks.
+     * But can also be useful whenever a task is failed and some measures have to be taken to ensure the state is not changed.
+     */
+    rollback?: (ctx: Ctx, task: TaskWrapper<Ctx, Renderer>) => void | ListrTaskResult<Ctx>;
+    /**
+     * Set exit on the error option from task-level instead of setting it for all the subtasks.
+     */
+    exitOnError?: boolean | ((ctx: Ctx) => boolean | Promise<boolean>);
+    /**
+     * Per task options, that depends on the selected renderer.
+     *
+     * These options depend on the implementation of the selected renderer. If the selected renderer has no options it will
+     * be displayed as never.
+     */
+    options?: ListrGetRendererTaskOptions<Renderer>;
+}
+/**
+ * Options to set the behavior of this base task.
+ */
+export interface ListrOptions<Ctx = ListrContext> {
+    /**
+     * To inject a context through this options wrapper. Context can also be defined in run time.
+     *
+     * @default {}
+     */
+    ctx?: Ctx;
+    /**
+     * Concurrency sets how many tasks will be run at the same time in parallel.
+     *
+     * @default false > Default is to run everything synchronously.
+     *
+     * `true` will set it to `Infinity`, `false` will set it to synchronous.
+     *
+     * If you pass in a `number` it will limit it to that number.
+     */
+    concurrent?: boolean | number;
+    /**
+     * Determine the default behavior of exiting on errors.
+     *
+     * @default true > exit on any error coming from the tasks.
+     */
+    exitOnError?: boolean;
+    /**
+     * Determine the behavior of exiting after rollback actions.
+     *
+     * This is independent of exitOnError, since failure of a rollback can be a more critical operation comparing to
+     * failing a single task.
+     *
+     * @default true > exit after rolling back tasks
+     */
+    exitAfterRollback?: boolean;
+    /**
+     * By default, Listr2 will track SIGINIT signal to update the renderer one last time before completely failing.
+     *
+     * @default true
+     */
+    registerSignalListeners?: boolean;
+    /**
+     * Determine the certain condition required to use the non-TTY renderer.
+     *
+     * @default null > handled internally
+     */
+    rendererFallback?: boolean | (() => boolean);
+    /**
+     * Determine the certain condition required to use the silent renderer.
+     *
+     * @default null > handled internally
+     */
+    rendererSilent?: boolean | (() => boolean);
+    /**
+     * Disabling the color, useful for tests and such.
+     *
+     * @default false
+     */
+    disableColor?: boolean;
+    /**
+     * Inject data directly to TaskWrapper.
+     */
+    injectWrapper?: {
+        enquirer?: Enquirer<object>;
+    };
+}
+/**
+ * Task can be set of sync or async function, an Observable or a stream.
+ */
+export declare type ListrTaskResult<Ctx> = string | Promise<any> | Listr<Ctx, ListrRendererValue, any> | Readable | NodeJS.ReadableStream | Observable<any>;
+/**
+ * Parent class options.
+ *
+ * Parent class has more options where you can also select the and set renderer and non-tty renderer.
+ *
+ * Any subtasks will respect those options so they will be stripped of that properties.
+ */
+export declare type ListrBaseClassOptions<Ctx = ListrContext, Renderer extends ListrRendererValue = ListrDefaultRendererValue, FallbackRenderer extends ListrRendererValue = ListrFallbackRendererValue> = ListrOptions<Ctx> & ListrDefaultRendererOptions<Renderer> & ListrDefaultNonTTYRendererOptions<FallbackRenderer>;
+/**
+ * Sub class options.
+ *
+ * Subtasks has reduced set options where the missing ones are explicitly set by the base class.
+ */
+export declare type ListrSubClassOptions<Ctx = ListrContext, Renderer extends ListrRendererValue = ListrDefaultRendererValue> = ListrOptions<Ctx> & Omit<ListrDefaultRendererOptions<Renderer>, 'renderer'>;
+/** The internal communication event. */
+export declare type ListrEvent = {
+    type: Exclude<ListrEventType, 'MESSAGE' | 'DATA'>;
+    data?: string | boolean;
+} | {
+    type: ListrEventType.DATA;
+    data: string;
+} | {
+    type: ListrEventType.MESSAGE;
+    data: Task<any, any>['message'];
+};
+/**
+ * Used to match event.type to ListrEvent permutations
+ */
+export declare type ListrEventFromType<T extends ListrEventType, E = ListrEvent> = E extends {
+    type: infer U;
+} ? T extends U ? E : never : never;

node_modules/listr2/dist/interfaces/listr.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/listr2/dist/interfaces/renderer.interface.d.ts

@@ -0,0 +1,92 @@
+import { Subject } from 'rxjs';
+import { Task } from '../lib/task';
+import { DefaultRenderer } from '../renderer/default.renderer';
+import { SilentRenderer } from '../renderer/silent.renderer';
+import { SimpleRenderer } from '../renderer/simple.renderer';
+import { VerboseRenderer } from '../renderer/verbose.renderer';
+/** The default renderer value used in Listr2 applications */
+export declare type ListrDefaultRendererValue = 'default';
+/** Type of default renderer */
+export declare type ListrDefaultRenderer = typeof DefaultRenderer;
+/** Name of default fallback renderer */
+export declare type ListrFallbackRendererValue = 'verbose';
+/** Type of default fallback renderer */
+export declare type ListrFallbackRenderer = typeof VerboseRenderer;
+/** Silent rendere for internal usage */
+export declare type ListrSilentRendererValue = 'silent';
+/** Typeof silent renderer */
+export declare type ListrSilentRenderer = typeof SilentRenderer;
+/** Simple renderer that simplifies things */
+export declare type ListrSimpleRendererValue = 'simple';
+/** Typeof simple renderer */
+export declare type ListrSimpleRenderer = typeof SimpleRenderer;
+/**
+ * Listr2 can process either the integrated renderers as string aliases,
+ * or utilize a compatible style renderer that extends the ListrRenderer abstract class.
+ */
+export declare type ListrRendererValue = ListrSilentRendererValue | ListrDefaultRendererValue | ListrSimpleRendererValue | ListrFallbackRendererValue | ListrRendererFactory;
+/**
+ * Returns the class type from friendly names of the renderers.
+ */
+export declare type ListrGetRendererClassFromValue<T extends ListrRendererValue> = T extends ListrDefaultRendererValue ? ListrDefaultRenderer : T extends ListrSimpleRendererValue ? ListrSimpleRenderer : T extends ListrFallbackRendererValue ? ListrFallbackRenderer : T extends ListrSilentRenderer ? ListrSilentRenderer : T extends ListrRendererFactory ? T : never;
+/**
+ * Returns the friendly names from the type of renderer classes.
+ */
+export declare type ListrGetRendererValueFromClass<T extends ListrRendererFactory> = T extends DefaultRenderer ? ListrDefaultRendererValue : T extends SimpleRenderer ? ListrSimpleRendererValue : T extends VerboseRenderer ? ListrFallbackRendererValue : T extends SilentRenderer ? ListrSilentRenderer : T extends ListrRendererFactory ? T : never;
+/**
+ * Returns renderer global options depending on the renderer type.
+ */
+export declare type ListrGetRendererOptions<T extends ListrRendererValue> = T extends ListrDefaultRendererValue ? ListrDefaultRenderer['rendererOptions'] : T extends ListrSimpleRendererValue ? ListrSimpleRenderer['rendererOptions'] : T extends ListrFallbackRendererValue ? ListrFallbackRenderer['rendererOptions'] : T extends ListrSilentRenderer ? ListrSilentRenderer['rendererOptions'] : T extends ListrRendererFactory ? T['rendererOptions'] : never;
+/**
+ * Returns renderer per task options depending on the renderer type.
+ */
+export declare type ListrGetRendererTaskOptions<T extends ListrRendererValue> = T extends ListrDefaultRendererValue ? ListrDefaultRenderer['rendererTaskOptions'] : T extends ListrSimpleRendererValue ? ListrSimpleRenderer : T extends ListrFallbackRendererValue ? ListrFallbackRenderer['rendererTaskOptions'] : T extends ListrSilentRenderer ? ListrSilentRenderer['rendererTaskOptions'] : T extends ListrRendererFactory ? T['rendererTaskOptions'] : never;
+/** Select renderer as default renderer */
+export interface ListrDefaultRendererOptions<T extends ListrRendererValue> {
+    /** the default renderer */
+    renderer?: T;
+    /** Renderer options depending on the current renderer */
+    rendererOptions?: ListrGetRendererOptions<T>;
+}
+/** Select a fallback renderer to fallback to in non-tty conditions */
+export interface ListrDefaultNonTTYRendererOptions<T extends ListrRendererValue> {
+    /** the fallback renderer to fallback to on non-tty conditions */
+    nonTTYRenderer?: T;
+    /** Renderer options depending on the current renderer */
+    nonTTYRendererOptions?: ListrGetRendererOptions<T>;
+}
+/** Renderer options for the base class, including setup for selecting default and fallback renderers.  */
+export declare type ListrRendererOptions<Renderer extends ListrRendererValue, FallbackRenderer extends ListrRendererValue> = ListrDefaultRendererOptions<Renderer> & ListrDefaultNonTTYRendererOptions<FallbackRenderer>;
+/** The bones of a listr renderer. */
+export declare class ListrRenderer {
+    /** designate renderer global options that is specific to the current renderer */
+    static rendererOptions: Record<PropertyKey, any>;
+    /** designate renderer per task options that is specific to the current renderer  */
+    static rendererTaskOptions: Record<PropertyKey, any>;
+    /** designate whether this renderer can work in non-tty environments */
+    static nonTTY: boolean;
+    /** A function to what to do on render */
+    render: () => void;
+    /** A function to what to do on end of the render */
+    end: (err?: Error) => void;
+    /** create a new renderer */
+    constructor(tasks: readonly Task<any, ListrRendererFactory>[], options: typeof ListrRenderer.rendererOptions, renderHook$?: Subject<void>);
+}
+/** Exported for javascript applications to extend the base renderer */
+export declare class ListrBaseRenderer implements ListrRenderer {
+    static rendererOptions: Record<PropertyKey, any>;
+    static rendererTaskOptions: Record<PropertyKey, any>;
+    static nonTTY: boolean;
+    tasks: Task<any, typeof ListrBaseRenderer>[];
+    options: typeof ListrBaseRenderer.rendererOptions;
+    render: () => void;
+    end: (err?: Error) => void;
+    constructor(tasks: Task<any, typeof ListrBaseRenderer>[], options: typeof ListrBaseRenderer.rendererOptions);
+}
+/** A renderer factory from the current type */
+export declare type ListrRendererFactory = typeof ListrRenderer;
+/** Supported type of renderers for each type in the listr. */
+export interface SupportedRenderer {
+    renderer: ListrRendererFactory;
+    nonTTY: boolean;
+}

node_modules/listr2/dist/interfaces/renderer.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/listr2/dist/interfaces/task.interface.d.ts

@@ -0,0 +1,4 @@
+import type { Task } from '../lib/task';
+import type { TaskWrapper } from '../lib/task-wrapper';
+export { Task as ListrTaskObject };
+export { TaskWrapper as ListrTaskWrapper };

node_modules/listr2/dist/interfaces/task.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });