@voicemaster/core 1.0.0 → 1.0.2

package/dist/index.d.mts

@@ -5,60 +5,42 @@ interface VoiceClientConfig {
     autoConnect?: boolean;
     iceServers?: RTCIceServer[];
 }
-interface VoiceEvents {
-    connected: () => void;
-    disconnected: () => void;
-    remoteStream: (stream: MediaStream) => void;
-    localStream: (stream: MediaStream) => void;
-    error: (error: Error) => void;
-    userJoined: (userId: string) => void;
-    userLeft: (userId: string) => void;
-    speaking: (userId: string) => void;
-    stoppedSpeaking: (userId: string) => void;
-}
-type EventHandler<T extends keyof VoiceEvents> = VoiceEvents[T];
 declare class VoiceClient {
     private ws;
-    private peers;
+    private peer;
     private localStream;
-    private remoteStreams;
+    private remoteStream;
     private eventHandlers;
-    private userId;
-    private roomId;
     private signalingUrl;
+    private roomId;
+    private userId;
     private iceServers;
-    private speakingDetectionInterval;
-    private audioContext;
-    private sourceNode;
-    private analyserNode;
-    private speakingThreshold;
-    private isSpeaking;
-    private reconnectAttempts;
-    private maxReconnectAttempts;
-    private isConnected;
+    private isConnectedFlag;
     constructor(config: VoiceClientConfig);
-    on<K extends keyof VoiceEvents>(event: K, handler: EventHandler<K>): void;
-    off<K extends keyof VoiceEvents>(event: K, handler: EventHandler<K>): void;
+    on(event: string, callback: Function): void;
     private emit;
     connect(): Promise<void>;
     private initMicrophone;
-    private setupSpeakingDetection;
-    private broadcastSpeakingStatus;
     private initWebSocket;
-    private handleReconnect;
     private handleSignalingMessage;
     private initPeer;
     private handlePeerSignal;
-    private closePeer;
     private send;
     disconnect(): void;
     toggleMute(): void;
     isMuted(): boolean;
-    setSpeakingThreshold(threshold: number): void;
-    getRemoteStream(userId?: string): MediaStream | null;
-    getPeers(): string[];
     getUserId(): string;
-    isConnectedToRoom(): boolean;
+}
+interface VoiceEvents {
+    connected: () => void;
+    disconnected: () => void;
+    remoteStream: (stream: MediaStream) => void;
+    localStream: (stream: MediaStream) => void;
+    error: (error: Error) => void;
+    userJoined: (userId: string) => void;
+    userLeft: (userId: string) => void;
+    speaking: (userId: string) => void;
+    stoppedSpeaking: (userId: string) => void;
 }
 
 export { VoiceClient, type VoiceClientConfig, type VoiceEvents };

package/dist/index.d.ts

@@ -5,60 +5,42 @@ interface VoiceClientConfig {
     autoConnect?: boolean;
     iceServers?: RTCIceServer[];
 }
-interface VoiceEvents {
-    connected: () => void;
-    disconnected: () => void;
-    remoteStream: (stream: MediaStream) => void;
-    localStream: (stream: MediaStream) => void;
-    error: (error: Error) => void;
-    userJoined: (userId: string) => void;
-    userLeft: (userId: string) => void;
-    speaking: (userId: string) => void;
-    stoppedSpeaking: (userId: string) => void;
-}
-type EventHandler<T extends keyof VoiceEvents> = VoiceEvents[T];
 declare class VoiceClient {
     private ws;
-    private peers;
+    private peer;
     private localStream;
-    private remoteStreams;
+    private remoteStream;
     private eventHandlers;
-    private userId;
-    private roomId;
     private signalingUrl;
+    private roomId;
+    private userId;
     private iceServers;
-    private speakingDetectionInterval;
-    private audioContext;
-    private sourceNode;
-    private analyserNode;
-    private speakingThreshold;
-    private isSpeaking;
-    private reconnectAttempts;
-    private maxReconnectAttempts;
-    private isConnected;
+    private isConnectedFlag;
     constructor(config: VoiceClientConfig);
-    on<K extends keyof VoiceEvents>(event: K, handler: EventHandler<K>): void;
-    off<K extends keyof VoiceEvents>(event: K, handler: EventHandler<K>): void;
+    on(event: string, callback: Function): void;
     private emit;
     connect(): Promise<void>;
     private initMicrophone;
-    private setupSpeakingDetection;
-    private broadcastSpeakingStatus;
     private initWebSocket;
-    private handleReconnect;
     private handleSignalingMessage;
     private initPeer;
     private handlePeerSignal;
-    private closePeer;
     private send;
     disconnect(): void;
     toggleMute(): void;
     isMuted(): boolean;
-    setSpeakingThreshold(threshold: number): void;
-    getRemoteStream(userId?: string): MediaStream | null;
-    getPeers(): string[];
     getUserId(): string;
-    isConnectedToRoom(): boolean;
+}
+interface VoiceEvents {
+    connected: () => void;
+    disconnected: () => void;
+    remoteStream: (stream: MediaStream) => void;
+    localStream: (stream: MediaStream) => void;
+    error: (error: Error) => void;
+    userJoined: (userId: string) => void;
+    userLeft: (userId: string) => void;
+    speaking: (userId: string) => void;
+    stoppedSpeaking: (userId: string) => void;
 }
 
 export { VoiceClient, type VoiceClientConfig, type VoiceEvents };

