lavalink-client 1.0.4 → 1.0.6

package/README.md

@@ -1,17 +1,43 @@
-# lavalink-client
-Easy and advanced lavalink client. Use it with lavalink plugins as well as latest lavalink versions
+# Lavalink Client
+Easy and advanced lavalink client. Use it with lavalink plugins as well as latest lavalink versions.
 
 # Install
 
 Latest stable Version: (currently, unreleased)
-```
+
+<details><summary>👉 via NPM</summary>
+
+```bash
 npm install --save lavalink-client
 ```
+
+
 Dev Version: (Current)
-```
+
+```bash
 npm install tomato6966/lavalink-client
 ```
 
+</details>
+
+<details><summary>👉 via YARN</summary>
+
+```bash
+yarn add lavalink-client
+```
+
+Dev Version: (Current)
+
+```bash
+yarn add tomato6966/lavalink-client
+```
+
+</details>
+
+# Documentation
+
+Check out the [Documentation](https://lc4.gitbook.io/lavalink-client) for **Examples**, and **__detailled__ Docs**, and to figure out **how to get started**. *note: it's not fully done yet (see the docs)*
+
 # Features
 
 - 💯 Lavalink v4 Supported only (with Lavalink Plugins)
@@ -21,6 +47,8 @@ npm install tomato6966/lavalink-client
 
 - ✨ Choose able queue stores (maps, collections, redis, databases, ...)
   - You can create your own queueStore, thus make it easy to sync queues accross multiple connections (e.g. dashboard-bot)
+  - Automated Queue Sync methods 
+  - Automated unresolveable Tracks (save the queries as Partial Track Objects -> Fetch the tracks only once they are gonna play)
 
 - 😍 Included Filter & Equalizer Management
 
@@ -41,98 +69,5 @@ npm install tomato6966/lavalink-client
   - Destroys the player on channeldelete
   - Pauses / resumes the player if it get's muted / unmuted (server-wide) [soon]
   - ...
-- 😁 Much much more!
-
-# Documentation
-
-*soon*
-
-# How to Use
-
-1. Import the Manager
-
-```ts
-import { LavalinkManager } from "lavalink-client"; // Modular JS  /  Typescript
-```
-
-```js
-const { LavalinkManager } = require("lavalink-client"); // Common Js
-```
-
-2. create the Manager
-
-```ts
-// Suggest it to extend it to the bot Client
-client.lavalink = new LavalinkManager({
-    nodes: [
-        {
-            authorization: "youshallnotpass",
-            host: "localhost",
-            port: 2333,
-            id: "testnode",
-            requestTimeout: 10000,
-        }
-    ],
-    sendToShard: (guildId, payload) => client.guilds.cache.get(guildId)?.shard?.send(payload),
-    autoSkip: true,
-    client: {
-        id: envConfig.clientId,
-        username: "TESTBOT",
-        shards: "auto"
-    },
-    playerOptions: {
-        applyVolumeAsFilter: false,
-        clientBasedUpdateInterval: 50,
-        defaultSearchPlatform: "dzsearch",
-        volumeDecrementer: 0.7
-    },
-    queueOptions: {
-        maxPreviousTracks: 5
-    },
-    // queueStore: new myCustomStore(client.redis), // OPTIONAL! 'class myCustomStore extends DefaultQueueStore' --> for custom queue stores, e.g. redis, etc. | default is lavalink-client#MiniMap
-    // queueChangesWatcher: new myCustomWatcher(), // OPTIONAL! 'class myCustomWatcher extends QueueChangesWatcher' --> for queue action logs!
-});
-```
-
-3. **VERY IMPORTANT!** - Register Voice State updates + initialize the Manager
-
-```ts
-client.on("raw", d => client.lavalink.sendRawData(d)); // for voice state updates!
-client.on("ready", async () => {
-    console.log("Discord Bot is ready to be Used!");
-    // user.id is required, user.shards (not), user.username (not, but recommended for lavalink stats!) 
-    await client.lavalink.init({ ...client.user!, shards: "auto" }); 
-});
-```
-
-4. **Use it!**
-
-```ts
-// create player
-const player = await client.lavalink.createPlayer({
-    guildId: guild.id, voiceChannelId: voice.id, textChannelId: text.id, // in what guild + channel(s)
-    selfDeaf: true, selfMute: false, volume: 100 // configuration(s)
-}); 
-// connect the player to it's vc
-await player.connect();
-
-const res = await player.search({
-    query: `Elton John`, // source: `soundcloud`,
-}, client.user); // search a query (query-search, url search, identifier search, etc.)
-
-await player.queue.add(res.tracks); // add 1 track, or an array of tracks
-await player.play(); // you can provide specific track, or let the manager choose the track from the queue!
-```
-
-## Example (typescript)
-
-Can be found in the [`/testBot`](https://github.com/Tomato6966/lavalink-client/blob/main/testBot/README.md) Directory
-
-It contains the following features:
 
-- Example Use for `Redis based Queue`
-- Example Use for `Queue Changes Watcher Logger`
-- Example Use for `Filters`, `Audio Output`, `equalizers`
-- How to make an easy, yet advanced `Slash Commands Only Bot`
-- `Slim Memory Usage`
-- `All lavalink-client events` displayments
+- 😁 Much much more!

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

@@ -5,14 +5,15 @@ 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";
-import { Track } from "./Track";
+import { Track, UnresolvedTrack } from "./Track";
 export interface LavalinkManager {
     nodeManager: NodeManager;
     utils: ManagerUitls;
 }
 export interface BotClientOptions {
-    shards?: number | number[] | "auto";
+    /** Bot Client Id */
     id: string;
+    /** Bot Client Username */
     username?: string;
     /** So users can pass entire objects / classes */
     [x: string | number | symbol | undefined]: any;
@@ -40,6 +41,7 @@ export interface LavalinkPlayerOptions {
         autoPlayFunction?: (player: Player, lastPlayedTrack: Track) => Promise<void>;
         destroyAfterMs?: number;
     };
+    useUnresolvedData?: boolean;
 }
 export interface ManagerOptions {
     nodes: LavalinkNodeOptions[];
@@ -47,40 +49,38 @@ export interface ManagerOptions {
     client?: BotClientOptions;
     playerOptions?: LavalinkPlayerOptions;
     autoSkip?: boolean;
-    defaultLeastUsedNodeSortType?: "memory" | "calls" | "players";
-    defaultLeastLoadNodeSortType?: "cpu" | "memory";
     /** @async */
     sendToShard: (guildId: string, payload: GuildShardPayload) => void;
 }
 interface LavalinkManagerEvents {
     /**
      * Emitted when a Track started playing.
-     * @event Manager.playerManager#trackStart
+     * @event Manager#trackStart
      */
     "trackStart": (player: Player, track: Track, payload: TrackStartEvent) => void;
     /**
      * Emitted when a Track finished.
-     * @event Manager.playerManager#trackEnd
+     * @event Manager#trackEnd
      */
     "trackEnd": (player: Player, track: Track, payload: TrackEndEvent) => void;
     /**
      * Emitted when a Track got stuck while playing.
-     * @event Manager.playerManager#trackStuck
+     * @event Manager#trackStuck
      */
     "trackStuck": (player: Player, track: Track, payload: TrackStuckEvent) => void;
     /**
      * Emitted when a Track errored.
-     * @event Manager.playerManager#trackError
+     * @event Manager#trackError
      */
-    "trackError": (player: Player, track: Track, payload: TrackExceptionEvent) => void;
+    "trackError": (player: Player, track: Track | UnresolvedTrack, payload: TrackExceptionEvent) => void;
     /**
      * Emitted when the Playing finished and no more tracks in the queue.
-     * @event Manager.playerManager#queueEnd
+     * @event Manager#queueEnd
      */
     "queueEnd": (player: Player, track: Track, payload: TrackEndEvent | TrackStuckEvent | TrackExceptionEvent) => void;
     /**
      * Emitted when a Player is created.
-     * @event Manager.playerManager#create
+     * @event Manager#playerCreate
      */
     "playerCreate": (player: Player) => void;
     /**
@@ -90,19 +90,24 @@ interface LavalinkManagerEvents {
     "playerMove": (player: Player, oldVoiceChannelId: string, newVoiceChannelId: string) => void;
     /**
      * Emitted when a Player is disconnected from a channel.
-     * @event Manager.playerManager#disconnect
+     * @event Manager#playerDisconnect
      */
     "playerDisconnect": (player: Player, voiceChannelId: string) => void;
     /**
      * Emitted when a Node-Socket got closed for a specific Player.
-     * @event Manager.playerManager#socketClosed
+     * @event Manager#playerSocketClosed
      */
     "playerSocketClosed": (player: Player, payload: WebSocketClosedEvent) => void;
     /**
      * Emitted when a Player get's destroyed
-     * @event Manager.playerManager#destroy
+     * @event Manager#playerDestroy
      */
     "playerDestroy": (player: Player, destroyReason?: DestroyReasonsType) => void;
+    /**
+     * Always emits when the player (on lavalink side) got updated
+     * @event Manager#playerUpdate
+     */
+    "playerUpdate": (player: Player) => void;
 }
 export interface LavalinkManager {
     options: ManagerOptions;

package/dist/cjs/structures/LavalinkManager.js

@@ -45,10 +45,6 @@ class LavalinkManager extends events_1.EventEmitter {
             };
         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
@@ -66,13 +62,9 @@ class LavalinkManager extends events_1.EventEmitter {
         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(typeof options.client !== "object" || typeof options.client.id !== "string") throw new SyntaxError("ManagerOption.client = { id: string, username?:string } 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 */
@@ -157,9 +149,7 @@ class LavalinkManager extends events_1.EventEmitter {
      * @param data
      */
     async sendRawData(data) {
-        if (!this.initiated)
-            return;
-        if (!("t" in data))
+        if (!this.initiated || !("t" in data))
             return;
         // for channel Delete
         if ("CHANNEL_DELETE" === data.t) {
@@ -167,9 +157,8 @@ class LavalinkManager extends events_1.EventEmitter {
             if (!update.guild_id)
                 return;
             const player = this.getPlayer(update.guild_id);
-            if (player.voiceChannelId === update.id) {
+            if (player && player.voiceChannelId === update.id)
                 return player.destroy(Player_1.DestroyReasons.ChannelDeleted);
-            }
         }
         // for voice updates
         if (["VOICE_STATE_UPDATE", "VOICE_SERVER_UPDATE"].includes(data.t)) {

package/dist/cjs/structures/Node.d.ts

@@ -4,7 +4,7 @@ import { NodeManager } from "./NodeManager";
 import internal from "stream";
 import { InvalidLavalinkRestRequest, LavalinkPlayer, PlayerUpdateInfo, RoutePlanner, Session, Base64 } from "./Utils";
 import { DestroyReasonsType } from "./Player";
-import { TrackInfo } from "./Track";
+import { Track } from "./Track";
 /** Modifies any outgoing REST requests. */
 export type ModifyRequest = (options: Dispatcher.RequestOptions) => void;
 export interface LavalinkNodeOptions {
@@ -185,13 +185,13 @@ export declare class LavalinkNode {
          * @param encoded
          * @returns
          */
-        singleTrack: (encoded: Base64) => Promise<TrackInfo>;
+        singleTrack: (encoded: Base64, requester: unknown) => Promise<Track>;
         /**
          *
          * @param encodeds Decodes multiple tracks into their info
          * @returns
          */
-        multipleTracks: (encodeds: Base64[]) => Promise<TrackInfo[]>;
+        multipleTracks: (encodeds: Base64[], requester: unknown) => Promise<Track[]>;
     };
     /**
      * Request Lavalink statistics.

package/dist/cjs/structures/Node.js

@@ -137,9 +137,8 @@ class LavalinkNode {
             return;
         const headers = {
             Authorization: this.options.authorization,
-            "Num-Shards": String(this.NodeManager.LavalinkManager.options.client.shards || "auto"),
             "User-Id": this.NodeManager.LavalinkManager.options.client.id,
-            "User-Name": this.NodeManager.LavalinkManager.options.client.username || "Lavalink-Client",
+            "Client-Name": this.NodeManager.LavalinkManager.options.client.username || "Lavalink-Client",
         };
         if (typeof this.options.sessionId === "string" || typeof sessionId === "string") {
             headers["Session-Id"] = this.options.sessionId || sessionId;
@@ -228,25 +227,27 @@ class LavalinkNode {
          * @param encoded
          * @returns
          */
-        singleTrack: async (encoded) => {
+        singleTrack: async (encoded, requester) => {
             if (!encoded)
                 throw new SyntaxError("No encoded (Base64 string) was provided");
-            return await this.request(`/decodetrack?encodedTrack=${encoded}`);
+            // return the decoded + builded track
+            return this.NodeManager.LavalinkManager.utils.buildTrack(await this.request(`/decodetrack?encodedTrack=${encoded}`), requester);
         },
         /**
          *
          * @param encodeds Decodes multiple tracks into their info
          * @returns
          */
-        multipleTracks: async (encodeds) => {
+        multipleTracks: async (encodeds, requester) => {
             if (!Array.isArray(encodeds) || !encodeds.every(v => typeof v === "string" && v.length > 1))
                 throw new SyntaxError("You need to provide encodeds, which is an array of base64 strings");
+            // return the decoded + builded tracks
             return await this.request(`/decodetracks`, r => {
                 r.method = "POST";
                 r.body = JSON.stringify(encodeds);
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 r.headers["Content-Type"] = "application/json";
-            });
+            }).then((r) => r.map(track => this.NodeManager.LavalinkManager.utils.buildTrack(track, requester)));
         }
     };
     /**
@@ -477,6 +478,7 @@ class LavalinkNode {
                         player.filterManager.filterUpdatedState = 0;
                     }
                 }
+                this.NodeManager.LavalinkManager.emit("playerUpdate", player);
                 break;
             case "event":
                 this.handleEvent(payload);
@@ -523,6 +525,7 @@ class LavalinkNode {
         return this.NodeManager.LavalinkManager.emit("trackStart", player, track, payload);
     }
     async trackEnd(player, track, payload) {
+        console.log(payload.reason);
         // If there are no songs in the queue
         if (!player.queue.tracks.length && player.repeatMode === "off")
             return this.queueEnd(player, track, payload);
@@ -531,7 +534,7 @@ 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 (0, Utils_1.queueTrackEnd)(player.queue, false);
+            await (0, Utils_1.queueTrackEnd)(player);
             // if no track available, end queue
             if (!player.queue.current)
                 return this.queueEnd(player, track, payload);
@@ -542,7 +545,7 @@ class LavalinkNode {
         }
         // remove tracks from the queue
         if (player.repeatMode !== "track")
-            await (0, Utils_1.queueTrackEnd)(player.queue, player.repeatMode === "queue");
+            await (0, Utils_1.queueTrackEnd)(player);
         // if no track available, end queue
         if (!player.queue.current)
             return this.queueEnd(player, track, payload);
@@ -552,15 +555,17 @@ class LavalinkNode {
         return this.NodeManager.LavalinkManager.options.autoSkip && player.play({ noReplace: true });
     }
     async queueEnd(player, track, payload) {
+        // add previous track to the queue!
         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 (0, Utils_1.queueTrackEnd)(player.queue, player.repeatMode === "queue");
+                await (0, Utils_1.queueTrackEnd)(player);
             if (player.queue.current)
                 return player.play({ noReplace: true, paused: false });
         }
+        player.queue.previous.unshift(track);
         if (payload?.reason !== "stopped") {
             await player.queue.utils.save();
         }
@@ -585,7 +590,7 @@ class LavalinkNode {
         if (!player.queue.tracks.length && player.repeatMode === "off")
             return;
         // remove the current track, and enqueue the next one
-        await (0, Utils_1.queueTrackEnd)(player.queue, player.repeatMode === "queue");
+        await (0, Utils_1.queueTrackEnd)(player);
         // if no track available, end queue
         if (!player.queue.current)
             return this.queueEnd(player, track, payload);
@@ -595,7 +600,7 @@ class LavalinkNode {
     async trackError(player, track, payload) {
         this.NodeManager.LavalinkManager.emit("trackError", player, track, payload);
         // remove the current track, and enqueue the next one
-        await (0, Utils_1.queueTrackEnd)(player.queue, player.repeatMode === "queue");
+        await (0, Utils_1.queueTrackEnd)(player);
         // if no track available, end queue
         if (!player.queue.current)
             return this.queueEnd(player, track, payload);

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

@@ -55,18 +55,7 @@ export declare class NodeManager extends EventEmitter {
     nodes: MiniMap<string, LavalinkNode>;
     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[];
+    leastUsedNodes(sortType?: "memory" | "cpuLavalink" | "cpuSystem" | "calls" | "playingPlayers" | "players"): LavalinkNode[];
     deleteNode(node: LavalinkNodeIdentifier | LavalinkNode): void;
 }
 export {};

package/dist/cjs/structures/NodeManager.js

@@ -20,68 +20,61 @@ class NodeManager extends stream_1.EventEmitter {
         this.nodes.set(newNode.id, newNode);
         return newNode;
     }
-    get leastUsedNodes() {
-        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;
-        });
+    leastUsedNodes(sortType = "players") {
+        switch (sortType) {
+            case "memory":
+                {
+                    return [...this.nodes.values()]
+                        .filter((node) => node.connected)
+                        .sort((a, b) => (a.stats?.memory?.used || 0) - (b.stats?.memory?.used || 0)); // sort after memor
+                }
+                break;
+            case "cpuLavalink":
+                {
+                    return [...this.nodes.values()]
+                        .filter((node) => node.connected)
+                        .sort((a, b) => (a.stats?.cpu?.lavalinkLoad || 0) - (b.stats?.cpu?.lavalinkLoad || 0)); // sort after memor
+                }
+                break;
+            case "cpuSystem":
+                {
+                    return [...this.nodes.values()]
+                        .filter((node) => node.connected)
+                        .sort((a, b) => (a.stats?.cpu?.systemLoad || 0) - (b.stats?.cpu?.systemLoad || 0)); // sort after memor
+                }
+                break;
+            case "calls":
+                {
+                    return [...this.nodes.values()]
+                        .filter((node) => node.connected)
+                        .sort((a, b) => a.calls - b.calls); // client sided sorting
+                }
+                break;
+            case "playingPlayers":
+                {
+                    return [...this.nodes.values()]
+                        .filter((node) => node.connected)
+                        .sort((a, b) => (a.stats?.playingPlayers || 0) - (b.stats?.playingPlayers || 0));
+                }
+                break;
+            case "players":
+                {
+                    return [...this.nodes.values()]
+                        .filter((node) => node.connected)
+                        .sort((a, b) => (a.stats?.players || 0) - (b.stats?.players || 0));
+                }
+                break;
+            default:
+                {
+                    return [...this.nodes.values()]
+                        .filter((node) => node.connected)
+                        .sort((a, b) => (a.stats?.players || 0) - (b.stats?.players || 0));
+                }
+                break;
+        }
     }
     deleteNode(node) {
-        const decodeNode = typeof node === "string" ? this.nodes.get(node) : node || this.leastUsedNodes[0];
+        const decodeNode = typeof node === "string" ? this.nodes.get(node) : node || this.leastUsedNodes()[0];
         if (!decodeNode)
             throw new Error("Node was not found");
         decodeNode.destroy(Player_1.DestroyReasons.NodeDeleted);

package/dist/cjs/structures/Player.d.ts

@@ -110,7 +110,7 @@ export declare class Player {
      * Play the next track from the queue / a specific track, with playoptions for Lavalink
      * @param options
      */
-    play(options?: Partial<PlayOptions>): Promise<void>;
+    play(options?: Partial<PlayOptions>): any;
     /**
      * Set the Volume for the Player
      * @param volume The Volume in percent
@@ -143,12 +143,12 @@ export declare class Player {
      * Set the Repeatmode of the Player
      * @param repeatMode
      */
-    setRepeatMode(repeatMode: RepeatMode): Promise<void>;
+    setRepeatMode(repeatMode: RepeatMode): Promise<RepeatMode>;
     /**
      * Skip the current song, or a specific amount of songs
      * @param amount provide the index of the next track to skip to
      */
-    skip(skipTo?: number): Promise<true | void>;
+    skip(skipTo?: number): Promise<any>;
     /**
      * Connects the Player to the Voice Channel
      * @returns
@@ -172,6 +172,7 @@ export declare class Player {
     /** Converts the Player including Queue to a Json state */
     toJSON(): {
         guildId: string;
+        options: PlayerOptions;
         voiceChannelId: string;
         textChannelId: string;
         position: number;
@@ -184,7 +185,6 @@ export declare class Player {
         createdTimeStamp: number;
         filters: {};
         equalizer: import("./Filters").EQBand[];
-        queue: import("./Queue").StoredQueue;
         nodeId: string;
     };
 }