lavalink-client 2.5.6 → 2.5.8

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

@@ -1,100 +0,0 @@
-import { EventEmitter } from "events";
-import { LavalinkNode } from "./Node.js";
-import { MiniMap } from "./Utils.js";
-import type { LavalinkNodeIdentifier, LavalinkNodeOptions, NodeManagerEvents } from "./Types/Node.js";
-import type { LavalinkManager } from "./LavalinkManager.js";
-export declare class NodeManager extends EventEmitter {
-    /**
-     * Emit an event
-     * @param event The event to emit
-     * @param args The arguments to pass to the event
-     * @returns
-     */
-    emit<Event extends keyof NodeManagerEvents>(event: Event, ...args: Parameters<NodeManagerEvents[Event]>): boolean;
-    /**
-     * Add an event listener
-     * @param event The event to listen to
-     * @param listener The listener to add
-     * @returns
-     */
-    on<Event extends keyof NodeManagerEvents>(event: Event, listener: NodeManagerEvents[Event]): this;
-    /**
-     * Add an event listener that only fires once
-     * @param event The event to listen to
-     * @param listener The listener to add
-     * @returns
-     */
-    once<Event extends keyof NodeManagerEvents>(event: Event, listener: NodeManagerEvents[Event]): this;
-    /**
-     * Remove an event listener
-     * @param event The event to remove the listener from
-     * @param listener The listener to remove
-     * @returns
-     */
-    off<Event extends keyof NodeManagerEvents>(event: Event, listener: NodeManagerEvents[Event]): this;
-    /**
-     * Remove an event listener
-     * @param event The event to remove the listener from
-     * @param listener The listener to remove
-     * @returns
-     */
-    removeListener<Event extends keyof NodeManagerEvents>(event: Event, listener: NodeManagerEvents[Event]): this;
-    /**
-     * The LavalinkManager that created this NodeManager
-     */
-    LavalinkManager: LavalinkManager;
-    /**
-     * A map of all nodes in the nodeManager
-     */
-    nodes: MiniMap<string, LavalinkNode>;
-    /**
-     * @param LavalinkManager The LavalinkManager that created this NodeManager
-     */
-    constructor(LavalinkManager: LavalinkManager);
-    /**
-     * 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
-     */
-    disconnectAll(deleteAllNodes?: boolean, destroyPlayers?: boolean): Promise<number>;
-    /**
-     * Connects all not connected nodes
-     * @returns Amount of connected Nodes
-     */
-    connectAll(): Promise<number>;
-    /**
-     * Forcefully reconnects all nodes
-     * @returns amount of nodes
-     */
-    reconnectAll(): Promise<number>;
-    /**
-     * Create a node and add it to the nodeManager
-     * @param options The options for the node
-     * @returns The node that was created
-     */
-    createNode(options: LavalinkNodeOptions): LavalinkNode;
-    /**
-     * Get the nodes sorted for the least usage, by a sorttype
-     * @param sortType The type of sorting to use
-     * @returns
-     */
-    leastUsedNodes(sortType?: "memory" | "cpuLavalink" | "cpuSystem" | "calls" | "playingPlayers" | "players"): LavalinkNode[];
-    /**
-     * Delete a node from the nodeManager and destroy it
-     * @param node The node to delete
-     * @param movePlayers whether to movePlayers to different connected node before deletion. @default false
-     * @returns
-     *
-     * @example
-     * Deletes the node
-     * ```ts
-     * client.lavalink.nodeManager.deleteNode("nodeId to delete");
-     * ```
-     * Moves players to a different node before deleting
-     * ```ts
-     * client.lavalink.nodeManager.deleteNode("nodeId to delete", true);
-     * ```
-     */
-    deleteNode(node: LavalinkNodeIdentifier | LavalinkNode, movePlayers?: boolean): void;
-}

package/dist/cjs/structures/NodeManager.js

