lavalink-client 2.3.5 → 2.4.0

package/dist/esm/structures/NodeManager.js

@@ -1,5 +1,5 @@
 import { EventEmitter } from "events";
-import { DestroyReasons } from "./Constants.js";
+import { DestroyReasons, DisconnectReasons } from "./Constants.js";
 import { LavalinkNode } from "./Node.js";
 import { MiniMap } from "./Utils.js";
 export class NodeManager extends EventEmitter {
@@ -70,18 +70,24 @@ export class NodeManager extends EventEmitter {
     /**
      * Disconnects all Nodes from lavalink ws sockets
      * @param deleteAllNodes if the nodes should also be deleted from nodeManager.nodes
+     * @param destroyPlayers if the players should be destroyed
      * @returns amount of disconnected Nodes
      */
-    async disconnectAll(deleteAllNodes = false) {
+    async disconnectAll(deleteAllNodes = false, destroyPlayers = true) {
         if (!this.nodes.size)
             throw new Error("There are no nodes to disconnect (no nodes in the nodemanager)");
         if (!this.nodes.filter(v => v.connected).size)
             throw new Error("There are no nodes to disconnect (all nodes disconnected)");
         let counter = 0;
-        for (const node of [...this.nodes.values()]) {
+        for (const node of this.nodes.values()) {
             if (!node.connected)
                 continue;
-            await node.destroy(DestroyReasons.DisconnectAllNodes, deleteAllNodes);
+            if (destroyPlayers) {
+                await node.destroy(DestroyReasons.DisconnectAllNodes, deleteAllNodes);
+            }
+            else {
+                await node.disconnect(DisconnectReasons.DisconnectAllNodes);
+            }
             counter++;
         }
         return counter;
@@ -96,7 +102,7 @@ export class NodeManager extends EventEmitter {
         if (!this.nodes.filter(v => !v.connected).size)
             throw new Error("There are no nodes to connect (all nodes connected)");
         let counter = 0;
-        for (const node of [...this.nodes.values()]) {
+        for (const node of this.nodes.values()) {
             if (node.connected)
                 continue;
             await node.connect();
@@ -112,7 +118,7 @@ export class NodeManager extends EventEmitter {
         if (!this.nodes.size)
             throw new Error("There are no nodes to reconnect (no nodes in the nodemanager)");
         let counter = 0;
-        for (const node of [...this.nodes.values()]) {
+        for (const node of this.nodes.values()) {
             const sessionId = node.sessionId ? `${node.sessionId}` : undefined;
             await node.destroy(DestroyReasons.ReconnectAllNodes, false);
             await node.connect(sessionId);
@@ -138,53 +144,47 @@ export class NodeManager extends EventEmitter {
      * @returns
      */
     leastUsedNodes(sortType = "players") {
+        const connectedNodes = Array.from(this.nodes.values()).filter((node) => node.connected);
         switch (sortType) {
             case "memory":
                 {
-                    return [...this.nodes.values()]
-                        .filter((node) => node.connected)
+                    return connectedNodes
                         .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)
+                    return connectedNodes
                         .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)
+                    return connectedNodes
                         .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)
+                    return connectedNodes
                         .sort((a, b) => a.calls - b.calls); // client sided sorting
                 }
                 break;
             case "playingPlayers":
                 {
-                    return [...this.nodes.values()]
-                        .filter((node) => node.connected)
+                    return connectedNodes
                         .sort((a, b) => (a.stats?.playingPlayers || 0) - (b.stats?.playingPlayers || 0));
                 }
                 break;
             case "players":
                 {
-                    return [...this.nodes.values()]
-                        .filter((node) => node.connected)
+                    return connectedNodes
                         .sort((a, b) => (a.stats?.players || 0) - (b.stats?.players || 0));
                 }
                 break;
             default:
                 {
-                    return [...this.nodes.values()]
-                        .filter((node) => node.connected)
+                    return connectedNodes
                         .sort((a, b) => (a.stats?.players || 0) - (b.stats?.players || 0));
                 }
                 break;

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

@@ -1,6 +1,7 @@
 import { FilterManager } from "./Filters.js";
 import { Queue } from "./Queue.js";
 import type { DestroyReasons } from "./Constants.js";
+import type { Track } from "./Types/Track.js";
 import type { LavalinkNode } from "./Node.js";
 import type { SponsorBlockSegment } from "./Types/Node.js";
 import type { PlayerJson, PlayerOptions, PlayOptions, RepeatMode } from "./Types/Player.js";
@@ -51,6 +52,13 @@ export declare class Player {
     connected: boolean | undefined;
     /** Voice Server Data (from Lavalink) */
     voice: LavalinkPlayerVoiceOptions;
+    voiceState: {
+        selfDeaf: boolean;
+        selfMute: boolean;
+        serverDeaf: boolean;
+        serverMute: boolean;
+        suppress: boolean;
+    };
     /** Custom data for the player */
     private readonly data;
     /**
@@ -96,7 +104,7 @@ export declare class Player {
      * @param throwOnEmpty If an error should be thrown if no track is found
      * @returns The search result
      */
-    lavaSearch(query: LavaSearchQuery, requestUser: unknown, throwOnEmpty?: boolean): Promise<import("./Types/Utils.js").SearchResult | import("./Types/Utils.js").LavaSearchResponse>;
+    lavaSearch(query: LavaSearchQuery, requestUser: unknown, throwOnEmpty?: boolean): Promise<import("./Types/Utils.js").LavaSearchResponse | import("./Types/Utils.js").SearchResult>;
     /**
      * Set the SponsorBlock
      * @param segments The segments to set
@@ -164,6 +172,48 @@ export declare class Player {
      * Destroy the player and disconnect from the voice channel
      */
     destroy(reason?: DestroyReasons | string, disconnect?: boolean): Promise<this>;
+    /**
+     * Get the current lyrics of the track currently playing on the guild
+     * @param guildId The guild id to get the current lyrics for
+     * @param skipTrackSource If true, it will not try to get the lyrics from the track source
+     * @returns The current lyrics
+     * @example
+     * ```ts
+     * const lyrics = await player.getCurrentLyrics();
+     * ```
+     */
+    getCurrentLyrics(skipTrackSource?: boolean): Promise<import("./Types/Node.js").LyricsResult>;
+    /**
+     * Get the lyrics of a specific track
+     * @param track The track to get the lyrics for
+     * @param skipTrackSource If true, it will not try to get the lyrics from the track source
+     * @returns The lyrics of the track
+     * @example
+     * ```ts
+     * const lyrics = await player.getLyrics(player.queue.tracks[0], true);
+     * ```
+     */
+    getLyrics(track: Track, skipTrackSource?: boolean): Promise<import("./Types/Node.js").LyricsResult>;
+    /**
+     * Subscribe to the lyrics event on a specific guild to active live lyrics events
+     * @param guildId The guild id to subscribe to
+     * @returns The unsubscribe function
+     * @example
+     * ```ts
+     * const lyrics = await player.subscribeLyrics();
+     * ```
+     */
+    subscribeLyrics(): Promise<unknown>;
+    /**
+     * Unsubscribe from the lyrics event on a specific guild to disable live lyrics events
+     * @param guildId The guild id to unsubscribe from
+     * @returns The unsubscribe function
+     * @example
+     * ```ts
+     * const lyrics = await player.unsubscribeLyrics();
+     * ```
+     */
+    unsubscribeLyrics(guildId: string): Promise<void>;
     /**
      * Move the player on a different Audio-Node
      * @param newNode New Node / New Node Id

package/dist/esm/structures/Player.js

@@ -56,6 +56,13 @@ export class Player {
         sessionId: null,
         token: null
     };
+    voiceState = {
+        selfDeaf: false,
+        selfMute: false,
+        serverDeaf: false,
+        serverMute: false,
+        suppress: false,
+    };
     /** Custom data for the player */
     data = {};
     /**
@@ -142,6 +149,7 @@ export class Player {
                     functionLayer: "Player > play()",
                 });
             }
+            this.LavalinkManager.emit("playerQueueEmptyCancel", this);
             clearTimeout(this.get("internal_queueempty"));
             this.set("internal_queueempty", undefined);
         }
@@ -540,6 +548,10 @@ export class Player {
     async destroy(reason, disconnect = true) {
         if (this.LavalinkManager.options.advancedOptions?.debugOptions.playerDestroy.debugLog)
             console.log(`Lavalink-Client-Debug | PlayerDestroy [::] destroy Function, [guildId ${this.guildId}] - Destroy-Reason: ${String(reason)}`);
+        if (this.get("internal_queueempty")) {
+            clearTimeout(this.get("internal_queueempty"));
+            this.set("internal_queueempty", undefined);
+        }
         if (this.get("internal_destroystatus") === true) {
             if (this.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
                 this.LavalinkManager.emit("debug", DebugEvents.PlayerDestroyingSomewhereElse, {
@@ -571,6 +583,56 @@ export class Player {
         // return smt
         return this;
     }
+    /**
+     * Get the current lyrics of the track currently playing on the guild
+     * @param guildId The guild id to get the current lyrics for
+     * @param skipTrackSource If true, it will not try to get the lyrics from the track source
+     * @returns The current lyrics
+     * @example
+     * ```ts
+     * const lyrics = await player.getCurrentLyrics();
+     * ```
+     */
+    async getCurrentLyrics(skipTrackSource) {
+        return await this.node.lyrics.getCurrent(this.guildId, skipTrackSource);
+    }
+    /**
+     * Get the lyrics of a specific track
+     * @param track The track to get the lyrics for
+     * @param skipTrackSource If true, it will not try to get the lyrics from the track source
+     * @returns The lyrics of the track
+     * @example
+     * ```ts
+     * const lyrics = await player.getLyrics(player.queue.tracks[0], true);
+     * ```
+     */
+    async getLyrics(track, skipTrackSource) {
+        return await this.node.lyrics.get(track, skipTrackSource);
+    }
+    /**
+     * Subscribe to the lyrics event on a specific guild to active live lyrics events
+     * @param guildId The guild id to subscribe to
+     * @returns The unsubscribe function
+     * @example
+     * ```ts
+     * const lyrics = await player.subscribeLyrics();
+     * ```
+     */
+    subscribeLyrics() {
+        return this.node.lyrics.subscribe(this.guildId);
+    }
+    /**
+     * Unsubscribe from the lyrics event on a specific guild to disable live lyrics events
+     * @param guildId The guild id to unsubscribe from
+     * @returns The unsubscribe function
+     * @example
+     * ```ts
+     * const lyrics = await player.unsubscribeLyrics();
+     * ```
+     */
+    unsubscribeLyrics(guildId) {
+        return this.node.lyrics.unsubscribe(guildId);
+    }
     /**
      * Move the player on a different Audio-Node
      * @param newNode New Node / New Node Id

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

@@ -1,4 +1,3 @@
-import { MiniMap } from "./Utils.js";
 import type { Track, UnresolvedTrack } from "./Types/Track.js";
 import type { ManagerQueueOptions, QueueStoreManager, StoredQueue } from "./Types/Queue.js";
 export declare class QueueSaver {
@@ -24,14 +23,14 @@ export declare class QueueSaver {
      * @param guildId The guild ID
      * @returns The queue for the guild
      */
-    delete(guildId: string): Promise<unknown>;
+    delete(guildId: string): Promise<boolean | void>;
     /**
      * Set the queue for a guild
      * @param guildId The guild ID
      * @param valueToStringify The queue to set
      * @returns The queue for the guild
      */
-    set(guildId: string, valueToStringify: StoredQueue): Promise<unknown>;
+    set(guildId: string, valueToStringify: StoredQueue): Promise<boolean | void>;
     /**
      * Sync the queue for a guild
      * @param guildId The guild ID
@@ -47,32 +46,32 @@ export declare class DefaultQueueStore implements QueueStoreManager {
      * @param guildId The guild ID
      * @returns The queue for the guild
      */
-    get(guildId: any): Promise<unknown>;
+    get(guildId: string): Promise<StoredQueue>;
     /**
      * Set the queue for a guild
      * @param guildId The guild ID
      * @param valueToStringify The queue to set
      * @returns The queue for the guild
      */
-    set(guildId: any, valueToStringify: any): Promise<MiniMap<unknown, unknown>>;
+    set(guildId: string, valueToStringify: any): Promise<boolean>;
     /**
      * Delete the queue for a guild
      * @param guildId The guild ID
      * @returns The queue for the guild
      */
-    delete(guildId: any): Promise<boolean>;
+    delete(guildId: string): Promise<boolean>;
     /**
      * Stringify the queue for a guild
      * @param value The queue to stringify
      * @returns The stringified queue
      */
-    stringify(value: any): Promise<any>;
+    stringify(value: StoredQueue): Promise<StoredQueue>;
     /**
      * Parse the queue for a guild
      * @param value The queue to parse
      * @returns The parsed queue
      */
-    parse(value: any): Promise<Partial<StoredQueue>>;
+    parse(value: StoredQueue): Promise<StoredQueue>;
 }
 export declare class Queue {
     readonly tracks: (Track | UnresolvedTrack)[];
@@ -100,13 +99,13 @@ export declare class Queue {
         /**
          * Save the current cached Queue on the database/server (overides the server)
          */
-        save: () => Promise<unknown>;
+        save: () => Promise<boolean | void>;
         /**
          * Sync the current queue database/server with the cached one
          * @returns {void}
          */
         sync: (override?: boolean, dontSyncCurrent?: boolean) => Promise<void>;
-        destroy: () => Promise<unknown>;
+        destroy: () => Promise<boolean | void>;
         /**
          * @returns {{current:Track|null, previous:Track[], tracks:Track[]}}The Queue, but in a raw State, which allows easier handling for the QueueStoreManager
          */

package/dist/esm/structures/Queue.js

@@ -57,7 +57,7 @@ export class DefaultQueueStore {
      * @returns The queue for the guild
      */
     async get(guildId) {
-        return await this.data.get(guildId);
+        return this.data.get(guildId);
     }
     /**
      * Set the queue for a guild
@@ -66,7 +66,7 @@ export class DefaultQueueStore {
      * @returns The queue for the guild
      */
     async set(guildId, valueToStringify) {
-        return await this.data.set(guildId, valueToStringify);
+        return this.data.set(guildId, valueToStringify) ? true : false;
     }
     /**
      * Delete the queue for a guild
@@ -74,7 +74,7 @@ export class DefaultQueueStore {
      * @returns The queue for the guild
      */
     async delete(guildId) {
-        return await this.data.delete(guildId);
+        return this.data.delete(guildId);
     }
     /**
      * Stringify the queue for a guild

package/dist/esm/structures/Types/Manager.d.ts

@@ -4,7 +4,7 @@ import type { LavalinkNodeOptions } from "./Node.js";
 import type { DestroyReasonsType, PlayerJson } from "./Player.js";
 import type { ManagerQueueOptions } from "./Queue.js";
 import type { Track, UnresolvedTrack } from "./Track.js";
-import type { GuildShardPayload, SearchPlatform, SponsorBlockChaptersLoaded, SponsorBlockChapterStarted, SponsorBlockSegmentSkipped, SponsorBlockSegmentsLoaded, TrackExceptionEvent, TrackEndEvent, TrackStuckEvent, WebSocketClosedEvent, TrackStartEvent } from "./Utils.js";
+import type { GuildShardPayload, SearchPlatform, SponsorBlockChaptersLoaded, SponsorBlockChapterStarted, SponsorBlockSegmentSkipped, SponsorBlockSegmentsLoaded, TrackExceptionEvent, TrackEndEvent, TrackStuckEvent, WebSocketClosedEvent, TrackStartEvent, LyricsFoundEvent, LyricsNotFoundEvent, LyricsLineEvent } from "./Utils.js";
 /**
  * The events from the lavalink Manager
  */
@@ -73,6 +73,46 @@ export interface LavalinkManagerEvents {
      * @event Manager#playerUpdate
      */
     "playerUpdate": (oldPlayerJson: PlayerJson, newPlayer: Player) => void;
+    /**
+     * Emitted when the player's selfMuted or serverMuted state changed (true -> false | false -> true)
+     * @event Manager#playerMuteChange
+     */
+    "playerMuteChange": (player: Player, selfMuted: boolean, serverMuted: boolean) => void;
+    /**
+     * Emitted when the player's selfDeafed or serverDeafed state changed (true -> false | false -> true)
+     * @event Manager#playerDeafChange
+     */
+    "playerDeafChange": (player: Player, selfDeafed: boolean, serverDeafed: boolean) => void;
+    /**
+     * Emitted when the player's suppressed (true -> false | false -> true)
+     * @event Manager#playerSuppressChange
+     */
+    "playerSuppressChange": (player: Player, suppress: boolean) => void;
+    /**
+     * Emitted when the player's queue got empty, and the timeout started
+     * @event Manager#playerQueueEmptyStart
+     */
+    "playerQueueEmptyStart": (player: Player, timeoutMs: number) => void;
+    /**
+     * Emitted when the player's queue got empty, and the timeout finished leading to destroying the player
+     * @event Manager#playerQueueEmptyEnd
+     */
+    "playerQueueEmptyEnd": (player: Player) => void;
+    /**
+     * Emitted when the player's queue got empty, and the timeout got cancelled becuase a track got re-added to it.
+     * @event Manager#playerQueueEmptyEnd
+     */
+    "playerQueueEmptyCancel": (player: Player) => void;
+    /**
+     * Emitted, when a user joins the voice channel, while there is a player existing
+     * @event Manager#playerQueueEmptyStart
+     */
+    "playerVoiceJoin": (player: Player, userId: string) => void;
+    /**
+     * Emitted, when a user leaves the voice channel, while there is a player existing
+     * @event Manager#playerQueueEmptyEnd
+     */
+    "playerVoiceLeave": (player: Player, userId: string) => void;
     /**
      * SPONSORBLOCK-PLUGIN EVENT
      * Emitted when Segments are loaded
@@ -114,6 +154,24 @@ export interface LavalinkManagerEvents {
         error?: Error | string;
         functionLayer: string;
     }) => void;
+    /**
+     * Emitted when a Lyrics line is received
+     * @link https://github.com/topi314/LavaLyrics
+     * @event Manager#LyricsLine
+     */
+    "LyricsLine": (player: Player, track: Track | UnresolvedTrack | null, payload: LyricsLineEvent) => void;
+    /**
+     * Emitted when a Lyrics is found
+     * @link https://github.com/topi314/LavaLyrics
+     * @event Manager#LyricsFound
+     */
+    "LyricsFound": (player: Player, track: Track | UnresolvedTrack | null, payload: LyricsFoundEvent) => void;
+    /**
+     * Emitted when a Lyrics is not found
+     * @link https://github.com/topi314/LavaLyrics
+     * @event Manager#LyricsNotFound
+     */
+    "LyricsNotFound": (player: Player, track: Track | UnresolvedTrack | null, payload: LyricsNotFoundEvent) => void;
 }
 /**
  * The Bot client Options needed for the manager

package/dist/esm/structures/Types/Node.d.ts

@@ -1,8 +1,8 @@
-/// <reference types="node" />
 import type internal from "stream";
 import type { LavalinkNode } from "../Node.js";
 import type { DestroyReasonsType } from "./Player.js";
 import type { InvalidLavalinkRestRequest, LavalinkPlayer } from "./Utils.js";
+import type { PluginInfo } from "./Track.js";
 /** Ability to manipulate fetch requests */
 export type ModifyRequest = (options: RequestInit & {
     path: string;
@@ -157,6 +157,28 @@ export interface PluginObject {
     /** The version of the plugin */
     version: string;
 }
+export interface LyricsResult {
+    /**The name of the source */
+    sourceName: string;
+    /**The name of the provider */
+    provider: string;
+    /**The result text */
+    text: string | null;
+    /**The lyrics lines */
+    lines: LyricsLine[];
+    /**Information about the plugin */
+    plugin: PluginInfo;
+}
+export interface LyricsLine {
+    /**The millisecond timestamp */
+    timestamp: number;
+    /**The line duration in milliseconds */
+    duration: number | null;
+    /**The line text */
+    line: string;
+    /**Information about the plugin */
+    plugin: PluginInfo;
+}
 export type LavalinkNodeIdentifier = string;
 export interface NodeManagerEvents {
     /**

package/dist/esm/structures/Types/Player.d.ts

@@ -1,9 +1,11 @@
-import type { DestroyReasons } from "../Constants.js";
+import type { DestroyReasons, DisconnectReasons } from "../Constants.js";
 import type { LavalinkNode } from "../Node.js";
 import type { EQBand, FilterData, LavalinkFilterData } from "./Filters.js";
+import type { StoredQueue } from "./Queue.js";
 import type { Track, UnresolvedTrack } from "./Track.js";
 import type { Base64, LavalinkPlayerVoiceOptions } from "./Utils.js";
 export type DestroyReasonsType = keyof typeof DestroyReasons | string;
+export type DisconnectReasonsType = keyof typeof DisconnectReasons | string;
 export interface PlayerJson {
     /** Guild Id where the player was playing in */
     guildId: string;
@@ -46,6 +48,8 @@ export interface PlayerJson {
     nodeId?: string;
     /** The SessionId of the node */
     nodeSessionId?: string;
+    /** The stored queue */
+    queue?: StoredQueue;
 }
 export type RepeatMode = "queue" | "track" | "off";
 export interface PlayerOptions {

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

@@ -4,17 +4,17 @@ export interface StoredQueue {
     previous: Track[];
     tracks: (Track | UnresolvedTrack)[];
 }
-export interface QueueStoreManager extends Record<string, any> {
+export interface QueueStoreManager {
     /** @async get a Value (MUST RETURN UNPARSED!) */
-    get: (guildId: unknown) => Promise<unknown>;
+    get: (guildId: string) => Promise<StoredQueue | string>;
     /** @async Set a value inside a guildId (MUST BE UNPARSED) */
-    set: (guildId: unknown, value: unknown) => Promise<unknown>;
+    set: (guildId: string, value: StoredQueue | string) => Promise<void | boolean>;
     /** @async Delete a Database Value based of it's guildId */
-    delete: (guildId: unknown) => Promise<unknown>;
+    delete: (guildId: string) => Promise<void | boolean>;
     /** @async Transform the value(s) inside of the QueueStoreManager (IF YOU DON'T NEED PARSING/STRINGIFY, then just return the value) */
-    stringify: (value: unknown) => Promise<unknown>;
+    stringify: (value: StoredQueue | string) => Promise<StoredQueue | string>;
     /** @async Parse the saved value back to the Queue (IF YOU DON'T NEED PARSING/STRINGIFY, then just return the value) */
-    parse: (value: unknown) => Promise<Partial<StoredQueue>>;
+    parse: (value: StoredQueue | string) => Promise<Partial<StoredQueue>>;
 }
 export interface ManagerQueueOptions {
     /** Maximum Amount of tracks for the queue.previous array. Set to 0 to not save previous songs. Defaults to 25 Tracks */

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

@@ -5,8 +5,10 @@ import type { Base64 } from "./Utils.js";
 export type LavalinkSourceNames = "youtube" | "youtubemusic" | "soundcloud" | "bandcamp" | "twitch";
 /** Source Names provided by lava src plugin */
 export type LavalinkPlugin_LavaSrc_SourceNames = "deezer" | "spotify" | "applemusic" | "yandexmusic" | "flowery-tts";
+/** Source Names provided by jiosaavan plugin */
+export type LavalinkPlugin_JioSaavn_SourceNames = "jiosaavn";
 /** The SourceNames provided by lavalink */
-export type SourceNames = LavalinkSourceNames | LavalinkPlugin_LavaSrc_SourceNames;
+export type SourceNames = LavalinkSourceNames | LavalinkPlugin_LavaSrc_SourceNames | LavalinkPlugin_JioSaavn_SourceNames;
 export interface LavalinkTrackInfo {
     /** The Identifier of the Track */
     identifier: string;