aqualink 2.5.0 → 2.6.0

package/build/structures/Aqua.js

@@ -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,

package/build/structures/Connection.js

@@ -2,40 +2,44 @@
 
 class Connection {
     constructor(player) {
-        this.playerRef = new WeakRef(player);
+        this.player = player;
         
         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;
+        
+        this.selfDeaf = false;
+        this.selfMute = false;
+        
+        this.hasDebugListeners = this.aqua.listenerCount('debug') > 0;
     }
 
     setServerUpdate(data) {
-        if (!data?.endpoint) return;
+        if (!data || !data.endpoint) return;
         
         const { endpoint, token } = data;
-        const dotIndex = endpoint.indexOf('.');
         
+        const dotIndex = endpoint.indexOf('.');
         if (dotIndex === -1) return;
+        
         const newRegion = endpoint.substring(0, dotIndex);
         
         if (this.region !== newRegion) {
-            const prevRegion = this.region;
-            [this.endpoint, this.token, this.region] = [endpoint, token, newRegion];
+            this.endpoint = endpoint;
+            this.token = token;
+            this.region = newRegion;
             
-            if (this.aqua.listenerCount('debug')) {
+            if (this.hasDebugListeners) {
                 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
                     }`
                 );
             }
@@ -45,10 +49,12 @@ class Connection {
     }
 
     setStateUpdate(data) {
-        const { channel_id, session_id, self_deaf, self_mute } = data || {};
+        if (!data) return this.player?.destroy();
+        
+        const { channel_id, session_id, self_deaf, self_mute } = data;
         
         if (!channel_id || !session_id) {
-            this.playerRef.deref()?.destroy();
+            this.player?.destroy();
             return;
         }
         
@@ -57,36 +63,35 @@ class Connection {
             this.voiceChannel = channel_id;
         }
         
-        this.selfDeaf = !!self_deaf;
-        this.selfMute = !!self_mute;
+        this.selfDeaf = Boolean(self_deaf);
+        this.selfMute = Boolean(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({
-                guildId: this.guildId,
-                data: { 
-                    voice: {
-                        sessionId: this.sessionId,
-                        endpoint: this.endpoint,
-                        token: this.token
-                    }, 
-                    volume: player.volume 
-                }
-            });
-        } catch (error) {
-            if (this.aqua.listenerCount('apiError')) {
+        this.nodes.rest.updatePlayer({
+            guildId: this.guildId,
+            data: { 
+                voice: voiceData, 
+                volume: this.player.volume 
+            }
+        }).catch(error => {
+            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;

package/build/structures/Player.js

@@ -37,8 +37,8 @@ class Player extends EventEmitter {
         
         this.volume = Math.min(Math.max(options.defaultVolume ?? 100, 0), 200);
         this.loop = Player.validModes.has(options.loop) ? options.loop : Player.LOOP_MODES.NONE;
-        this.shouldDeleteMessage = Boolean(options.shouldDeleteMessage);
-        this.leaveOnEnd = Boolean(options.leaveOnEnd);
+        this.shouldDeleteMessage = !!this.aqua.options.shouldDeleteMessage;
+        this.leaveOnEnd = !!this.aqua.options.leaveOnEnd;
         
         this.previousTracks = new Array(50);
         this.previousTracksIndex = 0;

package/build/structures/Queue.js

@@ -38,23 +38,32 @@ class Queue extends Array {
     remove(track) {
         const index = this.indexOf(track);
         if (index !== -1) {
-            this.splice(index, 1);
+            if (index === this.length - 1) {
+                this.pop();
+            } else {
+                this.splice(index, 1);
+            }
+            return true;
         }
+        return false;
     }
 
     // Clear all tracks from the queue
     clear() {
-        this.length = 0; // More efficient memory handling
+        this.length = 0;
     }
 
     // Shuffle the tracks in the queue
     shuffle() {
-        for (let i = this.length - 1; i > 0; i--) {
+        const length = this.length;
+        for (let i = length - 1; i > 0; i--) {
             const j = Math.floor(Math.random() * (i + 1));
-            [this[i], this[j]] = [this[j], this[i]];
+            if (i !== j) {
+                [this[i], this[j]] = [this[j], this[i]];
+            }
         }
+        return this;
     }
-
     // Peek at the element at the front of the queue without removing it
     peek() {
         return this.first;
@@ -62,7 +71,7 @@ class Queue extends Array {
 
     // Get all tracks in the queue as an array
     toArray() {
-        return [...this]; // Create a shallow copy of the queue
+        return this.slice();
     }
 
     /**
@@ -71,9 +80,8 @@ class Queue extends Array {
      * @returns {*} The track at the specified index or null if out of bounds.
      */
     at(index) {
-        return this[index] || null; // Return null if index is out of bounds
+        return (index >= 0 && index < this.length) ? this[index] : null;
     }
-
     // Remove the first track from the queue
     dequeue() {
         return this.shift(); // Removes and returns the first element

package/build/structures/Track.js

@@ -10,7 +10,8 @@ class Track {
     this.identifier = info.identifier || '';
     this.isSeekable = Boolean(info.isSeekable);
     this.author = info.author || '';
-    this.length = info.length | 0;
+    this.length = info.length || 0;
+    this.duration = info.length || 0;
     this.isStream = Boolean(info.isStream);
     this.title = info.title || '';
     this.uri = info.uri || '';

package/package.json

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