@pisell/core 0.0.2

package/es/socket/types.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Socket配置选项
+ */
+export interface SocketOptions {
+    /** 是否自动连接 */
+    autoConnect?: boolean;
+    /** 是否启用重连功能 */
+    reconnection?: boolean;
+    /** 最大重连尝试次数，默认无限 */
+    reconnectionAttempts?: number;
+    /** 重连延迟时间（毫秒） */
+    reconnectionDelay?: number;
+    /** 最大重连延迟时间（毫秒） */
+    reconnectionDelayMax?: number;
+    /** 是否启用心跳检测 */
+    heartbeat?: boolean;
+    /** 心跳间隔时间（毫秒） */
+    heartbeatInterval?: number;
+    /** 请求超时时间（毫秒） */
+    timeout?: number;
+    /** 心跳超时时间（毫秒） */
+    heartbeatTimeout?: number;
+    /** 自定义协议 */
+    protocols?: string | string[];
+    /** 连接URL */
+    url: string;
+}
+/**
+ * Socket连接状态
+ */
+export declare enum SocketStatus {
+    CONNECTING = 0,
+    OPEN = 1,
+    CLOSING = 2,
+    CLOSED = 3,
+    RECONNECTING = 4
+}
+/**
+ * Socket消息格式
+ */
+export interface SocketMessage {
+    /** 事件类型 */
+    type: string;
+    /** 消息数据 */
+    data?: any;
+    /** 消息ID */
+    id?: string;
+    event?: any;
+}
+/**
+ * 心跳配置选项
+ */
+export interface HeartbeatOptions {
+    /** 心跳间隔时间（毫秒） */
+    interval: number;
+    /** 心跳超时时间（毫秒） */
+    timeout: number;
+    /** 心跳探测消息 */
+    message?: SocketMessage;
+}
+/**
+ * 重连配置选项
+ */
+export interface ReconnectOptions {
+    /** 是否启用重连 */
+    enabled: boolean;
+    /** 最大重连尝试次数 */
+    attempts?: number;
+    /** 重连延迟时间（毫秒） */
+    delay: number;
+    /** 最大重连延迟时间（毫秒） */
+    delayMax?: number;
+    /** 是否使用指数退避算法 */
+    jitter?: boolean;
+}
+/**
+ * 事件处理函数类型
+ */
+export declare type EventHandler = (...args: any[]) => void;
+/**
+ * 事件处理函数映射
+ */
+export interface EventHandlerMap {
+    [event: string]: EventHandler[];
+}

package/es/socket/types.js

@@ -0,0 +1,35 @@
+/**
+ * Socket配置选项
+ */
+
+/**
+ * Socket连接状态
+ */
+export var SocketStatus = /*#__PURE__*/function (SocketStatus) {
+  SocketStatus[SocketStatus["CONNECTING"] = 0] = "CONNECTING";
+  SocketStatus[SocketStatus["OPEN"] = 1] = "OPEN";
+  SocketStatus[SocketStatus["CLOSING"] = 2] = "CLOSING";
+  SocketStatus[SocketStatus["CLOSED"] = 3] = "CLOSED";
+  SocketStatus[SocketStatus["RECONNECTING"] = 4] = "RECONNECTING";
+  return SocketStatus;
+}({});
+
+/**
+ * Socket消息格式
+ */
+
+/**
+ * 心跳配置选项
+ */
+
+/**
+ * 重连配置选项
+ */
+
+/**
+ * 事件处理函数类型
+ */
+
+/**
+ * 事件处理函数映射
+ */

package/es/storage/index.d.ts

@@ -0,0 +1,17 @@
+import App from '../app';
+export interface StorageOptions {
+    storageKey?: string;
+    removeStorageAfter?: (key: string) => void;
+    setStorageAfter?: (key: string, value: string) => void;
+}
+export declare class Storage {
+    private storageKey;
+    private app?;
+    private options;
+    constructor(app?: App, options?: StorageOptions);
+    createKey: (key: string) => string;
+    setStorage: (key: string, value: string) => void;
+    getStorage: (key: string) => string | null;
+    removeStorage: (key: string) => void;
+    clear: () => void;
+}

package/es/storage/index.js