package/dist/index.js

@@ -39,50 +39,29 @@ var import_simple_peer = __toESM(require("simple-peer"));
 var VoiceClient = class {
   constructor(config) {
     this.ws = null;
-    this.peers = /* @__PURE__ */ new Map();
+    this.peer = null;
     this.localStream = null;
-    this.remoteStreams = /* @__PURE__ */ new Map();
-    this.eventHandlers = {};
-    this.speakingDetectionInterval = null;
-    this.audioContext = null;
-    this.sourceNode = null;
-    this.analyserNode = null;
-    this.speakingThreshold = 0.05;
-    this.isSpeaking = false;
-    this.reconnectAttempts = 0;
-    this.maxReconnectAttempts = 5;
-    this.isConnected = false;
-    this.userId = config.userId;
-    this.roomId = config.roomId;
+    this.remoteStream = null;
+    this.eventHandlers = /* @__PURE__ */ new Map();
+    this.isConnectedFlag = false;
     this.signalingUrl = config.signalingUrl;
+    this.roomId = config.roomId;
+    this.userId = config.userId;
     this.iceServers = config.iceServers || [
-      { urls: "stun:stun.l.google.com:19302" },
-      { urls: "stun:stun.relay.metered.ca:80" },
-      {
-        urls: "turn:openrelay.metered.ca:80",
-        username: "openrelayproject",
-        credential: "openrelayproject"
-      }
+      { urls: "stun:stun.l.google.com:19302" }
     ];
     if (config.autoConnect !== false) {
       this.connect();
     }
   }
-  on(event, handler) {
-    if (!this.eventHandlers[event]) {
-      this.eventHandlers[event] = [];
-    }
-    this.eventHandlers[event].push(handler);
-  }
-  off(event, handler) {
-    const handlers = this.eventHandlers[event];
-    if (handlers) {
-      const index = handlers.indexOf(handler);
-      if (index !== -1) handlers.splice(index, 1);
+  on(event, callback) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, []);
     }
+    this.eventHandlers.get(event).push(callback);
   }
   emit(event, ...args) {
-    const handlers = this.eventHandlers[event];
+    const handlers = this.eventHandlers.get(event);
     if (handlers) {
       handlers.forEach((handler) => handler(...args));
     }
@@ -93,7 +72,6 @@ var VoiceClient = class {
       this.initWebSocket();
     } catch (error) {
       this.emit("error", error);
-      this.handleReconnect();
     }
   }
   async initMicrophone() {
@@ -101,159 +79,74 @@ var VoiceClient = class {
       audio: {
         echoCancellation: true,
         noiseSuppression: true,
-        autoGainControl: true,
-        sampleRate: 48e3,
-        channelCount: 1
+        autoGainControl: true
       }
     });
     this.emit("localStream", this.localStream);
