aqualink 1.0.0

package/build/handlers/fetchImage.js

@@ -0,0 +1,39 @@
+const undici = require("undici");
+
+async function getImageUrl(info) {
+    if (!info || !info.sourceName || !info.uri) return null;
+
+    switch (info.sourceName.toLowerCase()) {
+        case "spotify":
+            return (await fetchFromUrl(`https://open.spotify.com/oembed?url=${info.uri}`))?.json().then(json => json.thumbnail_url || null);
+
+        case "soundcloud":
+            return (await fetchFromUrl(`https://soundcloud.com/oembed?format=json&url=${info.uri}`))?.json().then(json => json.thumbnail_url || null);
+
+        case "youtube":
+            const urls = [
+                `https://img.youtube.com/vi/${info.identifier}/maxresdefault.jpg`,
+                `https://img.youtube.com/vi/${info.identifier}/hqdefault.jpg`,
+                `https://img.youtube.com/vi/${info.identifier}/mqdefault.jpg`,
+                `https://img.youtube.com/vi/${info.identifier}/default.jpg`,
+            ];
+
+            const firstValidUrl = await Promise.any(urls.map(url => fetchFromUrl(url)));
+            return firstValidUrl ? firstValidUrl.url : null;
+
+        default:
+            return null;
+    }
+}
+
+async function fetchFromUrl(url) {
+    try {
+        const response = await undici.fetch(url, { cache: "force-cache" });
+        return response.ok ? response : null;
+    } catch (error) {
+        console.error(`Error fetching ${url}:`, error);
+        return null;
+    }
+}
+
+module.exports = { getImageUrl };

package/build/index.js

@@ -0,0 +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");
+
+module.exports = { Connection, Filters, Node, Aqua, Player, Plugin, Queue, Rest, Track };

package/build/structures/Aqua.js