@@ -0,0 +1,46 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+// 优先级
+// 失效期
+// 主动清理
+export var Storage = /*#__PURE__*/_createClass(function Storage(app, options) {
+  var _this = this;
+  _classCallCheck(this, Storage);
+  _defineProperty(this, "storageKey", 'CapacitorStorage.native_');
+  _defineProperty(this, "app", void 0);
+  _defineProperty(this, "options", {});
+  _defineProperty(this, "createKey", function (key) {
+    if (key.indexOf(_this.storageKey) !== -1) {
+      return key;
+    }
+    return _this.storageKey + key;
+  });
+  _defineProperty(this, "setStorage", function (key, value) {
+    var _this$options, _this$options$setStor;
+    localStorage.setItem(_this.createKey(key), value);
+    (_this$options = _this.options) === null || _this$options === void 0 || (_this$options$setStor = _this$options.setStorageAfter) === null || _this$options$setStor === void 0 || _this$options$setStor.call(_this$options, key, value);
+  });
+  _defineProperty(this, "getStorage", function (key) {
+    return localStorage.getItem(_this.createKey(key));
+  });
+  _defineProperty(this, "removeStorage", function (key) {
+    var _this$options2, _this$options2$remove;
+    localStorage.removeItem(_this.createKey(key));
+    (_this$options2 = _this.options) === null || _this$options2 === void 0 || (_this$options2$remove = _this$options2.removeStorageAfter) === null || _this$options2$remove === void 0 || _this$options2$remove.call(_this$options2, key);
+  });
+  _defineProperty(this, "clear", function () {
+    localStorage.clear();
+  });
+  this.app = app;
+  if (options) {
+    this.options = options;
+  }
+  if (options !== null && options !== void 0 && options.storageKey) {
+    this.storageKey = options.storageKey;
+  }
+});

package/es/tasks/index.d.ts

@@ -0,0 +1,127 @@
+import { Task, TasksModule, RunTaskParams, AddTaskParams, DeleteTaskParams } from "./type";
+import App from "../app";
+export declare class TasksManager {
+    private static instance;
+    private taskFunctions;
+    private tasks;
+    private app;
+    private db;
+    useTasks: () => {
+        tasks: TasksModule;
+    };
+    watchTaskCallback: (taskModule: TasksModule) => void;
+    private timerIds;
+    constructor(app: App);
+    static getInstance(app?: App): TasksManager;
+    addTaskFunction<T>(name: string, fun: T): void;
+    addTaskFunctions<T>(tasks: {
+        name: string;
+        fun: T;
+    }[]): void;
+    getTasks(): TasksModule;
+    getTaskFunction(name: string): any;
+    init(): Promise<void>;
+    private saveTaskQueueToLocal;
+    private loadTaskQueueFromLocal;
+    /**
+     * @title: 执行任务
+     * @description:
+     * @param {Task} task
+     * @return {*}
+     * @Author: zhiwei.Wang
+     * @Date: 2024-09-26 13:53
+     */
+    private runTask;
+    /**
+     * @title: 清除任务定时器
+     */
+    private clearTaskTimer;
+    /**
+     * @title: 计算下一次执行时间
+     * @description: 根据定时任务配置计算下一次执行时间
+     * @param {Task} task
+     * @return {string | null} 下一次执行时间
+     */
+    private calculateNextExecuteTime;
+    /**
+     * @title: 启动定时任务
+     * @description: 在特定时间点执行任务（仅在 scheduledTasks 模块中生效）
+     * @param {Task} task
+     * @return {*}
+     */
+    private startScheduledTask;
+    /**
+     * @title: 启动轮询
+     * @description: 根据轮询间隔定期执行任务
+     * @param {Task} task
+     * @return {*}
+     */
+    private startPolling;
+    /**
+     * @title: 创建任务数据
+     * @description:
+     * @param {Partial} payload
+     * @return {*}
+     * @Author: zhiwei.Wang
+     * @Date: 2024-09-26 13:54
+     */
+    private createTaskData;
+    private getTaskQueue;
+    private timeout;
+    /**
+     * @title: 执行任务队列
+     * @description:
+     * @return {*}
+     * @Author: zhiwei.Wang
+     * @Date: 2024-09-26 13:52
+     */
+    run(payload: RunTaskParams): Promise<void>;
+    deleteTask(payload: DeleteTaskParams): void;
+    /**
+     * @title: 重试任务
+     * @description:
+     * @return {*}
+     * @Author: zhiwei.Wang
+     * @Date: 2024-09-26 13:53
+     */
+    retryTask(payload: RunTaskParams): void;
+    addTask(payload: AddTaskParams): void;
+    private updateTask;
+    private updateQueueStatus;
+    /**
+     * @title: 更新队列运行状态
+     * @description: 标记队列是否正在执行
+     */
+    private updateQueueRunningState;
+    private setTasksData;
+    private setTasks;
+    clearAllTaskTimer(tasks: Task[]): void;
+    clearTasks(payload: RunTaskParams): void;
+    clearAllTasks(): void;
+    watchTask(callback: (taskModule: TasksModule) => void): void;
+    /**
+     * @title: 获取队列执行状态
+     * @description: 获取指定队列的执行状态和进度信息
+     * @param {string} module - 模块名
+     * @param {string} queueId - 队列ID
+     * @return {object} 队列状态信息
+     */
+    getQueueStatus(module: string, queueId: string): {
+        isRunning: boolean;
+        status: "uncompleted" | "completed";
+        progress: {
+            total: number;
+            completed: number;
+            failed: number;
+            inProgress: number;
+        };
+        lastRunAt: string | null;
+        tasksCount: number;
+    } | null;
+    /**
+     * @title: 获取所有队列状态
+     * @description: 获取所有任务队列的执行状态概览
+     * @return {object} 所有队列的状态信息
+     */
+    getAllQueuesStatus(): any;
+}