lavalink-client 1.1.25 → 1.2.1

package/README.md

@@ -82,6 +82,10 @@ Check out the [Documentation](https://lc4.gitbook.io/lavalink-client) for **Exam
 - 🛡️ Lavalink Validations
   - It only let's you use the filters / plugins / sources, if Lavalink actually has it enabled
 
+- 🛡️ Client Validations
+  - Allows you to whitelist links and even blacklist links / words / domain names, so that it doesn't allow requests you don't want!
+  - Checks almost all Lavalink Requests for out of bound errors, right before the request is made to prevent process breaking errors. 
+
 - 🧑‍💻 Memory friendly and easy style
   - Only the required data is displayed, and the store-way & types match Lavalink#IMPLEMENTATION.md
 
@@ -91,4 +95,38 @@ Check out the [Documentation](https://lc4.gitbook.io/lavalink-client) for **Exam
   - Pauses / resumes the player if it get's muted / unmuted (server-wide) [soon]
   - ...
 
-- 😁 Much much more!
+- 😁 Much much more!
+
+# UpdateLog
+
+## **Version 1.2.0**
+- Added `player.stopPlaying()`: When executed it **clears the Queue** and **stops playing**, **without destroying the Player**
+- Adjusted `Player.skip()`
+  - Added `throwError` Property to: `player.skip(skipTo?:number = 0, throwError?:boolean = true)`.
+    - If throwError = false, and no more tracks are in the queue, it won't throw an error and "ignore it". same thing as stopPlaying.
+- Added all Events and Methods from the [SponsorBlock Plugin](https://github.com/topi314/Sponsorblock-Plugin).
+  - It also validates if the plugin is in the bot, in order so that you can use the functions:
+  - `player.getSponsorBlock()` / `node.getSponsorBlock()`
+  - `player.setSponsorBlock(segments:SponsorBlockSegment[])` / `node.setSponsorBlock(segments:SponsorBlockSegment[])`
+  - `player.deleteSponsorBlock()` / `node.deleteSponsorBlock()`
+    - That Plugin adds following **Events** to the **Manager**: `"SegmentsLoaded"`, `"SegmentSkipped"`, `"ChapterStarted"`, `"ChaptersLoaded"`
+- Example Bot show example in autoplayFunction how to "disable" / "enable" Autoplay with bot data variables.
+- Added `ManagerOptions#emitNewSongsOnly`. If set to true, it won't emit "trackStart" Event, when track.loop is active, or the new current track == the previous (current) track. 
+- Added `ManagerOptions#linksBlacklist` which allows user to specify an array of regExp / strings to match query strings (for links / words) and if a match happens it doesn't allow the request (blacklist) 
+- Added `ManagerOptions#linksWhitelist` which allows user to specify an array of regExp / strings to match query strings (for links only) and if a match does NOT HAPPEN it doesn't allow the request (whitelist)
+- Added `ManagerOptions#linksAllowed` if set to false, it does not allow requests which are links
+- Moved `ManaagerOptions#debugOptions` to `ManaagerOptions#advancedOptions.debugOptions`
+
+### **Version 1.2.1**
+- Adjusted `player.stopPlaying()`
+  - There are now following parameters. `stopPlaying(clearQueue:boolean = true, executeAutoplay:boolean = false)`.
+    - On Default it now clears the queue and stops playing. Also it does not execute Autoplay on default. IF you want the function to behave differently, you can use the 2 states for that. 
+  - Fixed that it looped the current track if repeatmode === "track" / "queue". (it stops playing and loop stays)
+- Implemented a `parseLavalinkConnUrl(connectionUrl:string)` Util Function.
+  - It allows you to parse Lavalink Connection Data of a Lavalink Connection Url. 
+  Pattern: `lavalink://<nodeId>:<nodeAuthorization(Password)>@<NodeHost>:<NodePort>`
+  - Note that the nodeId and NodeAuthorization must be encoded via encodeURIComponents before you provide it into the function.
+  - The function will return the following: `{ id: string, authorization: string, host: string, port: number }`
+  - Example: `parseLavalinkConnUrl("lavalink://LavalinkNode_1:strong%23password1@localhost:2345")` will give you:
+  `{ id: "LavalinkNode_1", authorization: "strong#password1", host: "localhost", port: 2345 }`
+    - Note that the password "strong#password1" when encoded turns into "strong%23password1". For more information check the example bot

package/dist/cjs/structures/CustomSearches/BandCampSearch.js

@@ -5,6 +5,7 @@ const undici_1 = require("undici");
 const bandCampSearch = async (player, query, requestUser) => {
     let error = null;
     let tracks = [];
+    player.LavalinkManager.utils.validateQueryString(player.node, query);
     try {
         const data = await (0, undici_1.fetch)(`https://bandcamp.com/api/nusearch/2/autocomplete?q=${encodeURIComponent(query)}`, {
             headers: {

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

@@ -5,7 +5,7 @@ import { NodeManager } from "./NodeManager";
 import { DestroyReasonsType, Player, PlayerJson, PlayerOptions } from "./Player";
 import { ManagerQueueOptions } from "./Queue";
 import { Track, UnresolvedTrack } from "./Track";
-import { ChannelDeletePacket, GuildShardPayload, ManagerUtils, MiniMap, SearchPlatform, TrackEndEvent, TrackExceptionEvent, TrackStartEvent, TrackStuckEvent, VoicePacket, VoiceServer, VoiceState, WebSocketClosedEvent } from "./Utils";
+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;
@@ -33,7 +33,7 @@ export interface ManagerPlayerOptions {
     onDisconnect?: {
         /** Try to reconnect? -> If fails -> Destroy */
         autoReconnect?: boolean;
-        /** Instantly destroy player (overrides autoReconnect) */
+        /** Instantly destroy player (overrides autoReconnect) | Don't provide == disable feature*/
         destroyPlayer?: boolean;
     };
     onEmptyQueue?: {
@@ -56,16 +56,27 @@ export interface ManagerOptions {
     playerOptions?: ManagerPlayerOptions;
     /** If it should skip to the next Track on TrackEnd / TrackError etc. events */
     autoSkip?: boolean;
-    /** optional */
-    debugOptions?: {
-        /** logs for debugging the "no-Audio" playing error */
-        noAudio?: boolean;
-        /** For Logging the Destroy function */
-        playerDestroy?: {
-            /** To show the debug reason at all times. */
-            debugLog?: boolean;
-            /** If you get 'Error: Use Player#destroy("reason") not LavalinkManager#deletePlayer() to stop the Player' put it on true */
-            dontThrowError?: boolean;
+    /** If it should emit only new (unique) songs and not when a looping track (or similar) is plaid, default false */
+    emitNewSongsOnly?: boolean;
+    /** Only allow link requests with links either matching some of that regExp or including some of that string */
+    linksWhitelist?: (RegExp | string)[];
+    /** Never allow link requests with links either matching some of that regExp or including some of that string (doesn't even allow if it's whitelisted) */
+    linksBlacklist?: (RegExp | string)[];
+    /** If links should be allowed or not. If set to false, it will throw an error if a link was provided. */
+    linksAllowed?: boolean;
+    /** Advanced Options for the Library, which may or may not be "library breaking" */
+    advancedOptions?: {
+        /** optional */
+        debugOptions?: {
+            /** logs for debugging the "no-Audio" playing error */
+            noAudio?: boolean;
+            /** For Logging the Destroy function */
+            playerDestroy?: {
+                /** To show the debug reason at all times. */
+                debugLog?: boolean;
+                /** If you get 'Error: Use Player#destroy("reason") not LavalinkManager#deletePlayer() to stop the Player' put it on true */
+                dontThrowError?: boolean;
+            };
         };
     };
 }
@@ -125,6 +136,34 @@ interface LavalinkManagerEvents {
      * @event Manager#playerUpdate
      */
     "playerUpdate": (oldPlayerJson: PlayerJson, newPlayer: Player) => void;
+    /**
+     * SPONSORBLOCK-PLUGIN EVENT
+     * Emitted when Segments are loaded
+     * @link https://github.com/topi314/Sponsorblock-Plugin#segmentsloaded
+     * @event Manager#trackError
+     */
+    "SegmentsLoaded": (player: Player, track: Track | UnresolvedTrack, payload: SponsorBlockSegmentsLoaded) => void;
+    /**
+     * SPONSORBLOCK-PLUGIN EVENT
+     * Emitted when a specific Segment was skipped
+     * @link https://github.com/topi314/Sponsorblock-Plugin#segmentskipped
+     * @event Manager#trackError
+     */
+    "SegmentSkipped": (player: Player, track: Track | UnresolvedTrack, payload: SponsorBlockSegmentSkipped) => void;
+    /**
+     * SPONSORBLOCK-PLUGIN EVENT
+     * Emitted when a specific Chapter starts playing
+     * @link https://github.com/topi314/Sponsorblock-Plugin#chapterstarted
+     * @event Manager#trackError
+     */
+    "ChapterStarted": (player: Player, track: Track | UnresolvedTrack, payload: SponsorBlockChapterStarted) => void;
+    /**
+     * SPONSORBLOCK-PLUGIN EVENT
+     * Emitted when Chapters are loaded
+     * @link https://github.com/topi314/Sponsorblock-Plugin#chaptersloaded
+     * @event Manager#trackError
+     */
+    "ChaptersLoaded": (player: Player, track: Track | UnresolvedTrack, payload: SponsorBlockChaptersLoaded) => void;
 }
 export interface LavalinkManager {
     options: ManagerOptions;

package/dist/cjs/structures/LavalinkManager.js

@@ -37,17 +37,22 @@ class LavalinkManager extends events_1.EventEmitter {
                 requesterTransformer: options?.playerOptions?.requesterTransformer ?? null,
                 useUnresolvedData: options?.playerOptions?.useUnresolvedData ?? false,
             },
+            linksWhitelist: options?.linksWhitelist ?? [],
+            linksBlacklist: options?.linksBlacklist ?? [],
             autoSkip: options?.autoSkip ?? true,
+            emitNewSongsOnly: options?.emitNewSongsOnly ?? false,
             queueOptions: {
                 maxPreviousTracks: options?.queueOptions?.maxPreviousTracks ?? 25,
                 queueChangesWatcher: options?.queueOptions?.queueChangesWatcher ?? null,
                 queueStore: options?.queueOptions?.queueStore ?? new Queue_1.DefaultQueueStore(),
             },
-            debugOptions: {
-                noAudio: options?.debugOptions?.noAudio ?? false,
-                playerDestroy: {
-                    dontThrowError: options?.debugOptions?.playerDestroy?.dontThrowError ?? false,
-                    debugLog: options?.debugOptions?.playerDestroy?.debugLog ?? false,
+            advancedOptions: {
+                debugOptions: {
+                    noAudio: options?.advancedOptions?.debugOptions?.noAudio ?? false,
+                    playerDestroy: {
+                        dontThrowError: options?.advancedOptions?.debugOptions?.playerDestroy?.dontThrowError ?? false,
+                        debugLog: options?.advancedOptions?.debugOptions?.playerDestroy?.debugLog ?? false,
+                    }
                 }
             }
         };
@@ -60,6 +65,8 @@ class LavalinkManager extends events_1.EventEmitter {
         // 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?.emitNewSongsOnly && typeof options?.emitNewSongsOnly !== "boolean")
+            throw new SyntaxError("ManagerOption.emitNewSongsOnly must be either false | true aka boolean");
         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 */
@@ -113,7 +120,7 @@ class LavalinkManager extends events_1.EventEmitter {
             return;
         // oldPlayer.connected is operational. you could also do oldPlayer.voice?.token 
         if (oldPlayer.voiceChannelId === "string" && oldPlayer.connected && !oldPlayer.get("internal_destroywithoutdisconnect")) {
-            if (!this.options?.debugOptions?.playerDestroy?.dontThrowError)
+            if (!this.options?.advancedOptions?.debugOptions?.playerDestroy?.dontThrowError)
                 throw new Error(`Use Player#destroy() not LavalinkManager#deletePlayer() to stop the Player ${JSON.stringify(oldPlayer.toJSON?.())}`);
             else
                 console.error("Use Player#destroy() not LavalinkManager#deletePlayer() to stop the Player", oldPlayer.toJSON?.());
@@ -159,12 +166,12 @@ class LavalinkManager extends events_1.EventEmitter {
      */
     async sendRawData(data) {
         if (!this.initiated) {
-            if (this.options?.debugOptions?.noAudio === true)
+            if (this.options?.advancedOptions?.debugOptions?.noAudio === true)
                 console.debug("Lavalink-Client-Debug | NO-AUDIO [::] sendRawData function, manager is not initated yet");
             return;
         }
         if (!("t" in data)) {
-            if (this.options?.debugOptions?.noAudio === true)
+            if (this.options?.advancedOptions?.debugOptions?.noAudio === true)
                 console.debug("Lavalink-Client-Debug | NO-AUDIO [::] sendRawData function, no 't' in payload-data of the raw event:", data);
             return;
         }
@@ -181,23 +188,23 @@ class LavalinkManager extends events_1.EventEmitter {
         if (["VOICE_STATE_UPDATE", "VOICE_SERVER_UPDATE"].includes(data.t)) {
             const update = ("d" in data ? data.d : data);
             if (!update) {
-                if (this.options?.debugOptions?.noAudio === true)
+                if (this.options?.advancedOptions?.debugOptions?.noAudio === true)
                     console.debug("Lavalink-Client-Debug | NO-AUDIO [::] sendRawData function, no update data found in payload:", data);
                 return;
             }
             if (!("token" in update) && !("session_id" in update)) {
-                if (this.options?.debugOptions?.noAudio === true)
+                if (this.options?.advancedOptions?.debugOptions?.noAudio === true)
                     console.debug("Lavalink-Client-Debug | NO-AUDIO [::] sendRawData function, no 'token' nor 'session_id' found in payload:", data);
                 return;
             }
             const player = this.getPlayer(update.guild_id);
             if (!player) {
-                if (this.options?.debugOptions?.noAudio === true)
+                if (this.options?.advancedOptions?.debugOptions?.noAudio === true)
                     console.debug("Lavalink-Client-Debug | NO-AUDIO [::] sendRawData function, No Lavalink Player found via key: 'guild_id' of update-data:", update);
                 return;
             }
             if (player.get("internal_destroystatus") === true) {
-                if (this.options?.debugOptions?.noAudio === true)
+                if (this.options?.advancedOptions?.debugOptions?.noAudio === true)
                     console.debug("Lavalink-Client-Debug | NO-AUDIO [::] sendRawData function, Player is in a destroying state. can't signal the voice states");
                 return;
             }
@@ -214,13 +221,13 @@ class LavalinkManager extends events_1.EventEmitter {
                         }
                     }
                 });
-                if (this.options?.debugOptions?.noAudio === true)
+                if (this.options?.advancedOptions?.debugOptions?.noAudio === true)
                     console.debug("Lavalink-Client-Debug | NO-AUDIO [::] sendRawData function, Sent updatePlayer for voice token session", { voice: { token: update.token, endpoint: update.endpoint, sessionId: player.voice?.sessionId, } });
                 return;
             }
             /* voice state update */
             if (update.user_id !== this.options?.client.id) {
-                if (this.options?.debugOptions?.noAudio === true)
+                if (this.options?.advancedOptions?.debugOptions?.noAudio === true)
                     console.debug("Lavalink-Client-Debug | NO-AUDIO [::] sendRawData function, voice update user is not equal to provided client id of the manageroptions#client#id", "user:", update.user_id, "manager client id:", this.options?.client.id);
                 return;
             }

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

@@ -2,11 +2,13 @@
 import internal from "stream";
 import { Dispatcher, Pool } from "undici";
 import { NodeManager } from "./NodeManager";
-import { DestroyReasonsType } from "./Player";
+import { DestroyReasonsType, Player } from "./Player";
 import { Track } from "./Track";
 import { Base64, InvalidLavalinkRestRequest, LavalinkPlayer, LavaSearchQuery, LavaSearchResponse, PlayerUpdateInfo, RoutePlanner, SearchQuery, SearchResult, Session } from "./Utils";
 /** Modifies any outgoing REST requests. */
 export type ModifyRequest = (options: Dispatcher.RequestOptions) => void;
+export declare const validSponsorBlocks: string[];
+export type SponsorBlockSegment = "sponsor" | "selfpromo" | "interaction" | "intro" | "outro" | "preview" | "music_offtopic" | "filler";
 export interface LavalinkNodeOptions {
     /** The Lavalink Server-Ip / Domain-URL */
     host: string;
@@ -240,8 +242,15 @@ export declare class LavalinkNode {
     private handleEvent;
     private trackStart;
     private trackEnd;
-    private queueEnd;
     private trackStuck;
     private trackError;
     private socketClosed;
+    private SponsorBlockSegmentLoaded;
+    private SponsorBlockSegmentkipped;
+    private SponsorBlockChaptersLoaded;
+    private SponsorBlockChapterStarted;
+    getSponsorBlock(player: Player): Promise<SponsorBlockSegment[]>;
+    setSponsorBlock(player: Player, segments?: SponsorBlockSegment[]): Promise<void>;
+    deleteSponsorBlock(player: Player): Promise<void>;
+    private queueEnd;
 }

package/dist/cjs/structures/Node.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LavalinkNode = void 0;
+exports.LavalinkNode = exports.validSponsorBlocks = void 0;
 const tslib_1 = require("tslib");
 const path_1 = require("path");
 const undici_1 = require("undici");
 const ws_1 = tslib_1.__importDefault(require("ws"));
 const Player_1 = require("./Player");
 const Utils_1 = require("./Utils");
+exports.validSponsorBlocks = ["sponsor", "selfpromo", "interaction", "intro", "outro", "preview", "music_offtopic", "filler"];
 class LavalinkNode {
     /** The provided Options of the Node */
     options;
@@ -98,9 +99,8 @@ class LavalinkNode {
     }
     async search(query, requestUser) {
         const Query = this.NodeManager.LavalinkManager.utils.transformQuery(query);
-        if (/^https?:\/\//.test(Query.query))
-            this.NodeManager.LavalinkManager.utils.validateQueryString(this, Query.source);
-        else if (Query.source)
+        this.NodeManager.LavalinkManager.utils.validateQueryString(this, Query.query);
+        if (Query.source)
             this.NodeManager.LavalinkManager.utils.validateSourceString(this, Query.source);
         if (["bcsearch", "bandcamp"].includes(Query.source)) {
             throw new Error("Bandcamp Search only works on the player!");
@@ -566,6 +566,7 @@ class LavalinkNode {
                 return;
         }
     }
+    // LAVALINK EVENT HANDLING UTIL FUNCTION
     async handleEvent(payload) {
         if (!payload.guildId)
             return;
@@ -588,20 +589,36 @@ class LavalinkNode {
             case "WebSocketClosedEvent":
                 this.socketClosed(player, payload);
                 break;
+            case "SegmentsLoaded":
+                this.SponsorBlockSegmentLoaded(player, player.queue.current, payload);
+                break;
+            case "SegmentSkipped":
+                this.SponsorBlockSegmentkipped(player, player.queue.current, payload);
+                break;
+            case "ChaptersLoaded":
+                this.SponsorBlockChaptersLoaded(player, player.queue.current, payload);
+                break;
+            case "ChapterStarted":
+                this.SponsorBlockChapterStarted(player, player.queue.current, payload);
+                break;
             default:
                 this.NodeManager.emit("error", this, new Error(`Node#event unknown event '${payload.type}'.`), payload);
                 break;
         }
         return;
     }
+    // LAVALINK EVENT HANDLING FUNCTIONS
     trackStart(player, track, payload) {
         player.playing = true;
         player.paused = false;
+        // don't emit the event if previous track == new track aka track loop
+        if (this.NodeManager.LavalinkManager.options?.emitNewSongsOnly === true && player.queue.previous[0]?.info?.identifier === track?.info?.identifier)
+            return;
         return this.NodeManager.LavalinkManager.emit("trackStart", player, track, payload);
     }
     async trackEnd(player, track, payload) {
         // If there are no songs in the queue
-        if (!player.queue.tracks.length && player.repeatMode === "off")
+        if (!player.queue.tracks.length && (player.repeatMode === "off" || player.get("internal_stopPlaying")))
             return this.queueEnd(player, track, payload);
         // If a track was forcibly played
         if (payload.reason === "replaced")
@@ -620,6 +637,12 @@ class LavalinkNode {
         // remove tracks from the queue
         if (player.repeatMode !== "track")
             await (0, Utils_1.queueTrackEnd)(player);
+        else if (player.queue.current) { // If there was a current Track already and repeatmode === true, add it to the queue.
+            player.queue.previous.unshift(player.queue.current);
+            if (player.queue.previous.length > player.queue.options.maxPreviousTracks)
+                player.queue.previous.splice(player.queue.options.maxPreviousTracks, player.queue.previous.length);
+            await player.queue.utils.save();
+        }
         // if no track available, end queue
         if (!player.queue.current)
             return this.queueEnd(player, track, payload);
@@ -628,11 +651,92 @@ class LavalinkNode {
         // play track if autoSkip is true
         return this.NodeManager.LavalinkManager.options.autoSkip && player.play({ noReplace: true });
     }
+    async trackStuck(player, track, payload) {
+        this.NodeManager.LavalinkManager.emit("trackStuck", player, track, payload);
+        // If there are no songs in the queue
+        if (!player.queue.tracks.length && (player.repeatMode === "off" || player.get("internal_stopPlaying")))
+            return this.queueEnd(player, track, payload);
+        // remove the current track, and enqueue the next one
+        await (0, Utils_1.queueTrackEnd)(player);
+        // if no track available, end queue
+        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({ noReplace: true });
+    }
+    async trackError(player, track, payload) {
+        this.NodeManager.LavalinkManager.emit("trackError", player, track, payload);
+        // If there are no songs in the queue
+        if (!player.queue.tracks.length && (player.repeatMode === "off" || player.get("internal_stopPlaying")))
+            return this.queueEnd(player, track, payload);
+        // remove the current track, and enqueue the next one
+        await (0, Utils_1.queueTrackEnd)(player);
+        // if no track available, end queue
+        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({ noReplace: true });
+    }
+    socketClosed(player, payload) {
+        return this.NodeManager.LavalinkManager.emit("playerSocketClosed", player, payload);
+    }
+    // SPONSOR BLOCK EVENT FUNCTIONS
+    SponsorBlockSegmentLoaded(player, track, payload) {
+        return this.NodeManager.LavalinkManager.emit("SegmentsLoaded", player, track, payload);
+    }
+    SponsorBlockSegmentkipped(player, track, payload) {
+        return this.NodeManager.LavalinkManager.emit("SegmentSkipped", player, track, payload);
+    }
+    SponsorBlockChaptersLoaded(player, track, payload) {
+        return this.NodeManager.LavalinkManager.emit("ChaptersLoaded", player, track, payload);
+    }
+    SponsorBlockChapterStarted(player, track, payload) {
+        return this.NodeManager.LavalinkManager.emit("ChapterStarted", player, track, payload);
+    }
+    // SPONSOR BLOCK EXECUTE FUNCTIONS
+    async getSponsorBlock(player) {
+        // no plugin enabled
+        if (!this.info.plugins.find(v => v.name === "sponsorblock-plugin"))
+            throw new RangeError(`there is no sponsorblock-plugin available in the lavalink node: ${this.id}`);
+        // do the request
+        return await this.request(`/sessions/${this.sessionId}/players/${player.guildId}/sponsorblock/categories`);
+    }
+    async setSponsorBlock(player, segments = ["sponsor", "selfpromo"]) {
+        // no plugin enabled
+        if (!this.info.plugins.find(v => v.name === "sponsorblock-plugin"))
+            throw new RangeError(`there is no sponsorblock-plugin available in the lavalink node: ${this.id}`);
+        // no segments length
+        if (!segments.length)
+            throw new RangeError("No Segments provided. Did you ment to use 'deleteSponsorBlock'?");
+        // a not valid segment
+        if (segments.some(v => !exports.validSponsorBlocks.includes(v.toLowerCase())))
+            throw new SyntaxError(`You provided a sponsorblock which isn't valid, valid ones are: ${exports.validSponsorBlocks.map(v => `'${v}'`).join(", ")}`);
+        // do the request
+        await this.request(`/sessions/${this.sessionId}/players/${player.guildId}/sponsorblock/categories`, (request) => {
+            request.method = "PUT";
+            request.body = JSON.stringify(segments.map(v => v.toLowerCase()));
+            return request;
+        });
+        return;
+    }
+    async deleteSponsorBlock(player) {
+        // no plugin enabled
+        if (!this.info.plugins.find(v => v.name === "sponsorblock-plugin"))
+            throw new RangeError(`there is no sponsorblock-plugin available in the lavalink node: ${this.id}`);
+        // do the request
+        await this.request(`/sessions/${this.sessionId}/players/${player.guildId}/sponsorblock/categories`, (request) => {
+            request.method = "DELETE";
+            return request;
+        });
+        return;
+    }
+    // UTIL FOR QUEUE END
     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") {
+        player.set("internal_stopPlaying", undefined);
+        if (typeof this.NodeManager.LavalinkManager.options?.playerOptions?.onEmptyQueue?.autoPlayFunction === "function" && typeof player.get("internal_autoplayStopPlaying") === "undefined") {
             await this.NodeManager.LavalinkManager.options?.playerOptions?.onEmptyQueue?.autoPlayFunction(player, track);
             if (player.queue.tracks.length > 0)
                 await (0, Utils_1.queueTrackEnd)(player);
@@ -642,6 +746,7 @@ class LavalinkNode {
                 return player.play({ noReplace: true, paused: false });
             }
         }
+        player.set("internal_autoplayStopPlaying", undefined);
         player.queue.previous.unshift(track);
         if (payload?.reason !== "stopped") {
             await player.queue.utils.save();
@@ -661,31 +766,5 @@ class LavalinkNode {
         }
         return this.NodeManager.LavalinkManager.emit("queueEnd", player, track, payload);
     }
-    async trackStuck(player, track, payload) {
-        this.NodeManager.LavalinkManager.emit("trackStuck", player, track, payload);
-        // If there are no songs in the queue
-        if (!player.queue.tracks.length && player.repeatMode === "off")
-            return;
-        // remove the current track, and enqueue the next one
-        await (0, Utils_1.queueTrackEnd)(player);
-        // if no track available, end queue
-        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({ noReplace: true });
-    }
-    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);
-        // if no track available, end queue
-        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({ noReplace: true });
-    }
-    socketClosed(player, payload) {
-        return this.NodeManager.LavalinkManager.emit("playerSocketClosed", player, payload);
-    }
 }
 exports.LavalinkNode = LavalinkNode;

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

@@ -1,6 +1,6 @@
 import { EQBand, FilterData, FilterManager, LavalinkFilterData } from "./Filters";
 import { LavalinkManager } from "./LavalinkManager";
-import { LavalinkNode } from "./Node";
+import { LavalinkNode, SponsorBlockSegment } from "./Node";
 import { Queue } from "./Queue";
 import { Track, UnresolvedTrack } from "./Track";
 import { LavalinkPlayerVoiceOptions, LavaSearchQuery, SearchQuery } from "./Utils";
@@ -149,6 +149,9 @@ export declare class Player {
      */
     setVolume(volume: number, ignoreVolumeDecrementer?: boolean): Promise<this>;
     lavaSearch(query: LavaSearchQuery, requestUser: unknown): Promise<import("./Utils").SearchResult | import("./Utils").LavaSearchResponse>;
+    setSponsorBlock(segments?: SponsorBlockSegment[]): Promise<void>;
+    getSponsorBlock(): Promise<SponsorBlockSegment[]>;
+    deleteSponsorBlock(): Promise<void>;
     /**
      *
      * @param query Query for your data
@@ -177,12 +180,22 @@ export declare class Player {
      * 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<any>;
+    skip(skipTo?: number, throwError?: boolean): Promise<any>;
+    /**
+     * 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