@@ -0,0 +1,196 @@
+const { EventEmitter } = require("events");
+const { Node } = require("./Node");
+const { Player } = require("./Player");
+const { Track } = require("./Track");
+const { version: pkgVersion } = require("../../package.json");
+
+class Aqua extends EventEmitter {
+    constructor(client, nodes, options) {
+      super()
+        // Input validation
+        if (!client) throw new Error("Client is required to initialize Aqua");
+        if (!Array.isArray(nodes) || nodes.length === 0) throw new Error(`Nodes must be a non-empty Array (Received ${typeof nodes})`);
+        if (typeof options.send !== "function") throw new Error("Send function is required to initialize Aqua");
+
+        this.client = client;
+        this.nodes = nodes;
+        this.nodeMap = new Map();
+        this.players = new Map();
+        this.clientId = null;
+        this.initiated = false;
+        this.sessionId = null;
+        this.defaultSearchPlatform = options.defaultSearchPlatform || "ytmsearch";
+        this.restVersion = options.restVersion || "v3";
+        this.plugins = options.plugins || [];
+        this.version = pkgVersion;
+        this.loadType = null;
+        this.tracks = [];
+        this.playlistInfo = null;
+        this.pluginInfo = null;
+        this.options = options;
+        this.send = options.send || null;
+    }
+    get leastUsedNodes() {
+        return [...this.nodeMap.values()]
+            .filter(node => node.connected)
+            .sort((a, b) => a.rest.calls - b.rest.calls);
+    }
+
+    init(clientId) {
+        if (this.initiated) return this;
+
+        this.clientId = clientId;
+        this.nodes.forEach(nodeConfig => this.createNode(nodeConfig));
+        this.initiated = true;
+
+        this.plugins.forEach(plugin => plugin.load(this));
+    }
+
+    createNode(options) {
+        const node = new Node(this, options, this.options);
+        this.nodeMap.set(options.name || options.host, node);
+        node.connect();
+        this.emit("nodeCreate", node);
+        return node;
+    }
+
+    destroyNode(identifier) {
+        const node = this.nodeMap.get(identifier);
+        if (!node) return;
+
+        node.disconnect();
+        this.nodeMap.delete(identifier);
+        this.emit("nodeDestroy", node);
+    }
+
+    updateVoiceState(packet) {
+        if (!["VOICE_STATE_UPDATE", "VOICE_SERVER_UPDATE"].includes(packet.t)) return;
+
+        const player = this.players.get(packet.d.guild_id);
+        if (!player) return;
+
+        if (packet.t === "VOICE_SERVER_UPDATE") {
+            player.connection.setServerUpdate(packet.d);
+        } else if (packet.t === "VOICE_STATE_UPDATE") {
+            if (packet.d.user_id !== this.clientId) return;
+            player.connection.setStateUpdate(packet.d);
+        }
+    }
+
+    fetchRegion(region) {
+        const nodesByRegion = [...this.nodeMap.values()]
+            .filter(node => node.connected && node.regions?.includes(region?.toLowerCase()))
+            .sort((a, b) => {
+                const aLoad = a.stats.cpu ? (a.stats.cpu.systemLoad / a.stats.cpu.cores) * 100 : 0;
+                const bLoad = b.stats.cpu ? (b.stats.cpu.systemLoad / b.stats.cpu.cores) * 100 : 0;
+                return aLoad - bLoad;
+            });
+
+        return nodesByRegion;
+    }
+
+    createConnection(options) {
+        if (!this.initiated) throw new Error("BRO! Get aqua on before !!!");
+        if (this.leastUsedNodes.length === 0) throw new Error("No nodes are available");
+        const node = options.region 
+            ? this.fetchRegion(options.region)[0] || this.leastUsedNodes[0]
+            : this.leastUsedNodes[0];
+        if (!node) throw new Error("No nodes are available");
+        return this.createPlayer(node, options);
+    }
+
+    createPlayer(node, options) {
+        const player = new Player(this, node, options);
+        this.players.set(options.guildId, player);
+        player.connect(options);
+
+        this.emit("playerCreate", player);
+        return player;
+    }
+
+    destroyPlayer(guildId) {
+        const player = this.players.get(guildId);
+        if (!player) return;
+
+        player.destroy();
+        this.players.delete(guildId);
+        this.emit("playerDestroy", player);
+    }
+
+    removeConnection(guildId) {
+        const player = this.players.get(guildId);
+        if (player) {
+            player.destroy();
+            this.players.delete(guildId);
+        }
+    }
+
+    async resolve({ query, source, requester, nodes }) {
+        if (!this.initiated) throw new Error("Aqua must be initialized before resolving");
+
+        if (nodes && (typeof nodes !== "string" && !(nodes instanceof Node))) {
+            throw new Error(`'nodes' must be a string or Node instance, but received: ${typeof nodes}`);
+        }
+
+        const searchSources = source || this.defaultSearchPlatform;
+        const requestNode = (typeof nodes === 'string' ? this.nodeMap.get(nodes) : nodes) || this.leastUsedNodes[0];
+
+        if (!requestNode) throw new Error("No nodes are available.");
+
+        const formattedQuery = /^https?:\/\//.test(query) ? query : `${searchSources}:${query}`;
+        let response = await requestNode.rest.makeRequest("GET", `/v4/loadtracks?identifier=${encodeURIComponent(formattedQuery)}`);
+
+        // Fallback attempts if response loadType indicates no matches
+        if (["empty", "NO_MATCHES"].includes(response.loadType)) {
+            response = await this.handleNoMatches(requestNode.rest, query);
+        }
+
+        this.loadTracks(response, requester, requestNode);
+        return this.constructResponse();
+    }
+
+    async handleNoMatches(rest, query) {
+        let response = await rest.makeRequest("GET", `/v4/loadtracks?identifier=https://open.spotify.com/track/${query}`);
+        if (["empty", "NO_MATCHES"].includes(response.loadType)) {
+            response = await rest.makeRequest("GET", `/v4/loadtracks?identifier=https://www.youtube.com/watch?v=${query}`);
+        }
+        return 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));
+        }
+
+        this.loadType = response.loadType;
+        this.pluginInfo = response.pluginInfo || {};
+    }
+
+    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()] : [],
+        };
+    }
+
+    get(guildId) {
+        const player = this.players.get(guildId);
+        if (!player) throw new Error(`Player not found for guild ID: ${guildId}`);
+        return player;
+    }
+}
+
+module.exports = { Aqua };
+
+

