aqualink 1.0.5 → 1.2.0

package/README.md

@@ -20,6 +20,19 @@ This code is based in riffy, but its an 100% Rewrite made from scratch...
 # Docs (Wiki)
 - https://github.com/ToddyTheNoobDud/AquaLink/wiki
 
+- Example bot: https://github.com/ToddyTheNoobDud/Thorium-Music
+
+# Yay, Version 1.2.0 is released ! aqualink so cool
+
++ Fixed all the loop system
++ Fixed could not play after ending (weird ahh bug)
++ Improved the general queue handler
++ Remade the REST system (improved speed, ram, and removed useless queue handling)
++ Updated player stuff (Fixed bugs, Added methods: shuffle, getQueue(), restart)
++ Updated the NODE system (misc improvements for speed)
++ Rewrited Aqua system (Fixed playlists support (finnaly), rewrited resolve(), Improved all the code, auto cleanup)
++ Remade the connection system for handling
+
 # How to install
 
 `npm install aqualink`

package/build/structures/Aqua.js

@@ -13,6 +13,7 @@ class Aqua extends EventEmitter {
      * @param {string} [options.defaultSearchPlatform="ytsearch"] - Default search platform.
      * @param {string} [options.restVersion="v4"] - Version of the REST API.
      * @param {Array<Object>} [options.plugins=[]] - Plugins to load.
+     * @param {string} [options.shouldDeleteMessage='none'] - Should delete your message? (true, false)
      */
     constructor(client, nodes, options) {
         super();
@@ -27,6 +28,7 @@ class Aqua extends EventEmitter {
         this.clientId = null;
         this.initiated = false;
         this.sessionId = null;
+        this.shouldDeleteMessage = options.shouldDeleteMessage || "false";
         this.defaultSearchPlatform = options.defaultSearchPlatform || "ytmsearch";
         this.restVersion = options.restVersion || "v3";
         this.plugins = options.plugins || [];
@@ -51,7 +53,7 @@ class Aqua extends EventEmitter {
 
     /**
      * Initializes Aqua with the provided client ID.
-     * @param {string} clientId - The client ID.
+     * @param {string} clientId - The client ID
      * @returns {Aqua} The Aqua instance.
      */
     init(clientId) {
@@ -98,7 +100,7 @@ class Aqua extends EventEmitter {
         if (packet.t === "VOICE_SERVER_UPDATE") player.connection.setServerUpdate(packet.d);
         else if (packet.t === "VOICE_STATE_UPDATE" && packet.d.user_id === this.clientId) player.connection.setStateUpdate(packet.d);
     }
-    
+
     /**
      * Fetches nodes by the specified region.
      * @param {string} region - The region to filter nodes by.
@@ -155,6 +157,7 @@ class Aqua extends EventEmitter {
      */
     destroyPlayer(guildId) {
         const player = this.players.get(guildId);
+        player.clearData();
         if (!player) return;
         player.destroy();
         this.players.delete(guildId);
@@ -167,6 +170,7 @@ class Aqua extends EventEmitter {
      */
     removeConnection(guildId) {
         const player = this.players.get(guildId);
+        player.clearData();
         if (player) {
             player.destroy();
             this.players.delete(guildId);
@@ -200,8 +204,7 @@ class Aqua extends EventEmitter {
             response = await this.handleNoMatches(requestNode.rest, query);
         }
 
-        this.loadTracks(response, requester, requestNode);
-        return this.constructResponse();
+        return this.constructorResponse(response, requester, requestNode);
     }
 
     /**
@@ -223,37 +226,52 @@ class Aqua extends EventEmitter {
      * @param {Object} response - The response from the track resolution.
      * @param {Object} requester - The requester of the tracks.
      * @param {Node} requestNode - The node that handled the request.
+     * @returns {Object} The constructed response.
      */
-    loadTracks(response, requester, requestNode) {
-        this.tracks = [];
-        if (response.loadType === "track") {
-            if (response.data) {
-                this.tracks.push(new Track(response.data, requester, requestNode));
-            }
-        } else if (response.loadType === "playlist") {
-            this.tracks = response.data?.tracks.map(track => new Track(track, requester, requestNode)) || [];
-            this.playlistInfo = response.data?.info || null;
-        } else if (response.loadType === "search") {
-            this.tracks = response.data.map(track => new Track(track, requester, requestNode));
+    constructorResponse(response, requester, requestNode) {
+        switch (response.loadType) {
+            case "track":
+                if (response.data) {
+                    return {
+                        loadType: response.loadType,
+                        exception: null,
+                        playlistInfo: null,
+                        pluginInfo: response.pluginInfo || {},
+                        tracks: [new Track(response.data, requester, requestNode)],
+                    };
+                }
+                break;
+            case "playlist":
+                return {
+                    loadType: response.loadType,
+                    exception: null,
+                    playlistInfo: {
+                        name: response.data?.info?.name || response.data?.info?.title,
+                        ...response.data?.info,
+                    },
+                    pluginInfo: response.pluginInfo || {},
+                    tracks: response.data?.tracks?.map(track => new Track(track, requester, requestNode)) || [],
+                };
+            case "search":
+                return {
+                    loadType: response.loadType,
+                    exception: null,
+                    playlistInfo: null,
+                    pluginInfo: response.pluginInfo || {},
+                    tracks: response.data?.map(track => new Track(track, requester, requestNode)),
+                };
         }
-        this.loadType = response.loadType;
-        this.pluginInfo = response.pluginInfo || {};
-    }
 
-    /**
-     * Constructs the response object for the resolved tracks.
-     * @returns {Object} The constructed response.
-     */
-    constructResponse() {
         return {
-            loadType: this.loadType,
-            exception: this.loadType === "error" ? this.loadType.data : (this.loadType === "LOAD_FAILED" ? this.loadType.exception : null),
-            playlistInfo: this.playlistInfo,
-            pluginInfo: this.pluginInfo,
-            tracks: this.tracks.length ? [this.tracks.shift()] : [],
+            loadType: response.loadType,
+            exception: response.loadType === "error" ? response.loadType.data : (response.loadType === "LOAD_FAILED" ? response.loadType.exception : null),
+            playlistInfo: null,
+            pluginInfo: response.pluginInfo || {},
+            tracks: [],
         };
     }
 
+
     /**
      * Gets the player associated with the specified guild ID.
      * @param {string} guildId - The ID of the guild.
@@ -280,4 +298,4 @@ class Aqua extends EventEmitter {
     }
 }
 
-module.exports = { Aqua };
+module.exports = { Aqua };

package/build/structures/Connection.js

@@ -1,7 +1,3 @@
-/**
- * Class representing a player connection.
- * @param {Player} player The player instance of this connection.
- */
 class Connection {
     constructor(player) {
         this.player = player;
@@ -10,42 +6,27 @@ class Connection {
         this.selfDeaf = false;
         this.selfMute = false;
         this.voiceChannel = player.voiceChannel;
+        this.lastUpdateTime = 0;
+        this.updateThrottle = 1000;
     }
 
-    /**
-     * Sets the server update data (endpoint and token) for the player.
-     * @param {object} data The server update data from the VOICE_SERVER_UPDATE packet.
-     * @param {string} data.endpoint The endpoint URL of the voice server.
-     * @param {string} data.token The token for the voice server.
-     */
     setServerUpdate({ endpoint, token }) {
-        if (!endpoint) {
-            throw new Error("Missing 'endpoint' property in VOICE_SERVER_UPDATE packet/payload. Please wait or disconnect the bot from the voice channel and try again.");
-        }
+        if (!endpoint) throw new Error("Missing 'endpoint' property in VOICE_SERVER_UPDATE");
 
         const previousVoiceRegion = this.region;
         this.voice.endpoint = endpoint;
         this.voice.token = token;
         this.region = endpoint.split(".")[0].replace(/[0-9]/g, "");
+
         this.player.aqua.emit("debug", `[Player ${this.player.guildId} - CONNECTION] ${previousVoiceRegion ? `Changed Voice Region from ${previousVoiceRegion} to ${this.region}` : `Voice Server: ${this.region}`}`);
 
-        if (this.player.paused) {
-            this.player.pause(false);
-        }
+        if (this.player.paused) this.player.pause(false);
 
         this.updatePlayerVoiceData();
     }
 
-    /**
-     * Sets the state update data (session_id, channel_id, self_deaf, and self_mute) for the player.
-     * @param {object} data The state update data from the VOICE_STATE_UPDATE packet.
-     * @param {string} data.session_id The session id of the voice server.
-     * @param {string} data.channel_id The voice channel id of the player.
-     * @param {boolean} data.self_deaf The self-deafened status of the player.
-     * @param {boolean} data.self_mute The self-muted status of the player.
-     */
     setStateUpdate({ session_id, channel_id, self_deaf, self_mute }) {
-        if (channel_id == null || session_id == null) {
+        if (!channel_id || !session_id) {
             this.player.aqua.emit("playerLeave", this.player.voiceChannel);
             this.player.voiceChannel = null;
             this.voiceChannel = null;
@@ -67,9 +48,6 @@ class Connection {
         this.updatePlayerVoiceData();
     }
 
-    /**
-     * Updates the player voice data.
-     */
     updatePlayerVoiceData() {
         this.player.nodes.rest.updatePlayer({
             guildId: this.player.guildId,

package/build/structures/Node.js

@@ -1,4 +1,3 @@
-
 const WebSocket = require("ws");
 const { Rest } = require("./Rest");
 
@@ -19,22 +18,18 @@ class Node {
         this.secure = nodes.secure || false;
         this.sessionId = nodes.sessionId || null;
         this.rest = new Rest(aqua, this);
-
         this.wsUrl = `ws${this.secure ? 's' : ''}://${this.host}:${this.port}/v4/websocket`;
-        this.restUrl = `http${this.secure ? 's' : ''}://${this.host}:${this.port}`;
-        
         this.ws = null;
         this.regions = nodes.regions || [];
         this.info = null;
         this.connected = false;
-
         this.resumeKey = options.resumeKey || null;
         this.resumeTimeout = options.resumeTimeout || 60;
         this.autoResume = options.autoResume || false;
-
         this.reconnectTimeout = options.reconnectTimeout || 5000;
         this.reconnectTries = options.reconnectTries || 3;
         this.reconnectAttempted = 0;
+        this.lastStatsRequest = 0; // Track the last time stats were requested
     }
 
     initializeStats() {
@@ -61,22 +56,14 @@ class Node {
         };
     }
 
-    /**
-     * Fetches the lavalink node's information.
-     * @param {Object} [options] Options to pass to the rest request.
-     * @param {boolean} [options.includeHeaders=false] Include headers in the response.
-     * @returns {Promise<Object>} The lavalink node's information.
-     */
     async fetchInfo(options = {}) {
         return await this.rest.makeRequest("GET", `/v4/info`, null, options.includeHeaders);
     }
-    
 
     async connect() {
         if (this.ws) this.ws.close();
         this.aqua.emit('debug', this.name, `Attempting to connect...`);
-        const headers = this.constructHeaders();
-        this.ws = new WebSocket(this.wsUrl, { headers });
+        this.ws = new WebSocket(this.wsUrl, { headers: this.constructHeaders() });
         this.setupWebSocketListeners();
     }
 
@@ -100,12 +87,12 @@ class Node {
     async onOpen() {
         this.connected = true;
         this.aqua.emit('debug', this.name, `Connected to Lavalink at ${this.wsUrl}`);
-
-        this.info = await this.fetchInfo()
-            .catch(err => {
-                this.aqua.emit('debug', `Failed to fetch info: ${err.message}`);
-                return null;
-            });
+        try {
+            this.info = await this.fetchInfo();
+        } catch (err) {
+            this.aqua.emit('debug', `Failed to fetch info: ${err.message}`);
+            this.info = null;
+        }
 
         if (!this.info && !this.aqua.bypassChecks.nodeFetchInfo) {
             throw new Error(`Failed to fetch node info.`);
@@ -114,30 +101,27 @@ class Node {
         if (this.autoResume) {
             this.resumePlayers();
         }
-
         this.lastStats = 0;
     }
 
     async getStats() {
-        if (Date.now() - this.lastStats < 5000) {
-            return this.stats;
+        const now = Date.now();
+        if (now - this.lastStatsRequest < 5000) {
+            return this.stats; // Return cached stats if requested too soon
         }
-        
-    
-        const stats = await this.rest.makeRequest("GET", `/v4/stats`)
-            .catch(err => {
-                this.aqua.emit('debug', `Error fetching stats: ${err.message}`);
-                return null;
-           });
-    
-        if (stats) {
+
+        try {
+            const response = await this.rest.makeRequest("GET", `/v4/stats`);
+            const stats = await response.json();
             this.stats = { ...this.stats, ...stats };
-            this.lastStats = Date.now();
+            this.lastStatsRequest = now; // Update last request time
+            return stats;
+        } catch (err) {
+            this.aqua.emit('debug', `Error fetching stats: ${err.message}`);
+            return this.stats; // Return last known stats on error
         }
-        return stats;
     }
 
-
     resumePlayers() {
         for (const player of this.aqua.players.values()) {
             if (player.node === this) {
@@ -153,13 +137,10 @@ class Node {
     onMessage(msg) {
         if (Array.isArray(msg)) msg = Buffer.concat(msg);
         if (msg instanceof ArrayBuffer) msg = Buffer.from(msg);
-
         const payload = JSON.parse(msg.toString());
         if (!payload.op) return;
-
         this.aqua.emit("raw", "Node", payload);
         this.aqua.emit("debug", this.name, `Received update: ${JSON.stringify(payload)}`);
-
         this.handlePayload(payload);
     }
 
@@ -175,9 +156,7 @@ class Node {
                 break;
             default:
                 const player = this.aqua.players.get(payload.guildId);
-                if (payload.guildId && player) {
-                    player.emit(payload.op, payload);
-                }
+                if (player) player.emit(payload.op, payload);
                 break;
         }
     }
@@ -196,8 +175,7 @@ class Node {
     }
 
     reconnect() {
-        this.reconnectAttempted++;
-        if (this.reconnectAttempted > this.reconnectTries) {
+        if (this.reconnectAttempted++ >= this.reconnectTries) {
             this.aqua.emit("nodeError", this, new Error(`Unable to connect after ${this.reconnectTries} attempts.`));
             return this.destroy();
         }
@@ -216,17 +194,13 @@ class Node {
             this.aqua.nodes.delete(this.name);
             return;
         }
-
         if (!this.connected) return;
-
         this.aqua.players.forEach((player) => {
             if (player.node === this) player.destroy();
         });
-
-        if (this.ws) this.ws.close(1000, "destroy");
+        this.ws?.close(1000, "destroy");
         this.ws?.removeAllListeners();
         this.ws = null;
-
         this.aqua.emit("nodeDestroy", this);
         this.aqua.nodeMap.delete(this.name);
         this.connected = false;
@@ -255,4 +229,4 @@ class Node {
     }
 }
 
-module.exports = { Node };
+module.exports = { Node };

package/build/structures/Player.js

@@ -16,7 +16,7 @@ class Player extends EventEmitter {
      * @param {number} [options.defaultVolume=100] - The default volume level (0-200).
      * @param {string} [options.loop='none'] - The loop mode ('none', 'track', 'queue').
      */
-    constructor(aqua, nodes, options) {
+    constructor(aqua, nodes, options = {}) {
         super();
         this.aqua = aqua;
         this.nodes = nodes;
@@ -33,13 +33,16 @@ class Player extends EventEmitter {
         this.queue = new Queue();
         this.position = 0;
         this.current = null;
-        this.previousTracks = [];
         this.playing = false;
         this.paused = false;
         this.connected = false;
         this.timestamp = 0;
         this.ping = 0;
         this.isAutoplay = false;
+        this.nowPlayingMessage = null;
+        this.previousTracks = new Array();
+        
+        this.shouldDeleteMessage = options.shouldDeleteMessage ?? true;
 
         this.setupEventListeners();
     }
@@ -62,9 +65,10 @@ class Player extends EventEmitter {
         this.position = state.position;
         this.ping = state.ping;
         this.timestamp = state.time;
-
+    this.aqua.emit("playerUpdate", this, packet);
     }
 
+
     /**
      * Gets the previous track.
      * @returns {Object|null} The previous track or null if none exists.
@@ -83,64 +87,68 @@ class Player extends EventEmitter {
 
     /**
      * Plays the next track in the queue.
+     * @param {Object} options - Options for playing the next track.
+     * @param {string} options.query - The query to search for the next track.
+     * @param {boolean} options.force - Whether to force play the next track even if the queue is empty.
      * @returns {Promise<Player>} The player instance.
      * @throws {Error} If the player is not connected.
+     * @throws {Error} If the queue is empty and force is not set to true.
+     * @description This method plays the next track in the queue.
+     * @event play
      */
     async play() {
-        if (!this.connected) throw new Error("Player connection is not established. Please connect first.");
-        this.current = this.queue.shift();
-        if (!this.current) return this;
+    if (!this.connected) throw new Error("Bro go on and use the connection first");
+    if (!this.queue.length) return;
 
-        if (!this.current.track) {
-            this.current = await this.current.resolve(this.aqua);
-        }
+    this.current = this.queue.shift();
+    this.current = this.current.track ? this.current : await this.current.resolve(this.aqua);
+    this.playing = true;
+    this.position = 0;
 
-        this.playing = true;
-        this.position = 0;
+    this.aqua.emit("debug", this.guildId, `Playing track: ${this.current.track}`);
+    await this.updatePlayer({ track: { encoded: this.current.track } });
+    return this;
+}
 
-        this.aqua.emit("debug", this.guildId, `Playing track: ${this.current.track}`);
-        await this.updatePlayer({ track: { encoded: this.current.track } });
-        return this;
-    }
     /**
-     * Connects the player to the voice channel.
-     * @param {Object} [options=this] - Connection options.
-     * @param {string} options.guildId - The ID of the guild.
-     * @param {string} options.voiceChannel - The ID of the voice channel.
-     * @param {boolean} [options.deaf=true] - Whether to deaf the player.
-     * @param {boolean} [options.mute=false] - Whether to mute the player.
+     * Connects the player to a voice channel.
+     * @param {Object} options - Options for connecting the player.
+     * @param {string} options.guildId - The guild ID to connect to.
+     * @param {string} options.voiceChannel - The ID of the voice channel to connect to.
+     * @param {boolean} [options.deaf=true] - Whether the player should be deafened.
+     * @param {boolean} [options.mute=false] - Whether the player should be muted.
      * @returns {Promise<Player>} The player instance.
+     * @throws {Error} If the player is already connected.
+     * @description This method connects the player to a voice channel.
+     * @event ready
      */
     async connect(options = this) {
         const { guildId, voiceChannel, deaf = true, mute = false } = options;
-        await this.send({
-            guild_id: guildId,
-            channel_id: voiceChannel,
-            self_deaf: deaf,
-            self_mute: mute,
-        });
+        await this.send({ guild_id: guildId, channel_id: voiceChannel, self_deaf: deaf, self_mute: mute });
         this.connected = true;
         this.aqua.emit("debug", this.guildId, `Player has connected to voice channel: ${voiceChannel}.`);
     }
 
     /**
-     * Disconnects the player from the voice channel and leaves the channel.
-     * @returns {Promise<Player>} The player instance.
+     * Destroys the player instance.
+     * @returns {Promise<void>} The result of the destroy method.
+     * @description This method destroys the player instance and clears all data.
+     * @event destroy
      */
     async destroy() {
-        await this.updatePlayer({ track: { encoded: null },  });
+        await this.updatePlayer({ track: { encoded: null } });
         this.connected = false;
-        await this.send({
-            guild_id: this.guildId,
-            channel_id: null,
-        });
-        this.clearData(); // Clear data when destroyed
+        await this.send({ guild_id: this.guildId, channel_id: null });
+        this.clearData();
         this.aqua.emit("debug", this.guildId, "Player has disconnected from voice channel.");
     }
+
     /**
-     * Pauses or resumes the player.
-     * @param {boolean} paused - Whether to pause the player.
+     * Pauses the player.
+     * @param {boolean} paused - Whether the player should be paused.
      * @returns {Promise<Player>} The player instance.
+     * @description This method pauses the player.
+     * @event pause
      */
     async pause(paused) {
         this.paused = paused;
@@ -149,9 +157,11 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Seeks to a specific position in the current track.
-     * @param {number} position - The position in milliseconds to seek to.
+     * Seeks the player to a specific position.
+     * @param {number} position - The position to seek to in milliseconds.
      * @returns {Promise<Player>} The player instance.
+     * @description This method seeks the player to a specific position.
+     * @event seek
      */
     async seek(position) {
         this.position = position;
@@ -160,26 +170,27 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Stops playback and clears the current track.
+     * Stops the player.
      * @returns {Promise<Player>} The player instance.
+     * @description This method stops the player.
+     * @event stop
      */
     async stop() {
-        if (!this.playing) return this; // If not playing, return early
+        if (!this.playing) return this;
         this.playing = false;
         this.current = null;
         this.position = 0;
-        await this.updatePlayer({ track: 
-            {
-                encoded: null,
-            }
-         });
+        await this.updatePlayer({ track: { encoded: null } });
         return this;
     }
+
     /**
      * Sets the volume of the player.
-     * @param {number} volume - The volume level (0-200).
+     * @param {number} volume - The volume to set between 0 and 200.
      * @returns {Promise<Player>} The player instance.
-     * @throws {Error} If the volume is out of bounds.
+     * @throws {Error} If the volume is not between 0 and 200.
+     * @description This method sets the volume of the player.
+     * @event volumeChange
      */
     async setVolume(volume) {
         if (volume < 0 || volume > 200) throw new Error("[Volume] Volume must be between 0 and 200.");
@@ -189,10 +200,12 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Sets the loop mode for the player.
-     * @param {string} mode - The loop mode ('none', 'track', 'queue').
+     * Sets the loop mode of the player.
+     * @param {string} mode - The loop mode to set, either 'none', 'track', or 'queue'.
      * @returns {Promise<Player>} The player instance.
-     * @throws {Error} If the loop mode is invalid.
+     * @throws {Error} If the loop mode is not 'none', 'track', or 'queue'.
+     * @description This method sets the loop mode of the player.
+     * @event loopChange
      */
     async setLoop(mode) {
         if (!["none", "track", "queue"].includes(mode)) throw new Error("Loop mode must be 'none', 'track', or 'queue'.");
@@ -202,9 +215,11 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Sends data to the player.
-     * @param {Object} data - The data to send.
+     * Sends an update to the player.
+     * @param {Object} data - The data to send to the player.
      * @returns {Promise<Player>} The player instance.
+     * @description This method sends an update to the player.
+     * @event update
      */
     async send(data) {
         await this.updatePlayer(data);
@@ -212,9 +227,11 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Sets the text channel for the player.
-     * @param {string} channel - The ID of the text channel.
+     * Sets the text channel of the player.
+     * @param {string} channel - The ID of the text channel to set.
      * @returns {Promise<Player>} The player instance.
+     * @description This method sets the text channel of the player.
+     * @event textChannelChange
      */
     async setTextChannel(channel) {
         await this.updatePlayer({ text_channel: channel });
@@ -222,11 +239,11 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Sets the voice channel for the player.
-     * @param {string} channel - The ID of the voice channel.
+     * Sets the voice channel of the player.
+     * @param {string} channel - The ID of the voice channel to set.
      * @returns {Promise<Player>} The player instance.
-     * @throws {TypeError} If the channel is not a string.
-     * @throws {ReferenceError} If the player is already connected to the channel.
+     * @description This method sets the voice channel of the player.
+     * @event voiceChannelChange
      */
     async setVoiceChannel(channel) {
         if (typeof channel !== "string") throw new TypeError("Channel must be a non-empty string.");
@@ -240,48 +257,77 @@ class Player extends EventEmitter {
 
     /**
      * Disconnects the player from the voice channel.
-     * @returns {Promise<Player>} The player instance.
+     * @returns {Promise<void>} The result of the disconnect method.
+     * @description This method disconnects the player from the voice channel.
+     * @event disconnect
      */
     async disconnect() {
-        await this.updatePlayer({ track: { encoded: null }});
+        await this.updatePlayer({ track: { encoded: null } });
         await this.send({ guild_id: this.guildId, channel_id: null });
         this.connected = false;
         this.aqua.emit("debug", this.guildId, "Player has disconnected from voice channel.");
     }
 
     /**
-     * Handles events from the player.
-     * @param {Object} payload - The event payload.
+     * Shuffles the queue of the player.
+     * @returns {Promise<Player>} The player instance.
+     * @description This method shuffles the queue of the player.
+     * @event shuffle
      */
-    async handleEvent(payload) {
-        const player = this.aqua.players.get(payload.guildId);
-        if (!player) return;
-
-        const track = this.current;
-
-        switch (payload.type) {
-            case "TrackStartEvent":
-                this.trackStart(player, track, payload);
-                break;
-            case "TrackEndEvent":
-                this.trackEnd(player, track, payload);
-                break;
-            case "TrackExceptionEvent":
-                this.trackError(player, track, payload);
-                break;
-            case "TrackStuckEvent":
-                this.trackStuck(player, track, payload);
-                break;
-            case "TrackChangeEvent":
-                this.trackChange(player, track, payload);
-            case "WebSocketClosedEvent":
-                this.socketClosed(player, track, payload);
-                break;
-            default:
-                this.handleUnknownEvent(payload);
-                break;
-        }
+    async shuffle() {
+        this.queue.shuffle();
+        return this;
+    }
+
+    /**
+     * Gets the queue of the player.
+     * @returns {Array<Object>} The queue of the player.
+     * @description This method gets the queue of the player.
+     * @event getQueue
+     */
+    async getQueue() {
+        return this.queue;
+    }
+
+    /**
+     * Replays the current track from the start.
+     * @returns {Promise<Player>} The player instance.
+     * @description This method replays the current track from the start.
+     * @event replay
+     */
+    async replay() {
+        return this.seek(0);
+    }
+async handleEvent(payload) {
+    const player = this.aqua.players.get(payload.guildId);
+    if (!player) return;
+
+    const track = this.current;
+
+    switch (payload.type) {
+        case "TrackStartEvent":
+            this.trackStart(player, track, payload);
+            break;
+        case "TrackEndEvent":
+            this.trackEnd(player, track, payload);
+            break;
+        case "TrackExceptionEvent":
+            this.trackError(player, track, payload);
+            break;
+        case "TrackStuckEvent":
+            this.trackStuck(player, track, payload);
+            break;
+        case "TrackChangeEvent":
+            this.trackChange(player, track, payload);
+            break;
+        case "WebSocketClosedEvent":
+            this.socketClosed(player, track, payload);
+            break;
+        default:
+            this.handleUnknownEvent(payload);
+            break;
     }
+}
 
     /**
      * Handles track start events.
@@ -297,7 +343,7 @@ class Player extends EventEmitter {
 
     trackChange(player, track, payload) {
         this.playing = true;
-        this.paused = this.player.this.paused
+        this.paused = false
         this.aqua.emit("trackChange", player, track, payload);
     }
 
@@ -307,31 +353,27 @@ class Player extends EventEmitter {
      * @param {Object} payload - The event payload.
      */
     trackEnd(player, track, payload) {
-        this.addToPreviousTrack(this.current);
+
+        if (this.shouldDeleteMessage && this.nowPlayingMessage) {
+            this.nowPlayingMessage.delete();
+            this.nowPlayingMessage = null;
+            
+        }
         if (["loadfailed", "cleanup"].includes(payload.reason.replace("_", "").toLowerCase())) {
-            if (player.queue.length === 0) {
-                this.playing = false;
-                return this.aqua.emit("queueEnd", player);
-            }
-            this.aqua.emit("trackEnd", player, payload);
-            return player.play();
+            return player.queue.length === 0 ? this.aqua.emit("queueEnd", player) : player.play();
         }
+        this.addToPreviousTrack(track)
         if (this.loop === "track") {
-            player.queue.unshift(player.previous);
-            this.aqua.emit("trackEnd", player, payload);
-            return player.play();
-        } else if (this.loop === "queue") {
-            player.queue.push(player.previous);
-            this.aqua.emit("trackEnd", player, payload);
+            player.queue.push(this.previous);
             return player.play();
         }
         if (player.queue.length === 0) {
             this.playing = false;
             return this.aqua.emit("queueEnd", player);
-        } else {
-            this.aqua.emit("trackEnd", player, payload);
-            return player.play();
         }
+        this.cleanup();
+        this.clearData();
+        return player.play();
     }
 
     /**
@@ -403,7 +445,7 @@ class Player extends EventEmitter {
      * @returns {Player} The player instance.
      */
     clearData() {
-        this.data = {} // Clear all custom data efficiently
+        this.data = {};
         return this;
     }
 
@@ -439,4 +481,5 @@ class Player extends EventEmitter {
     }
 }
 
-module.exports = { Player };
+module.exports = { Player };
+

package/build/structures/Queue.js

@@ -100,3 +100,4 @@ class Queue extends Array {
 }
 
 module.exports = { Queue };
+

package/build/structures/Rest.js

@@ -1,5 +1,4 @@
 const { fetch: undiciFetch } = require("undici");
-const nodeUtil = require("node:util");
 
 class Rest {
     constructor(aqua, options) {
@@ -9,10 +8,6 @@ class Rest {
         this.password = options.password;
         this.version = options.restVersion;
         this.calls = 0;
-        this.queue = []; 
-        this.maxQueueSize = options.maxQueueSize || 100; 
-        this.maxConcurrentRequests = options.maxConcurrentRequests || 5; 
-        this.activeRequests = 0; 
     }
 
     setSessionId(sessionId) {
@@ -24,24 +19,22 @@ class Rest {
             "Content-Type": "application/json",
             Authorization: this.password,
         };
-        const requestOptions = {
+
+        const response = await undiciFetch(`${this.url}${endpoint}`, {
             method,
             headers,
-            body: body ? JSON.stringify(body) : null,
-        };
-        try {
-            const response = await undiciFetch(`${this.url}${endpoint}`, requestOptions);
-            this.calls++;
-            const data = await this.parseResponse(response);
-            this.aqua.emit("apiResponse", endpoint, response);
-            this.aqua.emit(
-                "debug",
-                `[Rest] ${method} ${endpoint} ${body ? `body: ${JSON.stringify(body)}` : ""} -> Status Code: ${response.status} Response: ${nodeUtil.inspect(data)}`
-            );
-            return includeHeaders ? { data, headers: response.headers } : data;
-        } catch (error) {
-            throw new Error(`Network error during request: ${method} ${this.url}${endpoint}`, { cause: error });
+            body: body && JSON.stringify(body),
+        });
+
+        this.calls++;
+
+        const data = await response.json();
+        this.aqua.emit("apiResponse", endpoint, response);
+
+        if (includeHeaders) {
+            return { data, headers: response.headers };
         }
+        return data;
     }
 
     async getPlayers() {
@@ -50,15 +43,18 @@ class Rest {
 
     async updatePlayer(options) {
         const requestBody = { ...options.data };
+
         if ((requestBody.track && requestBody.track.encoded && requestBody.track.identifier) ||
             (requestBody.encodedTrack && requestBody.identifier)) {
             throw new Error(`Cannot provide both 'encoded' and 'identifier' for track in Update Player Endpoint`);
         }
+
         if (this.version === "v3" && options.data?.track) {
             const { track } = requestBody;
             delete requestBody.track;
             Object.assign(requestBody, track.encoded ? { encodedTrack: track.encoded } : { identifier: track.identifier });
         }
+
         return this.makeRequest("PATCH", `/${this.version}/sessions/${this.sessionId}/players/${options.guildId}?noReplace=false`, requestBody);
     }
 
@@ -70,7 +66,7 @@ class Rest {
         return this.makeRequest("GET", `/${this.version}/loadtracks?identifier=${encodeURIComponent(identifier)}`);
     }
 
-    async decodeTrack(track, node) {
+    async decodeTrack(track) {
         return this.makeRequest("GET", `/${this.version}/decodetrack?encodedTrack=${encodeURIComponent(track)}`);
     }
 
@@ -79,10 +75,7 @@ class Rest {
     }
 
     async getStats() {
-        if (this.version === "v3") {
-            return this.makeRequest("GET", `/${this.version}/stats`);
-        }
-        return this.makeRequest("GET", `/${this.version}/stats/all`);
+        return this.makeRequest("GET", this.version === "v3" ? `/${this.version}/stats` : `/${this.version}/stats/all`);
     }
 
     async getInfo() {
@@ -96,25 +89,7 @@ class Rest {
     async getRoutePlannerAddress(address) {
         return this.makeRequest("POST", `/${this.version}/routeplanner/free/address`, { address });
     }
-
-    async parseResponse(response) {
-        if (response.status === 204) {
-            return null;
-        }
-        try {
-            const contentType = response.headers.get("Content-Type");
-            return await response[contentType.includes("text/plain") ? "text" : "json"]();
-        } catch (error) {
-            this.aqua.emit("debug", `[Rest - Error] Failed to process response from ${response.url}: ${error}`);
-            return null;
-        }
-    }
-    /**
-     * Cleans up resources related to the queue.
-     */
-    cleanupQueue() {
-        this.queue = []; 
-    }
 }
 
-module.exports = { Rest };
+module.exports = { Rest };
+

package/build/structures/Track.js

@@ -7,7 +7,7 @@ const { getImageUrl } = require("../handlers/fetchImage");
  */
 class Track {
     /**
-     * @param {{ encoded: string, info: { identifier: string, isSeekable: boolean, author: string, length: number, isStream: boolean, position: number, title: string, uri: string, sourceName: string, thumbnail: string, track: string, tracks: Array<Track>, playlist: { name: string, selectedTrack: number } } }} data
+     * @param {{ encoded: string, info: { identifier: string, isSeekable: boolean, author: string, length: number, isStream: boolean, position: number, title: string, uri: string, sourceName: string, artworkUrl: string, track: string, tracks: Array<Track>, playlist: { name: string, selectedTrack: number } } }} data
      * @param {Player} requester
      * @param {Node} nodes
      */
@@ -17,6 +17,7 @@ class Track {
         this.requester = requester;
         this.nodes = nodes;
         this.track = data.encoded || Buffer.from(data.track, "base64").toString("utf8");
+        this.playlist = data.playlist || null;
     }
 
     /**
@@ -62,14 +63,18 @@ class Track {
     updateTrackInfo(track) {
         this.info.identifier = track.info.identifier;
         this.track = track.track;
+        if (track.playlist) {
+            this.playlist = track.playlist;
+        }
     }
 
     /**
      * @private
      */
     cleanup() {
-        this.rawData = this.track = this.info = null;
+        this.rawData = this.track = this.info = this.playlist = null;
     }
 }
 
 module.exports = { Track };
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aqualink",
-  "version": "1.0.5",
+  "version": "1.2.0",
   "description": "An Lavalink wrapper, focused in speed, performance, and features, Based in Riffy!",
   "main": "build/index.js",
   "scripts": {