@pisell/core 0.0.2

package/lib/tasks/index.js

@@ -0,0 +1,710 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/tasks/index.ts
+var tasks_exports = {};
+__export(tasks_exports, {
+  TasksManager: () => TasksManager
+});
+module.exports = __toCommonJS(tasks_exports);
+var import_dayjs = __toESM(require("dayjs"));
+var import_utils = require("@pisell/utils");
+var import_useTasks = __toESM(require("./useTasks"));
+var TasksManager = class _TasksManager {
+  static instance;
+  taskFunctions;
+  tasks = {
+    // 内置模块，  定时任务专用
+    scheduledTasks: {}
+  };
+  app;
+  db;
+  useTasks = import_useTasks.default;
+  watchTaskCallback = () => {
+  };
+  timerIds = [];
+  constructor(app) {
+    if (!app) {
+      throw new Error("app is required");
+    }
+    this.app = app;
+    this.taskFunctions = /* @__PURE__ */ new Map();
+    this.tasks = {
+      scheduledTasks: {}
+    };
+    this.db = app.dbManager;
+    this.timerIds = [];
+  }
+  // 单例模式
+  static getInstance(app) {
+    if (!_TasksManager.instance && app) {
+      _TasksManager.instance = new _TasksManager(app);
+    }
+    return _TasksManager.instance;
+  }
+  // 注册任务函数
+  addTaskFunction(name, fun) {
+    this.taskFunctions.set(name, fun);
+    console.log("Tasks--->", `注册任务函数成功: ${name}`);
+  }
+  // 注册任务函数列表
+  addTaskFunctions(tasks) {
+    tasks.forEach(({ name, fun }) => {
+      this.taskFunctions.set(name, fun);
+    });
+  }
+  getTasks() {
+    return this.tasks;
+  }
+  // 获取任务函数
+  getTaskFunction(name) {
+    if (!name) {
+      return null;
+    }
+    return this.taskFunctions.get(name);
+  }
+  // 初始化任务
+  async init() {
+  }
+  // 将任务队列状态同步到 local
+  saveTaskQueueToLocal = async (state) => {
+    var _a;
+    console.log("saveTaskQueueToLocal", state);
+    (_a = this.watchTaskCallback) == null ? void 0 : _a.call(this, this.tasks);
+  };
+  // 从 local 加载任务队列状态
+  loadTaskQueueFromLocal = async () => {
+    var _a, _b;
+    try {
+      const tasks = await this.db.get("tasks", "tasks");
+      for (let module2 in tasks) {
+        for (let queueId in tasks[module2]) {
+          for (let task of ((_b = (_a = tasks == null ? void 0 : tasks[module2]) == null ? void 0 : _a[queueId]) == null ? void 0 : _b.tasks) || []) {
+            if (task.destroy) {
+              delete tasks[module2][queueId].tasks;
+            }
+          }
+        }
+      }
+      return tasks;
+    } catch (err) {
+      console.log("loadTaskQueueFromLocal", err);
+      return null;
+    }
+  };
+  /**
+   * @title: 执行任务
+   * @description:
+   * @param {Task} task
+   * @return {*}
+   * @Author: zhiwei.Wang
+   * @Date: 2024-09-26 13:53
+   */
+  runTask = async (task) => {
+    const beforeAction = this.getTaskFunction(task.beforeAction || "");
+    const afterAction = this.getTaskFunction(task.afterAction || "");
+    const action = this.getTaskFunction(task.action || "");
+    let beforeActionRes;
+    let afterActionRes;
+    let actionRes = { status: "success" };
+    try {
+      if (beforeAction) {
+        beforeActionRes = await beforeAction({ task });
+      }
+      if (action) {
+        actionRes = await action({ task, beforeActionRes });
+      }
+      if (afterAction) {
+        afterActionRes = await afterAction({ task, actionRes, afterActionRes });
+      }
+    } catch (error) {
+      this.app.logger.addLog({
+        type: "info",
+        title: `任务执行失败-${task.id}`,
+        metadata: { error, taskPayload: task == null ? void 0 : task.payload }
+      });
+      actionRes = { status: "failure" };
+    }
+    console.log("Tasks--->", `任务执行成功: ${task.id}`);
+    return actionRes;
+  };
+  /**
+   * @title: 清除任务定时器
+   */
+  clearTaskTimer = (params) => {
+    const { timerId, taskId } = params;
+    const _timerIds = [];
+    const needClearTimerIds = [];
+    this.timerIds.forEach((id) => {
+      const taskIdRult = taskId ? (id == null ? void 0 : id.taskId) === taskId : true;
+      const timerIdRult = timerId ? (id == null ? void 0 : id.timerId) === timerId : true;
+      if (taskIdRult && timerIdRult) {
+        needClearTimerIds.push(id);
+      } else {
+        _timerIds.push(id);
+      }
+    });
+    if (needClearTimerIds.length) {
+      for (let id of needClearTimerIds) {
+        clearTimeout(id.timerId);
+      }
+    }
+    this.timerIds = [..._timerIds || []];
+  };
+  /**
+   * @title: 计算下一次执行时间
+   * @description: 根据定时任务配置计算下一次执行时间
+   * @param {Task} task
+   * @return {string | null} 下一次执行时间
+   */
+  calculateNextExecuteTime = (task) => {
+    if (!task.scheduled) {
+      return null;
+    }
+    const { scheduled, scheduledResult } = task;
+    const now = (0, import_dayjs.default)();
+    if (scheduled.endAt && now.isAfter((0, import_dayjs.default)(scheduled.endAt))) {
+      return null;
+    }
+    if (Array.isArray(scheduled.executeAt)) {
+      const futureTime = scheduled.executeAt.map((time) => (0, import_dayjs.default)(time)).filter((time) => time.isAfter(now)).sort((a, b) => a.valueOf() - b.valueOf())[0];
+      if (futureTime) {
+        return futureTime.format("YYYY-MM-DD HH:mm:ss");
+      }
+      if (!scheduled.repeat) {
+        return null;
+      }
+    }
+    if (scheduled.repeat && (scheduledResult == null ? void 0 : scheduledResult.nextExecuteTime)) {
+      const lastExecuteTime = (0, import_dayjs.default)(scheduledResult.nextExecuteTime);
+      const interval = scheduled.repeatInterval || 1;
+      let nextTime = lastExecuteTime;
+      switch (scheduled.repeatType) {
+        case "daily":
+          nextTime = lastExecuteTime.add(interval, "day");
+          break;
+        case "weekly":
+          nextTime = lastExecuteTime.add(interval, "week");
+          break;
+        case "monthly":
+          nextTime = lastExecuteTime.add(interval, "month");
+          break;
+        case "yearly":
+          nextTime = lastExecuteTime.add(interval, "year");
+          break;
+        default:
+          nextTime = lastExecuteTime.add(interval, "day");
+      }
+      if (scheduled.endAt && nextTime.isAfter((0, import_dayjs.default)(scheduled.endAt))) {
+        return null;
+      }
+      return nextTime.format("YYYY-MM-DD HH:mm:ss");
+    }
+    const executeTime = Array.isArray(scheduled.executeAt) ? scheduled.executeAt[0] : scheduled.executeAt;
+    return (0, import_dayjs.default)(executeTime).format("YYYY-MM-DD HH:mm:ss");
+  };
+  /**
+   * @title: 启动定时任务
+   * @description: 在特定时间点执行任务（仅在 scheduledTasks 模块中生效）
+   * @param {Task} task
+   * @return {*}
+   */
+  startScheduledTask = (task) => {
+    var _a;
+    if (!task.scheduled) {
+      console.log("Tasks--->", "不是定时任务");
+      return;
+    }
+    if (task.module !== "scheduledTasks") {
+      console.warn("Tasks--->", `定时任务只在 scheduledTasks 模块中生效，任务 ${task.id} 将作为普通任务执行`);
+      return;
+    }
+    const nextExecuteTime = this.calculateNextExecuteTime(task);
+    if (!nextExecuteTime) {
+      console.log("Tasks--->", "定时任务已完成或无下次执行时间", task);
+      this.deleteTask({
+        module: task.module,
+        queueId: task.queueId,
+        taskId: task.id
+      });
+      return;
+    }
+    const now = (0, import_dayjs.default)();
+    const executeTime = (0, import_dayjs.default)(nextExecuteTime);
+    const delay = executeTime.diff(now);
+    if (delay < 0) {
+      console.log("Tasks--->", "执行时间已过，跳过此次执行");
+      if (task.scheduled.repeat) {
+        const _task = { ...task };
+        _task.scheduledResult = {
+          count: ((_a = _task.scheduledResult) == null ? void 0 : _a.count) || 0,
+          nextExecuteTime
+        };
+        const newTask = this.updateTask({
+          module: task.module,
+          queueId: task.queueId,
+          taskId: task.id,
+          other: _task
+        });
+        if (newTask) {
+          this.startScheduledTask(newTask);
+        }
+      } else {
+        this.deleteTask({
+          module: task.module,
+          queueId: task.queueId,
+          taskId: task.id
+        });
+      }
+      return;
+    }
+    console.log("Tasks--->", `定时任务将在 ${nextExecuteTime} 执行 (${delay}ms 后)`, task);
+    const timerId = setTimeout(async () => {
+      var _a2, _b;
+      try {
+        await this.runTask(task);
+        console.log("Tasks--->", "定时任务执行完成", task);
+        let _task = { ...task };
+        _task.scheduledResult = {
+          count: (((_a2 = _task.scheduledResult) == null ? void 0 : _a2.count) || 0) + 1,
+          timerId,
+          nextExecuteTime
+        };
+        if ((_b = task.scheduled) == null ? void 0 : _b.repeat) {
+          const newTask = this.updateTask({
+            module: task.module,
+            queueId: task.queueId,
+            taskId: task.id,
+            other: _task
+          });
+          if (newTask) {
+            this.startScheduledTask(newTask);
+          }
+        } else {
+          this.deleteTask({
+            module: task.module,
+            queueId: task.queueId,
+            taskId: task.id
+          });
+        }
+      } catch (error) {
+        this.clearTaskTimer({ timerId });
+        console.error("定时任务执行异常", error);
+      }
+    }, delay);
+    this.timerIds.push({ taskId: task.id, timerId });
+  };
+  /**
+   * @title: 启动轮询
+   * @description: 根据轮询间隔定期执行任务
+   * @param {Task} task
+   * @return {*}
+   */
+  startPolling = (task) => {
+    if (!task.polling || !task.polling.interval) {
+      console.log("不是轮询任务");
+      return;
+    }
+    const timerId = setTimeout(async () => {
+      var _a;
+      try {
+        await this.runTask(task);
+        console.log("轮询任务", task);
+        let _task = { ...task };
+        _task.pollingResult = {
+          count: (((_a = _task.pollingResult) == null ? void 0 : _a.count) || 0) + 1,
+          timerId
+        };
+        const newTask = this.updateTask({
+          module: task.module,
+          queueId: task.queueId,
+          taskId: task.id,
+          other: _task
+        });
+        if (!newTask) {
+          return;
+        }
+        this.startPolling(newTask);
+      } catch (error) {
+        this.clearTaskTimer({ timerId });
+        console.error("轮询任务异常", error);
+      }
+    }, task.polling.interval);
+    this.timerIds.push({ taskId: task.id, timerId });
+  };
+  /**
+   * @title: 创建任务数据
+   * @description:
+   * @param {Partial} payload
+   * @return {*}
+   * @Author: zhiwei.Wang
+   * @Date: 2024-09-26 13:54
+   */
+  createTaskData = (payload) => {
+    return {
+      id: (0, import_utils.getUniqueId)("task_"),
+      create_at: (0, import_dayjs.default)().format("YYYY-MM-DD HH:mm:ss"),
+      type: "local",
+      retries: 0,
+      maxRetries: 3,
+      status: "pending",
+      // 执行函数
+      action: "",
+      // 执行参数
+      payload: {},
+      // 执行前的钩子
+      beforeAction: "",
+      // 执行前的参数
+      beforePayload: {},
+      // 执行后的钩子
+      afterAction: "",
+      // 执行后的参数
+      afterPayload: {},
+      destroy: true,
+      ...payload
+    };
+  };
+  getTaskQueue = (payload) => {
+    var _a, _b;
+    const { queueId, module: module2 } = payload;
+    return (_b = (_a = this.tasks[module2]) == null ? void 0 : _a[queueId]) == null ? void 0 : _b.tasks;
+  };
+  timeout = (ms) => {
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        resolve(true);
+      }, ms || 5e3);
+    });
+  };
+  /**
+   * @title: 执行任务队列
+   * @description:
+   * @return {*}
+   * @Author: zhiwei.Wang
+   * @Date: 2024-09-26 13:52
+   */
+  async run(payload) {
+    var _a, _b, _c, _d, _e;
+    const { queueId, module: module2, callback } = payload;
+    const currentQueue = (_a = this.tasks[module2]) == null ? void 0 : _a[queueId];
+    if (currentQueue == null ? void 0 : currentQueue.isRunning) {
+      console.warn(
+        "Tasks--->",
+        `任务队列 [${module2}/${queueId}] 正在执行中，已拦截重复调用。`,
+        `当前进度: ${((_b = currentQueue.progress) == null ? void 0 : _b.completed) || 0}/${((_c = currentQueue.progress) == null ? void 0 : _c.total) || 0}`,
+        `如需重新执行，请等待当前任务队列执行完成。`
+      );
+      return;
+    }
+    this.updateQueueRunningState({
+      module: module2,
+      queueId,
+      isRunning: true,
+      lastRunAt: (0, import_dayjs.default)().format("YYYY-MM-DD HH:mm:ss")
+    });
+    console.log("Tasks--->", `任务队列 [${module2}/${queueId}] 开始执行`);
+    let taskQueueStatus = "";
+    try {
+      while (taskQueueStatus !== "completed") {
+        const taskQueue = this.getTaskQueue(payload);
+        const errorTaskIds = [];
+        if (taskQueue && taskQueue.length) {
+          const tasksToExecute = taskQueue.filter(
+            (task) => (task == null ? void 0 : task.status) === "pending" || (task == null ? void 0 : task.status) === "failure"
+          );
+          console.log("Tasks--->", "需要执行的任务", tasksToExecute);
+          for (let task of tasksToExecute) {
+            try {
+              if (task.retries !== void 0 && task.maxRetries !== void 0 && task.retries < task.maxRetries) {
+                task.status = "in-progress";
+                this.updateTask({ module: module2, queueId, taskId: task.id, other: { status: task.status } });
+                if (task.scheduled && module2 === "scheduledTasks") {
+                  this.startScheduledTask(task);
+                } else if (task.polling) {
+                  this.startPolling(task);
+                } else {
+                  const { status } = await this.runTask(task);
+                  task.status = status;
+                }
+                if (task.status === "success") {
+                  if ((_d = task.pollingResult) == null ? void 0 : _d.timerId) {
+                  }
+                  this.deleteTask({ module: module2, queueId, taskId: task.id });
+                } else {
+                  let _other = {
+                    status: task.status
+                  };
+                  if (task.status === "failure") {
+                    _other.retries = task.retries + 1;
+                  }
+                  errorTaskIds.push(task.id);
+                  this.updateTask({ module: module2, queueId, taskId: task.id, other: _other });
+                }
+              } else {
+                console.log("Tasks--->", "任务没有重试次数，需要删除", task);
+                this.deleteTask({ module: module2, queueId, taskId: task.id });
+              }
+            } catch (error) {
+              console.error("任务异常", error);
+            }
+          }
+          taskQueueStatus = ((_e = this.getTaskQueue(payload)) == null ? void 0 : _e.some((task) => task.status === "failure")) ? "uncompleted" : "completed";
+          this.updateQueueStatus({
+            queueId,
+            module: module2,
+            status: taskQueueStatus
+          });
+          console.log("Tasks--->", "任务队列执行完成", taskQueue);
+        } else {
+          taskQueueStatus = "completed";
+        }
+        if (taskQueueStatus === "uncompleted") {
+          this.app.logger.addLog({
+            type: "info",
+            title: `任务队列执行存在失败-${queueId}`,
+            metadata: { taskQueue, errorTaskIds }
+          });
+          await this.timeout();
+        } else if (taskQueueStatus === "completed") {
+          console.log("Tasks--->", "任务队列全部执行完成");
+          callback == null ? void 0 : callback();
+        }
+      }
+    } finally {
+      this.updateQueueRunningState({
+        module: module2,
+        queueId,
+        isRunning: false
+      });
+      console.log("Tasks--->", `任务队列 [${module2}/${queueId}] 执行结束`);
+    }
+  }
+  deleteTask(payload) {
+    var _a, _b, _c, _d;
+    const { queueId, module: module2, taskId } = payload;
+    this.tasks[module2][queueId].tasks = (_d = (_c = (_b = (_a = this.tasks) == null ? void 0 : _a[module2]) == null ? void 0 : _b[queueId]) == null ? void 0 : _c.tasks) == null ? void 0 : _d.filter((task) => {
+      var _a2, _b2;
+      if (task.id === taskId) {
+        if ((_a2 = task.pollingResult) == null ? void 0 : _a2.timerId) {
+          this.clearTaskTimer({ timerId: task.pollingResult.timerId });
+        }
+        if ((_b2 = task.scheduledResult) == null ? void 0 : _b2.timerId) {
+          this.clearTaskTimer({ timerId: task.scheduledResult.timerId });
+        }
+        return false;
+      }
+      return true;
+    });
+    this.saveTaskQueueToLocal(this.tasks);
+    console.log("Tasks--->", "删除指定任务", queueId, module2, taskId);
+  }
+  /**
+   * @title: 重试任务
+   * @description:
+   * @return {*}
+   * @Author: zhiwei.Wang
+   * @Date: 2024-09-26 13:53
+   */
+  retryTask(payload) {
+    const { queueId, module: module2 } = payload;
+    this.run({ queueId, module: module2 });
+  }
+  // 添加任务
+  addTask(payload) {
+    var _a, _b, _c;
+    const { queueId, module: module2, tasks } = payload;
+    const taskQueue = (_b = (_a = this.tasks[module2]) == null ? void 0 : _a[queueId]) == null ? void 0 : _b.tasks;
+    let _tasks = [...taskQueue || []];
+    let newTasks = (_c = tasks == null ? void 0 : tasks.map) == null ? void 0 : _c.call(tasks, (d) => {
+      if (d.scheduled && module2 !== "scheduledTasks") {
+        console.warn(
+          "Tasks--->",
+          `检测到定时任务配置，但模块为 "${module2}"。定时任务功能仅在 "scheduledTasks" 模块中生效。`,
+          `该任务将作为普通任务立即执行。如需使用定时功能，请将任务添加到 "scheduledTasks" 模块。`
+        );
+      }
+      return this.createTaskData({ ...d, queueId, module: module2 });
+    });
+    _tasks = _tasks.concat(newTasks);
+    this.setTasks({ queueId, module: module2, tasks: _tasks });
+    console.log("Tasks--->", `任务添加成功`, newTasks);
+  }
+  // 更新任务状态
+  updateTask(payload) {
+    var _a, _b, _c;
+    const { queueId, taskId, other, module: module2 } = payload;
+    let newTask = null;
+    const taskQueue = ((_b = (_a = this.tasks[module2]) == null ? void 0 : _a[queueId]) == null ? void 0 : _b.tasks) || [];
+    const updatedTasks = taskQueue.map((task) => {
+      if (task.id === taskId) {
+        newTask = { ...task, ...other };
+        return newTask;
+      }
+      return task;
+    });
+    const newState = {
+      ...this.tasks,
+      [module2]: {
+        ...this.tasks[module2],
+        [queueId]: {
+          ...(_c = this.tasks[module2]) == null ? void 0 : _c[queueId],
+          status: updatedTasks.some((task) => task.status === "failure") ? "uncompleted" : "completed",
+          tasks: updatedTasks
+        }
+      }
+    };
+    this.saveTaskQueueToLocal(newState);
+    this.tasks = newState;
+    return newTask;
+  }
+  updateQueueStatus(payload) {
+    const { queueId, status, module: module2 } = payload;
+    this.setTasksData({ queueId, module: module2, status });
+  }
+  /**
+   * @title: 更新队列运行状态
+   * @description: 标记队列是否正在执行
+   */
+  updateQueueRunningState(payload) {
+    const { queueId, module: module2, isRunning, lastRunAt } = payload;
+    this.setTasksData({ queueId, module: module2, isRunning, lastRunAt });
+  }
+  // 设置任务
+  setTasksData(payload) {
+    const { queueId, module: module2, ...data } = payload;
+    const moduleData = this.tasks[module2] || {};
+    const queueIdData = moduleData[queueId] || {};
+    const newState = {
+      ...this.tasks,
+      [module2]: {
+        ...moduleData,
+        [queueId]: {
+          ...queueIdData,
+          ...data
+        }
+      }
+    };
+    this.saveTaskQueueToLocal(newState);
+    this.tasks = newState;
+  }
+  // 设置任务
+  setTasks(payload) {
+    const { queueId, module: module2, tasks } = payload;
+    this.setTasksData({ queueId, module: module2, tasks });
+  }
+  clearAllTaskTimer(tasks) {
+    for (let task of tasks || []) {
+      this.clearTaskTimer({ taskId: task.id });
+    }
+  }
+  // 清空任务
+  clearTasks(payload) {
+    var _a, _b;
+    const { queueId, module: module2 } = payload;
+    if (!((_b = (_a = this.tasks) == null ? void 0 : _a[module2]) == null ? void 0 : _b[queueId])) {
+      return;
+    }
+    this.clearAllTaskTimer(this.tasks[module2][queueId].tasks);
+    this.tasks[module2][queueId].tasks = [];
+    this.saveTaskQueueToLocal(this.tasks);
+    console.log("Tasks--->", "清空指定任务", queueId, module2);
+  }
+  // 清空全部任务
+  clearAllTasks() {
+    this.tasks = {};
+    this.saveTaskQueueToLocal(this.tasks);
+    if (this.timerIds.length) {
+      for (let timerId of this.timerIds) {
+        clearTimeout(timerId);
+      }
+      this.timerIds = [];
+    }
+    console.log("Tasks--->", "清空全部任务");
+  }
+  watchTask(callback) {
+    this.watchTaskCallback = callback;
+  }
+  /**
+   * @title: 获取队列执行状态
+   * @description: 获取指定队列的执行状态和进度信息
+   * @param {string} module - 模块名
+   * @param {string} queueId - 队列ID
+   * @return {object} 队列状态信息
+   */
+  getQueueStatus(module2, queueId) {
+    var _a, _b;
+    const queue = (_a = this.tasks[module2]) == null ? void 0 : _a[queueId];
+    if (!queue) {
+      return null;
+    }
+    return {
+      isRunning: queue.isRunning || false,
+      status: queue.status,
+      progress: queue.progress || {
+        total: 0,
+        completed: 0,
+        failed: 0,
+        inProgress: 0
+      },
+      lastRunAt: queue.lastRunAt || null,
+      tasksCount: ((_b = queue.tasks) == null ? void 0 : _b.length) || 0
+    };
+  }
+  /**
+   * @title: 获取所有队列状态
+   * @description: 获取所有任务队列的执行状态概览
+   * @return {object} 所有队列的状态信息
+   */
+  getAllQueuesStatus() {
+    var _a;
+    const result = {};
+    for (const module2 in this.tasks) {
+      result[module2] = {};
+      for (const queueId in this.tasks[module2]) {
+        const queue = this.tasks[module2][queueId];
+        result[module2][queueId] = {
+          isRunning: queue.isRunning || false,
+          status: queue.status,
+          progress: queue.progress || {
+            total: 0,
+            completed: 0,
+            failed: 0,
+            inProgress: 0
+          },
+          lastRunAt: queue.lastRunAt || null,
+          tasksCount: ((_a = queue.tasks) == null ? void 0 : _a.length) || 0
+        };
+      }
+    }
+    return result;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TasksManager
+});