package/build/structures/Connection.js

@@ -0,0 +1,82 @@
+/**
+ * Class representing a player connection.
+ * @param {Player} player The player instance of this connection.
+ */
+class Connection {
+    constructor(player) {
+        this.player = player;
+        this.voice = { sessionId: null, endpoint: null, token: null };
+        this.region = null;
+        this.selfDeaf = false;
+        this.selfMute = false;
+        this.voiceChannel = player.voiceChannel;
+    }
+
+    /**
+     * 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.");
+        }
+        
+        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);
+        }
+
+        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) {
+            this.player.destroy();
+            this.player.aqua.emit("playerDestroy", this.player);
+            return;
+        }
+
+        if (this.player.voiceChannel !== channel_id) {
+            this.player.aqua.emit("playerMove", this.player.voiceChannel, channel_id);
+            this.player.voiceChannel = channel_id;
+            this.voiceChannel = channel_id;
+        }
+
+        this.selfDeaf = self_deaf;
+        this.selfMute = self_mute;
+        this.voice.sessionId = session_id || null;
+
+        this.updatePlayerVoiceData();
+    }
+
+    /**
+     * Updates the player voice data.
+     */
+    updatePlayerVoiceData() {
+        this.player.nodes.rest.updatePlayer({
+            guildId: this.player.guildId,
+            data: {
+                voice: this.voice,
+                volume: this.player.volume
+            }
+        });
+    }
+}
+
+module.exports = { Connection };
+

package/build/structures/Filters.js

@@ -0,0 +1,169 @@
+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;
+    }
+
+    setEqualizer(bands) {
+        this.equalizer = bands;
+        return this.updateFilters();
+    }
+
+    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();
+    }
+
+    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();
+    }
+
+    setTremolo(enabled, options = {}) {
+        this.tremolo = enabled ? {
+            frequency: options.frequency ?? 2.0,
+            depth: options.depth ?? 0.5
+        } : null;
+        return this.updateFilters();
+    }
+
+    setVibrato(enabled, options = {}) {
+        this.vibrato = enabled ? {
+            frequency: options.frequency ?? 2.0,
+            depth: options.depth ?? 0.5
+        } : null;
+        return this.updateFilters();
+    }
+
+    setRotation(enabled, options = {}) {
+        this.rotation = enabled ? {
+            rotationHz: options.rotationHz ?? 0.0
+        } : null;
+        return this.updateFilters();
+    }
+
+    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();
+    }
+
+    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();
+    }
+
+    setLowPass(enabled, options = {}) {
+        this.lowPass = enabled ? {
+            smoothing: options.smoothing ?? 20.0
+        } : null;
+        return this.updateFilters();
+    }
+
+    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
+            })));
+        }
+        this.bassboost = null;
+        return this.setEqualizer([]);
+    }
+
+    setSlowmode(enabled, options = {}) {
+        this.slowmode = enabled;
+        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);
+    }
+
+    setVaporwave(enabled, options = {}) {
+        this.vaporwave = enabled;
+        if (enabled) {
+            return this.setTimescale(true, { pitch: options.pitch ?? 0.5 });
+        }
+        return this.setTimescale(false);
+    }
+
+    set8D(enabled, options = {}) {
+        this._8d = enabled;
+        return this.setRotation(enabled, { rotationHz: enabled ? options.rotationHz ?? 0.2 : 0.0 });
+    }
+
+    async clearFilters() {
+        Object.assign(this, new Filters(this.player));
+        await this.updateFilters();
+        return this;
+    }
+
+    async updateFilters() {
+        const filterData = {
+            volume: this.volume,
+            equalizer: this.equalizer,
+            karaoke: this.karaoke,
+            timescale: this.timescale,
+            tremolo: this.tremolo,
+            vibrato: this.vibrato,
+            rotation: this.rotation,
+            distortion: this.distortion,
+            channelMix: this.channelMix,
+            lowPass: this.lowPass
+        };
+
+        await this.player.nodes.rest.updatePlayer({
+            guildId: this.player.guildId,
+            data: { filters: filterData }
+        });
+
+        return this;
+    }
+}
+
+module.exports =  {Filters}