aqualink 2.1.3 → 2.3.0

package/build/structures/Player.js

@@ -26,6 +26,7 @@ class Player extends EventEmitter {
 
     constructor(aqua, nodes, options = {}) {
         super();
+        
         this.aqua = aqua;
         this.nodes = nodes;
         this.guildId = options.guildId;
@@ -35,47 +36,41 @@ class Player extends EventEmitter {
         this.connection = new Connection(this);
         this.filters = new Filters(this);
         
-        const defaultVolume = options.defaultVolume ?? 100;
-        this.volume = defaultVolume > 200 ? 200 : (defaultVolume < 0 ? 0 : defaultVolume);
-        
+        this.volume = Math.max(0, Math.min(options.defaultVolume ?? 100, 200));
         this.loop = Player.validModes.has(options.loop) ? options.loop : Player.LOOP_MODES.NONE;
         
         this.queue = new Queue();
-        this.previousTracks = []; 
-        this.shouldDeleteMessage = !!options.shouldDeleteMessage;
-        this.leaveOnEnd = !!options.leaveOnEnd;
+        this.previousTracks = new Array(50);
+        this.previousTracksIndex = 0;
+        this.previousTracksCount = 0;
+        
+        this.shouldDeleteMessage = Boolean(options.shouldDeleteMessage);
+        this.leaveOnEnd = Boolean(options.leaveOnEnd);
 
         this.playing = false;
         this.paused = false;
         this.connected = false;
         this.current = null;
+        this.position = 0;
         this.timestamp = 0;
         this.ping = 0;
         this.nowPlayingMessage = null;
-
+        this.isAutoplayEnabled = false;
         this.isAutoplay = false;
-        this._autoplay = {
-            _addToHistory: (track) => {
-                if (this.previousTracks.length >= 50) {
-                    this.previousTracks.pop();
-                }
-                this.previousTracks.unshift(track);
-            },
-            _cleanup: () => {
-                this.previousTracks = [];
-                this.isAutoplay = false;
-            }
+        
+        this._boundHandlers = {
+            playerUpdate: this._handlePlayerUpdate.bind(this),
+            event: this._handleEvent.bind(this)
         };
-
-        this._handlePlayerUpdate = this._handlePlayerUpdate.bind(this);
-        this._handleEvent = this._handleEvent.bind(this);
         
-        this.on("playerUpdate", this._handlePlayerUpdate);
-        this.on("event", this._handleEvent);
+        this.on("playerUpdate", this._boundHandlers.playerUpdate);
+        this.on("event", this._boundHandlers.event);
+        
+        this._dataStore = null;
     }
 
     get previous() {
-        return this.previousTracks[0] || null;
+        return this.previousTracksCount > 0 ? this.previousTracks[this.previousTracksIndex] : null;
     }
     
     get currenttrack() {
@@ -99,26 +94,38 @@ class Player extends EventEmitter {
     
             let query, source, response;
     
-            switch (sourceName) {
-                case "youtube":
-                    query = `https://www.youtube.com/watch?v=${identifier}&list=RD${identifier}`;
-                    source = "ytmsearch";
-                    break;
-                case "soundcloud":
+            const sourceHandlers = {
+                youtube: async () => {
+                    return {
+                        query: `https://www.youtube.com/watch?v=${identifier}&list=RD${identifier}`,
+                        source: "ytmsearch"
+                    };
+                },
+                soundcloud: async () => {
                     const scResults = await scAutoPlay(uri);
-                    if (!scResults?.length) return this;
-                    query = scResults[0];
-                    source = "scsearch";
-                    break;
-                case "spotify":
+                    if (!scResults?.length) return null;
+                    return {
+                        query: scResults[0],
+                        source: "scsearch"
+                    };
+                },
+                spotify: async () => {
                     const spResult = await spAutoPlay(identifier);
-                    if (!spResult) return this;
-                    query = `https://open.spotify.com/track/${spResult}`;
-                    source = "spotify";
-                    break;
-                default:
-                    return this;
-            }
+                    if (!spResult) return null;
+                    return {
+                        query: `https://open.spotify.com/track/${spResult}`,
+                        source: "spotify"
+                    };
+                }
+            };
+            
+            const handler = sourceHandlers[sourceName];
+            if (!handler) return this;
+            
+            const result = await handler();
+            if (!result) return this;
+            
+            ({ query, source } = result);
     
             response = await this.aqua.resolve({ query, source, requester });
     
@@ -147,24 +154,27 @@ class Player extends EventEmitter {
     setAutoplay(enabled) {
         this.isAutoplayEnabled = Boolean(enabled);
         this.aqua.emit("debug", this.guildId, `Autoplay has been ${enabled ? "enabled" : "disabled"}.`);
+        return this;
     }
     
-    
-    
     addToPreviousTrack(track) {
         if (!track) return;
         
-        if (this.previousTracks.length >= 50) {
-            this.previousTracks.pop();
+        this.previousTracks[this.previousTracksIndex] = track;
+        this.previousTracksIndex = (this.previousTracksIndex + 1) % 50;
+        
+        if (this.previousTracksCount < 50) {
+            this.previousTracksCount++;
         }
-        this.previousTracks.unshift(track);
     }
 
     _handlePlayerUpdate({ state }) {
         if (state) {
-            if (state.position !== undefined) this.position = state.position;
-            if (state.timestamp !== undefined) this.timestamp = state.timestamp;
-            if (state.ping !== undefined) this.ping = state.ping;
+            const { position, timestamp, ping } = state;
+            
+            if (position !== undefined) this.position = position;
+            if (timestamp !== undefined) this.timestamp = timestamp;
+            if (ping !== undefined) this.ping = ping;
         }
         this.aqua.emit("playerUpdate", this, { state });
     }
@@ -193,12 +203,14 @@ class Player extends EventEmitter {
     connect({ guildId, voiceChannel, deaf = true, mute = false }) {
         if (this.connected) throw new Error("Player is already connected.");
         
-        this.send({
+        const payload = {
             guild_id: guildId,
             channel_id: voiceChannel,
             self_deaf: deaf,
             self_mute: mute
-        });
+        };
+        
+        this.send(payload);
         
         this.connected = true;
         this.aqua.emit("debug", this.guildId, `Player connected to voice channel: ${voiceChannel}.`);
@@ -210,18 +222,34 @@ class Player extends EventEmitter {
         
         this.disconnect();
         
-        this.nowPlayingMessage?.delete().catch(() => {});
+        this._cleanupNowPlayingMessage();
         
-        if (this._autoplay) {
-            this._autoplay._cleanup();
-        }
+        this.isAutoplay = false;
 
+        this.off("playerUpdate", this._boundHandlers.playerUpdate);
+        this.off("event", this._boundHandlers.event);
+        
         this.aqua.destroyPlayer(this.guildId);
         this.nodes.rest.destroyPlayer(this.guildId);
+        
         this.clearData();
         this.removeAllListeners();
+        
+        this._boundHandlers = null;
+        this.queue = null;
+        this.previousTracks = null;
+        this.connection = null;
+        this.filters = null;
+        
         return this;
     }
+    
+    _cleanupNowPlayingMessage() {
+        if (this.nowPlayingMessage) {
+            this.nowPlayingMessage.delete().catch(() => {});
+            this.nowPlayingMessage = null;
+        }
+    }
 
     pause(paused) {
         if (this.paused === paused) return this;
@@ -287,6 +315,7 @@ class Player extends EventEmitter {
         }
         
         this.voiceChannel = channel;
+        
         this.connect({
             deaf: this.deaf,
             guildId: this.guildId,
@@ -298,6 +327,8 @@ class Player extends EventEmitter {
     }
 
     disconnect() {
+        if (!this.connected) return this;
+        
         this.connected = false;
         this.send({ guild_id: this.guildId, channel_id: null });
         this.voiceChannel = null;
@@ -329,17 +360,14 @@ class Player extends EventEmitter {
     }
 
     async trackStart(player, track) {
-        this.updateTrackState(true, false);
+        this.playing = true;
+        this.paused = false;
         this.aqua.emit("trackStart", player, track);
     }
 
-    async trackChange(player, track) {
-        this.updateTrackState(true, false);
-        this.aqua.emit("trackChange", player, track);
-    }
-
     async trackEnd(player, track, payload) {
         this.addToPreviousTrack(track);
+        
         if (this.shouldDeleteMessage && this.nowPlayingMessage) {
             try {
                 await this.nowPlayingMessage.delete();
@@ -348,37 +376,47 @@ class Player extends EventEmitter {
                 console.error("Error deleting now playing message:", error);
             }
         }
-        const reason = payload.reason?.toLowerCase().replace("_", "");
-        if (reason === "loadfailed" || reason === "cleanup") {
+        
+        const reason = payload.reason;
+        if (reason === "LOAD_FAILED" || reason === "CLEANUP") {
             if (!player.queue.length) {
                 this.clearData();
                 this.aqua.emit("queueEnd", player);
             } else {
+                this.aqua.emit("trackEnd", player, track, reason);
                 await player.play();
             }
             return;
         }
 
+        await this._handleTrackLooping(player, track);
+
+        if (player.queue.isEmpty()) {
+            await this._handleEmptyQueue(player);
+        } else {
+            this.aqua.emit("trackEnd", player, track, reason);
+            await player.play();
+        }
+    }
+    
+    async _handleTrackLooping(player, track) {
         if (this.loop === Player.LOOP_MODES.TRACK) {
             player.queue.unshift(track);
         } else if (this.loop === Player.LOOP_MODES.QUEUE) {
             player.queue.push(track);
         }
-
-        if (player.queue.isEmpty()) {
-            if (this.isAutoplayEnabled) {
-                await player.autoplay(player, track);
-            } else {
-                this.playing = false;
-                if (this.leaveOnEnd) {
-                    this.clearData();
-                    this.cleanup();
-                }
-                this.aqua.emit("queueEnd", player);
-            }
-            return;
+    }
+    
+    async _handleEmptyQueue(player) {
+        if (this.isAutoplayEnabled) {
+            await player.autoplay(player);
         } else {
-            await player.play();
+            this.playing = false;
+            if (this.leaveOnEnd) {
+                this.clearData();
+                this.cleanup();
+            }
+            this.aqua.emit("queueEnd", player);
         }
     }
 
@@ -393,11 +431,11 @@ class Player extends EventEmitter {
     }
 
     async socketClosed(player, payload) {
-        const code = payload && payload.code;
+        const { code, guildId } = payload || {};
         
         if (code === 4015 || code === 4009) {
             this.send({
-                guild_id: payload.guildId,
+                guild_id: guildId,
                 channel_id: this.voiceChannel,
                 self_mute: this.mute,
                 self_deaf: this.deaf,
@@ -415,7 +453,7 @@ class Player extends EventEmitter {
 
     set(key, value) {
         if (!this._dataStore) {
-            this._dataStore = new WeakMap();
+            this._dataStore = new Map();
         }
         this._dataStore.set(key, value);
     }
@@ -425,7 +463,9 @@ class Player extends EventEmitter {
     }
 
     clearData() {
-        if (this.previousTracks) this.previousTracks.length = 0;
+        if (this.previousTracks) {
+            this.previousTracksCount = 0;
+        }
         this._dataStore = null;
         return this;
     }
@@ -444,11 +484,6 @@ class Player extends EventEmitter {
             this.destroy();
         }
     }
-
-    updateTrackState(playing, paused) {
-        this.playing = playing;
-        this.paused = paused;
-    }
 }
 
 module.exports = Player;

package/build/structures/Rest.js

@@ -2,10 +2,14 @@
 const https = require("https");
 const http = require("http");
 
-let http2 = null;
+let http2;
+try {
+    http2 = require("http2");
+} catch (e) {
+}
 
 class Rest {
-    constructor(aqua, { secure, host, port, sessionId, password }) {
+    constructor(aqua, { secure, host, port, sessionId, password, timeout = 30000 }) {
         this.aqua = aqua;
         this.sessionId = sessionId;
         this.version = "v4";
@@ -14,29 +18,17 @@ class Rest {
             "Content-Type": "application/json",
             "Authorization": password,
         };
-        
         this.secure = secure;
+        this.timeout = timeout;
+        
+        this.client = this.initializeClient();
     }
 
-    getClient() {
-        if (this.client) return this.client;
-        
+    initializeClient() {
         if (this.secure) {
-            if (!http2) {
-                try {
-                    http2 = require("http2");
-                    this.client = http2;
-                } catch (e) {
-                    this.client = https;
-                }
-            } else {
-                this.client = http2;
-            }
-        } else {
-            this.client = http;
+            return http2 || https;
         }
-        
-        return this.client;
+        return http;
     }
 
     setSessionId(sessionId) {
@@ -50,22 +42,24 @@ class Rest {
         };
 
         return new Promise((resolve, reject) => {
-            const client = this.getClient();
             const url = `${this.baseUrl}${endpoint}`;
-            
-            const req = client.request(url, options, (res) => {
-                const chunks = [];
+            const req = this.client.request(url, options, (res) => {
+                res.setEncoding('utf8');
+                
+                let data = '';
+                
+                res.on("data", (chunk) => {
+                    data += chunk;
+                });
                 
-                res.on("data", (chunk) => chunks.push(chunk));
                 res.on("end", () => {
                     if (res.statusCode >= 200 && res.statusCode < 300) {
-                        if (chunks.length === 0) {
+                        if (!data) {
                             resolve(null);
                             return;
                         }
                         
                         try {
-                            const data = Buffer.concat(chunks).toString('utf8');
                             resolve(data ? JSON.parse(data) : null);
                         } catch (error) {
                             reject(new Error(`Failed to parse response: ${error.message}`));
@@ -141,25 +135,27 @@ class Rest {
     }
 
     async getLyrics({ track }) {
-        if (!track) {
-            return null;
-        }
-
-        if (track.search) {
-            try {
-                const query = encodeURIComponent(track.info.title);
-                const res = await this.makeRequest("GET", `/${this.version}/lyrics/search?query=${query}&source=genius`);
-                if (res) return res;
-            } catch (error) {
-                console.error("Failed to fetch lyrics:", error.message);
+        if (!track) return null;
+        
+        try {
+            if (track.search) {
+                const query = track.info.title;
+                try {
+                    const res = await this.makeRequest("GET", `/${this.version}/lyrics/search?query=${query}&source=genius`);
+                    if (res) return res;
+                } catch (err) {}
+            } else {
+                this.validateSessionId();
+                return await this.makeRequest(
+                    "GET", 
+                    `/${this.version}/sessions/${this.sessionId}/players/${track.guild_id}/track/lyrics?skipTrackSource=false`
+                );
             }
+         
+        } catch (error) {
+            console.error("Failed to fetch lyrics:", error.message);
+            return null;
         }
-        
-        this.validateSessionId();
-        return this.makeRequest(
-            "GET", 
-            `/${this.version}/sessions/${this.sessionId}/players/${track.guild_id}/track/lyrics?skipTrackSource=false`
-        );
     }
 }
 

package/package.json

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