@pisell/core 0.0.2

package/lib/socket/socket.js

@@ -0,0 +1,426 @@
+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/socket/socket.ts
+var socket_exports = {};
+__export(socket_exports, {
+  Socket: () => Socket
+});
+module.exports = __toCommonJS(socket_exports);
+var import_types = require("./types");
+var import_constants = require("./constants");
+var import_events = require("./events");
+var import_heartbeat = require("./heartbeat");
+var import_reconnect = require("./reconnect");
+var import_monitor = require("./monitor");
+var import_app = require("../app");
+var Socket = class {
+  ws = null;
+  url;
+  options;
+  status = import_types.SocketStatus.CLOSED;
+  eventHandlers = {};
+  // 心跳和重连管理器
+  heartbeatManager = null;
+  reconnectManager = null;
+  // 监控器
+  monitor = null;
+  // 消息ID计数器
+  messageIdCounter = 0;
+  /**
+   * 创建Socket实例
+   * @param options Socket配置选项
+   */
+  constructor(options) {
+    this.url = options.url;
+    this.options = {
+      ...import_constants.DEFAULT_SOCKET_OPTIONS,
+      ...options
+    };
+    if (this.options.autoConnect) {
+      this.connect().catch((error) => {
+        console.warn("Socket connection failed:", error);
+      });
+    }
+  }
+  /**
+   * 建立WebSocket连接
+   */
+  async connect() {
+    const app = (0, import_app.getApp)();
+    const isConnected = this.isConnected();
+    if (isConnected || this.status === import_types.SocketStatus.CONNECTING) {
+      app.logger.addLog({
+        type: "info",
+        title: "socket已连接或连接中",
+        metadata: {
+          isConnected,
+          status: this.status
+        }
+      });
+      return;
+    }
+    this.setStatus(import_types.SocketStatus.CONNECTING);
+    try {
+      this.ws = new WebSocket(this.url, this.options.protocols);
+      this.setupWebSocketListeners();
+      await new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+          reject(new Error("Connection timeout"));
+        }, this.options.timeout);
+        const onOpen = () => {
+          clearTimeout(timeoutId);
+          resolve();
+        };
+        const onError = (error) => {
+          clearTimeout(timeoutId);
+          reject(error);
+        };
+        this.ws.addEventListener("open", onOpen, { once: true });
+        this.ws.addEventListener("error", onError, { once: true });
+      });
+      if (this.options.heartbeat) {
+        this.initHeartbeat();
+      }
+      if (this.options.reconnection) {
+        this.initReconnect();
+      }
+    } catch (error) {
+      this.handleConnectionFailure(error);
+      throw error;
+    }
+  }
+  /**
+   * 关闭WebSocket连接
+   * @param isManual 是否手动关闭
+   */
+  disconnect(isManual = false) {
+    if (!this.ws || this.status === import_types.SocketStatus.CLOSED || this.status === import_types.SocketStatus.CLOSING) {
+      return;
+    }
+    this.setStatus(import_types.SocketStatus.CLOSING);
+    if (this.heartbeatManager) {
+      this.heartbeatManager.stop();
+    }
+    if (this.reconnectManager) {
+      this.reconnectManager.stopReconnect();
+    }
+    try {
+      this.ws.close();
+    } catch (error) {
+      console.error("WebSocket close error:", error);
+    }
+    this.setStatus(import_types.SocketStatus.CLOSED);
+    this.ws = null;
+    this.emit(import_events.SocketEvents.DISCONNECT, { isManual });
+  }
+  /**
+   * 发送消息到服务器
+   * @param event 事件名称
+   * @param data 消息数据
+   * @param id 消息ID（可选，默认自动生成）
+   */
+  send(type, data, id) {
+    if (!this.isConnected()) {
+      throw new Error("WebSocket is not connected");
+    }
+    const message = {
+      type,
+      data,
+      id: id || this.generateMessageId()
+    };
+    this.sendRaw(message);
+    this.emit(import_events.SocketEvents.SEND, message);
+  }
+  /**
+   * 发送原始消息
+   * @param message 消息对象
+   */
+  sendRaw(message) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return;
+    }
+    try {
+      this.ws.send(JSON.stringify(message));
+    } catch (error) {
+      console.error("WebSocket send error:", error);
+      this.emit(import_events.SocketEvents.ERROR, error);
+    }
+  }
+  /**
+   * 注册事件监听器
+   * @param event 事件名称
+   * @param handler 事件处理函数
+   */
+  on(event, handler) {
+    if (!this.eventHandlers[event]) {
+      this.eventHandlers[event] = [];
+    }
+    this.eventHandlers[event].push(handler);
+  }
+  /**
+   * 移除事件监听器
+   * @param event 事件名称
+   * @param handler 事件处理函数（可选，不提供则移除所有该事件的处理函数）
+   */
+  off(event, handler) {
+    if (!this.eventHandlers[event]) {
+      return;
+    }
+    if (!handler) {
+      delete this.eventHandlers[event];
+    } else {
+      this.eventHandlers[event] = this.eventHandlers[event].filter((h) => h !== handler);
+    }
+  }
+  /**
+   * 触发事件
+   * @param event 事件名称
+   * @param args 事件参数
+   */
+  emit(event, ...args) {
+    const handlers = this.eventHandlers[event];
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(...args);
+        } catch (error) {
+          console.error(`Error in event handler for ${event}:`, error);
+        }
+      });
+    }
+  }
+  /**
+   * 获取当前连接状态
+   */
+  getStatus() {
+    return this.status;
+  }
+  /**
+   * 获取当前状态描述
+   */
+  getStatusText() {
+    return import_constants.WS_STATUS_MAP[this.status] || "未知状态";
+  }
+  /**
+   * 检查是否已连接
+   */
+  isConnected() {
+    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+  }
+  /**
+   * 设置连接状态
+   */
+  setStatus(status) {
+    this.status = status;
+  }
+  /**
+   * 设置WebSocket事件监听器
+   */
+  setupWebSocketListeners() {
+    if (!this.ws) {
+      return;
+    }
+    this.ws.addEventListener("open", () => {
+      this.setStatus(import_types.SocketStatus.OPEN);
+      this.emit(import_events.SocketEvents.CONNECT);
+    });
+    this.ws.addEventListener("close", (event) => {
+      if (this.status !== import_types.SocketStatus.CLOSING && this.status !== import_types.SocketStatus.CLOSED) {
+        this.handleConnectionClosed(event);
+      } else {
+        this.setStatus(import_types.SocketStatus.CLOSED);
+      }
+    });
+    this.ws.addEventListener("error", (event) => {
+      this.emit(import_events.SocketEvents.ERROR, event);
+    });
+    this.ws.addEventListener("message", (event) => {
+      this.handleMessage(event);
+    });
+  }
+  /**
+   * 处理接收到的消息
+   */
+  handleMessage(event) {
+    try {
+      const message = JSON.parse(event.data);
+      if (message.type === import_constants.DEFAULT_HEARTBEAT_RESPONSE) {
+        this.handleHeartbeatResponse();
+        return;
+      }
+      this.emit(import_events.SocketEvents.MESSAGE, message);
+      this.emit(message.type, message.data);
+    } catch (error) {
+      console.error("Error parsing message:", error, event.data);
+    }
+  }
+  /**
+   * 处理连接关闭
+   */
+  handleConnectionClosed(event) {
+    if (this.heartbeatManager) {
+      this.heartbeatManager.stop();
+    }
+    this.setStatus(import_types.SocketStatus.CLOSED);
+    this.ws = null;
+    this.emit(import_events.SocketEvents.DISCONNECT, event);
+    this.startReconnection();
+  }
+  /**
+   * 处理连接失败
+   */
+  handleConnectionFailure(error) {
+    this.setStatus(import_types.SocketStatus.CLOSED);
+    this.ws = null;
+    this.emit(import_events.SocketEvents.ERROR, error);
+    this.startReconnection();
+  }
+  /**
+   * 处理心跳响应
+   */
+  handleHeartbeatResponse() {
+    if (this.heartbeatManager) {
+      this.heartbeatManager.receiveHeartbeatResponse();
+      this.emit(import_events.SocketEvents.HEARTBEAT_RESPONSE);
+    }
+  }
+  /**
+   * 初始化心跳检测
+   */
+  initHeartbeat() {
+    if (!this.options.heartbeat) {
+      return;
+    }
+    const heartbeatOptions = {
+      interval: this.options.heartbeatInterval,
+      timeout: this.options.heartbeatTimeout,
+      message: import_constants.DEFAULT_HEARTBEAT_MESSAGE
+    };
+    this.heartbeatManager = new import_heartbeat.HeartbeatManager(heartbeatOptions, (msg) => this.sendRaw(msg), {
+      onTimeout: () => {
+        this.emit(import_events.SocketEvents.HEARTBEAT_TIMEOUT);
+        this.disconnect();
+        this.startReconnection();
+      },
+      onResponse: () => {
+        this.emit(import_events.SocketEvents.HEARTBEAT_RESPONSE);
+      }
+    });
+    this.heartbeatManager.start();
+  }
+  /**
+   * 初始化重连管理
+   */
+  initReconnect() {
+    if (!this.options.reconnection) {
+      return;
+    }
+    const reconnectOptions = {
+      enabled: true,
+      attempts: this.options.reconnectionAttempts,
+      delay: this.options.reconnectionDelay,
+      delayMax: this.options.reconnectionDelayMax,
+      jitter: false
+    };
+    this.reconnectManager = new import_reconnect.ReconnectManager(
+      reconnectOptions,
+      async () => {
+        try {
+          await this.connect();
+          return true;
+        } catch (error) {
+          return false;
+        }
+      },
+      {
+        onAttempt: (attempt) => {
+          this.emit(import_events.SocketEvents.RECONNECT_ATTEMPT, attempt);
+        },
+        onSuccess: () => {
+          this.emit(import_events.SocketEvents.RECONNECT);
+        },
+        onFail: (error) => {
+          this.emit(import_events.SocketEvents.RECONNECT_ERROR, error);
+        },
+        onMaxAttemptsExceeded: () => {
+          this.emit(import_events.SocketEvents.RECONNECT_FAILED);
+        }
+      }
+    );
+  }
+  /**
+   * 开始重连过程
+   */
+  startReconnection() {
+    if (this.reconnectManager && this.options.reconnection) {
+      this.setStatus(import_types.SocketStatus.RECONNECTING);
+      this.reconnectManager.startReconnect();
+    }
+  }
+  /**
+   * 生成消息ID
+   */
+  generateMessageId() {
+    this.messageIdCounter++;
+    return `msg_${Date.now()}_${this.messageIdCounter}`;
+  }
+  /**
+   * 启用监控功能
+   * @param options 监控配置选项
+   */
+  enableMonitoring(options) {
+    if (!this.monitor) {
+      this.monitor = new import_monitor.SocketMonitor(this, options);
+    } else if (!this.monitor.isActive()) {
+      this.monitor.start();
+    }
+    return this.monitor;
+  }
+  /**
+   * 禁用监控功能
+   */
+  disableMonitoring() {
+    if (this.monitor) {
+      this.monitor.stop();
+    }
+  }
+  /**
+   * 获取监控器实例
+   */
+  getMonitor() {
+    return this.monitor;
+  }
+  /**
+   * 释放资源
+   */
+  destroy() {
+    this.disconnect(true);
+    if (this.monitor) {
+      this.monitor.destroy();
+      this.monitor = null;
+    }
+    this.eventHandlers = {};
+    this.heartbeatManager = null;
+    this.reconnectManager = null;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Socket
+});

