aqualink 2.5.0 → 2.6.1

package/build/structures/Aqua.js

@@ -3,7 +3,7 @@ const Node = require("./Node");
 const Player = require("./Player");
 const Track = require("./Track");
 const { version: pkgVersion } = require("../../package.json");
-const { EventEmitter } = require('eventemitter3');
+const { EventEmitter } = require('tseep');
 
 const URL_REGEX = /^https?:\/\//;
 const DEFAULT_OPTIONS = Object.freeze({
@@ -199,7 +199,7 @@ class Aqua extends EventEmitter {
         const player = new Player(this, node, options);
         this.players.set(options.guildId, player);
         
-        player.once("destroy", () => {
+        player.on("destroy", () => {
             this.players.delete(options.guildId);
         });
         
@@ -233,7 +233,7 @@ class Aqua extends EventEmitter {
             const response = await requestNode.rest.makeRequest("GET", endpoint);
             
             if (["empty", "NO_MATCHES"].includes(response.loadType)) {
-                return await this.handleNoMatches(requestNode.rest, query);
+                return await this.handleNoMatches(query);
             }
             
             return this.constructResponse(response, requester, requestNode);
@@ -244,33 +244,29 @@ class Aqua extends EventEmitter {
             throw new Error(`Failed to resolve track: ${error.message}`);
         }
     }
-
+    
     getRequestNode(nodes) {
         if (!nodes) return this.leastUsedNodes[0];
         
         if (nodes instanceof Node) return nodes;
-        if (typeof nodes === "string") return this.nodeMap.get(nodes) || this.leastUsedNodes[0];
+        if (typeof nodes === "string") {
+            const mappedNode = this.nodeMap.get(nodes);
+            return mappedNode || this.leastUsedNodes[0];
+        }
         
         throw new TypeError(`'nodes' must be a string or Node instance, received: ${typeof nodes}`);
     }
-
-    async handleNoMatches(rest, query) {
-        try {
-            const ytEndpoint = `/v4/loadtracks?identifier=https://www.youtube.com/watch?v=${query}`;
-            const youtubeResponse = await rest.makeRequest("GET", ytEndpoint);
-            
-            if (!["empty", "NO_MATCHES"].includes(youtubeResponse.loadType)) {
-                return youtubeResponse;
-            }
-            
-            const spotifyEndpoint = `/v4/loadtracks?identifier=https://open.spotify.com/track/${query}`;
-            return await rest.makeRequest("GET", spotifyEndpoint);
-        } catch (error) {
-            console.error(`Failed to resolve track: ${error.message}`);
-            throw error;
-        }
+    
+    async handleNoMatches(query) {
+        return {
+            loadType: "empty",
+            exception: null,
+            playlistInfo: null,
+            pluginInfo: {},
+            tracks: []
+        };
     }
-
+    
     constructResponse(response, requester, requestNode) {
         const baseResponse = {
             loadType: response.loadType,
@@ -354,24 +350,13 @@ class Aqua extends EventEmitter {
         try {
             if (player.connection) {
                 try {
-                    await player.connection.disconnect();
+                    await player.destroy()
                     player.connection = null;
                 } catch (error) {
                     console.error(`Error disconnecting player connection: ${error.message}`);
                 }
             }
             
-            player.queue?.clear();
-            
-            if (typeof player.stop === 'function') {
-                try {
-                    await player.stop();
-                } catch (error) {
-                    console.error(`Error stopping player: ${error.message}`);
-                }
-            }
-            
-            player.removeAllListeners();
             this.players.delete(player.guildId);
             this.emit("playerCleanup", player.guildId);
         } catch (error) {

package/build/structures/Connection.js

@@ -2,88 +2,91 @@
 
 class Connection {
     constructor(player) {
-        this.playerRef = new WeakRef(player);
-        
+        this.player = player;
+        this.voiceChannel = player.voiceChannel;
+        this.guildId = player.guildId;
+        this.aqua = player.aqua;
+        this.nodes = player.nodes;
+
         this.sessionId = null;
         this.endpoint = null;
         this.token = null;
-        
         this.region = null;
         this.selfDeaf = false;
         this.selfMute = false;
-        this.voiceChannel = player.voiceChannel;
-        this.guildId = player.guildId;
-        
-        this.aqua = player.aqua;
-        this.nodes = player.nodes;
+
     }
 
     setServerUpdate(data) {
-        if (!data?.endpoint) return;
-        
+        if (!data || !data.endpoint) return;
+
         const { endpoint, token } = data;
-        const dotIndex = endpoint.indexOf('.');
-        
-        if (dotIndex === -1) return;
-        const newRegion = endpoint.substring(0, dotIndex);
-        
+
+        const [newRegion] = endpoint.split('.');
+        if (!newRegion) return;
+
         if (this.region !== newRegion) {
-            const prevRegion = this.region;
-            [this.endpoint, this.token, this.region] = [endpoint, token, newRegion];
-            
-            if (this.aqua.listenerCount('debug')) {
+            this.endpoint = endpoint;
+            this.token = token;
+            this.region = newRegion;
+
                 this.aqua.emit(
                     "debug",
                     `[Player ${this.guildId} - CONNECTION] Voice Server: ${
-                        prevRegion ? `Changed from ${prevRegion} to ${newRegion}` : newRegion
+                        this.region ? `Changed from ${this.region} to ${newRegion}` : newRegion
                     }`
                 );
-            }
             
+
             this._updatePlayerVoiceData();
         }
     }
 
     setStateUpdate(data) {
-        const { channel_id, session_id, self_deaf, self_mute } = data || {};
-        
+        if (!data) {
+            this.player?.destroy();
+            return;
+        }
+
+        const { channel_id, session_id, self_deaf, self_mute } = data;
+
         if (!channel_id || !session_id) {
-            this.playerRef.deref()?.destroy();
+            this.player?.destroy();
             return;
         }
-        
+
         if (this.voiceChannel !== channel_id) {
             this.aqua.emit("playerMove", this.voiceChannel, channel_id);
             this.voiceChannel = channel_id;
         }
-        
+
         this.selfDeaf = !!self_deaf;
         this.selfMute = !!self_mute;
         this.sessionId = session_id;
     }
 
-    async _updatePlayerVoiceData() {
-        const player = this.playerRef.deref();
-        if (!player) return;
+    _updatePlayerVoiceData() {
+        if (!this.player) return;
 
+        const voiceData = {
+            sessionId: this.sessionId,
+            endpoint: this.endpoint,
+            token: this.token
+        };
         try {
-            await this.nodes.rest.updatePlayer({
+            this.nodes.rest.updatePlayer({
                 guildId: this.guildId,
-                data: { 
-                    voice: {
-                        sessionId: this.sessionId,
-                        endpoint: this.endpoint,
-                        token: this.token
-                    }, 
-                    volume: player.volume 
+                data: {
+                    voice: voiceData,
+                    volume: this.player.volume
                 }
             });
         } catch (error) {
-            if (this.aqua.listenerCount('apiError')) {
-                this.aqua.emit("apiError", "updatePlayer", { 
+            if (this.aqua.listenerCount('apiError') > 0) {
+                this.aqua.emit("apiError", "updatePlayer", {
                     error,
                     guildId: this.guildId,
-                    voiceData: { ...this }
+                    voiceData
                 });
             }
         }

package/build/structures/Filters.js

@@ -3,205 +3,165 @@
 class Filters {
     constructor(player, options = {}) {
         this.player = player;
-        this.volume = options.volume || 1;
-        this.equalizer = options.equalizer || [];
-        this.karaoke = options.karaoke || null;
-        this.timescale = options.timescale || null;
-        this.tremolo = options.tremolo || null;
-        this.vibrato = options.vibrato || null;
-        this.rotation = options.rotation || null;
-        this.distortion = options.distortion || null;
-        this.channelMix = options.channelMix || null;
-        this.lowPass = options.lowPass || null;
-        this.bassboost = options.bassboost || null;
-        this.slowmode = options.slowmode || null;
-        this.nightcore = options.nightcore || null;
-        this.vaporwave = options.vaporwave || null;
-        this._8d = options._8d || null;
         
-        this._filterDataTemplate = {
-            volume: this.volume,
-            equalizer: this.equalizer,
-            karaoke: null,
-            timescale: null,
-            tremolo: null,
-            vibrato: null,
-            rotation: null,
-            distortion: null,
-            channelMix: null,
-            lowPass: null
+        this.defaults = {
+            karaoke: { level: 1.0, monoLevel: 1.0, filterBand: 220.0, filterWidth: 100.0 },
+            timescale: { speed: 1.0, pitch: 1.0, rate: 1.0 },
+            tremolo: { frequency: 2.0, depth: 0.5 },
+            vibrato: { frequency: 2.0, depth: 0.5 },
+            rotation: { rotationHz: 0.0 },
+            distortion: { sinOffset: 0.0, sinScale: 1.0, cosOffset: 0.0, cosScale: 1.0, tanOffset: 0.0, tanScale: 1.0, offset: 0.0, scale: 1.0 },
+            channelMix: { leftToLeft: 1.0, leftToRight: 0.0, rightToLeft: 0.0, rightToRight: 1.0 },
+            lowPass: { smoothing: 20.0 }
         };
+        
+        this.filters = {
+            volume: options.volume || 1,
+            equalizer: options.equalizer || [],
+            karaoke: options.karaoke || null,
+            timescale: options.timescale || null,
+            tremolo: options.tremolo || null,
+            vibrato: options.vibrato || null,
+            rotation: options.rotation || null,
+            distortion: options.distortion || null,
+            channelMix: options.channelMix || null,
+            lowPass: options.lowPass || null
+        };
+        
+        this.presets = {
+            bassboost: options.bassboost !== undefined ? options.bassboost : null,
+            slowmode: options.slowmode !== undefined ? options.slowmode : null,
+            nightcore: options.nightcore !== undefined ? options.nightcore : null,
+            vaporwave: options.vaporwave !== undefined ? options.vaporwave : null,
+            _8d: options._8d !== undefined ? options._8d : null
+        };
+        
+        this._pendingUpdate = false;
+        this._updateTimeout = null;
     }
 
-    _setFilter(filterName, enabled, options, defaults) {
-        if (!enabled) {
-            this[filterName] = null;
-            return this.updateFilters();
-        }
+    _setFilter(filterName, enabled, options = {}, defaultKey = filterName) {
+        this.filters[filterName] = enabled ? { ...this.defaults[defaultKey], ...options } : null;
+        return this._scheduleUpdate();
+    }
+
+    _scheduleUpdate() {
+        this._pendingUpdate = true;
         
-        const filterObj = {};
-        for (const [key, defaultValue] of Object.entries(defaults)) {
-            filterObj[key] = options[key] !== undefined ? options[key] : defaultValue;
+        if (this._updateTimeout) {
+            clearTimeout(this._updateTimeout);
         }
         
-        this[filterName] = filterObj;
-        return this.updateFilters();
+        this._updateTimeout = setTimeout(() => this.updateFilters(), 0);
+        return this;
     }
 
     setEqualizer(bands) {
-        this.equalizer = bands;
-        return this.updateFilters();
+        this.filters.equalizer = bands || [];
+        return this._scheduleUpdate();
     }
 
     setKaraoke(enabled, options = {}) {
-        return this._setFilter('karaoke', enabled, options, {
-            level: 1.0,
-            monoLevel: 1.0,
-            filterBand: 220.0,
-            filterWidth: 100.0
-        });
+        return this._setFilter('karaoke', enabled, options);
     }
 
     setTimescale(enabled, options = {}) {
-        return this._setFilter('timescale', enabled, options, {
-            speed: 1.0,
-            pitch: 1.0,
-            rate: 1.0
-        });
+        return this._setFilter('timescale', enabled, options);
     }
 
     setTremolo(enabled, options = {}) {
-        return this._setFilter('tremolo', enabled, options, {
-            frequency: 2.0,
-            depth: 0.5
-        });
+        return this._setFilter('tremolo', enabled, options);
     }
 
     setVibrato(enabled, options = {}) {
-        return this._setFilter('vibrato', enabled, options, {
-            frequency: 2.0,
-            depth: 0.5
-        });
+        return this._setFilter('vibrato', enabled, options);
     }
 
     setRotation(enabled, options = {}) {
-        return this._setFilter('rotation', enabled, options, {
-            rotationHz: 0.0
-        });
+        return this._setFilter('rotation', enabled, options);
     }
 
     setDistortion(enabled, options = {}) {
-        return this._setFilter('distortion', enabled, options, {
-            sinOffset: 0.0,
-            sinScale: 1.0,
-            cosOffset: 0.0,
-            cosScale: 1.0,
-            tanOffset: 0.0,
-            tanScale: 1.0,
-            offset: 0.0,
-            scale: 1.0
-        });
+        return this._setFilter('distortion', enabled, options);
     }
 
     setChannelMix(enabled, options = {}) {
-        return this._setFilter('channelMix', enabled, options, {
-            leftToLeft: 1.0,
-            leftToRight: 0.0,
-            rightToLeft: 0.0,
-            rightToRight: 1.0
-        });
+        return this._setFilter('channelMix', enabled, options);
     }
 
     setLowPass(enabled, options = {}) {
-        return this._setFilter('lowPass', enabled, options, {
-            smoothing: 20.0
-        });
+        return this._setFilter('lowPass', enabled, options);
     }
 
     setBassboost(enabled, options = {}) {
         if (!enabled) {
-            this.bassboost = null;
+            this.presets.bassboost = null;
             return this.setEqualizer([]);
         }
         
         const value = options.value || 5;
         if (value < 0 || value > 5) throw new Error("Bassboost value must be between 0 and 5");
         
-        this.bassboost = value;
-        const num = (value - 1) * (1.25 / 9) - 0.25;
+        this.presets.bassboost = value;
+        const gain = (value - 1) * (1.25 / 9) - 0.25;
         
-        const eq = new Array(13);
-        for (let i = 0; i < 13; i++) {
-            eq[i] = { band: i, gain: num };
-        }
+        const eq = Array.from({ length: 13 }, (_, i) => ({ band: i, gain }));
         
         return this.setEqualizer(eq);
     }
 
     setSlowmode(enabled, options = {}) {
-        this.slowmode = enabled;
+        this.presets.slowmode = enabled;
         return this.setTimescale(enabled, { rate: enabled ? (options.rate || 0.8) : 1.0 });
     }
 
     setNightcore(enabled, options = {}) {
-        this.nightcore = enabled;
+        this.presets.nightcore = enabled;
         return this.setTimescale(enabled, { rate: enabled ? (options.rate || 1.5) : 1.0 });
     }
 
     setVaporwave(enabled, options = {}) {
-        this.vaporwave = enabled;
+        this.presets.vaporwave = enabled;
         return this.setTimescale(enabled, { pitch: enabled ? (options.pitch || 0.5) : 1.0 });
     }
 
     set8D(enabled, options = {}) {
-        this._8d = enabled;
+        this.presets._8d = enabled;
         return this.setRotation(enabled, { rotationHz: enabled ? (options.rotationHz || 0.2) : 0.0 });
     }
 
     async clearFilters() {
-        this.volume = 1;
-        this.equalizer = [];
-        this.karaoke = null;
-        this.timescale = null;
-        this.tremolo = null;
-        this.vibrato = null;
-        this.rotation = null;
-        this.distortion = null;
-        this.channelMix = null;
-        this.lowPass = null;
-        this.bassboost = null;
-        this.slowmode = null;
-        this.nightcore = null;
-        this.vaporwave = null;
-        this._8d = null;
+        Object.keys(this.filters).forEach(key => {
+            this.filters[key] = key === 'volume' ? 1 : (key === 'equalizer' ? [] : null);
+        });
+        
+        Object.keys(this.presets).forEach(key => {
+            this.presets[key] = null;
+        });
         
-        this._filterDataTemplate.volume = 1;
-        this._filterDataTemplate.equalizer = [];
+        this._pendingUpdate = false;
+        if (this._updateTimeout) {
+            clearTimeout(this._updateTimeout);
+            this._updateTimeout = null;
+        }
         
         await this.updateFilters();
         return this;
     }
 
     async updateFilters() {
-        const filterData = {
-            ...this._filterDataTemplate,
-            volume: this.volume,
-            equalizer: this.equalizer,
-            karaoke: this.karaoke,
-            timescale: this.timescale,
-            tremolo: this.tremolo,
-            vibrato: this.vibrato,
-            rotation: this.rotation,
-            distortion: this.distortion,
-            channelMix: this.channelMix,
-            lowPass: this.lowPass
-        };
-
-        this._filterDataTemplate = { ...filterData };
-
+        if (!this._pendingUpdate && this._updateTimeout) {
+            clearTimeout(this._updateTimeout);
+            this._updateTimeout = null;
+            return this;
+        }
+        
+        this._pendingUpdate = false;
+        this._updateTimeout = null;
+        
         await this.player.nodes.rest.updatePlayer({
             guildId: this.player.guildId,
-            data: { filters: filterData }
+            data: { filters: { ...this.filters } }
         });
 
         return this;