aqualink 1.8.0 → 1.8.1-beta2

package/build/index.d.ts

@@ -0,0 +1,80 @@
+declare module "AquaLink" {
+    export class Aqua {
+    /**
+     * @param {Object} client - The client instance.
+     * @param {Array<Object>} nodes - An array of node configurations.
+     * @param {Object} options - Configuration options for Aqua.
+     * @param {Function} options.send - Function to send data.
+     * @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 {boolean} [options.autoResume=false] - Automatically resume tracks on reconnect.
+     * @param {boolean} [options.infiniteReconnects=false] - Reconnect infinitely.
+     */
+        constructor(client: any, nodes: Array<any>, options?: { [key: string]: any });
+        init(clientId: string): this;
+        createNode(options: { [key: string]: any }): Node;
+        createPlayer(node: Node, options: { [key: string]: any }): Player;
+        destroyPlayer(guildId: string): Promise<void>;
+        resolve(options: { query: string, source?: string, requester?: any, nodes?: any }): Promise<any>;
+        updateVoiceState(data: { d: any, t: string }): void;
+    }
+
+    export class Connection {
+        constructor(player: Player);
+        setServerUpdate(data: { endpoint: string, token: string }): void;
+        setStateUpdate(data: { channel_id: string, session_id: string, self_deaf: boolean, self_mute: boolean }): void;
+    }
+
+    export class Filters {
+        constructor(player: Player, options?: { [key: string]: any });
+        setEqualizer(bands: Array<any>): Promise<void>;
+        setKaraoke(enabled: boolean, options?: { [key: string]: any }): Promise<void>;
+        clearFilters(): Promise<void>;
+    }
+
+    export class Node {
+        constructor(aqua: Aqua, connOptions: { [key: string]: any }, options?: { [key: string]: any });
+        connect(): Promise<void>;
+        getStats(): Promise<any>;
+        destroy(clean?: boolean): void;
+    }
+
+    export class Player {
+        constructor(aqua: Aqua, nodes: any, options?: { [key: string]: any });
+        play(): Promise<void>;
+        pause(paused: boolean): this;
+        skip(): Promise<void>;
+        destroy(): void;
+    }
+
+    export class Plugin {
+        constructor(name: string);
+        load(aqua: Aqua): void;
+        unload(aqua: Aqua): void;
+    }
+
+    export class Queue extends Array {
+        add(track: any): this;
+        remove(track: any): void;
+        clear(): void;
+        shuffle(): void;
+        peek(): any;
+        toArray(): Array<any>;
+        at(index: number): any;
+        dequeue(): any;
+        isEmpty(): boolean;
+    }
+
+    export class Rest {
+        constructor(aqua: Aqua, options: { [key: string]: any });
+        makeRequest(method: string, endpoint: string, body?: any): Promise<any>;
+        getPlayers(): Promise<any>;
+        destroyPlayer(guildId: string): Promise<void>;
+    }
+
+    export class Track {
+        constructor(data: { [key: string]: any }, requester: Player, nodes: Node);
+        resolve(aqua: Aqua): Promise<Track | null>;
+    }
+}

package/build/index.js

@@ -1,11 +1,11 @@
-const { Connection } = require("./structures/Connection");
-const { Filters } = require("./structures/Filters");
-const { Node } = require("./structures/Node");
-const { Aqua } = require("./structures/Aqua");
-const { Player } = require("./structures/Player");
-const { Plugin } = require("./structures/Plugins");
-const { Queue } = require("./structures/Queue");
-const { Rest } = require("./structures/Rest");
-const { Track } = require("./structures/Track");
+const Connection = require("./structures/Connection");
+const Filters = require("./structures/Filters");
+const Node = require("./structures/Node");
+const Aqua = require("./structures/Aqua");
+const Player = require("./structures/Player");
+const Plugin = require("./structures/Plugins");
+const Queue = require("./structures/Queue");
+const Rest = require("./structures/Rest");
+const Track = require("./structures/Track");
 
 module.exports = { Connection, Filters, Node, Aqua, Player, Plugin, Queue, Rest, Track };

package/build/structures/Aqua.js

@@ -1,7 +1,9 @@
-const { EventEmitter } = require("events");
-const { Node } = require("./Node");
-const { Player } = require("./Player");
-const { Track } = require("./Track");
+"use strict";
+
+const { EventEmitter } = require("node:events");
+const  Node = require("./Node");
+const  Player  = require("./Player");
+const  Track  = require("./Track");
 const { version: pkgVersion } = require("../../package.json");
 const URL_REGEX = /^https?:\/\//;
 