package/lib/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/lib/socket/types.js

@@ -0,0 +1,36 @@
+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/socket/types.ts
+var types_exports = {};
+__export(types_exports, {
+  SocketStatus: () => SocketStatus
+});
+module.exports = __toCommonJS(types_exports);
+var SocketStatus = /* @__PURE__ */ ((SocketStatus2) => {
+  SocketStatus2[SocketStatus2["CONNECTING"] = 0] = "CONNECTING";
+  SocketStatus2[SocketStatus2["OPEN"] = 1] = "OPEN";
+  SocketStatus2[SocketStatus2["CLOSING"] = 2] = "CLOSING";
+  SocketStatus2[SocketStatus2["CLOSED"] = 3] = "CLOSED";
+  SocketStatus2[SocketStatus2["RECONNECTING"] = 4] = "RECONNECTING";
+  return SocketStatus2;
+})(SocketStatus || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SocketStatus
+});

package/lib/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/lib/storage/index.js

@@ -0,0 +1,64 @@
+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/storage/index.ts
+var storage_exports = {};
+__export(storage_exports, {
+  Storage: () => Storage
+});
+module.exports = __toCommonJS(storage_exports);
+var Storage = class {
+  storageKey = "CapacitorStorage.native_";
+  app;
+  options = {};
+  constructor(app, options) {
+    this.app = app;
+    if (options) {
+      this.options = options;
+    }
+    if (options == null ? void 0 : options.storageKey) {
+      this.storageKey = options.storageKey;
+    }
+  }
+  createKey = (key) => {
+    if (key.indexOf(this.storageKey) !== -1) {
+      return key;
+    }
+    return this.storageKey + key;
+  };
+  setStorage = (key, value) => {
+    var _a, _b;
+    localStorage.setItem(this.createKey(key), value);
+    (_b = (_a = this.options) == null ? void 0 : _a.setStorageAfter) == null ? void 0 : _b.call(_a, key, value);
+  };
+  getStorage = (key) => {
+    return localStorage.getItem(this.createKey(key));
+  };
+  removeStorage = (key) => {
+    var _a, _b;
+    localStorage.removeItem(this.createKey(key));
+    (_b = (_a = this.options) == null ? void 0 : _a.removeStorageAfter) == null ? void 0 : _b.call(_a, key);
+  };
+  clear = () => {
+    localStorage.clear();
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Storage
+});