@koi-design/callkit 2.2.0-beta.3 → 2.2.0-beta.4

package/dist/index.js

@@ -718,7 +718,7 @@ var Call = class {
 // package.json
 var package_default = {
   name: "@koi-design/callkit",
-  version: "2.2.0-beta.3",
+  version: "2.2.0-beta.4",
   description: "callkit",
   author: "koi",
   license: "ISC",
@@ -16702,12 +16702,152 @@ var Connect = class {
   }
 };
 
+// core/heartbeat-worker.ts
+var workerCode = `
+let timer = null;
+let interval = 30000;
+
+self.onmessage = function(e) {
+  const { type, interval: newInterval } = e.data;
+  
+  if (type === 'start') {
+    if (timer) {
+      clearInterval(timer);
+    }
+    interval = newInterval || interval;
+    timer = setInterval(() => {
+      self.postMessage({ type: 'tick' });
+    }, interval);
+  }
+  
+  if (type === 'stop') {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  }
+  
+  if (type === 'updateInterval') {
+    interval = newInterval;
+    if (timer) {
+      clearInterval(timer);
+      timer = setInterval(() => {
+        self.postMessage({ type: 'tick' });
+      }, interval);
+    }
+  }
+};
+`;
+function createHeartbeatWorker() {
+  try {
+    const blob = new Blob([workerCode], { type: "application/javascript" });
+    const workerUrl = URL.createObjectURL(blob);
+    const worker = new Worker(workerUrl);
+    URL.revokeObjectURL(workerUrl);
+    return worker;
+  } catch {
+    return null;
+  }
+}
+var HeartbeatManager = class {
+  worker = null;
+  fallbackTimer = null;
+  interval = 3e4;
+  onTick = null;
+  isRunning = false;
+  constructor() {
+    this.worker = createHeartbeatWorker();
+    if (this.worker) {
+      this.worker.onmessage = (e) => {
+        if (e.data.type === "tick" && this.onTick) {
+          this.onTick();
+        }
+      };
+    }
+  }
+  /**
+   * Start the heartbeat
+   * @param interval - Interval in milliseconds
+   * @param onTick - Callback function to execute on each tick
+   */
+  start(interval, onTick) {
+    this.stop();
+    this.interval = interval;
+    this.onTick = onTick;
+    this.isRunning = true;
+    if (this.worker) {
+      this.worker.postMessage({
+        type: "start",
+        interval
+      });
+    } else {
+      this.fallbackTimer = setInterval(() => {
+        if (this.onTick) {
+          this.onTick();
+        }
+      }, interval);
+    }
+  }
+  /**
+   * Stop the heartbeat
+   */
+  stop() {
+    this.isRunning = false;
+    this.onTick = null;
+    if (this.worker) {
+      this.worker.postMessage({ type: "stop" });
+    }
+    if (this.fallbackTimer) {
+      clearInterval(this.fallbackTimer);
+      this.fallbackTimer = null;
+    }
+  }
+  /**
+   * Update the heartbeat interval
+   * @param interval - New interval in milliseconds
+   */
+  updateInterval(interval) {
+    this.interval = interval;
+    if (!this.isRunning)
+      return;
+    if (this.worker) {
+      this.worker.postMessage({
+        type: "updateInterval",
+        interval
+      });
+    } else if (this.fallbackTimer && this.onTick) {
+      clearInterval(this.fallbackTimer);
+      this.fallbackTimer = setInterval(() => {
+        if (this.onTick) {
+          this.onTick();
+        }
+      }, interval);
+    }
+  }
+  /**
+   * Destroy the heartbeat manager and release resources
+   */
+  destroy() {
+    this.stop();
+    if (this.worker) {
+      this.worker.terminate();
+      this.worker = null;
+    }
+  }
+  /**
+   * Check if using Web Worker
+   */
+  isUsingWorker() {
+    return this.worker !== null;
+  }
+};
+
 // core/socket.ts
 var Socket = class {
   callKit;
   ws;
   lastPingTime = void 0;
-  pingTimer;
+  heartbeatManager;
   /**
    * @description reconnect timer
    */
@@ -16740,6 +16880,7 @@ var Socket = class {
   }
   constructor(callKit) {
     this.callKit = callKit;
+    this.heartbeatManager = new HeartbeatManager();
   }
   get reconnectConfig() {
     return this.callKit.config.getReconnectConfig("incall");
@@ -17101,22 +17242,27 @@ var Socket = class {
     }
   }
   checkPing() {
-    if (this.pingTimer) {
-      clearInterval(this.pingTimer);
-    }
-    this.pingTimer = setInterval(() => {
+    this.heartbeatManager.start(this.pingInterval, () => {
       this.ping();
-    }, this.pingInterval);
+    });
+    this.callKit.logger.info(
+      `Heartbeat started with Worker: ${this.heartbeatManager.isUsingWorker()}`,
+      {
+        caller: "Socket.checkPing",
+        type: "INCALL",
+        content: {
+          pingInterval: this.pingInterval,
+          usingWorker: this.heartbeatManager.isUsingWorker()
+        }
+      }
+    );
   }
   /**
    * reset socket connection and all states
    */
   async reset(config) {
     const { force = false } = config || {};
-    if (this.pingTimer) {
-      clearInterval(this.pingTimer);
-      this.pingTimer = void 0;
-    }
+    this.heartbeatManager.stop();
     if (force) {
       this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
         event: "INCALL_RESET"
@@ -17127,6 +17273,12 @@ var Socket = class {
     this.setConnectAuthState("startConfirm", false);
     this.clearWebSocket();
   }
+  /**
+   * Destroy the heartbeat manager
+   */
+  destroyHeartbeat() {
+    this.heartbeatManager.destroy();
+  }
   attemptReconnect() {
     if (this.reconnectTimer) {
       clearTimeout(this.reconnectTimer);