@tsed/cli-tasks 7.0.0-beta.13

package/lib/esm/domain/TaskLogger.js

@@ -0,0 +1,270 @@
+import { log, progress, spinner, taskLog } from "@clack/prompts";
+import { contextLogger } from "@tsed/di";
+export class TaskLogger {
+    #title;
+    #logger;
+    #verbose;
+    #parent;
+    #index;
+    constructor(opts) {
+        this.#title = opts.title;
+        this.type = opts.type;
+        this.#parent = opts.parent;
+        this.#verbose = opts.verbose;
+        this.#logger = this.create({
+            ...opts,
+            verbose: this.#verbose
+        });
+    }
+    get parent() {
+        return this.#parent;
+    }
+    get isReady() {
+        return !!this.#logger;
+    }
+    get title() {
+        return this.#title;
+    }
+    set title(title) {
+        if (title) {
+            this.#title = title;
+            this.#logger.message?.(title);
+        }
+    }
+    set output(message) {
+        if (message) {
+            (this.#logger.info || this.#logger.message)?.(message);
+        }
+    }
+    static from(opts) {
+        if (opts.parent) {
+            switch (opts.parent.type) {
+                case "progress":
+                    return new TaskLogger({
+                        ...opts,
+                        type: "progress",
+                        parent: opts.parent
+                    });
+                case "spinner":
+                    return opts.parent;
+            }
+        }
+        if (opts.parent) {
+            if (opts.parent?.parent) {
+                opts.type = opts.type || "group";
+            }
+            else {
+                opts.type = opts.type || "taskLog";
+            }
+        }
+        opts.type = opts.type || "log";
+        return new TaskLogger(opts);
+    }
+    log(message) {
+        this.#logger.message(`${this.title} - ${message}`);
+    }
+    message(message) {
+        this.#logger.message(`${this.title} - ${message}`);
+    }
+    advance() {
+        if (this.isReady && this.type === "progress") {
+            if (this.isRaw()) {
+                this.info(`${this.title} [${this.#index}/${this.parent.max}]`);
+            }
+            else {
+                const it = Math.round((1 / this.parent.max) * 100);
+                this.#logger.advance(it, this.title);
+            }
+        }
+        return this;
+    }
+    start() {
+        if (this.isReady) {
+            const msg = `${this.title}...`;
+            switch (this.type) {
+                default:
+                    this.#logger.message(msg);
+                    break;
+                case "log":
+                    this.#logger.info(msg);
+                    break;
+                case "progress":
+                    if (this.isChildProgress()) {
+                        this.advance();
+                    }
+                    else {
+                        this.#logger.start(this.title);
+                    }
+                    break;
+                case "spinner":
+                    this.#logger.start(this.title);
+                    break;
+            }
+        }
+        return this;
+    }
+    done() {
+        if (this.isReady) {
+            const msg = `${this.title} completed`;
+            switch (this.type) {
+                default:
+                    this.#logger.success(msg);
+                    break;
+                case "progress":
+                    if (!this.isChildProgress()) {
+                        this.#logger.stop(msg);
+                    }
+                    break;
+                case "spinner":
+                    this.#logger.stop(msg);
+                    break;
+            }
+        }
+        return this;
+    }
+    error(message) {
+        if (this.isReady) {
+            this.#logger.error(`${this.title} - ${message}`);
+        }
+        return this;
+    }
+    info(message) {
+        if (this.isReady) {
+            switch (this.type) {
+                case "log":
+                case "taskLog":
+                    this.#logger.info(`${this.title} - ${message}`);
+                    break;
+                default:
+                    this.#logger.message(`${this.title} - ${message}`);
+                    break;
+            }
+        }
+        return this;
+    }
+    warn(message) {
+        if (this.isReady) {
+            switch (this.type) {
+                case "log":
+                case "taskLog":
+                    this.#logger.warn(`${this.title} - ${message}`);
+                    break;
+                default:
+                    this.#logger.message(`${this.title} - WARN ${message}`);
+            }
+        }
+        return this;
+    }
+    skip() {
+        if (this.isReady) {
+            switch (this.type) {
+                default:
+                case "log":
+                    this.#logger.warn(`${this.title} skipped...`);
+                    break;
+                case "group":
+                case "taskLog":
+                    this.#logger.error(`${this.title} skipped...`);
+                    break;
+                case "progress":
+                    this.advance();
+                    break;
+                case "spinner":
+                    this.#logger.stop(`${this.title} skipped...`);
+                    break;
+            }
+        }
+        return this;
+    }
+    /**
+     * @ddeprecated use info or message instead
+     * @param message
+     */
+    report(message) {
+        (this.#logger.info || this.#logger.message)?.(message);
+    }
+    isChildProgress() {
+        return this.parent?.type === "progress" && this.type === "progress";
+    }
+    create(opts) {
+        const { type, title, parent } = opts;
+        if (this.isRaw()) {
+            const success = (message) => {
+                !this.isEnvTest() &&
+                    contextLogger()?.info({
+                        state: "SUCCESS",
+                        title,
+                        message
+                    });
+            };
+            const start = (message) => {
+                !this.isEnvTest() &&
+                    contextLogger()?.info({
+                        title,
+                        message
+                    });
+            };
+            const defaultLogger = {
+                message: (message) => {
+                    !this.isEnvTest() &&
+                        contextLogger()?.info({
+                            state: "MSG",
+                            title,
+                            message
+                        });
+                },
+                stop: success,
+                success,
+                info: start,
+                start,
+                warn: (message) => {
+                    !this.isEnvTest() &&
+                        contextLogger()?.warn({
+                            title,
+                            message
+                        });
+                },
+                error: (message) => {
+                    !this.isEnvTest() &&
+                        contextLogger()?.error({
+                            title,
+                            message
+                        });
+                }
+            };
+            defaultLogger.message("...");
+            return defaultLogger;
+        }
+        switch (type) {
+            case "spinner":
+                const spin = spinner();
+                spin.message(title);
+                return spin;
+            case "progress":
+                if (parent && this.isChildProgress()) {
+                    return parent.#logger;
+                }
+                return progress({
+                    style: "block",
+                    max: 100
+                });
+            case "taskLog":
+                return taskLog({
+                    title: this.title
+                });
+            case "log":
+                return log;
+            case "group":
+                if (!parent || parent.type !== "taskLog") {
+                    return log;
+                }
+                return parent.#logger.group(this.title);
+        }
+    }
+    isRaw() {
+        return this.#verbose || this.isEnvTest();
+    }
+    isEnvTest() {
+        return process.env.NODE_ENV === "test";
+    }
+}

package/lib/esm/fn/taskLogger.js

@@ -0,0 +1,4 @@
+import { context, ContextLogger, contextLogger } from "@tsed/di";
+export function taskLogger() {
+    return context().get("TASK_LOGGER") || contextLogger();
+}

package/lib/esm/index.js

@@ -0,0 +1,4 @@
+export * from "./domain/TaskLogger.js";
+export * from "./fn/taskLogger.js";
+export * from "./interfaces/Task.js";
+export * from "./tasks.js";

package/lib/esm/interfaces/Task.js

@@ -0,0 +1 @@
+import { TaskLogger } from "../domain/TaskLogger.js";

package/lib/esm/tasks.js

@@ -0,0 +1,101 @@
+import { isArray } from "@tsed/core/utils/isArray";
+import { isBoolean } from "@tsed/core/utils/isBoolean";
+import { isFunction } from "@tsed/core/utils/isFunction";
+import { isObservable } from "@tsed/core/utils/isObservable";
+import { isPromise } from "@tsed/core/utils/isPromise";
+import { isString } from "@tsed/core/utils/isString";
+import { context } from "@tsed/di";
+import { TaskLogger } from "./domain/TaskLogger.js";
+export async function tasks(list, ctx, parent) {
+    const items = list.filter((task) => isEnabled(task));
+    parent && (parent.max = items.length);
+    for (let i = 0; i < items.length; i++) {
+        const task = items[i];
+        const taskLogger = TaskLogger.from({
+            index: i,
+            title: task.title,
+            type: task.type,
+            parent,
+            verbose: ctx.verbose
+        });
+        try {
+            if (!(await isExecutable(task, ctx))) {
+                taskLogger.skip();
+                continue;
+            }
+            taskLogger.start();
+            context().set("TASK_LOGGER", taskLogger);
+            const result = await resolveTaskResult(task.task(ctx, taskLogger), taskLogger);
+            context().delete("TASK_LOGGER");
+            if (isArray(result)) {
+                await tasks(result, ctx, taskLogger);
+            }
+            taskLogger.done();
+        }
+        catch (er) {
+            taskLogger.error(er);
+            throw er;
+        }
+    }
+}
+function resolveTaskResult(result, logger) {
+    if (!result) {
+        return result;
+    }
+    if (isPromise(result)) {
+        return result;
+    }
+    if (isObservable(result)) {
+        return new Promise((resolve, reject) => {
+            let subscription;
+            subscription = result.subscribe({
+                next(value) {
+                    if (isString(value)) {
+                        logger.message(value);
+                    }
+                },
+                complete() {
+                    subscription?.unsubscribe?.();
+                    resolve(undefined);
+                },
+                error(err) {
+                    subscription?.unsubscribe?.();
+                    reject(err);
+                }
+            });
+        });
+    }
+    return result;
+}
+export async function concat(...args) {
+    const tasks = [];
+    for (const arg of args) {
+        if (isArray(arg)) {
+            tasks.push(...arg);
+        }
+    }
+    return tasks;
+}
+function isEnabled(item) {
+    return isBoolean(item.enabled) ? item.enabled : true;
+}
+async function isExecutable(item, ctx) {
+    if (isFunction(item.enabled)) {
+        const isEnable = await item.enabled(ctx);
+        if (!isEnable) {
+            return false;
+        }
+    }
+    if ("skip" in item) {
+        const isSkipped = isFunction(item.skip) ? await item.skip(ctx) : item.skip;
+        if (isSkipped) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * @deprecated use tasks function instead
+ */
+export const createTasksRunner = tasks;
+export const createSubTasks = tasks;