aqualink 2.1.2 → 2.2.0

package/README.md

@@ -22,50 +22,47 @@ This code is based in riffy, but its an 100% Rewrite made from scratch...
   - https://github.com/topi314/LavaLyrics (RECOMMENDED)
   - https://github.com/DRSchlaubi/lyrics.kt (?)
   - https://github.com/DuncteBot/java-timed-lyrics (RECOMMENDED)
-  
-# Tralalero Tralala 2.1.0 Released
+
+
+# Tralalero Tralala 2.2.0 Released
 ---
 - Improved the `AQUA` module
-  - Faster nodes loading
-  - Faster plugin loading
-  - Better listeners for player
-  - Faster resolving system for playlists
-
-- Remade the `Connection` system
-  - Less overheard now.
-  - Faster connections
-  - Improved the checkings
-  - Improved error handling
-  - Fixed creating useless Objects and arrays
-
-- Fully rewrite the `Node` system
-  - Way faster connections
-  - More stable (i think so)
-  - Faster events / messages / payloads handling
-  - Better stats handling (reusing, creating, destroyin)
-  - Some more bug fixes and stuff i forgot.
-
-- Remade the `Player` module
-  - Now support Lazy Loading by default
-  - Better State Updates
-  - Improved Garbage Collection
-  - Rewrite to use direct comparasions
+  - Added  Fast path in getRequestNode (     Reduces unnecessary type checks    )
+  - Early return in handleNoMatches (	Avoids unnecessary Spotify requests     )
+  - Rewrite to use manual loops on constructResponse (      faster than Array.prototype.map, makes the playlists and tracks load way faster and less recourses     )
+  - Pre-allocated arrays (	Avoids dynamic resizing   )
+  - Also fixed it sending double requests to lavalink.
 
-- Improved the `Rest` module
-  - Lazy loading of http2
-  - Faster request chunks
-  - Some overall upgrades
 
-- Improved `Track` module
-  - Faster track looking
-  - More micro optimizations (use Boolean instead of !!)
+- Remade the `Player` module
+  - More efficient track addition, void Array re-call
+  - faster event handling with direct states
+  - Faster autoplay system and more efficient by map()
+  - Reduced Object Creation
+  - Rewrite destroy() method
+  - Also improved Resource Cleanup
+  - Now emit TrackEnd and queueEnd correctly
+
+- Rewrite the `autoplay` system
+  - Added redirect handling
+  - More efficient regex processing
+  - Set for unique URLs to avoid duplicate
+  - Use array chunks for better performance
+  - About ~30%-40% faster for resolving now.
+
+- Rewrite the Filter system
+  - Uses Direct Assigments
+  - Avoid recreating objects on each update
+  - Property reuse in updateFilters()
+  - Uses traditional for loop
 
-- Remade the INDEX.D.TS File: Added more 1000 lines of code. Added autocomplete, options, and documented everything.
 
 # Docs (Wiki)
-- https://github.com/ToddyTheNoobDud/AquaLink/wiki
+- https://toddythenoobdud.github.io/aqualink.github.io/
+
+- Example bot: https://github.com/ToddyTheNoobDud/Kenium-Music
 
-- Example bot: https://github.com/ToddyTheNoobDud/Thorium-Music
+- Discord support: https://discord.com/invite/K4CVv84VBC
 
 
 # How to install
