lavalink-client 2.2.2 → 2.3.1

package/dist/structures/NodeManager.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeManager = void 0;
-const stream_1 = require("stream");
-const Node_1 = require("./Node");
-class NodeManager extends stream_1.EventEmitter {
-    nodes;
-    constructor(LavalinkManager) {
-        super();
-        this.LavalinkManager = LavalinkManager;
-    }
-    createNode(options) {
-        if (this.nodes.has(options.id || options.host))
-            return this.nodes.get(options.id || options.host);
-        const newNode = new Node_1.LavalinkNode(options, this);
-        this.nodes.set(newNode.id, newNode);
-        return newNode;
-    }
-    get leastUsedNodes() {
-        return [...this.nodes.values()].filter(v => v);
-    }
-    deleteNode(options) {
-    }
-}
-exports.NodeManager = NodeManager;

package/dist/structures/Player.d.ts

@@ -1,101 +0,0 @@
-import { FilterManager, LavalinkFilterData } from "./Filters";
-import { LavalinkNode } from "./Node";
-import { PlayerManager } from "./PlayerManager";
-import { Queue } from "./Queue";
-import { Track } from "./Track";
-import { LavalinkPlayerVoiceOptions, SearchPlatform, SearchResult } from "./Utils";
-export type RepeatMode = "queue" | "track" | "off";
-export interface PlayerOptions {
-    guildId: string;
-    voiceChannelId: string;
-    volume?: number;
-    vcRegion?: string;
-    selfDeaf?: boolean;
-    selfMute?: boolean;
-    textChannelId?: string;
-    node?: Node | string;
-    instaUpdateFiltersFix?: boolean;
-    applyVolumeAsFilter?: boolean;
-}
-export interface PlayOptions {
-    /** Which Track to play | don't provide, if it should pick from the Queue */
-    track?: Track;
-    /** Encoded Track to use, instead of the queue system... */
-    encodedTrack?: string | null;
-    /** Encoded Track to use&search, instead of the queue system (yt only)... */
-    identifier?: string;
-    /** The position to start the track. */
-    position?: number;
-    /** The position to end the track. */
-    endTime?: number;
-    /** Whether to not replace the track if a play payload is sent. */
-    noReplace?: boolean;
-    /** 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?: LavalinkPlayerVoiceOptions;
-}
-export interface Player {
-    filterManager: FilterManager;
-    playerManager: PlayerManager;
-    options: PlayerOptions;
-    node: LavalinkNode;
-    queue: Queue;
-}
-export declare class Player {
-    guildId: string;
-    voiceChannelId: string | null;
-    textChannelId: string | null;
-    playing: boolean;
-    paused: boolean;
-    repeatMode: RepeatMode;
-    ping: number;
-    wsPing: number;
-    volume: number;
-    lavalinkVolume: number;
-    position: number;
-    /** When the player was created [Timestamp] (from lavalink) */
-    createdTimeStamp: number;
-    /** If lavalink says it's connected or not */
-    connected: boolean | undefined;
-    voice: LavalinkPlayerVoiceOptions;
-    private readonly data;
-    /**
-     * Set custom data.
-     * @param key
-     * @param value
-     */
-    set(key: string, value: unknown): void;
-    /**
-     * Get custom data.
-     * @param key
-     */
-    get<T>(key: string): T;
-    clearData(): void;
-    getAllData(): Record<string, unknown>;
-    constructor(options: PlayerOptions, playerManager: PlayerManager);
-    play(options?: Partial<PlayOptions>): Promise<void>;
-    setVolume(volume: number, ignoreVolumeDecrementer?: boolean): Promise<void>;
-    search(query: {
-        query: string;
-        source: SearchPlatform;
-    }, requestUser: unknown): Promise<SearchResult>;
-    pause(): Promise<void>;
-    resume(): Promise<void>;
-    seek(position: number): Promise<any>;
-    setRepeatMode(repeatMode: RepeatMode): Promise<void>;
-    /**
-     * Skip a Song (on Lavalink it's called "STOP")
-     * @param amount provide the index of the next track to skip to
-     */
-    skip(skipTo?: number): Promise<boolean>;
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    /**
-     * Destroy the player
-     */
-    destroy(disconnect?: boolean): Promise<void>;
-}

package/dist/structures/Player.js