@@ -1,224 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeManager = void 0;
-const events_1 = require("events");
-const Constants_1 = require("./Constants.js");
-const Node_1 = require("./Node.js");
-const Utils_1 = require("./Utils.js");
-class NodeManager extends events_1.EventEmitter {
-    /**
-     * Emit an event
-     * @param event The event to emit
-     * @param args The arguments to pass to the event
-     * @returns
-     */
-    emit(event, ...args) {
-        return super.emit(event, ...args);
-    }
-    /**
-     * Add an event listener
-     * @param event The event to listen to
-     * @param listener The listener to add
-     * @returns
-     */
-    on(event, listener) {
-        return super.on(event, listener);
-    }
-    /**
-     * Add an event listener that only fires once
-     * @param event The event to listen to
-     * @param listener The listener to add
-     * @returns
-     */
-    once(event, listener) {
-        return super.once(event, listener);
-    }
-    /**
-     * Remove an event listener
-     * @param event The event to remove the listener from
-     * @param listener The listener to remove
-     * @returns
-     */
-    off(event, listener) {
-        return super.off(event, listener);
-    }
-    /**
-     * Remove an event listener
-     * @param event The event to remove the listener from
-     * @param listener The listener to remove
-     * @returns
-     */
-    removeListener(event, listener) {
-        return super.removeListener(event, listener);
-    }
-    /**
-     * The LavalinkManager that created this NodeManager
-     */
-    LavalinkManager;
-    /**
-     * A map of all nodes in the nodeManager
-     */
-    nodes = new Utils_1.MiniMap();
-    /**
-     * @param LavalinkManager The LavalinkManager that created this NodeManager
-     */
-    constructor(LavalinkManager) {
-        super();
-        this.LavalinkManager = LavalinkManager;
-        if (this.LavalinkManager.options.nodes)
-            this.LavalinkManager.options.nodes.forEach(node => {
-                this.createNode(node);
-            });
-    }
-    /**
-     * 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, 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()) {
-            if (!node.connected)
-                continue;
-            if (destroyPlayers) {
-                await node.destroy(Constants_1.DestroyReasons.DisconnectAllNodes, deleteAllNodes);
-            }
-            else {
-                await node.disconnect(Constants_1.DisconnectReasons.DisconnectAllNodes);
-            }
-            counter++;
-        }
-        return counter;
-    }
-    /**
-     * Connects all not connected nodes
-     * @returns Amount of connected Nodes
-     */
-    async connectAll() {
-        if (!this.nodes.size)
-            throw new Error("There are no nodes to connect (no nodes in the nodemanager)");
-        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()) {
-            if (node.connected)
-                continue;
-            await node.connect();
-            counter++;
-        }
-        return counter;
-    }
-    /**
-     * Forcefully reconnects all nodes
-     * @returns amount of nodes
-     */
-    async reconnectAll() {
-        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()) {
-            const sessionId = node.sessionId ? `${node.sessionId}` : undefined;
-            await node.destroy(Constants_1.DestroyReasons.ReconnectAllNodes, false);
-            await node.connect(sessionId);
-            counter++;
-        }
-        return counter;
-    }
-    /**
-     * Create a node and add it to the nodeManager
-     * @param options The options for the node
-     * @returns The node that was created
-     */
-    createNode(options) {
-        if (this.nodes.has(options.id || `${options.host}:${options.port}`))
-            return this.nodes.get(options.id || `${options.host}:${options.port}`);
-        const newNode = new Node_1.LavalinkNode(options, this);
-        this.nodes.set(newNode.id, newNode);
-        return newNode;
-    }
-    /**
-     * Get the nodes sorted for the least usage, by a sorttype
-     * @param sortType The type of sorting to use
-     * @returns
-     */
-    leastUsedNodes(sortType = "players") {
-        const connectedNodes = Array.from(this.nodes.values()).filter((node) => node.connected);
-        switch (sortType) {
-            case "memory":
-                {
-                    return connectedNodes
-                        .sort((a, b) => (a.stats?.memory?.used || 0) - (b.stats?.memory?.used || 0)); // sort after memor
-                }
-                break;
-            case "cpuLavalink":
-                {
-                    return connectedNodes
-                        .sort((a, b) => (a.stats?.cpu?.lavalinkLoad || 0) - (b.stats?.cpu?.lavalinkLoad || 0)); // sort after memor
-                }
-                break;
-            case "cpuSystem":
-                {
-                    return connectedNodes
-                        .sort((a, b) => (a.stats?.cpu?.systemLoad || 0) - (b.stats?.cpu?.systemLoad || 0)); // sort after memor
-                }
-                break;
-            case "calls":
-                {
-                    return connectedNodes
-                        .sort((a, b) => a.calls - b.calls); // client sided sorting
-                }
-                break;
-            case "playingPlayers":
-                {
-                    return connectedNodes
-                        .sort((a, b) => (a.stats?.playingPlayers || 0) - (b.stats?.playingPlayers || 0));
-                }
-                break;
-            case "players":
-                {
-                    return connectedNodes
-                        .sort((a, b) => (a.stats?.players || 0) - (b.stats?.players || 0));
-                }
-                break;
-            default:
-                {
-                    return connectedNodes
-                        .sort((a, b) => (a.stats?.players || 0) - (b.stats?.players || 0));
-                }
-                break;
-        }
-    }
-    /**
-     * Delete a node from the nodeManager and destroy it
-     * @param node The node to delete
-     * @param movePlayers whether to movePlayers to different connected node before deletion. @default false
-     * @returns
-     *
-     * @example
-     * Deletes the node
-     * ```ts
-     * client.lavalink.nodeManager.deleteNode("nodeId to delete");
-     * ```
-     * Moves players to a different node before deleting
-     * ```ts
-     * client.lavalink.nodeManager.deleteNode("nodeId to delete", true);
-     * ```
-     */
-    deleteNode(node, movePlayers = false) {
-        const decodeNode = typeof node === "string" ? this.nodes.get(node) : node || this.leastUsedNodes()[0];
-        if (!decodeNode)
-            throw new Error("Node was not found");
-        if (movePlayers)
-            decodeNode.destroy(Constants_1.DestroyReasons.NodeDeleted, true, true);
-        else
-            decodeNode.destroy(Constants_1.DestroyReasons.NodeDeleted);
-        this.nodes.delete(decodeNode.id);
-        return;
-    }
-}
-exports.NodeManager = NodeManager;

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