@@ -147,7 +144,9 @@ client.on("messageCreate", async (message) => {
 
     if (resolve.loadType === 'playlist') {
         await message.channel.send(`Added ${resolve.tracks.length} songs from ${resolve.playlistInfo.name} playlist.`);
-        player.queue.add(resolve.tracks);
+        for (const track of result.tracks) {
+          player.queue.add(track);
+        }
         if (!player.playing && !player.paused) return player.play();
 
     } else if (resolve.loadType === 'search' || resolve.loadType === 'track') {

package/build/handlers/autoplay.js

@@ -0,0 +1,95 @@
+const https = require('https');
+
+function fetch(url, options = {}) {
+    return new Promise((resolve, reject) => {
+        const req = https.get(url, options, (res) => {
+            if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                return fetch(res.headers.location, options).then(resolve).catch(reject);
+            }
+            
+            if (res.statusCode !== 200) {
+                res.resume();
+                reject(new Error(`Request failed. Status code: ${res.statusCode}`));
+                return;
+            }
+            
+            const chunks = [];
+            res.on('data', chunk => chunks.push(chunk));
+            res.on('end', () => resolve(Buffer.concat(chunks).toString()));
+        });
+        
+        req.setTimeout(10000, () => {
+            req.destroy();
+            reject(new Error('Request timeout'));
+        });
+        
+        req.on('error', err => {
+            reject(err);
+        });
+        
+        req.end();
+    });
+}
+
+async function scAutoPlay(url) {
+    try {
+        const html = await fetch(`${url}/recommended`);
+        
+        const regex = /<a itemprop="url" href="(\/.*?)"/g;
+        const hrefs = new Set();
+        let match;
+        
+        while ((match = regex.exec(html)) !== null) {
+            hrefs.add(`https://soundcloud.com${match[1]}`);
+        }
+        
+        if (hrefs.size === 0) {
+            throw new Error("No recommended tracks found on SoundCloud.");
+        }
+        
+        const shuffledHrefs = Array.from(hrefs);
+        for (let i = shuffledHrefs.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [shuffledHrefs[i], shuffledHrefs[j]] = [shuffledHrefs[j], shuffledHrefs[i]];
+        }
+        
+        return shuffledHrefs;
+    } catch (error) {
+        console.error("Error fetching SoundCloud recommendations:", error);
+        return [];
+    }
+}
+
+async function spAutoPlay(track_id) {
+    try {
+        const tokenResponse = await fetch("https://open.spotify.com/get_access_token?reason=transport&productType=embed");
+        const tokenData = JSON.parse(tokenResponse);
+        const accessToken = tokenData?.accessToken;
+        
+        if (!accessToken) throw new Error("Failed to retrieve Spotify access token");
+        
+        const recommendationsResponse = await fetch(
+            `https://api.spotify.com/v1/recommendations?limit=5&seed_tracks=${track_id}&fields=tracks.id`, 
+            {
+                headers: { 
+                    Authorization: `Bearer ${accessToken}`, 
+                    'Content-Type': 'application/json'
+                }
+            }
+        );
+        
+        const data = JSON.parse(recommendationsResponse);
+        const tracks = data?.tracks || [];
+        
+        if (tracks.length === 0) {
+            throw new Error("No recommended tracks found on Spotify.");
+        }
+        
+        return tracks[Math.floor(Math.random() * tracks.length)].id;
+    } catch (error) {
+        console.error("Error fetching Spotify recommendations:", error);
+        return null;
+    }
+}
+
+module.exports = { scAutoPlay, spAutoPlay };

package/build/structures/Aqua.js

@@ -21,7 +21,7 @@ class Aqua extends EventEmitter {
         this.players = new Map();
         this.clientId = null;
         this.initiated = false;
-        
+
         this.shouldDeleteMessage = options.shouldDeleteMessage ?? false;
         this.defaultSearchPlatform = options.defaultSearchPlatform ?? 'ytsearch';
         this.leaveOnEnd = options.leaveOnEnd ?? true;
@@ -32,7 +32,7 @@ class Aqua extends EventEmitter {
         this.autoResume = options.autoResume ?? false;
         this.infiniteReconnects = options.infiniteReconnects ?? false;
         this.options = options;
-        
+
         this.setMaxListeners(0);
         this._leastUsedCache = { nodes: [], timestamp: 0 };
     }
@@ -67,11 +67,11 @@ class Aqua extends EventEmitter {
         if (this.initiated) return this;
 
         this.clientId = clientId;
-        
+
         try {
             for (let i = 0; i < this.nodes.length; i++) { this.createNode(this.nodes[i]); }
             if (this.plugins.length > 0) { for (let i = 0; i < this.plugins.length; i++) { this.plugins[i].load(this); } }
-            
+
             this.initiated = true;
         } catch (error) {
             this.initiated = false;
@@ -129,7 +129,7 @@ class Aqua extends EventEmitter {
         if (!region) return this.leastUsedNodes;
 
         const lowerRegion = region.toLowerCase();
-        const regionNodes = Array.from(this.nodeMap.values()).filter(node => 
+        const regionNodes = Array.from(this.nodeMap.values()).filter(node =>
             node.connected && node.regions?.includes(lowerRegion)
         );
         regionNodes.sort((a, b) => this.calculateLoad(a) - this.calculateLoad(b));
@@ -151,7 +151,7 @@ class Aqua extends EventEmitter {
         const availableNodes = options.region ? this.fetchRegion(options.region) : this.leastUsedNodes;
         const node = availableNodes[0];
         if (!node) throw new Error("No nodes are available");
-        
+
         return this.createPlayer(node, options);
     }
 
@@ -159,11 +159,11 @@ class Aqua extends EventEmitter {
         this.destroyPlayer(options.guildId);
         const player = new Player(this, node, options);
         this.players.set(options.guildId, player);
-        
+
         player.once("destroy", () => {
             this.players.delete(options.guildId);
         });
-        
+
         player.connect(options);
         this.emit("playerCreate", player);
         return player;
@@ -193,7 +193,7 @@ class Aqua extends EventEmitter {
             if (["empty", "NO_MATCHES"].includes(response.loadType)) {
                 return await this.handleNoMatches(requestNode.rest, query);
             }
-            return this.constructorResponse(response, requester, requestNode);
+            return this.constructResponse(response, requester, requestNode);
         } catch (error) {
             if (error.name === "AbortError") {
                 throw new Error("Request timed out");
@@ -203,9 +203,12 @@ class Aqua extends EventEmitter {
     }
 
     getRequestNode(nodes) {
-        if (nodes && !(typeof nodes === "string" || nodes instanceof Node)) {
+        if (!nodes) return this.leastUsedNodes[0];
+
+        if (!(typeof nodes === "string" || nodes instanceof Node)) {
             throw new TypeError(`'nodes' must be a string or Node instance, received: ${typeof nodes}`);
         }
+
         return (typeof nodes === "string" ? this.nodeMap.get(nodes) : nodes) ?? this.leastUsedNodes[0];
     }
 
@@ -221,17 +224,20 @@ class Aqua extends EventEmitter {
         try {
             const ytIdentifier = `/v4/loadtracks?identifier=https://www.youtube.com/watch?v=${query}`;
             const youtubeResponse = await rest.makeRequest("GET", ytIdentifier);
-            if (["empty", "NO_MATCHES"].includes(youtubeResponse.loadType)) {
-                const spotifyIdentifier = `/v4/loadtracks?identifier=https://open.spotify.com/track/${query}`;
-                return await rest.makeRequest("GET", spotifyIdentifier);
+
+            if (!["empty", "NO_MATCHES"].includes(youtubeResponse.loadType)) {
+                return youtubeResponse;
             }
-            return youtubeResponse;
+
+            const spotifyIdentifier = `/v4/loadtracks?identifier=https://open.spotify.com/track/${query}`;
+            return await rest.makeRequest("GET", spotifyIdentifier);
         } catch (error) {
             console.error(`Failed to resolve track: ${error.message}`);
+            throw error;
         }
     }
 
-    constructorResponse(response, requester, requestNode) {
+    constructResponse(response, requester, requestNode) {
         const baseResponse = {
             loadType: response.loadType,
             exception: null,
@@ -245,8 +251,7 @@ class Aqua extends EventEmitter {
             return baseResponse;
         }
 
-        // Inline the track factory for better performance
-        const trackFactory = trackData => new Track(trackData, requester, requestNode);
+        const trackFactory = (trackData) => new Track(trackData, requester, requestNode);
 
         switch (response.loadType) {
             case "track":
@@ -254,6 +259,7 @@ class Aqua extends EventEmitter {
                     baseResponse.tracks.push(trackFactory(response.data));
                 }
                 break;
+
             case "playlist":
                 if (response.data?.info) {
                     baseResponse.playlistInfo = {
@@ -261,26 +267,32 @@ class Aqua extends EventEmitter {
                         ...response.data.info
                     };
                 }
+
                 const tracks = response.data?.tracks;
                 if (tracks?.length) {
-                    baseResponse.tracks = new Array(tracks.length);
-                    for (let i = 0; i < tracks.length; i++) {
+                    const len = tracks.length;
+                    baseResponse.tracks = new Array(len);
+                    for (let i = 0; i < len; i++) {
                         baseResponse.tracks[i] = trackFactory(tracks[i]);
                     }
                 }
                 break;
+
             case "search":
                 const searchData = response.data ?? [];
                 if (searchData.length) {
-                    baseResponse.tracks = new Array(searchData.length);
-                    for (let i = 0; i < searchData.length; i++) {
+                    const len = searchData.length;
+                    baseResponse.tracks = new Array(len);
+                    for (let i = 0; i < len; i++) {
                         baseResponse.tracks[i] = trackFactory(searchData[i]);
                     }
                 }
                 break;
         }
+
         return baseResponse;
     }
+
     get(guildId) {
         const player = this.players.get(guildId);
         if (!player) throw new Error(`Player not found for guild ID: ${guildId}`);

package/build/structures/Filters.js

@@ -3,21 +3,49 @@
 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.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
+        };
+    }
+
+    _setFilter(filterName, enabled, options, defaults) {
+        if (!enabled) {
+            this[filterName] = null;
+            return this.updateFilters();
+        }
+        
+        const filterObj = {};
+        for (const [key, defaultValue] of Object.entries(defaults)) {
+            filterObj[key] = options[key] !== undefined ? options[key] : defaultValue;
+        }
+        
+        this[filterName] = filterObj;
+        return this.updateFilters();
     }
 
     setEqualizer(bands) {
@@ -26,127 +54,137 @@ class Filters {
     }
 
     setKaraoke(enabled, options = {}) {
-        this.karaoke = enabled ? {
-            level: options.level ?? 1.0,
-            monoLevel: options.monoLevel ?? 1.0,
-            filterBand: options.filterBand ?? 220.0,
-            filterWidth: options.filterWidth ?? 100.0
-        } : null;
-        return this.updateFilters();
+        return this._setFilter('karaoke', enabled, options, {
+            level: 1.0,
+            monoLevel: 1.0,
+            filterBand: 220.0,
+            filterWidth: 100.0
+        });
     }
 
     setTimescale(enabled, options = {}) {
-        this.timescale = enabled ? {
-            speed: options.speed ?? 1.0,
-            pitch: options.pitch ?? 1.0,
-            rate: options.rate ?? 1.0
-        } : null;
-        return this.updateFilters();
+        return this._setFilter('timescale', enabled, options, {
+            speed: 1.0,
+            pitch: 1.0,
+            rate: 1.0
+        });
     }
 
     setTremolo(enabled, options = {}) {
-        this.tremolo = enabled ? {
-            frequency: options.frequency ?? 2.0,
-            depth: options.depth ?? 0.5
-        } : null;
-        return this.updateFilters();
+        return this._setFilter('tremolo', enabled, options, {
+            frequency: 2.0,
+            depth: 0.5
+        });
     }
 
     setVibrato(enabled, options = {}) {
-        this.vibrato = enabled ? {
-            frequency: options.frequency ?? 2.0,
-            depth: options.depth ?? 0.5
-        } : null;
-        return this.updateFilters();
+        return this._setFilter('vibrato', enabled, options, {
+            frequency: 2.0,
+            depth: 0.5
+        });
     }
 
     setRotation(enabled, options = {}) {
-        this.rotation = enabled ? {
-            rotationHz: options.rotationHz ?? 0.0
-        } : null;
-        return this.updateFilters();
+        return this._setFilter('rotation', enabled, options, {
+            rotationHz: 0.0
+        });
     }
 
     setDistortion(enabled, options = {}) {
-        this.distortion = enabled ? {
-            sinOffset: options.sinOffset ?? 0.0,
-            sinScale: options.sinScale ?? 1.0,
-            cosOffset: options.cosOffset ?? 0.0,
-            cosScale: options.cosScale ?? 1.0,
-            tanOffset: options.tanOffset ?? 0.0,
-            tanScale: options.tanScale ?? 1.0,
-            offset: options.offset ?? 0.0,
-            scale: options.scale ?? 1.0
-        } : null;
-        return this.updateFilters();
+        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
+        });
     }
 
     setChannelMix(enabled, options = {}) {
-        this.channelMix = enabled ? {
-            leftToLeft: options.leftToLeft ?? 1.0,
-            leftToRight: options.leftToRight ?? 0.0,
-            rightToLeft: options.rightToLeft ?? 0.0,
-            rightToRight: options.rightToRight ?? 1.0
-        } : null;
-        return this.updateFilters();
+        return this._setFilter('channelMix', enabled, options, {
+            leftToLeft: 1.0,
+            leftToRight: 0.0,
+            rightToLeft: 0.0,
+            rightToRight: 1.0
+        });
     }
 
     setLowPass(enabled, options = {}) {
-        this.lowPass = enabled ? {
-            smoothing: options.smoothing ?? 20.0
-        } : null;
-        return this.updateFilters();
+        return this._setFilter('lowPass', enabled, options, {
+            smoothing: 20.0
+        });
     }
 
     setBassboost(enabled, options = {}) {
-        if (enabled) {
-            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;
-            return this.setEqualizer(Array(13).fill(0).map((_, i) => ({
-                band: i,
-                gain: num
-            })));
+        if (!enabled) {
+            this.bassboost = null;
+            return this.setEqualizer([]);
         }
-        this.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;
+        
+        const eq = new Array(13);
+        for (let i = 0; i < 13; i++) {
+            eq[i] = { band: i, gain: num };
+        }
+        
+        return this.setEqualizer(eq);
     }
 
     setSlowmode(enabled, options = {}) {
         this.slowmode = enabled;
-        return this.setTimescale(enabled, { rate: enabled ? options.rate ?? 0.8 : 1.0 });
+        return this.setTimescale(enabled, { rate: enabled ? (options.rate || 0.8) : 1.0 });
     }
 
     setNightcore(enabled, options = {}) {
         this.nightcore = enabled;
-        if (enabled) {
-            return this.setTimescale(true, { rate: options.rate ?? 1.5 });
-        }
-        return this.setTimescale(false);
+        return this.setTimescale(enabled, { rate: enabled ? (options.rate || 1.5) : 1.0 });
     }
 
     setVaporwave(enabled, options = {}) {
         this.vaporwave = enabled;
-        if (enabled) {
-            return this.setTimescale(true, { pitch: options.pitch ?? 0.5 });
-        }
-        return this.setTimescale(false);
+        return this.setTimescale(enabled, { pitch: enabled ? (options.pitch || 0.5) : 1.0 });
     }
 
     set8D(enabled, options = {}) {
         this._8d = enabled;
-        return this.setRotation(enabled, { rotationHz: enabled ? options.rotationHz ?? 0.2 : 0.0 });
+        return this.setRotation(enabled, { rotationHz: enabled ? (options.rotationHz || 0.2) : 0.0 });
     }
 
     async clearFilters() {
-        Object.assign(this, new Filters(this.player));
+        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;
+        
+        this._filterDataTemplate.volume = 1;
+        this._filterDataTemplate.equalizer = [];
+        
         await this.updateFilters();
         return this;
     }
 
     async updateFilters() {
         const filterData = {
+            ...this._filterDataTemplate,
             volume: this.volume,
             equalizer: this.equalizer,
             karaoke: this.karaoke,
@@ -159,6 +197,8 @@ class Filters {
             lowPass: this.lowPass
         };
 
+        this._filterDataTemplate = { ...filterData };
+
         await this.player.nodes.rest.updatePlayer({
             guildId: this.player.guildId,
             data: { filters: filterData }
@@ -168,4 +208,4 @@ class Filters {
     }
 }
 
-module.exports = Filters
+module.exports = Filters;

package/build/structures/Player.js

@@ -4,6 +4,7 @@ const { EventEmitter } = require("events");
 const Connection = require("./Connection");
 const Queue = require("./Queue");
 const Filters = require("./Filters");
+const { spAutoPlay, scAutoPlay } = require('../handlers/autoplay');
 
 class Player extends EventEmitter {
     static LOOP_MODES = Object.freeze({
@@ -25,6 +26,7 @@ class Player extends EventEmitter {
 
     constructor(aqua, nodes, options = {}) {
         super();
+        
         this.aqua = aqua;
         this.nodes = nodes;
         this.guildId = options.guildId;
@@ -34,55 +36,145 @@ 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 = Array(50);
+        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._handlePlayerUpdate = this._handlePlayerUpdate.bind(this);
         this._handleEvent = this._handleEvent.bind(this);
         
         this.on("playerUpdate", this._handlePlayerUpdate);
         this.on("event", this._handleEvent);
-        
-        this._dataStore = null;
     }
 
     get previous() {
-        return this.previousTracks[0] || null;
+        return this.previousTracksCount > 0 ? this.previousTracks[0] : null;
     }
     
     get currenttrack() {
         return this.current;
     }
 
+    async autoplay(player) {
+        if (!player) throw new Error("Quick Fix: player.autoplay(player)");
+    
+        if (!this.isAutoplayEnabled) {
+            this.aqua.emit("debug", this.guildId, "Autoplay is disabled.");
+            return this;
+        }
+    
+        this.isAutoplay = true;
+        if (!this.previous) return this;
+    
+        try {
+            const { sourceName, identifier, uri, requester } = this.previous.info;
+            this.aqua.emit("debug", this.guildId, `Attempting autoplay for ${sourceName}`);
+    
+            let query, source, response;
+    
+            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 null;
+                    return {
+                        query: scResults[0],
+                        source: "scsearch"
+                    };
+                },
+                spotify: async () => {
+                    const spResult = await spAutoPlay(identifier);
+                    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 });
+    
+            if (!response?.tracks?.length || ["error", "empty", "LOAD_FAILED", "NO_MATCHES"].includes(response.loadType)) {
+                return this.stop();
+            }
+    
+            const track = response.tracks[Math.floor(Math.random() * response.tracks.length)];
+    
+            if (!track?.info?.title) {
+                throw new Error("Invalid track object: missing title or info.");
+            }
+    
+            track.requester = this.previous.requester || { id: "Unknown" };
+    
+            this.queue.push(track);
+            await this.play();
+    
+            return this;
+        } catch (error) {
+            console.error("Autoplay error:", error);
+            return this.stop();
+        }
+    }
+    
+    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();
+        if (this.previousTracksCount < 50) {
+            for (let i = this.previousTracksCount; i > 0; i--) {
+                this.previousTracks[i] = this.previousTracks[i-1];
+            }
+            this.previousTracks[0] = track;
+            this.previousTracksCount++;
+        } else {
+            for (let i = 49; i > 0; i--) {
+                this.previousTracks[i] = this.previousTracks[i-1];
+            }
+            this.previousTracks[0] = track;
         }
-        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 });
     }
@@ -111,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}.`);
@@ -128,8 +222,13 @@ class Player extends EventEmitter {
         
         this.disconnect();
         
-        this.nowPlayingMessage?.delete().catch(() => {});
+        if (this.nowPlayingMessage) {
+            this.nowPlayingMessage.delete().catch(() => {});
+            this.nowPlayingMessage = null;
+        }
         
+        this.isAutoplay = false;
+
         this.aqua.destroyPlayer(this.guildId);
         this.nodes.rest.destroyPlayer(this.guildId);
         this.clearData();
@@ -165,7 +264,6 @@ class Player extends EventEmitter {
 
     stop() {
         if (!this.playing) return this;
-        
         this.playing = false;
         this.position = 0;
         this.updatePlayer({ track: { encoded: null } });
@@ -202,6 +300,7 @@ class Player extends EventEmitter {
         }
         
         this.voiceChannel = channel;
+        
         this.connect({
             deaf: this.deaf,
             guildId: this.guildId,
@@ -244,30 +343,30 @@ 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();
                 this.nowPlayingMessage = null;
-            } catch {}
+            } catch (error) {
+                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;
@@ -280,16 +379,20 @@ class Player extends EventEmitter {
         }
 
         if (player.queue.isEmpty()) {
-            this.playing = false;
-            if (this.leaveOnEnd) {
-                this.clearData();   
-                this.cleanup();
+            if (this.isAutoplayEnabled) {
+                await player.autoplay(player);
+            } else {
+                this.playing = false;
+                if (this.leaveOnEnd) {
+                    this.clearData();
+                    this.cleanup();
+                }
+                this.aqua.emit("queueEnd", player);
             }
-            this.aqua.emit("queueEnd", player);
-            return;
+        } else {
+            this.aqua.emit("trackEnd", player, track, reason);
+            await player.play();
         }
-
-        await player.play();
     }
 
     async trackError(player, track, payload) {
@@ -303,11 +406,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,
@@ -325,7 +428,7 @@ class Player extends EventEmitter {
 
     set(key, value) {
         if (!this._dataStore) {
-            this._dataStore = new WeakMap();
+            this._dataStore = new Map();
         }
         this._dataStore.set(key, value);
     }
@@ -335,7 +438,9 @@ class Player extends EventEmitter {
     }
 
     clearData() {
-        if (this.previousTracks) this.previousTracks.length = 0;
+        if (this.previousTracks) {
+            this.previousTracksCount = 0;
+        }
         this._dataStore = null;
         return this;
     }
@@ -354,11 +459,6 @@ class Player extends EventEmitter {
             this.destroy();
         }
     }
-
-    updateTrackState(playing, paused) {
-        this.playing = playing;
-        this.paused = paused;
-    }
 }
 
 module.exports = Player;

package/package.json

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