@@ -1,232 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Player = void 0;
-const Filters_1 = require("./Filters");
-const LavalinkManagerStatics_1 = require("./LavalinkManagerStatics");
-const Queue_1 = require("./Queue");
-class Player {
-    // All properties
-    guildId;
-    voiceChannelId = null;
-    textChannelId = null;
-    playing = false;
-    paused = false;
-    repeatMode = "off";
-    ping = 0;
-    wsPing = 0;
-    volume = 100;
-    lavalinkVolume = 100;
-    position = 0;
-    /** When the player was created [Timestamp] (from lavalink) */
-    createdTimeStamp;
-    /** If lavalink says it's connected or not */
-    connected = false;
-    voice;
-    data = {};
-    /**
-     * Set custom data.
-     * @param key
-     * @param value
-     */
-    set(key, value) {
-        this.data[key] = value;
-        return;
-    }
-    /**
-     * Get custom data.
-     * @param key
-     */
-    get(key) { return this.data[key]; }
-    clearData() {
-        const toKeep = Object.keys(this.data).filter(v => v.startsWith("internal_"));
-        for (const key in this.data) {
-            if (toKeep.includes(key))
-                continue;
-            delete this.data[key];
-        }
-        return;
-    }
-    getAllData() { return Object.fromEntries(Object.entries(this.data).filter(v => !v[0].startsWith("internal_"))); }
-    // constructor
-    constructor(options, playerManager) {
-        this.options = options;
-        this.filterManager = new Filters_1.FilterManager(this);
-        this.playerManager = playerManager;
-        this.voiceChannelId = this.options.voiceChannelId;
-        this.textChannelId = this.options.textChannelId || null;
-        this.node = this.playerManager.LavalinkManager.nodeManager.leastUsedNodes.filter(v => options.vcRegion ? v.options?.regions?.includes(options.vcRegion) : true)[0] || this.playerManager.LavalinkManager.nodeManager.leastUsedNodes[0] || null;
-        if (!this.node)
-            throw new Error("No available Node was found, please add a LavalinkNode to the Manager via Manager.NodeManager#createNode");
-        if (this.playerManager.LavalinkManager.options.playerOptions.volumeDecrementer)
-            this.volume *= this.playerManager.LavalinkManager.options.playerOptions.volumeDecrementer;
-        this.playerManager.emit("create", this);
-        if (typeof options.volume === "number" && !isNaN(options.volume))
-            this.setVolume(options.volume);
-        this.queue = new Queue_1.Queue({}, this.guildId, new Queue_1.QueueSaver(this.playerManager.LavalinkManager.options.queueStore, this.playerManager.LavalinkManager.options.queueOptions));
-    }
-    // all functions
-    async play(options) {
-        const track = options.track || this.queue.currentTrack;
-        if (!track)
-            throw new Error(`There is no Track in the Queue, nor provided in the PlayOptions`);
-        if (typeof options.volume === "number" && !isNaN(options.volume)) {
-            this.volume = Math.max(Math.min(options.volume, 500), 0);
-            let vol = Number(this.volume);
-            if (this.playerManager.LavalinkManager.options.playerOptions.volumeDecrementer)
-                vol *= this.playerManager.LavalinkManager.options.playerOptions.volumeDecrementer;
-            this.lavalinkVolume = Math.floor(vol * 100) / 100;
-            options.volume = vol;
-        }
-        this.set("lastposition", this.position);
-        const now = performance.now();
-        await this.node.updatePlayer({
-            guildId: this.guildId,
-            noReplace: options.noReplace ?? false,
-            playerOptions: {
-                encodedTrack: track.encodedTrack,
-                volume: this.volume,
-                position: 0,
-                ...options
-            }
-        });
-        this.ping = Math.round((performance.now() - now) / 10) / 100;
-    }
-    async setVolume(volume, ignoreVolumeDecrementer = false) {
-        volume = Number(volume);
-        if (isNaN(volume))
-            throw new TypeError("Volume must be a number.");
-        this.volume = Math.max(Math.min(volume, 500), 0);
-        volume = Number(this.volume);
-        if (this.playerManager.LavalinkManager.options.playerOptions.volumeDecrementer && !ignoreVolumeDecrementer)
-            volume *= this.playerManager.LavalinkManager.options.playerOptions.volumeDecrementer;
-        this.lavalinkVolume = Math.floor(volume * 100) / 100;
-        const now = performance.now();
-        if (this.playerManager.LavalinkManager.options.playerOptions.applyVolumeAsFilter) {
-            await this.node.updatePlayer({ guildId: this.guildId, playerOptions: { filters: { volume: volume / 100 } } });
-        }
-        else {
-            await this.node.updatePlayer({ guildId: this.guildId, playerOptions: { volume } });
-        }
-        this.ping = Math.round((performance.now() - now) / 10) / 100;
-        return;
-    }
-    async search(query, requestUser) {
-        const _query = typeof query === "string" ? query : query.query;
-        const _source = LavalinkManagerStatics_1.DEFAULT_SOURCES[query.source ?? this.playerManager.LavalinkManager.options.playerOptions.defaultSearchPlatform] ?? query.source ?? this.playerManager.LavalinkManager.options.playerOptions.defaultSearchPlatform;
-        const srcSearch = !/^https?:\/\//.test(_query) ? `${_source}:` : "";
-        const res = await this.node.makeRequest(`/loadtracks?identifier=${srcSearch}${encodeURIComponent(_query)}`);
-        console.log("DEBUG LOG - RESPONSE", res);
-        const resTracks = res.loadType === "playlist" ? res.data?.tracks : res.loadType === "track" ? [res.data] : res.loadType === "search" ? Array.isArray(res.data) ? res.data : [res.data] : [];
-        const response = {
-            loadType: res.loadType,
-            exception: res.loadType === "error" ? res.data : null,
-            pluginInfo: res.pluginInfo || {},
-            playlist: res.loadType === "playlist" ? {
-                name: res.data.info?.name || res.data.pluginInfo?.name || null,
-                author: res.data.info?.author || res.data.pluginInfo?.author || null,
-                thumbnail: (res.data.info?.artworkUrl) || (res.data.pluginInfo?.artworkUrl) || ((typeof res.data?.info?.selectedTrack !== "number" || res.data?.info?.selectedTrack === -1) ? null : resTracks[res.data?.info?.selectedTrack] ? (resTracks[res.data?.info?.selectedTrack]?.info?.artworkUrl || resTracks[res.data?.info?.selectedTrack]?.info?.pluginInfo?.artworkUrl) : null) || null,
-                uri: res.data.info?.url || res.data.info?.uri || res.data.info?.link || res.data.pluginInfo?.url || res.data.pluginInfo?.uri || res.data.pluginInfo?.link || null,
-                selectedTrack: typeof res.data?.info?.selectedTrack !== "number" || res.data?.info?.selectedTrack === -1 ? null : resTracks[res.data?.info?.selectedTrack] ? this.playerManager.LavalinkManager.utilManager.buildTrack(resTracks[res.data?.info?.selectedTrack], requestUser) : null,
-                duration: resTracks.length ? resTracks.reduce((acc, cur) => acc + (cur?.info?.duration || 0), 0) : 0,
-            } : null,
-            tracks: resTracks.length ? resTracks.map(t => this.playerManager.LavalinkManager.utilManager.buildTrack(t, requestUser)) : []
-        };
-        return response;
-    }
-    async pause() {
-        if (this.paused && !this.playing)
-            throw new Error("Player is already paused - not able to pause.");
-        this.paused = true;
-        const now = performance.now();
-        await this.node.updatePlayer({ guildId: this.guildId, playerOptions: { paused: true } });
-        this.ping = Math.round((performance.now() - now) / 10) / 100;
-        return;
-    }
-    async resume() {
-        if (!this.paused)
-            throw new Error("Player isn't paused - not able to resume.");
-        this.paused = false;
-        const now = performance.now();
-        await this.node.updatePlayer({ guildId: this.guildId, playerOptions: { paused: false } });
-        this.ping = Math.round((performance.now() - now) / 10) / 100;
-        return;
-    }
-    async seek(position) {
-        if (!this.queue.currentTrack)
-            return undefined;
-        position = Number(position);
-        if (isNaN(position))
-            throw new RangeError("Position must be a number.");
-        if (!this.queue.currentTrack.info.isSeekable || this.queue.currentTrack.info.isStream)
-            throw new RangeError("Current Track is not seekable / a stream");
-        if (position < 0 || position > this.queue.currentTrack.info.duration)
-            position = Math.max(Math.min(position, this.queue.currentTrack.info.duration), 0);
-        this.position = position;
-        this.set("internal_lastposition", this.position);
-        const now = performance.now();
-        await this.node.updatePlayer({ guildId: this.guildId, playerOptions: { position } });
-        this.ping = Math.round((performance.now() - now) / 10) / 100;
-        return;
-    }
-    async setRepeatMode(repeatMode) {
-        if (!["off", "track", "queue"].includes(repeatMode))
-            throw new RangeError("Repeatmode must be either 'off', 'track', or 'queue'");
-        this.repeatMode = repeatMode;
-        return;
-    }
-    /**
-     * Skip a Song (on Lavalink it's called "STOP")
-     * @param amount provide the index of the next track to skip to
-     */
-    async skip(skipTo = 0) {
-        if (typeof skipTo === "number" && skipTo > 1) {
-            if (skipTo > this.queue.size)
-                throw new RangeError("Can't skip more than the queue size");
-            this.queue.splice(0, skipTo - 1);
-        }
-        const now = performance.now();
-        await this.node.updatePlayer({ guildId: this.guildId, playerOptions: { encodedTrack: null } });
-        this.ping = Math.round((performance.now() - now) / 10) / 100;
-        return true;
-    }
-    async connect() {
-        if (!this.options.voiceChannelId)
-            throw new RangeError("No Voice Channel id has been set.");
-        await this.playerManager.LavalinkManager.options.sendToShard(this.guildId, {
-            op: 4,
-            d: {
-                guild_id: this.guildId,
-                channel_id: this.options.voiceChannelId,
-                self_mute: this.options.selfMute ?? false,
-                self_deaf: this.options.selfDeaf ?? true,
-            }
-        });
-        return;
-    }
-    async disconnect() {
-        if (!this.options.voiceChannelId)
-            throw new RangeError("No Voice Channel id has been set.");
-        await this.playerManager.LavalinkManager.options.sendToShard(this.guildId, {
-            op: 4,
-            d: {
-                guild_id: this.guildId,
-                channel_id: null,
-                self_mute: false,
-                self_deaf: false,
-            }
-        });
-        this.voiceChannelId = null;
-        return;
-    }
-    /**
-     * Destroy the player
-     */
-    async destroy(disconnect = true) {
-        if (disconnect)
-            await this.disconnect();
-        await this.node.destroyPlayer(this.guildId);
-        this.playerManager.emit("destroy", this);
-        this.playerManager.deletePlayer(this.guildId);
-    }
-}
-exports.Player = Player;