-    this.setupSpeakingDetection();
-  }
-  setupSpeakingDetection() {
-    if (!this.localStream) return;
-    this.audioContext = new AudioContext();
-    this.sourceNode = this.audioContext.createMediaStreamSource(this.localStream);
-    this.analyserNode = this.audioContext.createAnalyser();
-    this.analyserNode.fftSize = 256;
-    this.sourceNode.connect(this.analyserNode);
-    this.sourceNode.connect(this.audioContext.destination);
-    const dataArray = new Uint8Array(this.analyserNode.frequencyBinCount);
-    this.speakingDetectionInterval = setInterval(() => {
-      if (!this.analyserNode) return;
-      this.analyserNode.getByteTimeDomainData(dataArray);
-      let maxSample = 0;
-      for (let i = 0; i < dataArray.length; i++) {
-        const sample = Math.abs(dataArray[i] / 128 - 1);
-        if (sample > maxSample) maxSample = sample;
-      }
-      const isCurrentlySpeaking = maxSample > this.speakingThreshold;
-      if (isCurrentlySpeaking && !this.isSpeaking) {
-        this.isSpeaking = true;
-        this.broadcastSpeakingStatus(true);
-        this.emit("speaking", this.userId);
-      } else if (!isCurrentlySpeaking && this.isSpeaking) {
-        this.isSpeaking = false;
-        this.broadcastSpeakingStatus(false);
-        this.emit("stoppedSpeaking", this.userId);
-      }
-    }, 100);
-  }
-  broadcastSpeakingStatus(isSpeaking) {
-    this.peers.forEach((peer) => {
-      if (peer && peer.connected) {
-        peer.send(JSON.stringify({
-          type: "speaking",
-          userId: this.userId,
-          isSpeaking
-        }));
-      }
-    });
   }
   initWebSocket() {
     const url = `${this.signalingUrl}?userId=${this.userId}&roomId=${this.roomId}`;
     this.ws = new WebSocket(url);
     this.ws.onopen = () => {
-      this.reconnectAttempts = 0;
-      this.isConnected = true;
-      this.send({
-        type: "join",
-        roomId: this.roomId,
-        userId: this.userId
-      });
+      this.send({ type: "join", roomId: this.roomId, userId: this.userId });
     };
     this.ws.onmessage = (event) => {
       const message = JSON.parse(event.data);
       this.handleSignalingMessage(message);
     };
     this.ws.onclose = () => {
-      this.isConnected = false;
-      this.handleReconnect();
-    };
-    this.ws.onerror = (error) => {
-      this.emit("error", new Error("WebSocket error"));
-    };
-  }
-  handleReconnect() {
-    if (this.reconnectAttempts < this.maxReconnectAttempts) {
-      this.reconnectAttempts++;
-      setTimeout(() => {
-        this.initWebSocket();
-      }, 1e3 * Math.min(30, this.reconnectAttempts));
-    } else {
       this.emit("disconnected");
-    }
+    };
   }
   handleSignalingMessage(message) {
     switch (message.type) {
       case "user-joined":
-        this.initPeer(message.userId, true);
-        this.emit("userJoined", message.userId);
+        if (message.userId !== this.userId) {
+          this.initPeer(true);
+          this.emit("userJoined", message.userId);
+        }
         break;
       case "signal":
         this.handlePeerSignal(message.userId, message.payload);
         break;
       case "user-left":
-        this.closePeer(message.userId);
         this.emit("userLeft", message.userId);
         break;
     }
   }
