@pisell/core 1.0.0 → 1.0.1

package/lib/tasks/index.js

@@ -0,0 +1,438 @@
+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 {
+  constructor(app) {
+    this.useTasks = import_useTasks.default;
+    this.watchTaskCallback = () => {
+    };
+    // 将任务队列状态同步到 local
+    this.saveTaskQueueToLocal = async (state) => {
+      var _a;
+      console.log("saveTaskQueueToLocal", state);
+      let tasksData = await this.db.get("tasks", "tasks");
+      const newData = { id: "tasks", ...state };
+      if (!tasksData) {
+        await this.db.add("tasks", newData);
+      } else {
+        await this.db.update("tasks", newData);
+      }
+      (_a = this.watchTaskCallback) == null ? void 0 : _a.call(this, this.tasks);
+    };
+    // 从 local 加载任务队列状态
+    this.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
+     */
+    this.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: "error",
+          title: `任务执行失败-${task.id}`,
+          metadata: { error, taskPayload: task == null ? void 0 : task.payload }
+        });
+        console.log("任务执行失败", error);
+        actionRes = { status: "failure" };
+      }
+      console.log("Tasks--->", `任务执行成功: ${task.id}`);
+      return actionRes;
+    };
+    /**
+     * @title: 启动轮询
+     * @description: 根据轮询间隔定期执行任务
+     * @param {Task} task
+     * @return {*}
+     */
+    this.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) {
+          clearTimeout(timerId);
+          console.error("轮询任务异常", error);
+        }
+      }, task.polling.interval);
+    };
+    /**
+     * @title: 创建任务数据
+     * @description:
+     * @param {Partial} payload
+     * @return {*}
+     * @Author: zhiwei.Wang
+     * @Date: 2024-09-26 13:54
+     */
+    this.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
+      };
+    };
+    this.getTaskQueue = (payload) => {
+      const { queueId, module: module2 } = payload;
+      return this.tasks[module2][queueId].tasks;
+    };
+    this.timeout = (ms) => {
+      return new Promise((resolve) => {
+        setTimeout(() => {
+          resolve(true);
+        }, ms || 5e3);
+      });
+    };
+    if (!app) {
+      throw new Error("app is required");
+    }
+    this.app = app;
+    this.taskFunctions = /* @__PURE__ */ new Map();
+    this.tasks = {};
+    this.db = app.dbManager;
+  }
+  // 单例模式
+  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() {
+    const tasks = await this.loadTaskQueueFromLocal();
+    if (tasks) {
+      console.log("initTasks", tasks);
+    }
+  }
+  /**
+   * @title: 执行任务队列
+   * @description:
+   * @return {*}
+   * @Author: zhiwei.Wang
+   * @Date: 2024-09-26 13:52
+   */
+  async run(payload) {
+    var _a, _b;
+    const { queueId, module: module2, callback } = payload;
+    let taskQueueStatus = "";
+    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.polling) {
+                this.startPolling(task);
+              } else {
+                const { status } = await this.runTask(task);
+                task.status = status;
+              }
+              if (task.status === "success") {
+                if ((_a = task.pollingResult) == null ? void 0 : _a.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 = ((_b = this.getTaskQueue(payload)) == null ? void 0 : _b.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();
+      }
+    }
+  }
+  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;
+      if ((_a2 = task.pollingResult) == null ? void 0 : _a2.timerId) {
+        clearTimeout(task.pollingResult.timerId);
+      }
+      return task.id !== taskId;
+    });
+    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) => {
+      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;
+    const newState = {
+      ...this.tasks,
+      [module2]: {
+        ...this.tasks[module2],
+        [queueId]: {
+          ...this.tasks[module2][queueId],
+          status
+        }
+      }
+    };
+    this.saveTaskQueueToLocal(newState);
+    this.tasks = newState;
+  }
+  // 设置任务
+  setTasks(payload) {
+    const { queueId, module: module2, tasks } = payload;
+    const moduleData = this.tasks[module2] || {};
+    const queueIdData = moduleData[queueId] || {};
+    const newState = {
+      ...this.tasks,
+      [module2]: {
+        ...moduleData,
+        [queueId]: {
+          ...queueIdData,
+          tasks
+        }
+      }
+    };
+    this.saveTaskQueueToLocal(newState);
+    this.tasks = newState;
+  }
+  clearAllTaskTimer(tasks) {
+    var _a;
+    for (let task of tasks || []) {
+      if ((_a = task.pollingResult) == null ? void 0 : _a.timerId) {
+        clearTimeout(task.pollingResult.timerId);
+      }
+    }
+  }
+  // 清空任务
+  clearTasks(payload) {
+    const { queueId, module: module2 } = payload;
+    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);
+    console.log("Tasks--->", "清空全部任务");
+  }
+  watchTask(callback) {
+    this.watchTaskCallback = callback;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TasksManager
+});

package/lib/tasks/type.d.ts

