aqualink 2.7.2 → 2.7.3-hotfix

package/build/structures/Connection.js

@@ -1,5 +1,7 @@
 "use strict";
 
+const REGION_REGEX = /^([a-z]+)/;
+
 class Connection {
     constructor(player) {
         this.player = player;
@@ -20,51 +22,75 @@ class Connection {
         if (!data?.endpoint) return;
 
         const { endpoint, token } = data;
-        const newRegion = endpoint.split('.')[0];
-        if (!newRegion) return;
-
-        if (this.region !== newRegion) {
-            const oldRegion = this.region;
-            this.endpoint = endpoint;
-            this.token = token;
-            this.region = newRegion;
-
-            this.aqua.emit(
-                "debug",
-                `[Player ${this.guildId} - CONNECTION] Voice Server: ${
-                    oldRegion ? `Changed from ${oldRegion} to ${newRegion}` : newRegion
-                }`
-            );
+        
+        const regionMatch = REGION_REGEX.exec(endpoint);
+        if (!regionMatch) return;
+        
+        const newRegion = regionMatch[1];
+        
+        if (this.endpoint === endpoint && this.token === token && this.region === newRegion) {
+            return;
+        }
 
-            this._updatePlayerVoiceData();
+        const oldRegion = this.region;
+        this.endpoint = endpoint;
+        this.token = token;
+        this.region = newRegion;
+
+        this.aqua.emit("debug", 
+            `[Player ${this.guildId} - CONNECTION] Voice Server: ${oldRegion ? `Changed from ${oldRegion} to ${newRegion}` : newRegion}`
+        );
+
+        if (this.player.paused) {
+            this.player.paused = false;
         }
+
+        this._updatePlayerVoiceData();
     }
 
     setStateUpdate(data) {
         if (!data) {
-            this.player?.destroy();
+            this._destroyPlayer();
             return;
         }
 
         const { channel_id, session_id, self_deaf, self_mute } = data;
+        
         if (!channel_id || !session_id) {
-            this.player?.destroy();
+            this._destroyPlayer();
             return;
         }
 
         if (this.voiceChannel !== channel_id) {
             this.aqua.emit("playerMove", this.voiceChannel, channel_id);
             this.voiceChannel = channel_id;
+            this.player.voiceChannel = channel_id;
         }
 
-        this.selfDeaf = Boolean(self_deaf);
-        this.selfMute = Boolean(self_mute);
-        this.sessionId = session_id;
+        this.selfDeaf = !!self_deaf;
+        this.selfMute = !!self_mute;
+
+        if (this.sessionId !== session_id) {
+            this.sessionId = session_id;
+            this._updatePlayerVoiceData();
+        }
+    }
+
+    _destroyPlayer() {
+        if (this.player) {
+            this.player.destroy();
+            this.aqua.emit("playerDestroy", this.player);
+        }
     }
 
     _updatePlayerVoiceData() {
         if (!this.player) return;
 
+        if (!this.sessionId || !this.endpoint || !this.token) {
+            this.aqua.emit("debug", `[Player ${this.guildId}] Incomplete voice data, waiting for complete data`);
+            return;
+        }
+
         const voiceData = {
             sessionId: this.sessionId,
             endpoint: this.endpoint,
@@ -87,6 +113,7 @@ class Connection {
             });
         }
     }
+
 }
 
-module.exports = Connection;
+module.exports = Connection;

package/build/structures/Player.js

@@ -18,14 +18,14 @@ const EVENT_HANDLERS = Object.freeze({
     TrackChangeEvent: "trackChange",
     WebSocketClosedEvent: "socketClosed",
     LyricsLineEvent: "lyricsLine",
-    LyricsFoundEvent: "lyricsFound" ,
+    LyricsFoundEvent: "lyricsFound",
     LyricsNotFoundEvent: "lyricsNotFound"
 });
 
 
 const VALID_MODES = new Set(Object.values(LOOP_MODES));
 const FAILURE_REASONS = new Set(["LOAD_FAILED", "CLEANUP"]);
-const RECONNECT_CODES = new Set([4015, 4009]);
+const RECONNECT_CODES = new Set([4015, 4009, 4006, 1000]);
 const FAIL_LOAD_TYPES = new Set(["error", "empty", "LOAD_FAILED", "NO_MATCHES"]);
 
 class UpdateBatcher {
@@ -94,7 +94,7 @@ class Player extends EventEmitter {
 
         const vol = options.defaultVolume ?? 100;
         this.volume = vol < 0 ? 0 : vol > 200 ? 200 : vol;
-        
+
         this.loop = VALID_MODES.has(options.loop) ? options.loop : LOOP_MODES.NONE;
         this.shouldDeleteMessage = Boolean(this.aqua.options.shouldDeleteMessage);
         this.leaveOnEnd = Boolean(this.aqua.options.leaveOnEnd);
@@ -249,47 +249,47 @@ class Player extends EventEmitter {
         return this;
     }
 
-  destroy() {
-    if (!this.connected) return this;
+    destroy() {
+        if (!this.connected) return this;
 
-    const voiceChannelId = this.voiceChannel ? this.voiceChannel.id || this.voiceChannel : null;
-    this._updateBatcher.destroy();
+        const voiceChannelId = this.voiceChannel ? this.voiceChannel.id || this.voiceChannel : null;
+        this._updateBatcher.destroy();
 
-    this.send({ guild_id: this.guildId, channel_id: null });
-    this._lastVoiceChannel = voiceChannelId;
-    this.voiceChannel = null;
-    this.connected = false;
-    this.send({ guild_id: this.guildId, channel_id: null });
+        this.send({ guild_id: this.guildId, channel_id: null });
+        this._lastVoiceChannel = voiceChannelId;
+        this.voiceChannel = null;
+        this.connected = false;
+        this.send({ guild_id: this.guildId, channel_id: null });
 
-    if (this.nowPlayingMessage) {
-        this.nowPlayingMessage.delete().catch(() => { });
-        this.nowPlayingMessage = null;
-    }
+        if (this.nowPlayingMessage) {
+            this.nowPlayingMessage.delete().catch(() => { });
+            this.nowPlayingMessage = null;
+        }
 
-    this.isAutoplay = false;
-    this.aqua.destroyPlayer(this.guildId);
-    
-    if (this.nodes?.connected) {
-        try {
-            this.nodes.rest.destroyPlayer(this.guildId);
-        } catch (error) {
-            if (!error.message.includes('ECONNREFUSED')) {
-                console.error('Error destroying player on node:', error);
+        this.isAutoplay = false;
+        this.aqua.destroyPlayer(this.guildId);
+
+        if (this.nodes?.connected) {
+            try {
+                this.nodes.rest.destroyPlayer(this.guildId);
+            } catch (error) {
+                if (!error.message.includes('ECONNREFUSED')) {
+                    console.error('Error destroying player on node:', error);
+                }
             }
         }
-    }
-    
-    this.previousTracksCount = 0;
-    this._dataStore.clear();
-    this.removeAllListeners();
 
-    this.queue = null;
-    this.previousTracks = null;
-    this.connection = null;
-    this.filters = null;
+        this.previousTracksCount = 0;
+        this._dataStore.clear();
+        this.removeAllListeners();
 
-    return this;
-}
+        this.queue = null;
+        this.previousTracks = null;
+        this.connection = null;
+        this.filters = null;
+
+        return this;
+    }
 
     pause(paused) {
         if (this.paused === paused) return this;
@@ -335,16 +335,16 @@ class Player extends EventEmitter {
         return this.nodes.rest.unsubscribeLiveLyrics(this.guildId);
     }
 
-  seek(position) {
-    if (!this.playing) return this;
-    if (position < 0) position = 0;
-    if (this.current?.info?.length && position > this.current.info.length) {
-      position = this.current.info.length;
+    seek(position) {
+        if (!this.playing) return this;
+        if (position < 0) position = 0;
+        if (this.current?.info?.length && position > this.current.info.length) {
+            position = this.current.info.length;
+        }
+        this.position = position;
+        this.batchUpdatePlayer({ position: this.position });
+        return this;
     }
-    this.position = position;
-    this.batchUpdatePlayer({ position: this.position });
-    return this;
-  }
 
     stop() {
         if (!this.playing) return this;
@@ -400,7 +400,7 @@ class Player extends EventEmitter {
     shuffle() {
         const queue = this.queue;
         const len = queue.length;
-        
+
         if (len <= 1) return this;
 
         if (len < 200) {
@@ -411,18 +411,18 @@ class Player extends EventEmitter {
         } else {
             this._shuffleAsync(queue, len - 1);
         }
-        
+
         return this;
     }
 
     _shuffleAsync(queue, i, chunkSize = 100) {
         const end = Math.max(0, i - chunkSize);
-        
+
         for (; i > end; i--) {
             const j = Math.floor(Math.random() * (i + 1));
             [queue[i], queue[j]] = [queue[j], queue[i]];
         }
-        
+
         if (i > 0) {
             setImmediate(() => this._shuffleAsync(queue, i, chunkSize));
         }
@@ -512,19 +512,58 @@ class Player extends EventEmitter {
         return this.stop();
     }
 
-    async socketClosed(player, payload) {
-        const { code, guildId } = payload || {};
+    async socketClosed(player, track, payload) {
+        const { code, guildId, reason } = payload || {};
+
         if (RECONNECT_CODES.has(code)) {
-            this.send({
-                guild_id: guildId,
-                channel_id: this.voiceChannel,
-                self_mute: this.mute,
-                self_deaf: this.deaf
-            });
+            try {
+                this.connected = false;
+
+                const voiceChannelId = this.voiceChannel?.id || this.voiceChannel;
+
+                if (!voiceChannelId) {
+                    console.error(`Cannot reconnect: No voice channel available for guild ${guildId}`);
+                    this.aqua.emit("socketClosed", player, payload);
+                    return;
+                }
+
+                this.aqua.emit("debug", guildId, `Attempting to reconnect to voice channel: ${voiceChannelId}`);
+
+                this.send({
+                    guild_id: guildId,
+                    channel_id: voiceChannelId,
+                    self_mute: this.mute || false,
+                    self_deaf: this.deaf || true
+                });
+
+                setTimeout(() => {
+                    if (!this.connected) {
+                        console.error(`Reconnection failed for guild ${guildId} after timeout`);
+                        this.aqua.emit("socketClosed", player, payload);
+                    }
+                }, 5000);
+
+                this.aqua.emit("debug", guildId, `Reconnection attempt sent for voice channel: ${voiceChannelId}`);
+                return;
+
+            } catch (error) {
+                console.error(`Failed to reconnect socket for guild ${guildId}:`, error);
+                this.connected = false;
+            }
         }
+
+        this.connected = false;
         this.aqua.emit("socketClosed", player, payload);
-        this.pause(true);
-        this.aqua.emit("debug", this.guildId, "Player paused due to socket closure.");
+
+        if (this.playing && this.current && this.queue.length > 0) {
+            try {
+                this.aqua.emit("debug", guildId, "Attempting to resume playback after socket close");
+                await this.play();
+            } catch (error) {
+                console.error(`Failed to resume playback after socket close for guild ${guildId}:`, error);
+                this.stop();
+            }
+        }
     }
 
     async lyricsLine(player, track, payload) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aqualink",
-  "version": "2.7.2",
+  "version": "2.7.3-hotfix",
   "description": "An Lavalink client, focused in pure performance and features",
   "main": "build/index.js",
   "types": "index.d.ts",