@@ -111,12 +113,13 @@ class Aqua extends EventEmitter {
     updateVoiceState({ d, t }) {
         const player = this.players.get(d.guild_id);
         if (!player) return;
+
         if (t === "VOICE_SERVER_UPDATE" || (t === "VOICE_STATE_UPDATE" && d.user_id === this.clientId)) {
             const updateMethod = t === "VOICE_SERVER_UPDATE" ? "setServerUpdate" : "setStateUpdate";
             if (player.connection && typeof player.connection[updateMethod] === "function") {
                 player.connection[updateMethod](d);
             }
-            if (d.status === "disconnected") {
+            if (d.channel_id === null) {
                 this.cleanupPlayer(player);
             }
         }
@@ -273,4 +276,4 @@ class Aqua extends EventEmitter {
     }
 }
 
-module.exports = { Aqua };
+module.exports = Aqua 

package/build/structures/Connection.js

@@ -1,75 +1,82 @@
+"use strict";
+
 class Connection {
-  constructor(player) {
-      this.playerRef = new WeakRef(player);
-      const { voiceChannel, guildId, aqua, nodes } = player;
-      this.voice = {
-          sessionId: null,
-          endpoint: null,
-          token: null
-      };
-      this.region = null;
-      this.selfDeaf = false;
-      this.selfMute = false;
-      this.voiceChannel = voiceChannel;
-      this.guildId = guildId;
-      this.aqua = aqua;
-      this.nodes = nodes;
-  }
+    constructor(player) {
+        this.playerRef = new WeakRef(player);
+        const { voiceChannel, guildId, aqua, nodes } = player;
+        this.voice = {
+            sessionId: null,
+            endpoint: null,
+            token: null
+        };
+        this.region = null;
+        this.selfDeaf = false;
+        this.selfMute = false;
+        this.voiceChannel = voiceChannel;
+        this.guildId = guildId;
+        this.aqua = aqua;
+        this.nodes = nodes;
+    }
+
+    setServerUpdate(data = {}) {
+        const { endpoint, token } = data;
+
+        if (!endpoint) {
+            throw new Error("Missing 'endpoint' property");
+        }
+
+        const newRegion = endpoint.split('.')[0];
+        if (this.region !== newRegion) {
+            this.voice.endpoint = endpoint;
+            this.voice.token = token;
+            const prevRegion = this.region;
+            this.region = newRegion;
+
+            const message = prevRegion
+                ? `Changed Voice Region from ${prevRegion} to ${newRegion}`
+                : `Voice Server: ${newRegion}`;
+
+            this.aqua.emit("debug", `[Player ${this.guildId} - CONNECTION] ${message}`);
+            this._updatePlayerVoiceData(); 
+        }
+    }
 
-  setServerUpdate(data) {
-      const { endpoint, token } = data || {};
-      if (!endpoint) {
-          throw new Error("Missing 'endpoint' property");
-      }
-      const regionMatch = endpoint.match(/^([a-zA-Z]+)/);
-      if (!regionMatch) return;
-      const newRegion = regionMatch[1];
+    setStateUpdate({ channel_id: channelId, session_id: sessionId, self_deaf: selfDeaf, self_mute: selfMute } = {}) {
+        if (!channelId || !sessionId) {
+            this.playerRef.deref()?.destroy();
+            return;
+        }
 
-      if (this.region !== newRegion) {
-          this.voice.endpoint = endpoint;
-          this.voice.token = token;
-          const prevRegion = this.region;
-          this.region = newRegion;
-          this.aqua.emit(
-              "debug",
-              `[Player ${this.guildId} - CONNECTION] ${
-                  prevRegion
-                      ? `Changed Voice Region from ${prevRegion} to ${newRegion}`
-                      : `Voice Server: ${newRegion}`
-              }`
-          );
-      }
-      this._updatePlayerVoiceData();
-  }
+        if (this.voiceChannel !== channelId) {
+            this.aqua.emit("playerMove", this.voiceChannel, channelId);
+            this.voiceChannel = channelId;
+        }
 
-  setStateUpdate(data) {
-      const { channel_id: channelId, session_id: sessionId, self_deaf: selfDeaf, self_mute: selfMute } = data || {};
-      if (!channelId || !sessionId) return;
+        this.selfDeaf = selfDeaf;
+        this.selfMute = selfMute;
+        this.voice.sessionId = sessionId;
+    }
 
-      if (this.voiceChannel !== channelId) {
-          this.aqua.emit("playerMove", this.voiceChannel, channelId);
-          this.voiceChannel = channelId;
-      }
-      this.selfDeaf = selfDeaf;
-      this.selfMute = selfMute;
-      this.voice.sessionId = sessionId;
-  }
+    async _updatePlayerVoiceData() {
+        const player = this.playerRef.deref();
+        if (!player) return;
 
-  async _updatePlayerVoiceData() {
-      const player = this.playerRef.deref();
-      if (!player) return;
-      try {
-          await this.nodes.rest.updatePlayer({
-              guildId: this.guildId,
-              data: {
-                  voice: this.voice,
-                  volume: player.volume
-              }
-          });
-      } catch (err) {
-          this.aqua.emit("apiError", "updatePlayer", err);
-      }
-  }
+        try {
+            await this.nodes.rest.updatePlayer({
+                guildId: this.guildId,
+                data: {
+                    voice: this.voice,
+                    volume: player.volume
+                }
+            });
+        } catch (err) {
+            this.aqua.emit("apiError", "updatePlayer", {
+                error: err,
+                guildId: this.guildId,
+                voiceData: this.voice
+            });
+        }
+    }
 }
 
-module.exports = { Connection };
+module.exports = Connection;

package/build/structures/Filters.js

@@ -1,3 +1,5 @@
+"use strict";
+
 class Filters {
     constructor(player, options = {}) {
         this.player = player;
@@ -166,4 +168,4 @@ class Filters {
     }
 }
 
-module.exports =  {Filters} 
+module.exports = Filters

package/build/structures/Node.js

@@ -1,5 +1,7 @@
+"use strict";
+
 const WebSocket = require("ws");
-const { Rest } = require("./Rest");
+const  Rest  = require("./Rest");
 
 class Node {
     #ws = null;
@@ -272,4 +274,4 @@ class Node {
     }
 }
 
-module.exports = { Node };
+module.exports = Node 

package/build/structures/Player.js

@@ -1,7 +1,9 @@
+"use strict";
+
 const { EventEmitter } = require("events");
-const { Connection } = require("./Connection");
-const { Queue } = require("./Queue");
-const { Filters } = require("./Filters");
+const  Connection = require("./Connection");
+const  Queue  = require("./Queue");
+const  Filters  = require("./Filters");
 
 class Player extends EventEmitter {
     static LOOP_MODES = Object.freeze({
@@ -347,4 +349,4 @@ class Player extends EventEmitter {
     }
 }
 
-module.exports = { Player };
+module.exports = Player 

package/build/structures/Plugins.js

@@ -1,3 +1,4 @@
+
 class Plugin {
     constructor(name) {
         this.name = name;
@@ -7,4 +8,4 @@ class Plugin {
     unload(aqua) { }
 }
 
-module.exports = { Plugin };
+module.exports = Plugin 

package/build/structures/Queue.js

@@ -1,3 +1,4 @@
+
 class Queue extends Array {
     /**
      * @param {...*} elements - The elements to initialize the queue with.
@@ -93,5 +94,4 @@ class Queue extends Array {
 
 }
 
-module.exports = { Queue };
-
+module.exports =  Queue 

package/build/structures/Rest.js

@@ -1,16 +1,15 @@
+"use strict";
 const { request } = require("undici");
 
 class Rest {
-    constructor(aqua, options) {
+    constructor(aqua, { secure, host, port, sessionId, password }) {
         this.aqua = aqua;
-        this.url = `http${options.secure ? "s" : ""}://${options.host}:${options.port}`;
-        this.sessionId = options.sessionId;
-        this.password = options.password;
-        this.version = options.restVersion || "v4";
-        this.calls = 0;
+        this.sessionId = sessionId;
+        this.version = "v4";
+        this.baseUrl = `http${secure ? "s" : ""}://${host}:${port}`;
         this.headers = {
             "Content-Type": "application/json",
-            Authorization: this.password,
+            Authorization: password,
         };
     }
 
@@ -22,90 +21,100 @@ class Rest {
         const options = {
             method,
             headers: this.headers,
+            body: body ? JSON.stringify(body) : undefined,
         };
 
-        if (body) {
-            options.body = JSON.stringify(body);
-        }
-
-        const response = await request(`${this.url}${endpoint}`, options);
-        if (response.statusCode === 204) return null;
-        this.calls++;
-        const data = await response.body.json();
-        this.aqua.emit("apiResponse", endpoint, {
-            status: response.statusCode,
-            headers: response.headers,
-        });
-        response.body.destroy();
-        return data;
-    }
+        try {
+            const { statusCode, headers, body: responseBody } = await request(`${this.baseUrl}${endpoint}`, options);
+            this.aqua.emit("apiResponse", endpoint, { status: statusCode, headers: headers });
 
-     updatePlayer(options) {
-        const requestBody = { ...options.data };
+            if (statusCode === 204) {
+                return null;
+            }
 
-        if ((requestBody.track?.encoded && requestBody.track?.identifier) ||
-            (requestBody.encodedTrack && requestBody.identifier)) {
-            throw new Error("Cannot provide both 'encoded' and 'identifier' for track");
+            const data = await responseBody.text();
+            return data ? JSON.parse(data) : null;
+        } catch (error) {
+            throw new Error(`Request to ${endpoint} failed: ${error.message}`);
         }
+    }
 
-        if (this.version === "v3" && requestBody.track) {
-            const { track } = requestBody;
-            delete requestBody.track;
-            requestBody[track.encoded ? 'encodedTrack' : 'identifier'] = track.encoded || track.identifier;
+    buildEndpoint(...segments) {
+        const validSegments = segments.filter(segment => segment && segment.trim());
+        return '/' + validSegments.join('/');
+    }
+    validateSessionId() {
+        if (!this.sessionId) {
+            throw new Error("Session ID is not set.");
         }
+    }
 
-        return this.makeRequest(
-            "PATCH",
-            `/${this.version}/sessions/${this.sessionId}/players/${options.guildId}?noReplace=false`,
-            requestBody
-        );
+    updatePlayer({ guildId, data }) {
+        if ((data.track?.encoded && data.track?.identifier) || (data.encodedTrack && data.identifier)) {
+            throw new Error("Cannot provide both 'encoded' and 'identifier' for track");
+        }
+        this.validateSessionId();
+        const endpoint = this.buildEndpoint(this.version, "sessions", this.sessionId, "players", guildId) + "?noReplace=false";
+        return this.makeRequest("PATCH", endpoint, data);
     }
 
-    getPlayers() {
-        return this.makeRequest("GET", `/${this.version}/sessions/${this.sessionId}/players`);
+    async getPlayers() {
+        this.validateSessionId();
+        const endpoint = this.buildEndpoint(this.version, "sessions", this.sessionId, "players");
+        return this.makeRequest("GET", endpoint);
     }
 
-    destroyPlayer(guildId) {
-        return this.makeRequest("DELETE", `/${this.version}/sessions/${this.sessionId}/players/${guildId}`);
+    async destroyPlayer(guildId) {
+        this.validateSessionId();
+        const endpoint = this.buildEndpoint(this.version, "sessions", this.sessionId, "players", guildId);
+        return this.makeRequest("DELETE", endpoint);
     }
 
-    getTracks(identifier) {
-        return this.makeRequest("GET", `/${this.version}/loadtracks?identifier=${encodeURIComponent(identifier)}`);
+    async getTracks(identifier) {
+        const endpoint = `/${this.version}/loadtracks?identifier=${encodeURIComponent(identifier)}`;
+        return this.makeRequest("GET", endpoint);
     }
 
-    decodeTrack(track) {
-        return this.makeRequest("GET", `/${this.version}/decodetrack?encodedTrack=${encodeURIComponent(track)}`);
+    async decodeTrack(track) {
+        const endpoint = `/${this.version}/decodetrack?encodedTrack=${encodeURIComponent(track)}`;
+        return this.makeRequest("GET", endpoint);
     }
 
-    decodeTracks(tracks) {
-        return this.makeRequest("POST", `/${this.version}/decodetracks`, tracks);
+    async decodeTracks(tracks) {
+        const endpoint = `/${this.version}/decodetracks`;
+        return this.makeRequest("POST", endpoint, tracks);
     }
 
-    getStats() {
-        return this.makeRequest("GET", `/${this.version}/stats${this.version !== "v3" ? "/all" : ""}`);
+    async getStats() {
+        const endpoint = `/${this.version}/stats/all`;
+        return this.makeRequest("GET", endpoint);
     }
 
-    getInfo() {
-        return this.makeRequest("GET", `/${this.version}/info`);
+    async getInfo() {
+        const endpoint = `/${this.version}/info`;
+        return this.makeRequest("GET", endpoint);
     }
 
-    getRoutePlannerStatus() {
-        return this.makeRequest("GET", `/${this.version}/routeplanner/status`);
+    async getRoutePlannerStatus() {
+        const endpoint = `/${this.version}/routeplanner/status`;
+        return this.makeRequest("GET", endpoint);
     }
 
-    getRoutePlannerAddress(address) {
-        return this.makeRequest("POST", `/${this.version}/routeplanner/free/address`, { address });
+    async getRoutePlannerAddress(address) {
+        const endpoint = `/${this.version}/routeplanner/free/address`;
+        return this.makeRequest("POST", endpoint, { address });
     }
+
     async getLyrics({ track }) {
         if (track.search) {
-            const v2 = await this.makeRequest("GET", `/v4/lyrics/search?query=${track.encoded.info.title}&source=genius`);
-            if (v2) {
-                return v2;
-            }
+            const endpoint = `/v4/lyrics/search?query=${encodeURIComponent(track.encoded.info.title)}&source=genius`;
+            const res = await this.makeRequest("GET", endpoint);
+            if (res) return res;
         }
-        const v4 = await this.makeRequest("GET", `/v4/sessions/${this.sessionId}/players/${track.guild_id}/track/lyrics?skipTrackSource=false`);
-        return  v4; 
+        this.validateSessionId();
+        const endpoint = this.buildEndpoint(this.version, "sessions", this.sessionId, "players", track.guild_id, "track", "lyrics") + "?skipTrackSource=false";
+        return this.makeRequest("GET", endpoint);
     }
 }
 
-module.exports = { Rest };
+module.exports = Rest;

package/build/structures/Track.js

@@ -1,3 +1,4 @@
+"use strict";
 const { getImageUrl } = require("../handlers/fetchImage");
 /**
  * @typedef {import("../Aqua")} Aqua
@@ -10,9 +11,9 @@ class Track {
    * @param {Player} requester
    * @param {Node} nodes
    */
-  constructor(data, requester, nodes) {
-    const { info = {}, encoded = null, playlist = null } = data || {};
-    this.info = Object.freeze({
+  constructor(data = {}, requester, nodes) {
+    const { info = {}, encoded = null, playlist = null } = data;
+    this.info = {
       identifier: info.identifier || '',
       isSeekable: !!info.isSeekable,
       author: info.author || '',
@@ -22,22 +23,20 @@ class Track {
       uri: info.uri || '',
       sourceName: info.sourceName || '',
       artworkUrl: info.artworkUrl || ''
-    });
+    };
     this.track = encoded;
     this.playlist = playlist;
     this.requester = requester;
     this.nodes = nodes;
   }
-
   /**
    * @param {string} thumbnail
    * @returns {string|null}
    */
   resolveThumbnail(thumbnail) {
     if (!thumbnail) return null;
-    return thumbnail.startsWith("http") ? thumbnail : getImageUrl(thumbnail, this.nodes);
+    return getImageUrl(thumbnail);
   }
-
   /**
    * @param {Aqua} aqua
    * @returns {Promise<Track|null>}
@@ -45,7 +44,6 @@ class Track {
   async resolve(aqua) {
     const searchPlatform = aqua?.options?.defaultSearchPlatform;
     if (!searchPlatform) return null;
-
     try {
       const query = `${this.info.author} - ${this.info.title}`;
       const result = await aqua.resolve({
@@ -54,41 +52,29 @@ class Track {
         requester: this.requester,
         node: this.nodes
       });
-
       if (!result?.tracks?.length) return null;
-
       const track = this._findMatchingTrack(result.tracks);
       if (!track) return null;
-
       this.info.identifier = track.info.identifier;
       this.track = track.track;
       this.playlist = track.playlist || null;
-
       return this;
     } catch (error) {
       console.error("Error resolving track:", error);
       return null;
     }
   }
-
-  /**
-   * @private
-   */
   _findMatchingTrack(tracks) {
     const { author, title, length } = this.info;
-
     for (const track of tracks) {
       const tInfo = track.info;
-
-      if (author && title && author === tInfo.author && title === tInfo.title) {
+      if (author === tInfo.author && title === tInfo.title) {
         if (!length || Math.abs(tInfo.length - length) <= 2000) {
           return track;
         }
       }
     }
-
-    return tracks[0];
+    return null;
   }
 }
-
-module.exports = { Track };
+module.exports = Track;

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "aqualink",
-  "version": "1.8.0",
+  "version": "1.8.1-beta2",
   "description": "An Lavalink wrapper, focused in speed, performance, and features, Based in Riffy!",
   "main": "build/index.js",
+  "types": "index.d.ts",
   "scripts": {
     "start": "node ./build/index.js"
   },