@@ -0,0 +1,62 @@
+export declare type TaskRunStatus = "pending" | "in-progress" | "success" | "failure";
+export interface Task {
+    id?: string;
+    type?: "local" | "cloud";
+    retries?: number;
+    maxRetries?: number;
+    status?: TaskRunStatus;
+    action: string;
+    payload: any;
+    beforeAction?: string;
+    beforePayload?: any;
+    afterAction?: string;
+    afterPayload?: any;
+    polling?: {
+        interval?: number;
+    };
+    pollingResult?: {
+        count: number;
+        timerId?: any;
+    };
+    manual?: boolean;
+    destroy?: boolean;
+    [key: string]: any;
+}
+export interface TaskConfig {
+    tasks: Task[];
+}
+declare type TaskModuleName = string;
+declare type TaskQueueName = string;
+declare type TaskStatus = "uncompleted" | "completed";
+export interface TaskQueue {
+    status: TaskStatus;
+    tasks: Task[];
+}
+export interface RunTaskParams {
+    module: TaskModuleName;
+    queueId: TaskQueueName;
+    callback?: () => void;
+}
+export interface DeleteTaskParams {
+    module: TaskModuleName;
+    queueId: TaskQueueName;
+    taskId: string;
+}
+export interface AddTaskParams {
+    module: TaskModuleName;
+    queueId: TaskQueueName;
+    tasks: Task[];
+}
+export interface TaskRunResult {
+    status: TaskRunStatus;
+    [key: string]: any;
+}
+export interface TasksModule {
+    [key: TaskModuleName]: {
+        [key: TaskQueueName]: {
+            status: TaskStatus;
+            tasks: Task[];
+        };
+    };
+}
+export {};

package/lib/{date → tasks}/type.js

@@ -12,6 +12,6 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/date/type.ts
+// src/tasks/type.ts
 var type_exports = {};
 module.exports = __toCommonJS(type_exports);

package/lib/tasks/useTasks.d.ts

@@ -0,0 +1,4 @@
+declare const useTasks: () => {
+    tasks: any;
+};
+export default useTasks;

package/lib/tasks/useTasks.js

@@ -0,0 +1,37 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/tasks/useTasks.tsx
+var useTasks_exports = {};
+__export(useTasks_exports, {
+  default: () => useTasks_default
+});
+module.exports = __toCommonJS(useTasks_exports);
+var import_app = require("../app");
+var import_react = require("react");
+var useTasks = () => {
+  const { app } = (0, import_app.useApp)();
+  const [tasks, setTasks] = (0, import_react.useState)({});
+  (0, import_react.useEffect)(() => {
+    app.tasksManager.watchTask((taskModule) => {
+      setTasks(taskModule);
+    });
+  }, []);
+  return { tasks };
+};
+var useTasks_default = useTasks;

package/lib/type.d.ts

@@ -1,2 +1,2 @@
-export interface UtilsConfig {
+export interface CoreConfig {
 }

package/lib/variables/VariablesProvider.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+export declare const useVariablesContext: () => any;
+interface VariablesProviderProps {
+    children: React.ReactNode;
+}
+export declare const VariablesProvider: React.FC<VariablesProviderProps>;
+export {};

package/lib/variables/VariablesProvider.js

@@ -0,0 +1,51 @@
+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/variables/VariablesProvider.tsx
+var VariablesProvider_exports = {};
+__export(VariablesProvider_exports, {
+  VariablesProvider: () => VariablesProvider,
+  useVariablesContext: () => useVariablesContext
+});
+module.exports = __toCommonJS(VariablesProvider_exports);
+var import_react = __toESM(require("react"));
+var VariablesContext = (0, import_react.createContext)({});
+VariablesContext.displayName = "VariablesContext";
+var useVariablesContext = () => {
+  return import_react.default.useContext(VariablesContext);
+};
+var VariablesProvider = ({
+  children
+}) => {
+  return /* @__PURE__ */ import_react.default.createElement(VariablesProvider.Provider, { value: {} }, children);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VariablesProvider,
+  useVariablesContext
+});

package/lib/variables/config.d.ts

@@ -0,0 +1,3 @@
+import { VariablesConfig } from './type';
+export declare const setConfig: (newConfig: Partial<VariablesConfig>) => void;
+export declare const getConfig: () => VariablesConfig;

package/lib/variables/config.js

@@ -0,0 +1,38 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/variables/config.ts
+var config_exports = {};
+__export(config_exports, {
+  getConfig: () => getConfig,
+  setConfig: () => setConfig
+});
+module.exports = __toCommonJS(config_exports);
+var defaultConfig = {
+  globalVariableMap: {}
+};
+var config = { ...defaultConfig };
+var setConfig = (newConfig) => {
+  config = { ...config, ...newConfig };
+};
+var getConfig = () => config;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getConfig,
+  setConfig
+});

package/lib/variables/index.d.ts

@@ -0,0 +1,6 @@
+export declare type VariableMap = Record<string, string>;
+declare const _default: {
+    setConfig: (newConfig: Partial<import("./type").VariablesConfig>) => void;
+    getConfig: () => import("./type").VariablesConfig;
+};
+export default _default;