lavalink-client 2.1.2 → 2.1.4

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

@@ -6,10 +6,6 @@ import { DestroyReasonsType, Player, PlayerJson, PlayerOptions } from "./Player"
 import { ManagerQueueOptions } from "./Queue";
 import { Track, UnresolvedTrack } from "./Track";
 import { ChannelDeletePacket, GuildShardPayload, ManagerUtils, MiniMap, SearchPlatform, SponsorBlockChaptersLoaded, SponsorBlockChapterStarted, SponsorBlockSegmentSkipped, SponsorBlockSegmentsLoaded, TrackEndEvent, TrackExceptionEvent, TrackStartEvent, TrackStuckEvent, VoicePacket, VoiceServer, VoiceState, WebSocketClosedEvent } from "./Utils";
-export interface LavalinkManager {
-    nodeManager: NodeManager;
-    utils: ManagerUtils;
-}
 export interface BotClientOptions {
     /** Bot Client Id */
     id: string;
@@ -168,31 +164,186 @@ interface LavalinkManagerEvents {
     "ChaptersLoaded": (player: Player, track: Track | UnresolvedTrack, payload: SponsorBlockChaptersLoaded) => void;
 }
 export interface LavalinkManager {
-    options: ManagerOptions;
+    /** @private */
     on<U extends keyof LavalinkManagerEvents>(event: U, listener: LavalinkManagerEvents[U]): this;
+    /** @private */
     emit<U extends keyof LavalinkManagerEvents>(event: U, ...args: Parameters<LavalinkManagerEvents[U]>): boolean;
 }
 export declare class LavalinkManager extends EventEmitter {
-    static DefaultSources: Record<SearchPlatform, import("./Utils").LavalinkSearchPlatform | import("./Utils").ClientCustomSearchPlatformUtils>;
-    static SourceLinksRegexes: Record<import("./Utils").SourcesRegex, RegExp>;
+    /** The Options of LavalinkManager (changeable) */
+    options: ManagerOptions;
+    /** LavalinkManager's NodeManager to manage all Nodes */
+    nodeManager: NodeManager;
+    /** LavalinkManager's Utils Class */
+    utils: ManagerUtils;
+    /** Wether the manager was initiated or not */
     initiated: boolean;
+    /** All Players stored in a MiniMap */
     readonly players: MiniMap<string, Player>;
+    /**
+     * Applies the options provided by the User
+     * @param options
+     * @returns
+     */
     private applyOptions;
+    /**
+     * Validates the current manager's options
+     * @param options
+     */
     private validateOptions;
+    /**
+     * Create the Lavalink Manager
+     * @param options
+     *
+     * @example
+     * ```ts
+     * //const client = new Client({...}); // create your BOT Client (e.g. via discord.js)
+     * client.lavalink = new LavalinkManager({
+     *   nodes: [
+     *     {
+     *       authorization: "yourverystrongpassword",
+     *       host: "localhost",
+     *       port: 2333,
+     *       id: "testnode"
+     *     },
+     *     sendToShard(guildId, payload) => client.guilds.cache.get(guildId)?.shard?.send(payload),
+     *     client: {
+     *       id: process.env.CLIENT_ID,
+     *       username: "TESTBOT"
+     *     },
+     *     // optional Options:
+     *     autoSkip: true,
+     *     playerOptions: {
+     *       applyVolumeAsFilter: false,
+     *       clientBasedPositionUpdateInterval: 150,
+     *       defaultSearchPlatform: "ytmsearch",
+     *       volumeDecrementer: 0.75,
+     *       //requesterTransformer: YourRequesterTransformerFunction,
+     *       onDisconnect: {
+     *         autoReconnect: true,
+     *         destroyPlayer: false
+     *       },
+     *       onEmptyQueue: {
+     *         destroyAfterMs: 30_000,
+     *         //autoPlayFunction: YourAutoplayFunction,
+     *       },
+     *       useUnresolvedData: true
+     *     },
+     *     queueOptions: {
+     *       maxPreviousTracks: 25,
+     *       //queueStore: yourCustomQueueStoreManagerClass,
+     *       //queueChangesWatcher: yourCustomQueueChangesWatcherClass
+     *     },
+     *     linksBlacklist: [],
+     *     linksWhitelist: [],
+     *     advancedOptions: {
+     *       debugOptions: {
+     *         noAudio: false,
+     *         playerDestroy: {
+     *           dontThrowError: false,
+     *           debugLogs: false
+     *         }
+     *       }
+     *     }
+     *   ]
+     * })
+     * ```
+     */
     constructor(options: ManagerOptions);
-    createPlayer(options: PlayerOptions): Player;
+    /**
+     * Get a Player from Lava
+     * @param guildId The guildId of the player
+     *
+     * @example
+     * ```ts
+     * const player = client.lavalink.getPlayer(interaction.guildId);
+     * ```
+     * A quicker and easier way than doing:
+     * ```ts
+     * const player = client.lavalink.players.get(interaction.guildId);
+     * ```
+     * @returns
+     */
     getPlayer(guildId: string): Player;
+    /**
+     * Create a Music-Player. If a player exists, then it returns it before creating a new one
+     * @param options
+     * @returns
+     *
+     * @example
+     * ```ts
+     * const player = client.lavalink.createPlayer({
+     *   guildId: interaction.guildId,
+     *   voiceChannelId: interaction.member.voice.channelId,
+     *   // everything below is optional
+     *   textChannelId: interaction.channelId,
+     *   volume: 100,
+     *   selfDeaf: true,
+     *   selfMute: false,
+     *   instaUpdateFiltersFix: true,
+     *   applyVolumeAsFilter: false
+     *   //only needed if you want to autopick node by region (configured by you)
+     *   // vcRegion: interaction.member.voice.rtcRegion,
+     *   // provide a specific node
+     *   // node: client.lavalink.nodeManager.leastUsedNodes("memory")[0]
+     * });
+     * ```
+     */
+    createPlayer(options: PlayerOptions): Player;
+    /**
+     * Destroy a player with optional destroy reason and disconnect it from the voice channel
+     * @param guildId
+     * @param destroyReason
+     * @returns
+     *
+     * @example
+     * ```ts
+     * client.lavalink.destroyPlayer(interaction.guildId, "forcefully destroyed the player");
+     * // recommend to do it on the player tho: player.destroy("forcefully destroyed the player");
+     * ```
+     */
     destroyPlayer(guildId: string, destroyReason?: string): Promise<Player>;
+    /**
+     * Delete's a player from the cache without destroying it on lavalink (only works when it's disconnected)
+     * @param guildId
+     * @returns
+     */
     deletePlayer(guildId: string): boolean;
+    /**
+     * Checks wether the the lib is useable based on if any node is connected
+     */
     get useable(): boolean;
     /**
-     * Initiates the Manager.
+     * Initiates the Manager, creates all nodes and connects all of them
      * @param clientData
+     *
+     * @example
+     *
+     * ```ts
+     * // on the bot ready event
+     * client.on("ready", () => {
+     *   client.lavalink.init({
+     *     id: client.user.id,
+     *     username: client.user.username
+     *   });
+     * });
+     * ```
      */
     init(clientData: BotClientOptions): Promise<this>;
     /**
      * Sends voice data to the Lavalink server.
+     * ! Without this the library won't work
      * @param data
+     *
+     * @example
+     *
+     * ```ts
+     * // on the bot "raw" event
+     * client.on("raw", (d) => {
+     *   // required in order to send audio updates and register channel deletion etc.
+     *   client.lavalink.sendRawData(d)
+     * })
+     * ```
      */
     sendRawData(data: VoicePacket | VoiceServer | VoiceState | ChannelDeletePacket): Promise<void>;
 }

package/dist/esm/structures/LavalinkManager.js

@@ -1,14 +1,24 @@
 import { EventEmitter } from "events";
-import { DefaultSources, SourceLinksRegexes } from "./LavalinkManagerStatics";
 import { NodeManager } from "./NodeManager";
 import { DestroyReasons, Player } from "./Player";
 import { DefaultQueueStore } from "./Queue";
 import { ManagerUtils, MiniMap } from "./Utils";
 export class LavalinkManager extends EventEmitter {
-    static DefaultSources = DefaultSources;
-    static SourceLinksRegexes = SourceLinksRegexes;
+    /** The Options of LavalinkManager (changeable) */
+    options;
+    /** LavalinkManager's NodeManager to manage all Nodes */
+    nodeManager;
+    /** LavalinkManager's Utils Class */
+    utils;
+    /** Wether the manager was initiated or not */
     initiated = false;
+    /** All Players stored in a MiniMap */
     players = new MiniMap();
+    /**
+     * Applies the options provided by the User
+     * @param options
+     * @returns
+     */
     applyOptions(options) {
         this.options = {
             client: {
@@ -56,6 +66,10 @@ export class LavalinkManager extends EventEmitter {
         };
         return;
     }
+    /**
+     * Validates the current manager's options
+     * @param options
+     */
     validateOptions(options) {
         if (typeof options?.sendToShard !== "function")
             throw new SyntaxError("ManagerOption.sendToShard was not provided, which is required!");
@@ -86,6 +100,64 @@ export class LavalinkManager extends EventEmitter {
         if (typeof options?.queueOptions?.maxPreviousTracks !== "number" || options?.queueOptions?.maxPreviousTracks < 0)
             options.queueOptions.maxPreviousTracks = 25;
     }
+    /**
+     * Create the Lavalink Manager
+     * @param options
+     *
+     * @example
+     * ```ts
+     * //const client = new Client({...}); // create your BOT Client (e.g. via discord.js)
+     * client.lavalink = new LavalinkManager({
+     *   nodes: [
+     *     {
+     *       authorization: "yourverystrongpassword",
+     *       host: "localhost",
+     *       port: 2333,
+     *       id: "testnode"
+     *     },
+     *     sendToShard(guildId, payload) => client.guilds.cache.get(guildId)?.shard?.send(payload),
+     *     client: {
+     *       id: process.env.CLIENT_ID,
+     *       username: "TESTBOT"
+     *     },
+     *     // optional Options:
+     *     autoSkip: true,
+     *     playerOptions: {
+     *       applyVolumeAsFilter: false,
+     *       clientBasedPositionUpdateInterval: 150,
+     *       defaultSearchPlatform: "ytmsearch",
+     *       volumeDecrementer: 0.75,
+     *       //requesterTransformer: YourRequesterTransformerFunction,
+     *       onDisconnect: {
+     *         autoReconnect: true,
+     *         destroyPlayer: false
+     *       },
+     *       onEmptyQueue: {
+     *         destroyAfterMs: 30_000,
+     *         //autoPlayFunction: YourAutoplayFunction,
+     *       },
+     *       useUnresolvedData: true
+     *     },
+     *     queueOptions: {
+     *       maxPreviousTracks: 25,
+     *       //queueStore: yourCustomQueueStoreManagerClass,
+     *       //queueChangesWatcher: yourCustomQueueChangesWatcherClass
+     *     },
+     *     linksBlacklist: [],
+     *     linksWhitelist: [],
+     *     advancedOptions: {
+     *       debugOptions: {
+     *         noAudio: false,
+     *         playerDestroy: {
+     *           dontThrowError: false,
+     *           debugLogs: false
+     *         }
+     *       }
+     *     }
+     *   ]
+     * })
+     * ```
+     */
     constructor(options) {
         super();
         if (!options)
@@ -97,6 +169,47 @@ export class LavalinkManager extends EventEmitter {
         // create classes
         this.nodeManager = new NodeManager(this);
     }
+    /**
+     * Get a Player from Lava
+     * @param guildId The guildId of the player
+     *
+     * @example
+     * ```ts
+     * const player = client.lavalink.getPlayer(interaction.guildId);
+     * ```
+     * A quicker and easier way than doing:
+     * ```ts
+     * const player = client.lavalink.players.get(interaction.guildId);
+     * ```
+     * @returns
+     */
+    getPlayer(guildId) {
+        return this.players.get(guildId);
+    }
+    /**
+     * Create a Music-Player. If a player exists, then it returns it before creating a new one
+     * @param options
+     * @returns
+     *
+     * @example
+     * ```ts
+     * const player = client.lavalink.createPlayer({
+     *   guildId: interaction.guildId,
+     *   voiceChannelId: interaction.member.voice.channelId,
+     *   // everything below is optional
+     *   textChannelId: interaction.channelId,
+     *   volume: 100,
+     *   selfDeaf: true,
+     *   selfMute: false,
+     *   instaUpdateFiltersFix: true,
+     *   applyVolumeAsFilter: false
+     *   //only needed if you want to autopick node by region (configured by you)
+     *   // vcRegion: interaction.member.voice.rtcRegion,
+     *   // provide a specific node
+     *   // node: client.lavalink.nodeManager.leastUsedNodes("memory")[0]
+     * });
+     * ```
+     */
     createPlayer(options) {
         const oldPlayer = this.getPlayer(options?.guildId);
         if (oldPlayer)
@@ -105,15 +218,29 @@ export class LavalinkManager extends EventEmitter {
         this.players.set(newPlayer.guildId, newPlayer);
         return newPlayer;
     }
-    getPlayer(guildId) {
-        return this.players.get(guildId);
-    }
+    /**
+     * Destroy a player with optional destroy reason and disconnect it from the voice channel
+     * @param guildId
+     * @param destroyReason
+     * @returns
+     *
+     * @example
+     * ```ts
+     * client.lavalink.destroyPlayer(interaction.guildId, "forcefully destroyed the player");
+     * // recommend to do it on the player tho: player.destroy("forcefully destroyed the player");
+     * ```
+     */
     destroyPlayer(guildId, destroyReason) {
         const oldPlayer = this.getPlayer(guildId);
         if (!oldPlayer)
             return;
         return oldPlayer.destroy(destroyReason);
     }
+    /**
+     * Delete's a player from the cache without destroying it on lavalink (only works when it's disconnected)
+     * @param guildId
+     * @returns
+     */
     deletePlayer(guildId) {
         const oldPlayer = this.getPlayer(guildId);
         if (!oldPlayer)
@@ -127,12 +254,27 @@ export class LavalinkManager extends EventEmitter {
         }
         return this.players.delete(guildId);
     }
+    /**
+     * Checks wether the the lib is useable based on if any node is connected
+     */
     get useable() {
         return this.nodeManager.nodes.filter(v => v.connected).size > 0;
     }
     /**
-     * Initiates the Manager.
+     * Initiates the Manager, creates all nodes and connects all of them
      * @param clientData
+     *
+     * @example
+     *
+     * ```ts
+     * // on the bot ready event
+     * client.on("ready", () => {
+     *   client.lavalink.init({
+     *     id: client.user.id,
+     *     username: client.user.username
+     *   });
+     * });
+     * ```
      */
     async init(clientData) {
         if (this.initiated)
@@ -162,7 +304,18 @@ export class LavalinkManager extends EventEmitter {
     }
     /**
      * Sends voice data to the Lavalink server.
+     * ! Without this the library won't work
      * @param data
+     *
+     * @example
+     *
+     * ```ts
+     * // on the bot "raw" event
+     * client.on("raw", (d) => {
+     *   // required in order to send audio updates and register channel deletion etc.
+     *   client.lavalink.sendRawData(d)
+     * })
+     * ```
      */
     async sendRawData(data) {
         if (!this.initiated) {

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

@@ -172,7 +172,7 @@ export declare class Player {
      * @param query Query for your data
      * @param requestUser
      */
-    search(query: SearchQuery, requestUser: unknown): Promise<import("./Utils").UnresolvedSearchResult | import("./Utils").SearchResult>;
+    search(query: SearchQuery, requestUser: unknown): Promise<import("./Utils").SearchResult | import("./Utils").UnresolvedSearchResult>;
     /**
      * Pause the player
      */

package/dist/esm/structures/Utils.js

@@ -239,7 +239,8 @@ export class ManagerUtils {
             source: DefaultSources[(typeof query === "string" ? undefined : query.source?.trim?.()?.toLowerCase?.()) ?? this.LavalinkManager?.options?.playerOptions?.defaultSearchPlatform?.toLowerCase?.()] ?? (typeof query === "string" ? undefined : query.source?.trim?.()?.toLowerCase?.()) ?? this.LavalinkManager?.options?.playerOptions?.defaultSearchPlatform?.toLowerCase?.()
         };
         const foundSource = Object.keys(DefaultSources).find(source => Query.query?.toLowerCase?.()?.startsWith(`${source}:`.toLowerCase()))?.trim?.()?.toLowerCase?.();
-        if (foundSource && DefaultSources[foundSource]) {
+        // ignore links...
+        if (foundSource && !["https", "http"].includes(foundSource) && DefaultSources[foundSource]) {
             Query.source = DefaultSources[foundSource]; // set the source to ytsearch:
             Query.query = Query.query.slice(`${foundSource}:`.length, Query.query.length); // remove ytsearch: from the query
         }