aqualink 2.6.2 → 2.6.3

package/build/structures/Aqua.js

@@ -349,26 +349,19 @@ class Aqua extends EventEmitter {
 
     async savePlayer(filePath = "./AquaPlayers.json") {
         const data = Array.from(this.players.values()).map(player => ({
-            guildId: player.guildId,
-            textChannel: player.textChannel,
-            voiceChannel: player.voiceChannel,
-            track: player.current ? {
-                identifier: player.current.identifier,
-                author: player.current.author,
-                title: player.current.title,
-                uri: player.current.uri,
-                sourceName: player.current.sourceName,
-                artworkUrl: player.current.artworkUrl,
-                duration: player.current.duration,
-                position: player.position,
-            } : null,
-            requester: player.requester || player.current?.requester,
-            volume: player.volume,
-            paused: player.paused
+            g: player.guildId,
+            t: player.textChannel,
+            v: player.voiceChannel,
+            u: player.current?.uri || null,
+            p: player.position || 0,
+            ts: player.timestamp || 0,
+            q: player.queue?.tracks?.map(tr => tr.uri).slice(0, 5) || [],
+            r: player.requester || player.current?.requester,
+            vol: player.volume,
+            pa: player.paused
         }));
-        console.log(`Saving ${data.length} players to ${filePath}`);
-        await fs.writeJSON(filePath, data, { spaces: 2 });
-        this.emit("debug", "Aqua", `Saved players to ${filePath}`);
+        await fs.writeFile(filePath, JSON.stringify(data), "utf8");
+        this.emit("debug", "Aqua", `Saved ${data.length} players to ${filePath}`);
     }
 
     async waitForFirstNode() {
@@ -386,45 +379,60 @@ class Aqua extends EventEmitter {
     }
 
     async loadPlayers(filePath = "./AquaPlayers.json") {
-        if (!fs.existsSync(filePath)) {
-            this.emit("debug", "Aqua", `No player data found at ${filePath}`);
+        try {
+            await fs.promises.access(filePath);
+        } catch {
+            this.emit("debug", "Aqua", `File ${filePath} does not exist, skipping load.`);
             return;
         }
         try {
             await this.waitForFirstNode();
-            const data = await fs.readJSON(filePath);
-            for (const playerData of data) {
-                const { guildId, textChannel, voiceChannel, track, volume, paused, requester } = playerData;
-                let player = this.players.get(guildId);
-
+            const data = JSON.parse(await fs.readFile(filePath, "utf8"));
+            for (const p of data) {
+                let player = this.players.get(p.g);
                 if (!player) {
                     player = await this.createConnection({
-                        guildId: guildId,
-                        textChannel: textChannel,
-                        voiceChannel: voiceChannel,
-                        defaultVolume: volume || 65,
+                        guildId: p.g,
+                        textChannel: p.t,
+                        voiceChannel: p.v,
+                        defaultVolume: p.vol || 65,
                         deaf: true
                     });
                 }
 
-                if (track && player) {
-                    const resolved = await this.resolve({ query: track.uri, requester });
+                if (p.u && player) {
+                    const resolved = await this.resolve({ query: p.u, requester: p.r });
                     if (resolved.tracks && resolved.tracks.length > 0) {
                         player.queue.add(resolved.tracks[0]);
-                        player.position = track.position || 0;
-                    } else {
-                        this.emit("debug", "Aqua", `Could not resolve track for guild ${guildId}: ${track.uri}`);
+                        player.position = p.p || 0;
+                        if (typeof p.ts === "number") {
+                            player.timestamp = p.ts;
+                        }
+                    }
+                }
+                if (Array.isArray(p.q) && player) {
+                    for (const uri of p.q) {
+                        if (!p.u || uri !== p.u) {
+                            const resolved = await this.resolve({ query: uri, requester: p.r });
+                            if (resolved.tracks && resolved.tracks.length > 0) {
+                                player.queue.add(resolved.tracks[0]);
+                                player.position = p.p || 0;
+                                if (typeof p.ts === "number") {
+                                    player.timestamp = p.ts;
+                                }
+                            }
+                        }
                     }
                 }
-
                 if (player) {
-                    player.paused = paused || false;
+                    player.paused = !!p.pa;
                     if (!player.playing && !player.paused && player.queue.size > 0) {
                         player.play();
                     }
                 }
             }
-            this.emit("debug", "Aqua", `Loaded players from ${filePath}`);
+            await fs.writeFile(filePath, "[]", "utf8");
+            this.emit("debug", "Aqua", `Loaded players from ${filePath} and cleared its content.`);
         } catch (error) {
             console.error(`Failed to load players from ${filePath}:`, error);
         }

package/build/structures/Connection.js

@@ -14,29 +14,27 @@ class Connection {
         this.region = null;
         this.selfDeaf = false;
         this.selfMute = false;
-
     }
 
     setServerUpdate(data) {
-        if (!data || !data.endpoint) return;
+        if (!data?.endpoint) return;
 
         const { endpoint, token } = data;
-
-        const [newRegion] = endpoint.split('.');
+        const newRegion = endpoint.split('.')[0];
         if (!newRegion) return;
 
         if (this.region !== newRegion) {
+            const oldRegion = this.region;
             this.endpoint = endpoint;
             this.token = token;
             this.region = newRegion;
 
-                this.aqua.emit(
-                    "debug",
-                    `[Player ${this.guildId} - CONNECTION] Voice Server: ${
-                        this.region ? `Changed from ${this.region} to ${newRegion}` : newRegion
-                    }`
-                );
-            
+            this.aqua.emit(
+                "debug",
+                `[Player ${this.guildId} - CONNECTION] Voice Server: ${
+                    oldRegion ? `Changed from ${oldRegion} to ${newRegion}` : newRegion
+                }`
+            );
 
             this._updatePlayerVoiceData();
         }
@@ -49,7 +47,6 @@ class Connection {
         }
 
         const { channel_id, session_id, self_deaf, self_mute } = data;
-
         if (!channel_id || !session_id) {
             this.player?.destroy();
             return;
@@ -60,8 +57,8 @@ 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;
     }
 
@@ -73,6 +70,7 @@ class Connection {
             endpoint: this.endpoint,
             token: this.token
         };
+
         try {
             this.nodes.rest.updatePlayer({
                 guildId: this.guildId,
@@ -82,15 +80,13 @@ class Connection {
                 }
             });
         } catch (error) {
-            if (this.aqua.listenerCount('apiError') > 0) {
-                this.aqua.emit("apiError", "updatePlayer", {
-                    error,
-                    guildId: this.guildId,
-                    voiceData
-                });
-            }
+            this.aqua.emit("apiError", "updatePlayer", {
+                error,
+                guildId: this.guildId,
+                voiceData
+            });
         }
     }
 }
 
-module.exports = Connection;
+module.exports = Connection;

package/build/structures/Player.js

@@ -6,21 +6,75 @@ const Queue = require("./Queue");
 const Filters = require("./Filters");
 const { spAutoPlay, scAutoPlay } = require('../handlers/autoplay');
 
-class Player extends EventEmitter {
-    static LOOP_MODES = Object.freeze({
-        NONE: "none", TRACK: "track", QUEUE: "queue"
-    });
+const LOOP_MODES = Object.freeze({
+    NONE: "none", TRACK: "track", QUEUE: "queue"
+});
+
+const EVENT_HANDLERS = Object.freeze({
+    TrackStartEvent: "trackStart",
+    TrackEndEvent: "trackEnd",
+    TrackExceptionEvent: "trackError",
+    TrackStuckEvent: "trackStuck",
+    TrackChangeEvent: "trackChange",
+    WebSocketClosedEvent: "socketClosed",
+});
+
+const VALID_MODES = new Set(Object.values(LOOP_MODES));
+const FAILURE_REASONS = new Set(["LOAD_FAILED", "CLEANUP"]);
+const RECONNECT_CODES = new Set([4015, 4009]);
+const FAIL_LOAD_TYPES = new Set(["error", "empty", "LOAD_FAILED", "NO_MATCHES"]);
+
+class UpdateBatcher {
+    constructor(player) {
+        this.player = player;
+        this.pendingUpdates = {};
+        this.timeout = null;
+        this.hasUpdates = false;
+    }
+
+    batch(data, immediate = false) {
+        Object.assign(this.pendingUpdates, data);
+        this.hasUpdates = true;
+
+        if (this.timeout) {
+            clearTimeout(this.timeout);
+            this.timeout = null;
+        }
+
+        if (immediate || data.track) {
+            const updates = this.pendingUpdates;
+            this.pendingUpdates = {};
+            this.hasUpdates = false;
+            return this.player.updatePlayer(updates);
+        }
+
+        this.timeout = setTimeout(() => {
+            if (this.hasUpdates) {
+                const updates = this.pendingUpdates;
+                this.pendingUpdates = {};
+                this.hasUpdates = false;
+                this.player.updatePlayer(updates);
+            }
+            this.timeout = null;
+        }, 32);
+
+        return Promise.resolve();
+    }
 
-    static EVENT_HANDLERS = Object.freeze({
-        TrackStartEvent: "trackStart",
-        TrackEndEvent: "trackEnd",
-        TrackExceptionEvent: "trackError",
-        TrackStuckEvent: "trackStuck",
-        TrackChangeEvent: "trackChange",
-        WebSocketClosedEvent: "socketClosed"
-    });
+    destroy() {
+        if (this.timeout) {
+            clearTimeout(this.timeout);
+            this.timeout = null;
+        }
+        this.pendingUpdates = {};
+        this.hasUpdates = false;
+    }
+}
 
-    static validModes = new Set(Object.values(Player.LOOP_MODES));
+class Player extends EventEmitter {
+    static LOOP_MODES = LOOP_MODES;
+    static EVENT_HANDLERS = EVENT_HANDLERS;
+    static validModes = VALID_MODES;
 
     constructor(aqua, nodes, options = {}) {
         super();
@@ -34,10 +88,12 @@ class Player extends EventEmitter {
         this.filters = new Filters(this);
         this.queue = new Queue();
 
-        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 = !!this.aqua.options.shouldDeleteMessage;
-        this.leaveOnEnd = !!this.aqua.options.leaveOnEnd;
+        const vol = options.defaultVolume ?? 100;
+        this.volume = vol < 0 ? 0 : vol > 200 ? 200 : vol;
+        
+        this.loop = VALID_MODES.has(options.loop) ? options.loop : LOOP_MODES.NONE;
+        this.shouldDeleteMessage = Boolean(this.aqua.options.shouldDeleteMessage);
+        this.leaveOnEnd = Boolean(this.aqua.options.leaveOnEnd);
 
         this.previousTracks = new Array(50);
         this.previousTracksIndex = 0;
@@ -54,32 +110,36 @@ class Player extends EventEmitter {
         this.isAutoplayEnabled = false;
         this.isAutoplay = false;
 
-        this._pendingUpdates = {};
-        this._updateTimeout = null;
+        this._updateBatcher = new UpdateBatcher(this);
         this._dataStore = new Map();
 
-        this.on("playerUpdate", (packet) => {
-            this.position = packet.state.position;
-            this.connected = packet.state.connected;
-            this.ping = packet.state.ping;
-            this.timestamp = packet.state.timestamp;
+        this._handlePlayerUpdate = this._handlePlayerUpdate.bind(this);
+        this._handleEvent = this._handleEvent.bind(this);
 
-            this.aqua.emit("playerUpdate", this, packet);
-        });
+        this.on("playerUpdate", this._handlePlayerUpdate);
+        this.on("event", this._handleEvent);
+    }
 
-        this.on("event", async (payload) => {
-            try {
-                const handlerName = Player.EVENT_HANDLERS[payload.type];
-                if (handlerName && typeof this[handlerName] === "function") {
-                    await this[handlerName](this, this.current, payload);
-                } else {
-                    this.aqua.emit("nodeError", this, new Error(`Node encountered an unknown event: '${payload.type}'`));
-                }
-            } catch (error) {
-                console.error(`Error handling event ${payload.type}:`, error);
-                this.aqua.emit("error", error);
+    _handlePlayerUpdate(packet) {
+        this.position = packet.state.position;
+        this.connected = packet.state.connected;
+        this.ping = packet.state.ping;
+        this.timestamp = packet.state.time;
+        this.aqua.emit("playerUpdate", this, packet);
+    }
+
+    async _handleEvent(payload) {
+        try {
+            const handlerName = EVENT_HANDLERS[payload.type];
+            if (handlerName && typeof this[handlerName] === "function") {
+                await this[handlerName](this, this.current, payload);
+            } else {
+                this.aqua.emit("nodeError", this, new Error(`Node encountered an unknown event: '${payload.type}'`));
             }
-        });
+        } catch (error) {
+            console.error(`Error handling event ${payload.type}:`, error);
+            this.aqua.emit("error", error);
+        }
     }
 
     get previous() {
@@ -91,23 +151,7 @@ class Player extends EventEmitter {
     }
 
     batchUpdatePlayer(data, immediate = false) {
-        this._pendingUpdates = { ...this._pendingUpdates, ...data };
-        if (this._updateTimeout) clearTimeout(this._updateTimeout);
-
-        if (immediate || data.track) {
-            const updates = this._pendingUpdates;
-            this._pendingUpdates = {};
-            return this.updatePlayer(updates);
-        }
-
-        this._updateTimeout = setTimeout(() => {
-            const updates = this._pendingUpdates;
-            this._pendingUpdates = {};
-            this.updatePlayer(updates);
-            this._updateTimeout = null;
-        }, 50);
-
-        return Promise.resolve();
+        return this._updateBatcher.batch(data, immediate);
     }
 
     async autoplay(player) {
@@ -124,36 +168,37 @@ class Player extends EventEmitter {
             const { sourceName, identifier, uri, requester } = this.previous.info;
             this.aqua.emit("debug", this.guildId, `Attempting autoplay for ${sourceName}`);
 
-            const sourceHandlers = {
-                youtube: async () => ({
-                    query: `https://www.youtube.com/watch?v=${identifier}&list=RD${identifier}`,
-                    source: "ytmsearch"
-                }),
-                soundcloud: async () => {
+            let query, source;
+
+            switch (sourceName) {
+                case "youtube":
+                    query = `https://www.youtube.com/watch?v=${identifier}&list=RD${identifier}`;
+                    source = "ytmsearch";
+                    break;
+                case "soundcloud":
                     const scResults = await scAutoPlay(uri);
-                    return scResults?.length ? { query: scResults[0], source: "scsearch" } : null;
-                },
-                spotify: async () => {
+                    if (!scResults?.length) return this;
+                    query = scResults[0];
+                    source = "scsearch";
+                    break;
+                case "spotify":
                     const spResult = await spAutoPlay(identifier);
-                    return spResult ? { query: `https://open.spotify.com/track/${spResult}`, source: "spotify" } : null;
-                }
-            };
-
-            const handler = sourceHandlers[sourceName];
-            if (!handler) return this;
-
-            const result = await handler();
-            if (!result) return this;
+                    if (!spResult) return this;
+                    query = `https://open.spotify.com/track/${spResult}`;
+                    source = "spotify";
+                    break;
+                default:
+                    return this;
+            }
 
-            const { query, source } = result;
             const response = await this.aqua.resolve({ query, source, requester });
 
-            const failTypes = new Set(["error", "empty", "LOAD_FAILED", "NO_MATCHES"]);
-            if (!response?.tracks?.length || failTypes.has(response.loadType)) {
+            if (!response?.tracks?.length || FAIL_LOAD_TYPES.has(response.loadType)) {
                 return this.stop();
             }
 
-            const track = response.tracks[Math.floor(Math.random() * response.tracks.length)];
+            const tracks = response.tracks;
+            const track = tracks[Math.floor(Math.random() * tracks.length)];
             if (!track?.info?.title) throw new Error("Invalid track object: missing title or info.");
 
             track.requester = this.previous.requester || { id: "Unknown" };
@@ -204,11 +249,7 @@ class Player extends EventEmitter {
         if (!this.connected) return this;
 
         const voiceChannelId = this.voiceChannel ? this.voiceChannel.id || this.voiceChannel : null;
-        if (this._updateTimeout) {
-            clearTimeout(this._updateTimeout);
-            this._updateTimeout = null;
-            this._pendingUpdates = {};
-        }
+        this._updateBatcher.destroy();
 
         this.send({ guild_id: this.guildId, channel_id: null });
         this._lastVoiceChannel = voiceChannelId;
@@ -244,9 +285,9 @@ class Player extends EventEmitter {
     }
 
     async getLyrics(options = {}) {
-        const { query = null, useCurrentTrack = true } = options;
-        if (query) return this.nodes.rest.getLyrics({ track: { info: { title: query }, search: true } }) || null;
-        if (useCurrentTrack && this.playing) return this.nodes.rest.getLyrics({ track: { encoded: this.current.track, guild_id: this.guildId } }) || null;
+        const { query = null, useCurrentTrack = true, skipTrackSource = false } = options;
+        if (query) return this.nodes.rest.getLyrics({ track: { info: { title: query }, search: true }, skipTrackSource }) || null;
+        if (useCurrentTrack && this.playing) return this.nodes.rest.getLyrics({ track: { encoded: this.current.track, guild_id: this.guildId }, skipTrackSource }) || null;
         return null;
     }
 
@@ -273,7 +314,7 @@ class Player extends EventEmitter {
     }
 
     setLoop(mode) {
-        if (!Player.validModes.has(mode)) throw new Error("Loop mode must be 'none', 'track', or 'queue'.");
+        if (!VALID_MODES.has(mode)) throw new Error("Loop mode must be 'none', 'track', or 'queue'.");
         this.loop = mode;
         this.batchUpdatePlayer({ loop: mode });
         return this;
@@ -310,11 +351,33 @@ class Player extends EventEmitter {
 
     shuffle() {
         const queue = this.queue;
-        for (let i = queue.length - 1; i > 0; i--) {
+        const len = queue.length;
+        
+        if (len <= 1) return this;
+
+        if (len < 200) {
+            for (let i = len - 1; i > 0; i--) {
+                const j = Math.floor(Math.random() * (i + 1));
+                [queue[i], queue[j]] = [queue[j], queue[i]];
+            }
+        } else {
+            this._shuffleAsync(queue, len - 1);
+        }
+        
+        return this;
+    }
+
+    _shuffleAsync(queue, i, chunkSize = 100) {
+        const end = Math.max(0, i - chunkSize);
+        
+        for (; i > end; i--) {
             const j = Math.floor(Math.random() * (i + 1));
             [queue[i], queue[j]] = [queue[j], queue[i]];
         }
-        return this;
+        
+        if (i > 0) {
+            setImmediate(() => this._shuffleAsync(queue, i, chunkSize));
+        }
     }
 
     getQueue() {
@@ -354,8 +417,7 @@ class Player extends EventEmitter {
         }
 
         const reason = payload.reason;
-        const failureReasons = new Set(["LOAD_FAILED", "CLEANUP"]);
-        if (failureReasons.has(reason)) {
+        if (FAILURE_REASONS.has(reason)) {
             if (!player.queue.length) {
                 this.previousTracksCount = 0;
                 this._dataStore.clear();
@@ -367,15 +429,13 @@ class Player extends EventEmitter {
             return;
         }
 
-        switch (this.loop) {
-            case Player.LOOP_MODES.TRACK:
-                player.queue.unshift(track);
-                break;
-            case Player.LOOP_MODES.QUEUE:
-                player.queue.push(track);
-                break;
+        if (this.loop === LOOP_MODES.TRACK) {
+            player.queue.unshift(track);
+        } else if (this.loop === LOOP_MODES.QUEUE) {
+            player.queue.push(track);
         }
 
+
         if (player.queue.isEmpty()) {
             if (this.isAutoplayEnabled) {
                 await player.autoplay(player);
@@ -406,8 +466,7 @@ class Player extends EventEmitter {
 
     async socketClosed(player, payload) {
         const { code, guildId } = payload || {};
-        const reconnectCodes = new Set([4015, 4009]);
-        if (reconnectCodes.has(code)) {
+        if (RECONNECT_CODES.has(code)) {
             this.send({
                 guild_id: guildId,
                 channel_id: this.voiceChannel,

package/build/structures/Rest.js

@@ -34,28 +34,48 @@ class Rest {
         }
     }
 
-    async makeRequest(method, endpoint, body = null) {
+ async makeRequest(method, endpoint, body = null) {
         const url = `${this.baseUrl}${endpoint}`;
+
+        if (!this.agent) {
+            const AgentClass = this.secure ? https.Agent : http.Agent;
+            this.agent = new AgentClass({
+                keepAlive: true,
+                maxSockets: 10,
+                maxFreeSockets: 5,
+                timeout: this.timeout,
+                freeSocketTimeout: 30000
+            });
+        }
+
         const options = {
             method,
             headers: this.headers,
             timeout: this.timeout,
-            keepAlive: true,
+            agent: this.agent
         };
 
         return new Promise((resolve, reject) => {
-            const req = this.client.request(url, options, (res) => {
+            const client = this.secure ? https : http;
+            const req = client.request(url, options, (res) => {
+                if (res.statusCode === 204) return;
+
                 const chunks = [];
-                res.setEncoding("utf8");
-                res.on("data", (chunk) => {
+                let totalLength = 0;
+
+                res.on('data', (chunk) => {
                     chunks.push(chunk);
+                    totalLength += chunk.length;
                 });
-                res.on("end", () => {
-                    const data = chunks.join("");
-                    if (!data) {
-                        resolve(null);
-                        return;
+
+                res.on('end', () => {
+                    if (totalLength === 0) {
+                        return resolve(null);
                     }
+
+                    const buffer = Buffer.concat(chunks, totalLength);
+                    const data = buffer.toString('utf8');
+
                     try {
                         resolve(JSON.parse(data));
                     } catch (err) {
@@ -64,15 +84,20 @@ class Rest {
                 });
             });
 
-            req.on("error", (err) => reject(new Error(`Request failed (${method} ${url}): ${err.message}`)));
-            req.on("timeout", () => {
+            req.on('error', (err) => {
+                reject(new Error(`Request failed (${method} ${url}): ${err.message}`));
+            });
+
+            req.on('timeout', () => {
                 req.destroy();
                 reject(new Error(`Request timed out after ${this.timeout}ms (${method} ${url})`));
             });
 
             if (body) {
-                req.write(JSON.stringify(body));
+                const bodyStr = typeof body === 'string' ? body : JSON.stringify(body);
+                req.write(bodyStr);
             }
+
             req.end();
         });
     }
@@ -134,27 +159,30 @@ class Rest {
         const endpoint = `/${this.version}/routeplanner/free/address`;
         return this.makeRequest("POST", endpoint, { address });
     }
-
     async getLyrics({ track }) {
         if (!track) return null;
 
+
         try {
             if (track.search) {
                 const query = encodeURIComponent(track.info.title);
                 try {
                     const res = await this.makeRequest(
-                        "GET", 
+                        "GET",
                         `/${this.version}/lyrics/search?query=${query}&source=genius`
                     );
+
                     if (res) return res;
                 } catch (_) {
                 }
             } else {
                 this.validateSessionId();
-                return await this.makeRequest(
+                const res = await this.makeRequest(
                     "GET",
-                    `/${this.version}/sessions/${this.sessionId}/players/${track.guild_id}/track/lyrics?skipTrackSource=true`
+                    `/${this.version}/sessions/${this.sessionId}/players/${track.guild_id}/lyrics`
                 );
+                console.log(res);
+                return res;
             }
         } catch (error) {
             console.error("Failed to fetch lyrics:", error.message);

package/package.json

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