package/dist/structures/PlayerManager.d.ts

@@ -1,62 +0,0 @@
-/// <reference types="node" />
-import { EventEmitter } from "stream";
-import { Player, PlayerOptions } from "./Player";
-import { LavalinkManager } from "./LavalinkManager";
-import { Track } from "./Track";
-import { TrackEndEvent, TrackExceptionEvent, TrackStartEvent, TrackStuckEvent, WebSocketClosedEvent } from "./Utils";
-interface PlayerManagerEvents {
-    /**
-     * Emitted when a Player is created.
-     * @event Manager.playerManager#create
-     */
-    "create": (player: Player) => void;
-    /**
-     * Emitted when a Track started playing.
-     * @event Manager.playerManager#trackStart
-     */
-    "trackStart": (player: Player, track: Track, payload: TrackStartEvent) => void;
-    /**
-     * Emitted when a Track finished.
-     * @event Manager.playerManager#trackEnd
-     */
-    "trackEnd": (player: Player, track: Track, payload: TrackEndEvent) => void;
-    /**
-     * Emitted when a Track finished.
-     * @event Manager.playerManager#trackStuck
-     */
-    "trackStuck": (player: Player, track: Track, payload: TrackStuckEvent) => void;
-    /**
-     * Emitted when a Track finished.
-     * @event Manager.playerManager#trackError
-     */
-    "trackError": (player: Player, track: Track, payload: TrackExceptionEvent) => void;
-    /**
-     * Emitted when a Track finished.
-     * @event Manager.playerManager#queueEnd
-     */
-    "queueEnd": (player: Player, track: Track, payload: TrackEndEvent | TrackStuckEvent) => void;
-    /**
-     * Emitted when a Node-Socket got closed for a specific Player.
-     * @event Manager.playerManager#socketClosed
-     */
-    "socketClosed": (player: Player, payload: WebSocketClosedEvent) => void;
-    /**
-     * Emitted when a Player get's destroyed
-     * @event Manager.playerManager#destroy
-     */
-    "destroy": (player: Player) => void;
-}
-export interface PlayerManager {
-    on<U extends keyof PlayerManagerEvents>(event: U, listener: PlayerManagerEvents[U]): this;
-    emit<U extends keyof PlayerManagerEvents>(event: U, ...args: Parameters<PlayerManagerEvents[U]>): boolean;
-    /** @private */
-    LavalinkManager: LavalinkManager;
-}
-export declare class PlayerManager extends EventEmitter {
-    private players;
-    constructor(LavalinkManager: LavalinkManager);
-    createPlayer(options: PlayerOptions): Player;
-    getPlayer(guildId: string): Player;
-    deletePlayer(guildId: string): boolean;
-}
-export {};

package/dist/structures/PlayerManager.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PlayerManager = void 0;
-const stream_1 = require("stream");
-const Player_1 = require("./Player");
-class PlayerManager extends stream_1.EventEmitter {
-    players;
-    constructor(LavalinkManager) {
-        super();
-        this.LavalinkManager = LavalinkManager;
-    }
-    createPlayer(options) {
-        if (this.players.has(options.guildId))
-            return this.players.get(options.guildId);
-        const newPlayer = new Player_1.Player(options, this);
-        this.players.set(newPlayer.guildId, newPlayer);
-        return newPlayer;
-    }
-    getPlayer(guildId) {
-        return this.players.get(guildId);
-    }
-    deletePlayer(guildId) {
-        return this.players.delete(guildId);
-    }
-}
-exports.PlayerManager = PlayerManager;

package/dist/structures/Queue.d.ts

@@ -1,93 +0,0 @@
-import { Track } from "./Track";
-export interface StoredQueue {
-    currentTrack: Track | null;
-    previousTracks: Track[];
-    nextTracks: Track[];
-}
-export interface QueueStoreManager extends Record<any, any> {
-    /** @async get a Value */
-    get: (key: unknown) => any;
-    /** @async Set a value inside a key */
-    set: (key: unknown, value: unknown) => any;
-    /** @async Delete a Database Value based of it's key */
-    delete: (key: unknown) => any;
-    /** @async Transform the value(s) inside of the QueueStoreManager */
-    stringify: (value: unknown) => any;
-    /** @async Parse the saved value back to the Queue */
-    parse: (value: unknown) => Queue;
-}
-export interface ManagerQueueOptions {
-    maxPreviousTracks: number;
-}
-export interface QueueSaver {
-    /** @private */
-    _: QueueStoreManager;
-    /** @private */
-    options: ManagerQueueOptions;
-}
-export declare class QueueSaver {
-    constructor(QueueStoreManager: QueueStoreManager, options: ManagerQueueOptions);
-    get(key: string): Promise<Queue>;
-    delete(key: string): Promise<any>;
-    set(key: string, value: any): Promise<any>;
-}
-export declare class DefaultQueueStore {
-    private data;
-    constructor();
-    get(key: any): any;
-    set(key: any, value: any): Map<any, any>;
-    delete(key: any): boolean;
-    stringify(value: any): any;
-    parse(value: any): any;
-}
-export declare class Queue {
-    private readonly _nextTracks;
-    private readonly _previousTracks;
-    private _currentTrack;
-    private readonly _guildId;
-    private readonly _QueueSaver;
-    constructor(data?: Partial<StoredQueue>, guildId?: string, QueueSaver?: QueueSaver);
-    isTrack(data: Track): boolean;
-    /** The Current Playing Track */
-    get currentTrack(): Track;
-    /** All Previous Track(s) [with the limited amount] */
-    get previousTracks(): Track[];
-    /** All Upcoming Track(s) */
-    get nextTracks(): Track[];
-    /** The Size of the upcoming Track(s) */
-    get size(): number;
-    /** The Size of the previous Track(s) */
-    get previousSize(): number;
-    /**
-     * @returns The Queue, but in a raw State, which allows easier handling for the QueueStoreManager
-     */
-    getStored(): StoredQueue;
-    /**
-     * Add a Track to the Queue, and after saved in the "db" it returns the amount of the Tracks
-     * @param Track
-     * @param index At what position to add the Track
-     * @returns Queue-Size (for the next Tracks)
-     */
-    add(TrackOrTracks: Track | Track[], index?: number): Promise<number | Track | Track[]>;
-    /**
-     *
-     * @param index Where to remove the Track
-     * @param amount How many Tracks to remove?
-     * @param TrackOrTracks Want to Add more Tracks?
-     */
-    splice(index: number, amount: number, TrackOrTracks?: Track | Track[]): Promise<Track | Track[]>;
-    /**
-     * Add a Track to the Previous Track list, and after saved in the "db" it returns the amount of the previous Tracks
-     * @param Track
-     * @returns PreviousTracksSize
-     */
-    addPrevious(Track: Track): Promise<number>;
-    /**
-     * Add a Track to the Previous Track list, and after saved in the "db" it returns the amount of the previous Tracks
-     * @param Track
-     * @returns PreviousTracksSize
-     */
-    setCurrent(Track: Track | null): Promise<Track>;
-    /** @private @hidden */
-    _trackEnd(addBackToQueue?: boolean): Promise<Track>;
-}