@@ -1,223 +0,0 @@
-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";
-import type { LavalinkManager } from "./LavalinkManager.js";
-import type { LavalinkPlayerVoiceOptions, LavaSearchQuery, SearchQuery } from "./Types/Utils.js";
-export declare class Player {
-    /** Filter Manager per player */
-    filterManager: FilterManager;
-    /** circular reference to the lavalink Manager from the Player for easier use */
-    LavalinkManager: LavalinkManager;
-    /** Player options currently used, mutation doesn't affect player's state */
-    options: PlayerOptions;
-    /** The lavalink node assigned the the player, don't change it manually */
-    node: LavalinkNode;
-    /** The queue from the player */
-    queue: Queue;
-    /** The Guild Id of the Player */
-    guildId: string;
-    /** The Voice Channel Id of the Player */
-    voiceChannelId: string | null;
-    /** The Text Channel Id of the Player */
-    textChannelId: string | null;
-    /** States if the Bot is supposed to be outputting audio */
-    playing: boolean;
-    /** States if the Bot is paused or not */
-    paused: boolean;
-    /** Repeat Mode of the Player */
-    repeatMode: RepeatMode;
-    /** Player's ping */
-    ping: {
-        lavalink: number;
-        ws: number;
-    };
-    /** The Display Volume */
-    volume: number;
-    /** The Volume Lavalink actually is outputting */
-    lavalinkVolume: number;
-    /** The current Positin of the player (Calculated) */
-    get position(): number;
-    /** The timestamp when the last position change update happened */
-    lastPositionChange: number;
-    /** The current Positin of the player (from Lavalink) */
-    lastPosition: number;
-    lastSavedPosition: number;
-    /** When the player was created [Timestamp in Ms] (from lavalink) */
-    createdTimeStamp: number;
-    /** The Player Connection's State (from Lavalink) */
-    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;
-    /**
-     * Create a new Player
-     * @param options
-     * @param LavalinkManager
-     */
-    constructor(options: PlayerOptions, LavalinkManager: LavalinkManager, dontEmitPlayerCreateEvent?: boolean);
-    /**
-     * Set custom data.
-     * @param key
-     * @param value
-     */
-    set(key: string, value: unknown): this;
-    /**
-     * Get custom data.
-     * @param key
-     */
-    get<T>(key: string): T;
-    /**
-     * CLears all the custom data.
-     */
-    clearData(): this;
-    /**
-     * Get all custom Data
-     */
-    getAllData(): Record<string, unknown>;
-    /**
-     * Play the next track from the queue / a specific track, with playoptions for Lavalink
-     * @param options
-     */
-    play(options?: Partial<PlayOptions>): any;
-    /**
-     * Set the Volume for the Player
-     * @param volume The Volume in percent
-     * @param ignoreVolumeDecrementer If it should ignore the volumedecrementer option
-     */
-    setVolume(volume: number, ignoreVolumeDecrementer?: boolean): Promise<this>;
-    /**
-     * Search for a track
-     * @param query The query to search for
-     * @param requestUser The user that requested the track
-     * @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").LavaSearchResponse | import("./Types/Utils.js").SearchResult>;
-    /**
-     * Set the SponsorBlock
-     * @param segments The segments to set
-     */
-    setSponsorBlock(segments?: SponsorBlockSegment[]): Promise<void>;
-    /**
-     * Get the SponsorBlock
-     */
-    getSponsorBlock(): Promise<SponsorBlockSegment[]>;
-    /**
-     * Delete the SponsorBlock
-     */
-    deleteSponsorBlock(): Promise<void>;
-    /**
-     *
-     * @param query Query for your data
-     * @param requestUser
-     */
-    search(query: SearchQuery, requestUser: unknown, throwOnEmpty?: boolean): Promise<import("./Types/Utils.js").UnresolvedSearchResult | import("./Types/Utils.js").SearchResult>;
-    /**
-     * Pause the player
-     */
-    pause(): Promise<this>;
-    /**
-     * Resume the Player
-     */
-    resume(): Promise<this>;
-    /**
-     * Seek to a specific Position
-     * @param position
-     */
-    seek(position: number): Promise<this>;
-    /**
-     * Set the Repeatmode of the Player
-     * @param repeatMode
-     */
-    setRepeatMode(repeatMode: RepeatMode): Promise<this>;
-    /**
-     * 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, throwError?: boolean): Promise<this>;
-    /**
-     * Clears the queue and stops playing. Does not destroy the Player and not leave the channel
-     * @returns
-     */
-    stopPlaying(clearQueue?: boolean, executeAutoplay?: boolean): Promise<this>;
-    /**
-     * Connects the Player to the Voice Channel
-     * @returns
-     */
-    connect(): Promise<this>;
-    changeVoiceState(data: {
-        voiceChannelId?: string;
-        selfDeaf?: boolean;
-        selfMute?: boolean;
-    }): Promise<this>;
-    /**
-     * Disconnects the Player from the Voice Channel, but keeps the player in the cache
-     * @param force If false it throws an error, if player thinks it's already disconnected
-     * @returns
-     */
-    disconnect(force?: boolean): Promise<this>;
-    /**
-     * 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
-     * @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
-     * @returns The unsubscribe function
-     * @example
-     * ```ts
-     * const lyrics = await player.unsubscribeLyrics();
-     * ```
-     */
-    unsubscribeLyrics(): Promise<void>;
-    /**
-     * Move the player on a different Audio-Node
-     * @param newNode New Node / New Node Id
-     * @param checkSources If it should check if the sources are supported by the new node
-     */
-    changeNode(newNode: LavalinkNode | string, checkSources?: boolean): Promise<string>;
-    /** Converts the Player including Queue to a Json state */
-    toJSON(): PlayerJson;
-}