lavalink-client 2.2.1 → 2.3.0

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

@@ -0,0 +1,184 @@
+import type { Player } from "../Player";
+import type { LavalinkNodeOptions } from "./Node";
+import type { DestroyReasonsType, PlayerJson } from "./Player";
+import type { ManagerQueueOptions } from "./Queue";
+import type { Track, UnresolvedTrack } from "./Track";
+import type { GuildShardPayload, SearchPlatform, SponsorBlockChaptersLoaded, SponsorBlockChapterStarted, SponsorBlockSegmentSkipped, SponsorBlockSegmentsLoaded, TrackExceptionEvent, TrackEndEvent, TrackStuckEvent, WebSocketClosedEvent, TrackStartEvent } from "./Utils";
+/**
+ * The events from the lavalink Manager
+ */
+export interface LavalinkManagerEvents {
+    /**
+     * Emitted when a Track started playing.
+     * @event Manager#trackStart
+     */
+    "trackStart": (player: Player, track: Track | null, payload: TrackStartEvent) => void;
+    /**
+     * Emitted when a Track finished.
+     * @event Manager#trackEnd
+     */
+    "trackEnd": (player: Player, track: Track | null, payload: TrackEndEvent) => void;
+    /**
+     * Emitted when a Track got stuck while playing.
+     * @event Manager#trackStuck
+     */
+    "trackStuck": (player: Player, track: Track | null, payload: TrackStuckEvent) => void;
+    /**
+     * Emitted when a Track errored.
+     * @event Manager#trackError
+     */
+    "trackError": (player: Player, track: Track | UnresolvedTrack | null, payload: TrackExceptionEvent) => void;
+    /**
+     * Emitted when the Playing finished and no more tracks in the queue.
+     * @event Manager#queueEnd
+     */
+    "queueEnd": (player: Player, track: Track | UnresolvedTrack | null, payload: TrackEndEvent | TrackStuckEvent | TrackExceptionEvent) => void;
+    /**
+     * Emitted when a Player is created.
+     * @event Manager#playerCreate
+     */
+    "playerCreate": (player: Player) => void;
+    /**
+     * Emitted when a Player is moved within the channel.
+     * @event Manager#playerMove
+     */
+    "playerMove": (player: Player, oldVoiceChannelId: string, newVoiceChannelId: string) => void;
+    /**
+     * Emitted when a Player is disconnected from a channel.
+     * @event Manager#playerDisconnect
+     */
+    "playerDisconnect": (player: Player, voiceChannelId: string) => void;
+    /**
+     * Emitted when a Node-Socket got closed for a specific Player.
+     * Usually emits when the audio websocket to discord is closed, This can happen for various reasons (normal and abnormal), e.g. when using an expired voice server update. 4xxx codes are usually bad.
+     *
+     * So this is just information, normally lavalink should handle disconnections
+     *
+     * Discord Docs:
+     * @link https://discord.com/developers/docs/topics/opcodes-and-status-codes#voice-voice-close-event-codes
+     *
+     * Lavalink Docs:
+     * @link https://lavalink.dev/api/websocket.html#websocketclosedevent
+     * @event Manager#playerSocketClosed
+     */
+    "playerSocketClosed": (player: Player, payload: WebSocketClosedEvent) => void;
+    /**
+     * Emitted when a Player get's destroyed
+     * @event Manager#playerDestroy
+     */
+    "playerDestroy": (player: Player, destroyReason?: DestroyReasonsType) => void;
+    /**
+     * Always emits when the player (on lavalink side) got updated
+     * @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 | null, 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 | null, 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 | null, 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 | null, payload: SponsorBlockChaptersLoaded) => void;
+}
+/**
+ * The Bot client Options needed for the manager
+ */
+export interface BotClientOptions {
+    /** Bot Client Id */
+    id: string;
+    /** Bot Client Username */
+    username?: string;
+    /** So users can pass entire objects / classes */
+    [x: string | number | symbol]: unknown;
+}
+/** Sub Manager Options, for player specific things */
+export interface ManagerPlayerOptions {
+    /** If the Lavalink Volume should be decremented by x number */
+    volumeDecrementer?: number;
+    /** How often it should update the the player Position */
+    clientBasedPositionUpdateInterval?: number;
+    /** What should be used as a searchPlatform, if no source was provided during the query */
+    defaultSearchPlatform?: SearchPlatform;
+    /** Applies the volume via a filter, not via the lavalink volume transformer */
+    applyVolumeAsFilter?: boolean;
+    /** Transforms the saved data of a requested user */
+    requesterTransformer?: (requester: unknown) => unknown;
+    /** What lavalink-client should do when the player reconnects */
+    onDisconnect?: {
+        /** Try to reconnect? -> If fails -> Destroy */
+        autoReconnect?: boolean;
+        /** Instantly destroy player (overrides autoReconnect) | Don't provide == disable feature*/
+        destroyPlayer?: boolean;
+    };
+    onEmptyQueue?: {
+        /** Get's executed onEmptyQueue -> You can do any track queue previous transformations, if you add a track to the queue -> it will play it, if not queueEnd will execute! */
+        autoPlayFunction?: (player: Player, lastPlayedTrack: Track) => Promise<void>;
+        destroyAfterMs?: number;
+    };
+    useUnresolvedData?: boolean;
+}
+/** Manager Options used to create the manager */
+export interface ManagerOptions {
+    /** The Node Options, for all Nodes! (on init) */
+    nodes: LavalinkNodeOptions[];
+    /** @async The Function to send the voice connection changes from Lavalink to Discord */
+    sendToShard: (guildId: string, payload: GuildShardPayload) => void;
+    /** The Bot Client's Data for Authorization */
+    client?: BotClientOptions;
+    /** QueueOptions for all Queues */
+    queueOptions?: ManagerQueueOptions;
+    /** PlayerOptions for all Players */
+    playerOptions?: ManagerPlayerOptions;
+    /** If it should skip to the next Track on TrackEnd / TrackError etc. events */
+    autoSkip?: boolean;
+    /** If it should skip to the next Track if track.resolve errors while trying to play a track. */
+    autoSkipOnResolveError?: 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?: {
+        /** Max duration for that the filter fix duration works (in ms) - default is 8mins */
+        maxFilterFixDuration?: number;
+        /** optional */
+        debugOptions?: {
+            /** For logging custom searches */
+            logCustomSearches?: boolean;
+            /** 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;
+            };
+        };
+    };
+}

package/dist/cjs/structures/Types/Manager.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,216 @@
+/// <reference types="node" />
+import type internal from "stream";
+import type { LavalinkNode } from "../Node";
+import type { DestroyReasonsType } from "./Player";
+import type { InvalidLavalinkRestRequest, LavalinkPlayer } from "./Utils";
+/** Ability to manipulate fetch requests */
+export type ModifyRequest = (options: RequestInit & {
+    path: string;
+    extraQueryUrlParams?: URLSearchParams;
+}) => void;
+export type SponsorBlockSegment = "sponsor" | "selfpromo" | "interaction" | "intro" | "outro" | "preview" | "music_offtopic" | "filler";
+/**
+ * Node Options for creating a lavalink node
+ */
+export interface LavalinkNodeOptions {
+    /** The Lavalink Server-Ip / Domain-URL */
+    host: string;
+    /** The Lavalink Connection Port */
+    port: number;
+    /** The Lavalink Password / Authorization-Key */
+    authorization: string;
+    /** Does the Server use ssl (https) */
+    secure?: boolean;
+    /** RESUME THE PLAYER? by providing a sessionid on the node-creation */
+    sessionId?: string;
+    /** Add a Custom ID to the node, for later use */
+    id?: string;
+    /** Voice Regions of this Node */
+    regions?: string[];
+    /** The retryAmount for the node. */
+    retryAmount?: number;
+    /** The retryDelay for the node. */
+    retryDelay?: number;
+    /** signal for cancelling requests - default: AbortSignal.timeout(options.requestSignalTimeoutMS || 10000) - put <= 0 to disable */
+    requestSignalTimeoutMS?: number;
+    /** Close on error */
+    closeOnError?: boolean;
+    /** Heartbeat interval , set to <= 0 to disable heartbeat system */
+    heartBeatInterval?: 30000;
+    /** Recommended, to check wether the client is still connected or not on the stats endpoint */
+    enablePingOnStatsCheck?: boolean;
+}
+/**
+ * Memory Stats object from lavalink
+ */
+export interface MemoryStats {
+    /** The free memory of the allocated amount. */
+    free: number;
+    /** The used memory of the allocated amount. */
+    used: number;
+    /** The total allocated memory. */
+    allocated: number;
+    /** The reservable memory. */
+    reservable: number;
+}
+/**
+ * CPU Stats object from lavalink
+ */
+export interface CPUStats {
+    /** The core amount the host machine has. */
+    cores: number;
+    /** The system load. */
+    systemLoad: number;
+    /** The lavalink load. */
+    lavalinkLoad: number;
+}
+/**
+ * FrameStats Object from lavalink
+ */
+export interface FrameStats {
+    /** The amount of sent frames. */
+    sent?: number;
+    /** The amount of nulled frames. */
+    nulled?: number;
+    /** The amount of deficit frames. */
+    deficit?: number;
+}
+/**
+ * BaseNodeStats object from Lavalink
+ */
+export interface BaseNodeStats {
+    /** The amount of players on the node. */
+    players: number;
+    /** The amount of playing players on the node. */
+    playingPlayers: number;
+    /** The uptime for the node. */
+    uptime: number;
+    /** The memory stats for the node. */
+    memory: MemoryStats;
+    /** The cpu stats for the node. */
+    cpu: CPUStats;
+    /** The frame stats for the node. */
+    frameStats: FrameStats;
+}
+/**
+ * Interface for nodeStats from lavalink
+ */
+export interface NodeStats extends BaseNodeStats {
+    /** The frame stats for the node. */
+    frameStats: FrameStats;
+}
+/**
+ * Entire lavalink information object from lavalink
+ */
+export interface LavalinkInfo {
+    /** The version of this Lavalink server */
+    version: VersionObject;
+    /** The millisecond unix timestamp when this Lavalink jar was built */
+    buildTime: number;
+    /** The git information of this Lavalink server */
+    git: GitObject;
+    /** The JVM version this Lavalink server runs on */
+    jvm: string;
+    /** The Lavaplayer version being used by this server */
+    lavaplayer: string;
+    /** The enabled source managers for this server */
+    sourceManagers: string[];
+    /** The enabled filters for this server */
+    filters: string[];
+    /** The enabled plugins for this server */
+    plugins: PluginObject[];
+}
+/**
+ * Lavalink's version object from lavalink
+ */
+export interface VersionObject {
+    /** The full version string of this Lavalink server */
+    semver: string;
+    /** The major version of this Lavalink server */
+    major: number;
+    /** The minor version of this Lavalink server */
+    minor: number;
+    /** The patch version of this Lavalink server */
+    patch: internal;
+    /** The pre-release version according to semver as a . separated list of identifiers */
+    preRelease?: string;
+    /** The build metadata according to semver as a . separated list of identifiers */
+    build?: string;
+}
+/**
+ * Git information object from lavalink
+ */
+export interface GitObject {
+    /** The branch this Lavalink server was built on */
+    branch: string;
+    /** The commit this Lavalink server was built on */
+    commit: string;
+    /** The millisecond unix timestamp for when the commit was created */
+    commitTime: string;
+}
+/**
+ * Lavalink's plugins object from lavalink's plugin
+ */
+export interface PluginObject {
+    /** The name of the plugin */
+    name: string;
+    /** The version of the plugin */
+    version: string;
+}
+export type LavalinkNodeIdentifier = string;
+export interface NodeManagerEvents {
+    /**
+     * Emitted when a Node is created.
+     * @event Manager.nodeManager#create
+     */
+    "create": (node: LavalinkNode) => void;
+    /**
+     * Emitted when a Node is destroyed.
+     * @event Manager.nodeManager#destroy
+     */
+    "destroy": (node: LavalinkNode, destroyReason?: DestroyReasonsType) => void;
+    /**
+     * Emitted when a Node is connected.
+     * @event Manager.nodeManager#connect
+     */
+    "connect": (node: LavalinkNode) => void;
+    /**
+     * Emitted when a Node is reconnecting.
+     * @event Manager.nodeManager#reconnecting
+    */
+    "reconnecting": (node: LavalinkNode) => void;
+    /**
+     * Emitted When a node starts to reconnect (if you have a reconnection delay, the reconnecting event will be emitted after the retryDelay.)
+     * Useful to check wether the internal node reconnect system works or not
+     * @event Manager.nodeManager#reconnectinprogress
+     */
+    "reconnectinprogress": (node: LavalinkNode) => void;
+    /**
+     * Emitted when a Node is disconnects.
+     * @event Manager.nodeManager#disconnect
+    */
+    "disconnect": (node: LavalinkNode, reason: {
+        code?: number;
+        reason?: string;
+    }) => void;
+    /**
+     * Emitted when a Node is error.
+     * @event Manager.nodeManager#error
+    */
+    "error": (node: LavalinkNode, error: Error, payload?: unknown) => void;
+    /**
+     * Emits every single Node event.
+     * @event Manager.nodeManager#raw
+    */
+    "raw": (node: LavalinkNode, payload: unknown) => void;
+    /**
+     * Emits when the node connects resumed. You then need to create all players within this event for your usecase.
+     * Aka for that you need to be able to save player data like vc channel + text channel in a db and then sync it again
+     * @event Manager.nodeManager#nodeResumed
+     */
+    "resumed": (node: LavalinkNode, paylaod: {
+        resumed: true;
+        sessionId: string;
+        op: "ready";
+    }, players: LavalinkPlayer[] | InvalidLavalinkRestRequest) => void;
+}

package/dist/cjs/structures/Types/Node.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,108 @@
+import type { DestroyReasons } from "../Constants";
+import type { LavalinkNode } from "../Node";
+import type { EQBand, FilterData, LavalinkFilterData } from "./Filters";
+import type { Track, UnresolvedTrack } from "./Track";
+import type { Base64, LavalinkPlayerVoiceOptions } from "./Utils";
+export type DestroyReasonsType = keyof typeof DestroyReasons | string;
+export interface PlayerJson {
+    /** Guild Id where the player was playing in */
+    guildId: string;
+    /** Options provided to the player */
+    options: PlayerOptions;
+    /** Voice Channel Id the player was playing in */
+    voiceChannelId: string;
+    /** Text Channel Id the player was synced to */
+    textChannelId?: string;
+    /** Position the player was at */
+    position: number;
+    /** Lavalink's position the player was at */
+    lastPosition: number;
+    /** Last time the position was sent from lavalink */
+    lastPositionChange: number;
+    /** Volume in % from the player (without volumeDecrementer) */
+    volume: number;
+    /** Real Volume used in lavalink (with the volumeDecrementer) */
+    lavalinkVolume: number;
+    /** The repeatmode from the player */
+    repeatMode: RepeatMode;
+    /** Pause state */
+    paused: boolean;
+    /** Wether the player was playing or not */
+    playing: boolean;
+    /** When the player was created */
+    createdTimeStamp?: number;
+    /** All current used fitlers Data */
+    filters: FilterData;
+    /** The player's ping object */
+    ping: {
+        /** Ping to the voice websocket server */
+        ws: number;
+        /** Avg. calc. Ping to the lavalink server */
+        lavalink: number;
+    };
+    /** Equalizer Bands used in lavalink */
+    equalizer: EQBand[];
+    /** The Id of the last used node */
+    nodeId?: string;
+    /** The SessionId of the node */
+    nodeSessionId?: string;
+}
+export type RepeatMode = "queue" | "track" | "off";
+export interface PlayerOptions {
+    /** Guild id of the player */
+    guildId: string;
+    /** The Voice Channel Id */
+    voiceChannelId: string;
+    /** The Text Channel Id of the Player */
+    textChannelId?: string;
+    /** instantly change volume with the one play request */
+    volume?: number;
+    /** VC Region for node selections */
+    vcRegion?: string;
+    /** if it should join deafened */
+    selfDeaf?: boolean;
+    /** If it should join muted */
+    selfMute?: boolean;
+    /** If it should use a specific lavalink node */
+    node?: LavalinkNode | string;
+    /** If when applying filters, it should use the insta apply filters fix  */
+    instaUpdateFiltersFix?: boolean;
+    /** If a volume should be applied via filters instead of lavalink-volume */
+    applyVolumeAsFilter?: boolean;
+}
+export type anyObject = {
+    [key: string | number]: string | number | null | anyObject;
+};
+export interface BasePlayOptions {
+    /** The position to start the track. */
+    position?: number;
+    /** The position to end the track. */
+    endTime?: number;
+    /** If to start "paused" */
+    paused?: boolean;
+    /** The Volume to start with */
+    volume?: number;
+    /** The Lavalink Filters to use | only with the new REST API */
+    filters?: Partial<LavalinkFilterData>;
+    /** Voice Update for Lavalink */
+    voice?: LavalinkPlayerVoiceOptions;
+}
+export interface LavalinkPlayOptions extends BasePlayOptions {
+    /** Which Track to play | don't provide, if it should pick from the Queue */
+    track?: {
+        /** The track encoded base64 string to use instead of the one from the queue system */
+        encoded?: Base64 | null;
+        /** The identifier of the track to use */
+        identifier?: string;
+        /** Custom User Data for the track to provide, will then be on the userData object from the track */
+        userData?: anyObject;
+        /** The Track requester for when u provide encodedTrack / identifer */
+        requester?: unknown;
+    };
+}
+export interface PlayOptions extends LavalinkPlayOptions {
+    /** Whether to not replace the track if a play payload is sent. */
+    noReplace?: boolean;
+    /** Adds track on queue and skips to it */
+    clientTrack?: Track | UnresolvedTrack;
+}

package/dist/cjs/structures/Types/Player.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,34 @@
+import type { Track, UnresolvedTrack } from "./Track";
+export interface StoredQueue {
+    current: Track | null;
+    previous: Track[];
+    tracks: (Track | UnresolvedTrack)[];
+}
+export interface QueueStoreManager extends Record<string, any> {
+    /** @async get a Value (MUST RETURN UNPARSED!) */
+    get: (guildId: unknown) => Promise<unknown>;
+    /** @async Set a value inside a guildId (MUST BE UNPARSED) */
+    set: (guildId: unknown, value: unknown) => Promise<unknown>;
+    /** @async Delete a Database Value based of it's guildId */
+    delete: (guildId: unknown) => Promise<unknown>;
+    /** @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>;
+    /** @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>>;
+}
+export interface ManagerQueueOptions {
+    /** Maximum Amount of tracks for the queue.previous array. Set to 0 to not save previous songs. Defaults to 25 Tracks */
+    maxPreviousTracks?: number;
+    /** Custom Queue Store option */
+    queueStore?: QueueStoreManager;
+    /** Custom Queue Watcher class */
+    queueChangesWatcher?: QueueChangesWatcher;
+}
+export interface QueueChangesWatcher {
+    /** get a Value (MUST RETURN UNPARSED!) */
+    tracksAdd: (guildId: string, tracks: (Track | UnresolvedTrack)[], position: number, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue) => void;
+    /** Set a value inside a guildId (MUST BE UNPARSED) */
+    tracksRemoved: (guildId: string, tracks: (Track | UnresolvedTrack)[], position: number, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue) => void;
+    /** Set a value inside a guildId (MUST BE UNPARSED) */
+    shuffled: (guildId: string, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue) => void;
+}

package/dist/cjs/structures/Types/Queue.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/structures/{Track.d.ts → Types/Track.d.ts}

@@ -1,5 +1,6 @@
-import { anyObject, Player } from "./Player";
-import { Base64 } from "./Utils";
+import type { Player } from "../Player";
+import type { anyObject } from "./Player";
+import type { Base64 } from "./Utils";
 /** Sourcenames provided by lavalink server */
 export type LavalinkSourceNames = "youtube" | "youtubemusic" | "soundcloud" | "bandcamp" | "twitch";
 /** Source Names provided by lava src plugin */
@@ -81,6 +82,7 @@ export interface PluginInfo {
     uri?: string;
     /** You can put specific track information here, to transform the tracks... */
     clientData?: {
+        previousTrack?: boolean;
         [key: string]: any;
     };
 }

package/dist/cjs/structures/Types/Track.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });