lavalink-client 1.0.2 → 1.0.4

package/dist/esm/structures/LavalinkManager.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { EventEmitter } from "events";
 import { NodeManager } from "./NodeManager";
-import { QueueChangesWatcher, QueueSaverOptions, StoreManager } from "./Queue";
+import { QueueSaverOptions } from "./Queue";
 import { GuildShardPayload, LavalinkSearchPlatform, ManagerUitls, MiniMap, SearchPlatform, TrackEndEvent, TrackExceptionEvent, TrackStartEvent, TrackStuckEvent, VoicePacket, VoiceServer, VoiceState, WebSocketClosedEvent } from "./Utils";
 import { LavalinkNodeOptions } from "./Node";
 import { DestroyReasonsType, Player, PlayerOptions } from "./Player";
@@ -18,26 +18,37 @@ export interface BotClientOptions {
     [x: string | number | symbol | undefined]: any;
 }
 export interface LavalinkPlayerOptions {
+    /** If the Lavalink Volume should be decremented by x number */
     volumeDecrementer?: number;
-    clientBasedUpdateInterval?: number;
+    /** How often it should update the the player Position */
+    clientBasedPositionUpdateInterval?: number;
+    /** What should be used as a searchPlatform, if no source was provided during the query */
     defaultSearchPlatform?: SearchPlatform;
+    /** Applies the volume via a filter, not via the lavalink volume transformer */
     applyVolumeAsFilter?: boolean;
+    /** Transforms the saved data of a requested user */
+    requesterTransformer?: (requester: unknown) => unknown;
+    /** What lavalink-client should do when the player reconnects */
     onDisconnect?: {
+        /** Try to reconnect? -> If fails -> Destroy */
         autoReconnect?: boolean;
+        /** Instantly destroy player (overrides autoReconnect) */
         destroyPlayer?: boolean;
     };
     onEmptyQueue?: {
+        /** Get's executed onEmptyQueue -> You can do any track queue previous transformations, if you add a track to the queue -> it will play it, if not queueEnd will execute! */
+        autoPlayFunction?: (player: Player, lastPlayedTrack: Track) => Promise<void>;
         destroyAfterMs?: number;
     };
 }
 export interface ManagerOptions {
     nodes: LavalinkNodeOptions[];
     queueOptions?: QueueSaverOptions;
-    queueStore?: StoreManager;
-    queueChangesWatcher?: QueueChangesWatcher;
     client?: BotClientOptions;
     playerOptions?: LavalinkPlayerOptions;
     autoSkip?: boolean;
+    defaultLeastUsedNodeSortType?: "memory" | "calls" | "players";
+    defaultLeastLoadNodeSortType?: "cpu" | "memory";
     /** @async */
     sendToShard: (guildId: string, payload: GuildShardPayload) => void;
 }

package/dist/esm/structures/LavalinkManager.js