-  initPeer(targetUserId, initiator) {
-    if (this.peers.has(targetUserId)) return;
-    const peer = new import_simple_peer.default({
+  initPeer(initiator) {
+    if (this.peer) return;
+    this.peer = new import_simple_peer.default({
       initiator,
       trickle: true,
-      stream: this.localStream,
+      stream: this.localStream || void 0,
       config: { iceServers: this.iceServers }
     });
-    peer.on("signal", (data) => {
+    this.peer.on("signal", (data) => {
       this.send({
         type: "signal",
-        userId: targetUserId,
+        userId: this.userId,
+        roomId: this.roomId,
         payload: data
       });
     });
-    peer.on("stream", (stream) => {
-      this.remoteStreams.set(targetUserId, stream);
+    this.peer.on("stream", (stream) => {
+      this.remoteStream = stream;
       this.emit("remoteStream", stream);
     });
-    peer.on("data", (data) => {
-      try {
-        const parsed = JSON.parse(data.toString());
-        if (parsed.type === "speaking") {
-          if (parsed.isSpeaking) {
-            this.emit("speaking", parsed.userId);
-          } else {
-            this.emit("stoppedSpeaking", parsed.userId);
-          }
-        }
-      } catch (e) {
-      }
-    });
-    peer.on("error", (err) => {
-      this.emit("error", err);
+    this.peer.on("connect", () => {
+      this.isConnectedFlag = true;
+      this.emit("connected");
     });
-    peer.on("close", () => {
-      this.peers.delete(targetUserId);
+    this.peer.on("error", (err) => {
+      console.error("Peer error:", err);
     });
-    this.peers.set(targetUserId, peer);
   }
   handlePeerSignal(targetUserId, signal) {
-    let peer = this.peers.get(targetUserId);
-    if (!peer) {
-      this.initPeer(targetUserId, false);
-      peer = this.peers.get(targetUserId);
-    }
-    if (peer) {
-      peer.signal(signal);
-    }
-  }
-  closePeer(userId) {
-    const peer = this.peers.get(userId);
-    if (peer) {
-      peer.destroy();
-      this.peers.delete(userId);
+    if (!this.peer) {
+      this.initPeer(false);
     }
+    this.peer?.signal(signal);
   }
   send(data) {
     if (this.ws?.readyState === WebSocket.OPEN) {
@@ -261,22 +154,13 @@ var VoiceClient = class {
     }
   }
   disconnect() {
-    if (this.speakingDetectionInterval) {
-      clearInterval(this.speakingDetectionInterval);
-    }
-    if (this.audioContext) {
-      this.audioContext.close();
-    }
-    this.peers.forEach((peer) => {
-      peer.destroy();
-    });
-    this.peers.clear();
-    if (this.localStream) {
-      this.localStream.getTracks().forEach((track) => track.stop());
-    }
     if (this.ws) {
+      this.send({ type: "leave", roomId: this.roomId, userId: this.userId });
       this.ws.close();
     }
+    this.peer?.destroy();
+    this.localStream?.getTracks().forEach((track) => track.stop());
+    this.isConnectedFlag = false;
     this.emit("disconnected");
   }
   toggleMute() {
@@ -290,26 +174,9 @@ var VoiceClient = class {
   isMuted() {
     return this.localStream?.getAudioTracks()[0]?.enabled === false;
   }
-  setSpeakingThreshold(threshold) {
-    this.speakingThreshold = Math.min(1, Math.max(0, threshold));
-  }
-  getRemoteStream(userId) {
-    if (userId) {
-      const stream = this.remoteStreams.get(userId);
-      return stream || null;
-    }
-    const firstStream = this.remoteStreams.values().next().value;
-    return firstStream || null;
-  }
-  getPeers() {
-    return Array.from(this.peers.keys());
-  }
   getUserId() {
     return this.userId;
   }
-  isConnectedToRoom() {
-    return this.isConnected;
-  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/index.mjs

@@ -3,50 +3,29 @@ import Peer from "simple-peer";
 var VoiceClient = class {
   constructor(config) {
     this.ws = null;
-    this.peers = /* @__PURE__ */ new Map();
+    this.peer = null;
     this.localStream = null;
-    this.remoteStreams = /* @__PURE__ */ new Map();
-    this.eventHandlers = {};
-    this.speakingDetectionInterval = null;
-    this.audioContext = null;
-    this.sourceNode = null;
-    this.analyserNode = null;
-    this.speakingThreshold = 0.05;
-    this.isSpeaking = false;
-    this.reconnectAttempts = 0;
-    this.maxReconnectAttempts = 5;
-    this.isConnected = false;
-    this.userId = config.userId;
-    this.roomId = config.roomId;
+    this.remoteStream = null;
+    this.eventHandlers = /* @__PURE__ */ new Map();
+    this.isConnectedFlag = false;
     this.signalingUrl = config.signalingUrl;
+    this.roomId = config.roomId;
+    this.userId = config.userId;
     this.iceServers = config.iceServers || [
-      { urls: "stun:stun.l.google.com:19302" },
-      { urls: "stun:stun.relay.metered.ca:80" },
-      {
-        urls: "turn:openrelay.metered.ca:80",
-        username: "openrelayproject",
-        credential: "openrelayproject"
-      }
+      { urls: "stun:stun.l.google.com:19302" }
     ];
     if (config.autoConnect !== false) {
       this.connect();
     }
   }
-  on(event, handler) {
-    if (!this.eventHandlers[event]) {
-      this.eventHandlers[event] = [];
-    }
-    this.eventHandlers[event].push(handler);
-  }
-  off(event, handler) {
-    const handlers = this.eventHandlers[event];
-    if (handlers) {
-      const index = handlers.indexOf(handler);
-      if (index !== -1) handlers.splice(index, 1);
+  on(event, callback) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, []);
     }
+    this.eventHandlers.get(event).push(callback);
   }
   emit(event, ...args) {
-    const handlers = this.eventHandlers[event];
+    const handlers = this.eventHandlers.get(event);
     if (handlers) {
       handlers.forEach((handler) => handler(...args));
     }
@@ -57,7 +36,6 @@ var VoiceClient = class {
       this.initWebSocket();
     } catch (error) {
       this.emit("error", error);
-      this.handleReconnect();
     }
   }
   async initMicrophone() {
@@ -65,159 +43,74 @@ var VoiceClient = class {
       audio: {
         echoCancellation: true,
         noiseSuppression: true,
-        autoGainControl: true,
-        sampleRate: 48e3,
-        channelCount: 1
+        autoGainControl: true
       }
     });
     this.emit("localStream", this.localStream);
-    this.setupSpeakingDetection();
-  }
-  setupSpeakingDetection() {
-    if (!this.localStream) return;
-    this.audioContext = new AudioContext();
-    this.sourceNode = this.audioContext.createMediaStreamSource(this.localStream);
-    this.analyserNode = this.audioContext.createAnalyser();
-    this.analyserNode.fftSize = 256;
-    this.sourceNode.connect(this.analyserNode);
-    this.sourceNode.connect(this.audioContext.destination);
-    const dataArray = new Uint8Array(this.analyserNode.frequencyBinCount);
-    this.speakingDetectionInterval = setInterval(() => {
-      if (!this.analyserNode) return;
-      this.analyserNode.getByteTimeDomainData(dataArray);
-      let maxSample = 0;
-      for (let i = 0; i < dataArray.length; i++) {
-        const sample = Math.abs(dataArray[i] / 128 - 1);
-        if (sample > maxSample) maxSample = sample;
-      }
-      const isCurrentlySpeaking = maxSample > this.speakingThreshold;
-      if (isCurrentlySpeaking && !this.isSpeaking) {
-        this.isSpeaking = true;
-        this.broadcastSpeakingStatus(true);
-        this.emit("speaking", this.userId);
-      } else if (!isCurrentlySpeaking && this.isSpeaking) {
-        this.isSpeaking = false;
-        this.broadcastSpeakingStatus(false);
-        this.emit("stoppedSpeaking", this.userId);
-      }
-    }, 100);
-  }
-  broadcastSpeakingStatus(isSpeaking) {
-    this.peers.forEach((peer) => {
-      if (peer && peer.connected) {
-        peer.send(JSON.stringify({
-          type: "speaking",
-          userId: this.userId,
-          isSpeaking
-        }));
-      }
-    });
   }
   initWebSocket() {
     const url = `${this.signalingUrl}?userId=${this.userId}&roomId=${this.roomId}`;
     this.ws = new WebSocket(url);
     this.ws.onopen = () => {
-      this.reconnectAttempts = 0;
-      this.isConnected = true;
-      this.send({
-        type: "join",
-        roomId: this.roomId,
-        userId: this.userId
-      });
+      this.send({ type: "join", roomId: this.roomId, userId: this.userId });
     };
     this.ws.onmessage = (event) => {
       const message = JSON.parse(event.data);
       this.handleSignalingMessage(message);
     };
     this.ws.onclose = () => {
-      this.isConnected = false;
-      this.handleReconnect();
-    };
-    this.ws.onerror = (error) => {
-      this.emit("error", new Error("WebSocket error"));
-    };
-  }
-  handleReconnect() {
-    if (this.reconnectAttempts < this.maxReconnectAttempts) {
-      this.reconnectAttempts++;
-      setTimeout(() => {
-        this.initWebSocket();
-      }, 1e3 * Math.min(30, this.reconnectAttempts));
-    } else {
       this.emit("disconnected");
-    }
+    };
   }
   handleSignalingMessage(message) {
     switch (message.type) {
       case "user-joined":
-        this.initPeer(message.userId, true);
-        this.emit("userJoined", message.userId);
+        if (message.userId !== this.userId) {
+          this.initPeer(true);
+          this.emit("userJoined", message.userId);
+        }
         break;
       case "signal":
         this.handlePeerSignal(message.userId, message.payload);
         break;
       case "user-left":
-        this.closePeer(message.userId);
         this.emit("userLeft", message.userId);
         break;
     }
   }
-  initPeer(targetUserId, initiator) {
-    if (this.peers.has(targetUserId)) return;
-    const peer = new Peer({
+  initPeer(initiator) {
+    if (this.peer) return;
+    this.peer = new Peer({
       initiator,
       trickle: true,
-      stream: this.localStream,
+      stream: this.localStream || void 0,
       config: { iceServers: this.iceServers }
     });
-    peer.on("signal", (data) => {
+    this.peer.on("signal", (data) => {
       this.send({
         type: "signal",
-        userId: targetUserId,
+        userId: this.userId,
+        roomId: this.roomId,
         payload: data
       });
     });
-    peer.on("stream", (stream) => {
-      this.remoteStreams.set(targetUserId, stream);
+    this.peer.on("stream", (stream) => {
+      this.remoteStream = stream;
       this.emit("remoteStream", stream);
     });
-    peer.on("data", (data) => {
-      try {
-        const parsed = JSON.parse(data.toString());
-        if (parsed.type === "speaking") {
-          if (parsed.isSpeaking) {
-            this.emit("speaking", parsed.userId);
-          } else {
-            this.emit("stoppedSpeaking", parsed.userId);
-          }
-        }
-      } catch (e) {
-      }
-    });
-    peer.on("error", (err) => {
-      this.emit("error", err);
+    this.peer.on("connect", () => {
+      this.isConnectedFlag = true;
+      this.emit("connected");
     });
-    peer.on("close", () => {
-      this.peers.delete(targetUserId);
+    this.peer.on("error", (err) => {
+      console.error("Peer error:", err);
     });
-    this.peers.set(targetUserId, peer);
   }
   handlePeerSignal(targetUserId, signal) {
-    let peer = this.peers.get(targetUserId);
-    if (!peer) {
-      this.initPeer(targetUserId, false);
-      peer = this.peers.get(targetUserId);
-    }
-    if (peer) {
-      peer.signal(signal);
-    }
-  }
-  closePeer(userId) {
-    const peer = this.peers.get(userId);
-    if (peer) {
-      peer.destroy();
-      this.peers.delete(userId);
+    if (!this.peer) {
+      this.initPeer(false);
     }
+    this.peer?.signal(signal);
   }
   send(data) {
     if (this.ws?.readyState === WebSocket.OPEN) {
@@ -225,22 +118,13 @@ var VoiceClient = class {
     }
   }
   disconnect() {
-    if (this.speakingDetectionInterval) {
-      clearInterval(this.speakingDetectionInterval);
-    }
-    if (this.audioContext) {
-      this.audioContext.close();
-    }
-    this.peers.forEach((peer) => {
-      peer.destroy();
-    });
-    this.peers.clear();
-    if (this.localStream) {
-      this.localStream.getTracks().forEach((track) => track.stop());
-    }
     if (this.ws) {
+      this.send({ type: "leave", roomId: this.roomId, userId: this.userId });
       this.ws.close();
     }
+    this.peer?.destroy();
+    this.localStream?.getTracks().forEach((track) => track.stop());
+    this.isConnectedFlag = false;
     this.emit("disconnected");
   }
   toggleMute() {
@@ -254,26 +138,9 @@ var VoiceClient = class {
   isMuted() {
     return this.localStream?.getAudioTracks()[0]?.enabled === false;
   }
-  setSpeakingThreshold(threshold) {
-    this.speakingThreshold = Math.min(1, Math.max(0, threshold));
-  }
-  getRemoteStream(userId) {
-    if (userId) {
-      const stream = this.remoteStreams.get(userId);
-      return stream || null;
-    }
-    const firstStream = this.remoteStreams.values().next().value;
-    return firstStream || null;
-  }
-  getPeers() {
-    return Array.from(this.peers.keys());
-  }
   getUserId() {
     return this.userId;
   }
-  isConnectedToRoom() {
-    return this.isConnected;
-  }
 };
 export {
   VoiceClient

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voicemaster/core",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "WebRTC voice communication core library",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -17,10 +17,17 @@
     "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
     "prepublishOnly": "npm run build"
   },
-  "keywords": ["webrtc", "voice", "audio", "p2p", "typescript"],
+  "keywords": [
+    "webrtc",
+    "voice",
+    "audio",
+    "p2p",
+    "typescript"
+  ],
   "author": "Sergey Minasyan",
   "license": "MIT",
   "dependencies": {
+    "@voicemaster/core": "^1.0.1",
     "simple-peer": "^9.11.1"
   },
   "devDependencies": {
@@ -28,4 +35,4 @@
     "tsup": "^8.0.0",
     "typescript": "^5.3.0"
   }
-}
+}

package/src/VoiceClient.ts

@@ -8,52 +8,24 @@ export interface VoiceClientConfig {
   iceServers?: RTCIceServer[];
 }
 
-export interface VoiceEvents {
-  connected: () => void;
-  disconnected: () => void;
-  remoteStream: (stream: MediaStream) => void;
-  localStream: (stream: MediaStream) => void;
-  error: (error: Error) => void;
-  userJoined: (userId: string) => void;
-  userLeft: (userId: string) => void;
-  speaking: (userId: string) => void;
-  stoppedSpeaking: (userId: string) => void;
-}
-
-type EventHandler<T extends keyof VoiceEvents> = VoiceEvents[T];
-
 export class VoiceClient {
   private ws: WebSocket | null = null;
-  private peers: Map<string, Peer.Instance> = new Map();
+  private peer: Peer.Instance | null = null;
   private localStream: MediaStream | null = null;
-  private remoteStreams: Map<string, MediaStream> = new Map();
-  private eventHandlers: Partial<Record<keyof VoiceEvents, Function[]>> = {};
-  private userId: string;
-  private roomId: string;
+  private remoteStream: MediaStream | null = null;
+  private eventHandlers: Map<string, Function[]> = new Map();
   private signalingUrl: string;
+  private roomId: string;
+  private userId: string;
   private iceServers: RTCIceServer[];
-  private speakingDetectionInterval: NodeJS.Timeout | null = null;
-  private audioContext: AudioContext | null = null;
-  private sourceNode: MediaStreamAudioSourceNode | null = null;
-  private analyserNode: AnalyserNode | null = null;
-  private speakingThreshold = 0.05;
-  private isSpeaking = false;
-  private reconnectAttempts = 0;
-  private maxReconnectAttempts = 5;
-  private isConnected = false;
+  private isConnectedFlag = false;
 
   constructor(config: VoiceClientConfig) {
-    this.userId = config.userId;
-    this.roomId = config.roomId;
     this.signalingUrl = config.signalingUrl;
+    this.roomId = config.roomId;
+    this.userId = config.userId;
     this.iceServers = config.iceServers || [
-      { urls: 'stun:stun.l.google.com:19302' },
-      { urls: 'stun:stun.relay.metered.ca:80' },
-      {
-        urls: 'turn:openrelay.metered.ca:80',
-        username: 'openrelayproject',
-        credential: 'openrelayproject'
-      }
+      { urls: 'stun:stun.l.google.com:19302' }
     ];
 
     if (config.autoConnect !== false) {
@@ -61,25 +33,17 @@ export class VoiceClient {
     }
   }
 
-  on<K extends keyof VoiceEvents>(event: K, handler: EventHandler<K>): void {
-    if (!this.eventHandlers[event]) {
-      this.eventHandlers[event] = [];
+  on(event: string, callback: Function): void {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, []);
     }
-    this.eventHandlers[event]!.push(handler);
+    this.eventHandlers.get(event)!.push(callback);
   }
 
-  off<K extends keyof VoiceEvents>(event: K, handler: EventHandler<K>): void {
-    const handlers = this.eventHandlers[event];
+  private emit(event: string, ...args: any[]): void {
+    const handlers = this.eventHandlers.get(event);
     if (handlers) {
-      const index = handlers.indexOf(handler);
-      if (index !== -1) handlers.splice(index, 1);
-    }
-  }
-
-  private emit<K extends keyof VoiceEvents>(event: K, ...args: Parameters<EventHandler<K>>): void {
-    const handlers = this.eventHandlers[event];
-    if (handlers) {
-      handlers.forEach(handler => handler(...args as any));
+      handlers.forEach(handler => handler(...args));
     }
   }
 
@@ -88,8 +52,7 @@ export class VoiceClient {
       await this.initMicrophone();
       this.initWebSocket();
     } catch (error) {
-      this.emit('error', error as Error);
-      this.handleReconnect();
+      this.emit('error', error);
     }
   }
 
@@ -98,64 +61,10 @@ export class VoiceClient {
       audio: {
         echoCancellation: true,
         noiseSuppression: true,
-        autoGainControl: true,
-        sampleRate: 48000,
-        channelCount: 1
+        autoGainControl: true
       }
     });
-
     this.emit('localStream', this.localStream);
-    this.setupSpeakingDetection();
-  }
-
-  private setupSpeakingDetection(): void {
-    if (!this.localStream) return;
-
-    this.audioContext = new AudioContext();
-    this.sourceNode = this.audioContext.createMediaStreamSource(this.localStream);
-    this.analyserNode = this.audioContext.createAnalyser();
-    this.analyserNode.fftSize = 256;
-    
-    this.sourceNode.connect(this.analyserNode);
-    this.sourceNode.connect(this.audioContext.destination);
-    
-    const dataArray = new Uint8Array(this.analyserNode.frequencyBinCount);
-    
-    this.speakingDetectionInterval = setInterval(() => {
-      if (!this.analyserNode) return;
-      
-      this.analyserNode.getByteTimeDomainData(dataArray);
-      let maxSample = 0;
-      
-      for (let i = 0; i < dataArray.length; i++) {
-        const sample = Math.abs(dataArray[i] / 128 - 1);
-        if (sample > maxSample) maxSample = sample;
-      }
-      
-      const isCurrentlySpeaking = maxSample > this.speakingThreshold;
-      
-      if (isCurrentlySpeaking && !this.isSpeaking) {
-        this.isSpeaking = true;
-        this.broadcastSpeakingStatus(true);
-        this.emit('speaking', this.userId);
-      } else if (!isCurrentlySpeaking && this.isSpeaking) {
-        this.isSpeaking = false;
-        this.broadcastSpeakingStatus(false);
-        this.emit('stoppedSpeaking', this.userId);
-      }
-    }, 100);
-  }
-
-  private broadcastSpeakingStatus(isSpeaking: boolean): void {
-    this.peers.forEach((peer) => {
-      if (peer && peer.connected) {
-        peer.send(JSON.stringify({
-          type: 'speaking',
-          userId: this.userId,
-          isSpeaking
-        }));
-      }
-    });
   }
 
   private initWebSocket(): void {
@@ -163,13 +72,7 @@ export class VoiceClient {
     this.ws = new WebSocket(url);
 
     this.ws.onopen = () => {
-      this.reconnectAttempts = 0;
-      this.isConnected = true;
-      this.send({
-        type: 'join',
-        roomId: this.roomId,
-        userId: this.userId
-      });
+      this.send({ type: 'join', roomId: this.roomId, userId: this.userId });
     };
 
     this.ws.onmessage = (event) => {
@@ -178,112 +81,66 @@ export class VoiceClient {
     };
 
     this.ws.onclose = () => {
-      this.isConnected = false;
-      this.handleReconnect();
-    };
-
-    this.ws.onerror = (error) => {
-      this.emit('error', new Error('WebSocket error'));
-    };
-  }
-
-  private handleReconnect(): void {
-    if (this.reconnectAttempts < this.maxReconnectAttempts) {
-      this.reconnectAttempts++;
-      setTimeout(() => {
-        this.initWebSocket();
-      }, 1000 * Math.min(30, this.reconnectAttempts));
-    } else {
       this.emit('disconnected');
-    }
+    };
   }
 
   private handleSignalingMessage(message: any): void {
     switch (message.type) {
       case 'user-joined':
-        this.initPeer(message.userId, true);
-        this.emit('userJoined', message.userId);
+        if (message.userId !== this.userId) {
+          this.initPeer(true);
+          this.emit('userJoined', message.userId);
+        }
         break;
-
       case 'signal':
         this.handlePeerSignal(message.userId, message.payload);
         break;
-
       case 'user-left':
-        this.closePeer(message.userId);
         this.emit('userLeft', message.userId);
         break;
     }
   }
 
-  private initPeer(targetUserId: string, initiator: boolean): void {
-    if (this.peers.has(targetUserId)) return;
+  private initPeer(initiator: boolean): void {
+    if (this.peer) return;
 
-    const peer = new Peer({
+      this.peer = new Peer({
       initiator,
       trickle: true,
-      stream: this.localStream!,
+      stream: this.localStream || undefined,
       config: { iceServers: this.iceServers }
     });
 
-    peer.on('signal', (data) => {
+    this.peer.on('signal', (data) => {
       this.send({
         type: 'signal',
-        userId: targetUserId,
+        userId: this.userId,
+        roomId: this.roomId,
         payload: data
       });
     });
 
-    peer.on('stream', (stream) => {
-      this.remoteStreams.set(targetUserId, stream);
-      this.emit('remoteStream', stream);
-    });
-
-    peer.on('data', (data) => {
-      try {
-        const parsed = JSON.parse(data.toString());
-        if (parsed.type === 'speaking') {
-          if (parsed.isSpeaking) {
-            this.emit('speaking', parsed.userId);
-          } else {
-            this.emit('stoppedSpeaking', parsed.userId);
-          }
-        }
-      } catch (e) {
-        // Binary data, ignore
-      }
-    });
-
-    peer.on('error', (err) => {
-      this.emit('error', err);
-    });
+  this.peer.on('stream', (stream) => {
+    this.remoteStream = stream;
+    this.emit('remoteStream', stream);
+  });
 
-    peer.on('close', () => {
-      this.peers.delete(targetUserId);
-    });
+  this.peer.on('connect', () => {
+    this.isConnectedFlag = true;
+    this.emit('connected');
+  });
 
-    this.peers.set(targetUserId, peer);
-  }
+  this.peer.on('error', (err) => {
+    console.error('Peer error:', err);
+  });
+}
 
   private handlePeerSignal(targetUserId: string, signal: any): void {
-    let peer = this.peers.get(targetUserId);
-    
-    if (!peer) {
-      this.initPeer(targetUserId, false);
-      peer = this.peers.get(targetUserId);
-    }
-    
-    if (peer) {
-      peer.signal(signal);
-    }
-  }
-
-  private closePeer(userId: string): void {
-    const peer = this.peers.get(userId);
-    if (peer) {
-      peer.destroy();
-      this.peers.delete(userId);
+    if (!this.peer) {
+      this.initPeer(false);
     }
+    this.peer?.signal(signal);
   }
 
   private send(data: any): void {
@@ -293,27 +150,13 @@ export class VoiceClient {
   }
 
   disconnect(): void {
-    if (this.speakingDetectionInterval) {
-      clearInterval(this.speakingDetectionInterval);
-    }
-    
-    if (this.audioContext) {
-      this.audioContext.close();
-    }
-    
-    this.peers.forEach((peer) => {
-      peer.destroy();
-    });
-    this.peers.clear();
-    
-    if (this.localStream) {
-      this.localStream.getTracks().forEach(track => track.stop());
-    }
-    
     if (this.ws) {
+      this.send({ type: 'leave', roomId: this.roomId, userId: this.userId });
       this.ws.close();
     }
-    
+    this.peer?.destroy();
+    this.localStream?.getTracks().forEach(track => track.stop());
+    this.isConnectedFlag = false;
     this.emit('disconnected');
   }
 
@@ -330,30 +173,19 @@ export class VoiceClient {
     return this.localStream?.getAudioTracks()[0]?.enabled === false;
   }
 
-  setSpeakingThreshold(threshold: number): void {
-    this.speakingThreshold = Math.min(1, Math.max(0, threshold));
-  }
-
-  getRemoteStream(userId?: string): MediaStream | null {
-    if (userId) {
-        const stream = this.remoteStreams.get(userId);
-        return stream || null;
-    }
-    const firstStream = this.remoteStreams.values().next().value;
-    return firstStream || null;
-    }
-
-  getPeers(): string[] {
-    return Array.from(this.peers.keys());
-  }
-
   getUserId(): string {
     return this.userId;
   }
-
-  isConnectedToRoom(): boolean {
-    return this.isConnected;
-  }
 }
 
-export default VoiceClient;
+export interface VoiceEvents {
+  connected: () => void;
+  disconnected: () => void;
+  remoteStream: (stream: MediaStream) => void;
+  localStream: (stream: MediaStream) => void;
+  error: (error: Error) => void;
+  userJoined: (userId: string) => void;
+  userLeft: (userId: string) => void;
+  speaking: (userId: string) => void;
+  stoppedSpeaking: (userId: string) => void;
+}