@@ -10,36 +10,97 @@ export class LavalinkManager extends EventEmitter {
     initiated = false;
     players = new MiniMap();
     applyDefaultOptions() {
+        if (!this.options.playerOptions)
+            this.options.playerOptions = {
+                applyVolumeAsFilter: false,
+                clientBasedPositionUpdateInterval: 100,
+                defaultSearchPlatform: "ytsearch",
+                onDisconnect: {
+                    destroyPlayer: true,
+                    autoReconnect: false
+                },
+                onEmptyQueue: {
+                    autoPlayFunction: null,
+                    destroyAfterMs: undefined
+                },
+                requesterTransformer: (requester) => {
+                    // if it's already the transformed requester
+                    if (typeof requester === "object" && "avatar" in requester && Object.keys(requester).length === 3)
+                        return requester;
+                    // if it's still a discord.js User
+                    if (typeof requester === "object" && "displayAvatarURL" in requester) { // it's a user
+                        return {
+                            id: requester.id,
+                            username: requester.username,
+                            avatar: requester.displayAvatarURL(),
+                        };
+                    }
+                    // if it's non of the above
+                    return { id: requester.toString(), username: "unknown" }; // reteurn something that makes sense for you!
+                },
+                volumeDecrementer: 1
+            };
+        if (!this.options.autoSkip)
+            this.options.autoSkip = true;
+        if (!this.options.defaultLeastLoadNodeSortType)
+            this.options.defaultLeastLoadNodeSortType = "memory";
+        if (!this.options.defaultLeastUsedNodeSortType)
+            this.options.defaultLeastUsedNodeSortType = "players";
         if (!this.options.playerOptions.defaultSearchPlatform)
             this.options.playerOptions.defaultSearchPlatform = "ytsearch";
+        // default queue options
+        if (!this.options.queueOptions)
+            this.options.queueOptions = {
+                maxPreviousTracks: 25,
+                queueChangesWatcher: null,
+                queueStore: new DefaultQueueStore()
+            };
         if (typeof this.options?.queueOptions?.maxPreviousTracks !== "number" || this.options.queueOptions.maxPreviousTracks < 0)
             this.options.queueOptions.maxPreviousTracks = 25;
         return;
     }
     validateAndApply(options) {
+        if (typeof options.sendToShard !== "function")
+            throw new SyntaxError("ManagerOption.sendToShard was not provided, which is required!");
+        // only check in .init()
+        // if(typeof options.client !== "object" || typeof options.client.id !== "string") throw new SyntaxError("ManagerOption.client = { id: string, username?:string, shards?: 'auto'|number } was not provided, which is required");
+        if (options.autoSkip && typeof options.autoSkip !== "boolean")
+            throw new SyntaxError("ManagerOption.autoSkip must be either false | true aka boolean");
+        if (options.defaultLeastLoadNodeSortType && !["memory", "cpu"].includes(options.defaultLeastLoadNodeSortType))
+            throw new SyntaxError("ManagerOption.defaultLeastLoadNodeSortType must be 'memory' | 'cpu'");
+        if (options.defaultLeastUsedNodeSortType && !["memory", "players", "calls"].includes(options.defaultLeastUsedNodeSortType))
+            throw new SyntaxError("ManagerOption.defaultLeastLoadNodeSortType must be 'memory' | 'calls' | 'players'");
+        if (!options.nodes || !Array.isArray(options.nodes) || !options.nodes.every(node => this.utils.isNodeOptions(node)))
+            throw new SyntaxError("ManagerOption.nodes must be an Array of NodeOptions and is required of at least 1 Node");
         /* QUEUE STORE */
-        if (options.queueStore) {
-            const keys = Object.getOwnPropertyNames(Object.getPrototypeOf(options.queueStore));
+        if (options.queueOptions?.queueStore) {
+            const keys = Object.getOwnPropertyNames(Object.getPrototypeOf(options.queueOptions?.queueStore));
             const requiredKeys = ["get", "set", "stringify", "parse", "delete"];
-            if (!requiredKeys.every(v => keys.includes(v)) || !requiredKeys.every(v => typeof options.queueStore[v] === "function"))
-                throw new SyntaxError(`The provided QueueStore, does not have all required functions: ${requiredKeys.join(", ")}`);
+            if (!requiredKeys.every(v => keys.includes(v)) || !requiredKeys.every(v => typeof options.queueOptions?.queueStore[v] === "function"))
+                throw new SyntaxError(`The provided ManagerOption.QueueStore, does not have all required functions: ${requiredKeys.join(", ")}`);
         }
         else
-            this.options.queueStore = new DefaultQueueStore();
+            this.options.queueOptions.queueStore = new DefaultQueueStore();
+        /* QUEUE WATCHER */
+        if (options.queueOptions?.queueChangesWatcher) {
+            const keys = Object.getOwnPropertyNames(Object.getPrototypeOf(options.queueOptions?.queueChangesWatcher));
+            const requiredKeys = ["tracksAdd", "tracksRemoved", "shuffled"];
+            if (!requiredKeys.every(v => keys.includes(v)) || !requiredKeys.every(v => typeof options.queueOptions?.queueChangesWatcher[v] === "function"))
+                throw new SyntaxError(`The provided ManagerOption.QueueChangesWatcher, does not have all required functions: ${requiredKeys.join(", ")}`);
+        }
     }
     constructor(options) {
         super();
+        if (!options)
+            throw new SyntaxError("No Manager Options Provided");
         // create options
-        this.options = {
-            autoSkip: true,
-            ...options
-        };
+        this.options = options;
+        this.utils = new ManagerUitls(this);
         // use the validators
-        this.applyDefaultOptions();
         this.validateAndApply(options);
+        this.applyDefaultOptions();
         // create classes
         this.nodeManager = new NodeManager(this);
-        this.utils = new ManagerUitls(this);
     }
     createPlayer(options) {
         if (this.players.has(options.guildId))

package/dist/esm/structures/LavalinkManagerStatics.js

@@ -37,6 +37,7 @@ export const DefaultSources = {
     // speak PLUGIN
     "speak": "speak",
     "tts": "tts",
+    "ftts": "ftts"
 };
 export const SourceLinksRegexes = {
     /** DEFAULT SUPPORTED BY LAVALINK */

package/dist/esm/structures/Node.js

@@ -149,7 +149,7 @@ export class LavalinkNode {
     }
     /** Get the id of the node */
     get id() {
-        return this.options.id || this.options.host;
+        return this.options.id || `${this.options.host}:${this.options.port}`;
     }
     /**
      * Destroys the Node-Connection (Websocket) and all player's of the node
@@ -445,15 +445,15 @@ export class LavalinkNode {
                 player.ping.ws = payload.state.ping >= 0 ? payload.state.ping : player.ping.ws <= 0 && player.connected ? null : player.ping.ws || 0;
                 if (!player.createdTimeStamp && payload.state.time)
                     player.createdTimeStamp = payload.state.time;
-                if (typeof this.NodeManager.LavalinkManager.options.playerOptions.clientBasedUpdateInterval === "number" && this.NodeManager.LavalinkManager.options.playerOptions.clientBasedUpdateInterval >= 10) {
+                if (typeof this.NodeManager.LavalinkManager.options.playerOptions.clientBasedPositionUpdateInterval === "number" && this.NodeManager.LavalinkManager.options.playerOptions.clientBasedPositionUpdateInterval >= 10) {
                     player.set("internal_updateInterval", setInterval(() => {
-                        player.position += this.NodeManager.LavalinkManager.options.playerOptions.clientBasedUpdateInterval || 250;
+                        player.position += this.NodeManager.LavalinkManager.options.playerOptions.clientBasedPositionUpdateInterval || 250;
                         if (player.filterManager.filterUpdatedState >= 1) {
                             player.filterManager.filterUpdatedState++;
                             const maxMins = 8;
                             const currentDuration = player.queue.current?.info?.duration || 0;
                             if (currentDuration <= maxMins * 6e4 || isAbsolute(player.queue.current?.info?.uri)) {
-                                if (player.filterManager.filterUpdatedState >= ((this.NodeManager.LavalinkManager.options.playerOptions.clientBasedUpdateInterval || 250) > 400 ? 2 : 3)) {
+                                if (player.filterManager.filterUpdatedState >= ((this.NodeManager.LavalinkManager.options.playerOptions.clientBasedPositionUpdateInterval || 250) > 400 ? 2 : 3)) {
                                     player.filterManager.filterUpdatedState = 0;
                                     player.seek(player.position);
                                 }
@@ -462,7 +462,7 @@ export class LavalinkNode {
                                 player.filterManager.filterUpdatedState = 0;
                             }
                         }
-                    }, this.NodeManager.LavalinkManager.options.playerOptions.clientBasedUpdateInterval || 250));
+                    }, this.NodeManager.LavalinkManager.options.playerOptions.clientBasedPositionUpdateInterval || 250));
                 }
                 else {
                     if (player.filterManager.filterUpdatedState >= 1) { // if no interval but instafix available, findable via the "filterUpdatedState" property
@@ -527,14 +527,14 @@ export class LavalinkNode {
             return this.NodeManager.LavalinkManager.emit("trackEnd", player, track, payload);
         // If a track had an error while starting
         if (["loadFailed", "cleanup"].includes(payload.reason)) {
-            await queueTrackEnd(player.queue);
+            await queueTrackEnd(player.queue, false);
             // if no track available, end queue
             if (!player.queue.current)
                 return this.queueEnd(player, track, payload);
             // fire event
             this.NodeManager.LavalinkManager.emit("trackEnd", player, track, payload);
             // play track if autoSkip is true
-            return this.NodeManager.LavalinkManager.options.autoSkip && player.play({ track: player.queue.current, noReplace: true });
+            return this.NodeManager.LavalinkManager.options.autoSkip && player.play({ noReplace: true });
         }
         // remove tracks from the queue
         if (player.repeatMode !== "track")
@@ -545,11 +545,18 @@ export class LavalinkNode {
         // fire event
         this.NodeManager.LavalinkManager.emit("trackEnd", player, track, payload);
         // play track if autoSkip is true
-        return this.NodeManager.LavalinkManager.options.autoSkip && player.play({ track: player.queue.current, noReplace: true });
+        return this.NodeManager.LavalinkManager.options.autoSkip && player.play({ noReplace: true });
     }
     async queueEnd(player, track, payload) {
         player.queue.current = null;
         player.playing = false;
+        if (typeof this.NodeManager.LavalinkManager.options?.playerOptions?.onEmptyQueue?.autoPlayFunction === "function") {
+            await this.NodeManager.LavalinkManager.options?.playerOptions?.onEmptyQueue?.autoPlayFunction(player, track);
+            if (player.queue.tracks.length > 0)
+                await queueTrackEnd(player.queue, player.repeatMode === "queue");
+            if (player.queue.current)
+                return player.play({ noReplace: true, paused: false });
+        }
         if (payload?.reason !== "stopped") {
             await player.queue.utils.save();
         }
@@ -579,7 +586,7 @@ export class LavalinkNode {
         if (!player.queue.current)
             return this.queueEnd(player, track, payload);
         // play track if autoSkip is true
-        return (this.NodeManager.LavalinkManager.options.autoSkip && player.queue.current) && player.play({ track: player.queue.current, noReplace: true });
+        return (this.NodeManager.LavalinkManager.options.autoSkip && player.queue.current) && player.play({ noReplace: true });
     }
     async trackError(player, track, payload) {
         this.NodeManager.LavalinkManager.emit("trackError", player, track, payload);
@@ -589,7 +596,7 @@ export class LavalinkNode {
         if (!player.queue.current)
             return this.queueEnd(player, track, payload);
         // play track if autoSkip is true
-        return (this.NodeManager.LavalinkManager.options.autoSkip && player.queue.current) && player.play({ track: player.queue.current, noReplace: true });
+        return (this.NodeManager.LavalinkManager.options.autoSkip && player.queue.current) && player.play({ noReplace: true });
     }
     socketClosed(player, payload) {
         return this.NodeManager.LavalinkManager.emit("playerSocketClosed", player, payload);

package/dist/esm/structures/NodeManager.d.ts

@@ -56,6 +56,17 @@ export declare class NodeManager extends EventEmitter {
     constructor(LavalinkManager: LavalinkManager);
     createNode(options: LavalinkNodeOptions): LavalinkNode;
     get leastUsedNodes(): LavalinkNode[];
+    /** Returns the least used Nodes sorted by amount of calls. */
+    private get leastUsedNodesCalls();
+    /** Returns the least used Nodes sorted by amount of players. */
+    private get leastUsedNodesPlayers();
+    /** Returns the least used Nodes sorted by amount of memory usage. */
+    private get leastUsedNodesMemory();
+    /** Returns the least system load Nodes. */
+    get leastLoadNodes(): LavalinkNode[];
+    get leastLoadNodesMemory(): LavalinkNode[];
+    /** Returns the least system load Nodes. */
+    get leastLoadNodesCpu(): LavalinkNode[];
     deleteNode(node: LavalinkNodeIdentifier | LavalinkNode): void;
 }
 export {};

package/dist/esm/structures/NodeManager.js

@@ -11,14 +11,71 @@ export class NodeManager extends EventEmitter {
             this.LavalinkManager.options.nodes.forEach(node => this.createNode(node));
     }
     createNode(options) {
-        if (this.nodes.has(options.id || options.host))
-            return this.nodes.get(options.id || options.host);
+        if (this.nodes.has(options.id || `${options.host}:${options.port}`))
+            return this.nodes.get(options.id || `${options.host}:${options.port}`);
         const newNode = new LavalinkNode(options, this);
         this.nodes.set(newNode.id, newNode);
         return newNode;
     }
     get leastUsedNodes() {
-        return [...this.nodes.values()].filter(v => v);
+        if (this.LavalinkManager.options.defaultLeastUsedNodeSortType === "memory")
+            return this.leastUsedNodesMemory;
+        else if (this.LavalinkManager.options.defaultLeastUsedNodeSortType === "calls")
+            return this.leastUsedNodesCalls;
+        else
+            return this.leastUsedNodesPlayers; // this.options.defaultLeastUsedNodeSortType === "players"
+    }
+    /** Returns the least used Nodes sorted by amount of calls. */
+    get leastUsedNodesCalls() {
+        return [...this.nodes.values()]
+            .filter((node) => node.connected)
+            .sort((a, b) => b.calls - a.calls); // client sided sorting
+    }
+    /** Returns the least used Nodes sorted by amount of players. */
+    get leastUsedNodesPlayers() {
+        return [...this.nodes.values()]
+            .filter((node) => node.connected)
+            .sort((a, b) => (a.stats?.players || 0) - (b.stats?.players || 0));
+    }
+    /** Returns the least used Nodes sorted by amount of memory usage. */
+    get leastUsedNodesMemory() {
+        return [...this.nodes.values()]
+            .filter((node) => node.connected)
+            .sort((a, b) => (b.stats?.memory?.used || 0) - (a.stats?.memory?.used || 0)); // sort after memory
+    }
+    /** Returns the least system load Nodes. */
+    get leastLoadNodes() {
+        if (this.LavalinkManager.options.defaultLeastLoadNodeSortType === "cpu")
+            return this.leastLoadNodesCpu;
+        else
+            return this.leastLoadNodesMemory; // this.options.defaultLeastLoadNodeSortType === "memory"
+    }
+    get leastLoadNodesMemory() {
+        return [...this.nodes.values()]
+            .filter((node) => node.connected)
+            .sort((a, b) => {
+            const aload = a.stats.memory?.used
+                ? a.stats.memory.used
+                : 0;
+            const bload = b.stats.memory?.used
+                ? b.stats.memory.used
+                : 0;
+            return aload - bload;
+        });
+    }
+    /** Returns the least system load Nodes. */
+    get leastLoadNodesCpu() {
+        return [...this.nodes.values()]
+            .filter((node) => node.connected)
+            .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;
+        });
     }
     deleteNode(node) {
         const decodeNode = typeof node === "string" ? this.nodes.get(node) : node || this.leastUsedNodes[0];

package/dist/esm/structures/Player.js

@@ -63,7 +63,9 @@ export class Player {
         this.guildId = this.options.guildId;
         this.voiceChannelId = this.options.voiceChannelId;
         this.textChannelId = this.options.textChannelId || null;
-        this.node = this.LavalinkManager.nodeManager.leastUsedNodes.filter(v => options.vcRegion ? v.options?.regions?.includes(options.vcRegion) : true)[0] || this.LavalinkManager.nodeManager.leastUsedNodes[0] || null;
+        this.node = typeof this.options.node === "string" ? this.LavalinkManager.nodeManager.nodes.get(this.options.node) : this.options.node;
+        if (!this.node || typeof this.node?.request !== "function")
+            this.node = this.LavalinkManager.nodeManager.leastUsedNodes.filter(v => options.vcRegion ? v.options?.regions?.includes(options.vcRegion) : true)[0] || this.LavalinkManager.nodeManager.leastUsedNodes[0] || null;
         if (!this.node)
             throw new Error("No available Node was found, please add a LavalinkNode to the Manager via Manager.NodeManager#createNode");
         if (this.LavalinkManager.options.playerOptions.volumeDecrementer)
@@ -71,7 +73,7 @@ export class Player {
         this.LavalinkManager.emit("playerCreate", this);
         if (typeof options.volume === "number" && !isNaN(options.volume))
             this.setVolume(options.volume);
-        this.queue = new Queue(this.guildId, {}, new QueueSaver(this.LavalinkManager.options.queueStore, this.LavalinkManager.options.queueOptions), this.LavalinkManager.options.queueChangesWatcher);
+        this.queue = new Queue(this.guildId, {}, new QueueSaver(this.LavalinkManager.options.queueOptions), this.LavalinkManager.options.queueOptions);
     }
     /**
      * Set custom data.
@@ -200,8 +202,9 @@ export class Player {
             Query.source = DefaultSources[foundSource]; // set the source to ytsearch:
             Query.query = Query.query.replace(`${foundSource}:`, ""); // remove ytsearch: from the query
         }
-        // request the data
-        const res = await this.node.request(`/loadtracks?identifier=${!/^https?:\/\//.test(Query.query) ? `${Query.source}:` : ""}${encodeURIComponent(Query.query)}`);
+        // ftts query parameters: ?voice=Olivia&audio_format=ogg_opus&translate=False&silence=1000&speed=1.0 | example raw get query: https://api.flowery.pw/v1/tts?voice=Olivia&audio_format=ogg_opus&translate=False&silence=0&speed=1.0&text=Hello%20World
+        // request the data 
+        const res = await this.node.request(`/loadtracks?identifier=${!/^https?:\/\//.test(Query.query) ? `${Query.source}:${Query.source === "ftts" ? "//" : ""}` : ""}${encodeURIComponent(Query.query)}`);
         // transform the data which can be Error, Track or Track[] to enfore [Track] 
         const resTracks = res.loadType === "playlist" ? res.data?.tracks : res.loadType === "track" ? [res.data] : res.loadType === "search" ? Array.isArray(res.data) ? res.data : [res.data] : [];
         return {

package/dist/esm/structures/Queue.d.ts

@@ -18,6 +18,8 @@ export interface StoreManager extends Record<any, any> {
 }
 export interface QueueSaverOptions {
     maxPreviousTracks: number;
+    queueStore?: StoreManager;
+    queueChangesWatcher?: QueueChangesWatcher;
 }
 export interface QueueSaver {
     /** @private */
@@ -26,7 +28,7 @@ export interface QueueSaver {
     options: QueueSaverOptions;
 }
 export declare class QueueSaver {
-    constructor(storeManager: StoreManager, options: QueueSaverOptions);
+    constructor(options: QueueSaverOptions);
     get(guildId: string): Promise<Partial<StoredQueue>>;
     delete(guildId: string): Promise<any>;
     set(guildId: string, value: any): Promise<any>;
@@ -59,7 +61,7 @@ export declare class Queue {
     static readonly StaticSymbol: Symbol;
     private managerUtils;
     private queueChanges;
-    constructor(guildId: string, data?: Partial<StoredQueue>, QueueSaver?: QueueSaver, queueChangesWatcher?: QueueChangesWatcher);
+    constructor(guildId: string, data?: Partial<StoredQueue>, QueueSaver?: QueueSaver, queueOptions?: QueueSaverOptions);
     /**
      * Utils for a Queue
      */

package/dist/esm/structures/Queue.js

@@ -1,8 +1,10 @@
 import { ManagerUitls, QueueSymbol } from "./Utils";
 export class QueueSaver {
-    constructor(storeManager, options) {
-        this._ = storeManager;
-        this.options = options;
+    constructor(options) {
+        this._ = options.queueStore || new DefaultQueueStore();
+        this.options = {
+            maxPreviousTracks: options.maxPreviousTracks
+        };
     }
     async get(guildId) {
         return await this._.parse(await this._.get(guildId));
@@ -60,15 +62,14 @@ export class Queue {
     static StaticSymbol = QueueSymbol;
     managerUtils = new ManagerUitls();
     queueChanges;
-    constructor(guildId, data = {}, QueueSaver, queueChangesWatcher) {
-        this.queueChanges = queueChangesWatcher || null;
+    constructor(guildId, data = {}, QueueSaver, queueOptions) {
+        this.queueChanges = queueOptions.queueChangesWatcher || null;
         this.guildId = guildId;
         this.QueueSaver = QueueSaver;
         this.options.maxPreviousTracks = this.QueueSaver?.options?.maxPreviousTracks ?? this.options.maxPreviousTracks;
         this.current = this.managerUtils.isTrack(data.current) ? data.current : null;
         this.previous = Array.isArray(data.previous) && data.previous.some(track => this.managerUtils.isTrack(track)) ? data.previous.filter(track => this.managerUtils.isTrack(track)) : [];
         this.tracks = Array.isArray(data.tracks) && data.tracks.some(track => this.managerUtils.isTrack(track)) ? data.tracks.filter(track => this.managerUtils.isTrack(track)) : [];
-        this.utils.sync(false, true);
     }
     /**
      * Utils for a Queue

package/dist/esm/structures/Track.d.ts

@@ -1,4 +1,7 @@
 import { Base64 } from "./Utils";
+type LavalinkSourceNames = "youtube" | "youtubemusic" | "soundcloud" | "bandcamp" | "twitch";
+type LavalinkPlugin_LavaSrc_SourceNames = "deezer" | "spotify" | "applemusic" | "yandexmusic" | "flowery-tts";
+type SourceNames = LavalinkSourceNames | LavalinkPlugin_LavaSrc_SourceNames;
 export interface TrackInfo {
     identifier: string;
     title: string;
@@ -6,7 +9,7 @@ export interface TrackInfo {
     duration: number;
     artworkUrl: string | null;
     uri: string;
-    sourceName: string;
+    sourceName: SourceNames;
     isSeekable: boolean;
     isStream: boolean;
     isrc: string | null;
@@ -24,6 +27,10 @@ export interface PluginInfo {
     url?: string;
     /** The Url provided by a Plugin */
     uri?: string;
+    /** You can put specific track information here, to transform the tracks... */
+    clientData?: {
+        [key: string]: any;
+    };
 }
 export interface LavalinkTrack {
     /** The Base 64 encoded String */
@@ -45,3 +52,4 @@ export interface UnresolvedQuery {
     /** The Track's Requester */
     requester?: unknown;
 }
+export {};

package/dist/esm/structures/Utils.d.ts

@@ -1,6 +1,6 @@
 import { LavalinkFilterData } from "./Filters";
 import { LavalinkManager } from "./LavalinkManager";
-import { LavalinkNode, NodeStats } from "./Node";
+import { LavalinkNode, LavalinkNodeOptions, NodeStats } from "./Node";
 import { PlayOptions } from "./Player";
 import { Queue } from "./Queue";
 import { PluginInfo, Track } from "./Track";
@@ -8,7 +8,7 @@ export declare const TrackSymbol: unique symbol;
 export declare const UnresolvedTrackSymbol: unique symbol;
 export declare const QueueSymbol: unique symbol;
 export declare const NodeSymbol: unique symbol;
-export type LavalinkSearchPlatform = "ytsearch" | "ytmsearch" | "scsearch" | "spsearch" | "sprec" | "amsearch" | "dzsearch" | "dzisrc" | "sprec" | "ymsearch" | "speak" | "tts";
+export type LavalinkSearchPlatform = "ytsearch" | "ytmsearch" | "scsearch" | "spsearch" | "sprec" | "amsearch" | "dzsearch" | "dzisrc" | "sprec" | "ymsearch" | "speak" | "tts" | "ftts";
 export type ClientSearchPlatform = "youtube" | "yt" | "yt" | "youtube music" | "youtubemusic" | "ytm" | "soundcloud" | "sc" | "am" | "apple music" | "applemusic" | "apple" | "yandex music" | "sp" | "sprec" | "spsuggestion" | "spotify" | "dz" | "deezer" | "yandex" | "yandexmusic";
 export type SearchPlatform = LavalinkSearchPlatform | ClientSearchPlatform;
 export type SourcesRegex = "YoutubeRegex" | "YoutubeMusicRegex" | "SoundCloudRegex" | "SoundCloudMobileRegex" | "DeezerTrackRegex" | "DeezerArtistRegex" | "DeezerEpisodeRegex" | "DeezerMixesRegex" | "DeezerPageLinkRegex" | "DeezerPlaylistRegex" | "DeezerAlbumRegex" | "AllDeezerRegex" | "AllDeezerRegexWithoutPageLink" | "SpotifySongRegex" | "SpotifyPlaylistRegex" | "SpotifyArtistRegex" | "SpotifyEpisodeRegex" | "SpotifyShowRegex" | "SpotifyAlbumRegex" | "AllSpotifyRegex" | "mp3Url" | "m3uUrl" | "m3u8Url" | "mp4Url" | "m4aUrl" | "wavUrl" | "aacpUrl" | "tiktok" | "mixcloud" | "musicYandex" | "radiohost" | "bandcamp" | "appleMusic" | "TwitchTv" | "vimeo";
@@ -40,10 +40,20 @@ export interface ManagerUitls {
 export declare class ManagerUitls {
     constructor(LavalinkManager?: LavalinkManager);
     buildTrack(data: any, requester: any): Track;
+    /**
+     * Validate if a data is equal to a node
+     * @param data
+     */
+    isNode(data: LavalinkNode): boolean;
+    /**
+     * Validate if a data is equal to node options
+     * @param data
+     */
+    isNodeOptions(data: LavalinkNodeOptions | any): boolean;
     /**
      * Validate if a data is euqal to a track
-     * @param {Track|any} data the Track to validate
-     * @returns {boolean}
+     * @param data the Track to validate
+     * @returns
      */
     isTrack(data: Track | any): boolean;
     validatedQuery(queryString: string, node: LavalinkNode): void;
@@ -85,6 +95,8 @@ export declare class MiniMap<K, V> extends Map<K, V> {
     filter<This, K2 extends K>(fn: (this: This, value: V, key: K, miniMap: this) => key is K2, thisArg: This): MiniMap<K2, V>;
     filter<This, V2 extends V>(fn: (this: This, value: V, key: K, miniMap: this) => value is V2, thisArg: This): MiniMap<K, V2>;
     filter<This>(fn: (this: This, value: V, key: K, miniMap: this) => boolean, thisArg: This): MiniMap<K, V>;
+    toJSON(): V[];
+    private static defaultSort;
     /**
      * Maps each item to another value into an array. Identical in behavior to
      * [Array.map()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map).

package/dist/esm/structures/Utils.js

@@ -29,7 +29,7 @@ export class ManagerUitls {
                     isrc: data.info?.isrc,
                 },
                 pluginInfo: data.pluginInfo || data.plugin || {},
-                requester: data?.requester || requester,
+                requester: typeof this.manager.options?.playerOptions?.requesterTransformer === "function" ? this.manager.options?.playerOptions?.requesterTransformer(data?.requester || requester) : requester,
             };
             Object.defineProperty(r, TrackSymbol, { configurable: true, value: true });
             return r;
@@ -38,10 +38,58 @@ export class ManagerUitls {
             throw new RangeError(`Argument "data" is not a valid track: ${error.message}`);
         }
     }
+    /**
+     * Validate if a data is equal to a node
+     * @param data
+     */
+    isNode(data) {
+        if (!data)
+            return false;
+        const keys = Object.getOwnPropertyNames(Object.getPrototypeOf(data));
+        if (!keys.includes("constructor"))
+            return false;
+        if (!keys.length)
+            return false;
+        // all required functions
+        if (!["connect", "destroy", "destroyPlayer", "fetchAllPlayers", "fetchInfo", "fetchPlayer", "fetchStats", "fetchVersion", "request", "updatePlayer", "updateSession"].every(v => keys.includes(v)))
+            return false;
+        return true;
+    }
+    /**
+     * Validate if a data is equal to node options
+     * @param data
+     */
+    isNodeOptions(data) {
+        if (!data || typeof data !== "object" || Array.isArray(data))
+            return false;
+        if (typeof data.host !== "string" || !data.host.length)
+            return false;
+        if (typeof data.port !== "number" || isNaN(data.port) || data.port < 0 || data.port > 65535)
+            return false;
+        if (typeof data.authorization !== "string" || !data.authorization.length)
+            return false;
+        if ("secure" in data && typeof data.secure !== "boolean")
+            return false;
+        if ("sessionId" in data && typeof data.sessionId !== "string")
+            return false;
+        if ("id" in data && typeof data.id !== "string")
+            return false;
+        if ("regions" in data && (!Array.isArray(data.regions) || !data.regions.every(v => typeof v === "string")))
+            return false;
+        if ("poolOptions" in data && typeof data.poolOptions !== "object")
+            return false;
+        if ("retryAmount" in data && (typeof data.retryAmount !== "number" || isNaN(data.retryAmount) || data.retryAmount <= 0))
+            return false;
+        if ("retryDelay" in data && (typeof data.retryDelay !== "number" || isNaN(data.retryDelay) || data.retryDelay <= 0))
+            return false;
+        if ("requestTimeout" in data && (typeof data.requestTimeout !== "number" || isNaN(data.requestTimeout) || data.requestTimeout <= 0))
+            return false;
+        return true;
+    }
     /**
      * Validate if a data is euqal to a track
-     * @param {Track|any} data the Track to validate
-     * @returns {boolean}
+     * @param data the Track to validate
+     * @returns
      */
     isTrack(data) {
         return typeof data?.encoded === "string" && typeof data?.info === "object";
@@ -118,6 +166,10 @@ export class ManagerUitls {
         if (source === "tts" && !node.info.sourceManagers.includes("tts")) {
             throw new Error("Lavalink Node has not 'tts' enabled, which is required to have 'tts' work");
         }
+        if (source === "ftts" && !node.info.sourceManagers.includes("ftts")) {
+            console.log(node.info.sourceManagers);
+            throw new Error("Lavalink Node has not 'ftts' enabled, which is required to have 'ftts' work");
+        }
         if (source === "ymsearch" && !node.info.sourceManagers.includes("yandexmusic")) {
             throw new Error("Lavalink Node has not 'yandexmusic' enabled, which is required to have 'ymsearch' work");
         }
@@ -144,6 +196,13 @@ export class MiniMap extends Map {
         }
         return results;
     }
+    toJSON() {
+        // toJSON is called recursively by JSON.stringify.
+        return [...this.values()];
+    }
+    static defaultSort(firstValue, secondValue) {
+        return Number(firstValue > secondValue) || Number(firstValue === secondValue) - 1;
+    }
     map(fn, thisArg) {
         if (typeof thisArg !== 'undefined')
             fn = fn.bind(thisArg);
@@ -161,11 +220,11 @@ export async function queueTrackEnd(queue, addBackToQueue = false) {
         if (queue.previous.length > queue.options.maxPreviousTracks)
             queue.previous.splice(queue.options.maxPreviousTracks, queue.previous.length);
     }
-    // change the current Track to the next upcoming one
-    queue.current = queue.tracks.shift() || null;
     // and if repeatMode == queue, add it back to the queue!
     if (addBackToQueue && queue.current)
         queue.tracks.push(queue.current);
+    // change the current Track to the next upcoming one
+    queue.current = queue.tracks.shift() || null;
     // save it in the DB
     await queue.utils.save();
     // return the new current Track

package/dist/structures/LavalinkManager.d.ts

@@ -17,7 +17,7 @@ export interface BotClientOptions {
 }
 export interface LavalinkPlayerOptions {
     volumeDecrementer?: number;
-    clientBasedUpdateInterval?: number;
+    clientBasedPositionUpdateInterval?: number;
     defaultSearchPlatform?: SearchPlatform;
     applyVolumeAsFilter?: boolean;
 }