lavalink-client 1.0.5 → 1.0.7

package/README.md

@@ -1,5 +1,26 @@
 # Lavalink Client
-Easy and advanced lavalink client. Use it with lavalink plugins as well as latest lavalink versions.
+Easy, flexible and feature-rich lavalink@v4 Client. Both for Beginners and Proficients.
+
+<div align="center">
+  <p> 
+    <img src="https://madewithlove.now.sh/at?heart=true&template=for-the-badge" alt="Made with love in Austria">
+    <img alt="Made with TypeScript" src="https://img.shields.io/badge/typescript-%23007ACC.svg?style=for-the-badge&logo=typescript&logoColor=white">
+  </p>
+  <p>
+    <a href="https://www.npmjs.com/package/lavalink-client">
+      <img src="https://img.shields.io/npm/v/lavalink-client.svg?maxAge=3600&style=for-the-badge&logo=npm&logoColor=red" alt="NPM version" />
+    </a>
+    <a href="https://www.npmjs.com/package/lavalink-client">
+      <img src="https://img.shields.io/npm/dt/lavalink-client.svg?maxAge=3600&style=for-the-badge&logo=npm&logoColor=red" alt="NPM downloads" />
+    </a>
+    <a href="https://lc4.gitbook.io/lavalink-client/">
+      <img src="https://img.shields.io/badge/Documation-%230288D1.svg?style=for-the-badge&logo=gitbook&logoColor=white" alt="Get Started Now">
+    </a>
+  </p>
+  <p>
+    <a href="https://www.npmjs.com/package/lavalink-client"><img src="https://nodei.co/npm/lavalink-client.png?downloads=true&stars=true" alt="npm install lavalink-client" /></a>
+  </p>
+</div>
 
 # Install
 
@@ -11,6 +32,7 @@ Latest stable Version: (currently, unreleased)
 npm install --save lavalink-client
 ```
 
+
 Dev Version: (Current)
 
 ```bash

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

@@ -7,7 +7,7 @@ export declare class FilterManager {
     equalizerBands: EQBand[];
     filterUpdatedState: number;
     filters: PlayerFilters;
-    data: LavalinkFilterData;
+    data: FilterData;
     constructor(player: Player);
     applyPlayerFilters(): Promise<void>;
     /**
@@ -215,9 +215,8 @@ export interface ReverbFilter {
     delay: number;
     decay: number;
 }
-export interface LavalinkFilterData {
+export interface FilterData {
     volume?: number;
-    equalizer?: EQBand[];
     karaoke?: KaraokeFilter;
     timescale?: TimescaleFilter;
     tremolo?: FreqFilter;
@@ -229,3 +228,6 @@ export interface LavalinkFilterData {
     echo: EchoFilter;
     reverb: ReverbFilter;
 }
+export interface LavalinkFilterData extends FilterData {
+    equalizer?: EQBand[];
+}

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

@@ -1,22 +1,24 @@
 /// <reference types="node" />
 import { EventEmitter } from "events";
 import { NodeManager } from "./NodeManager";
-import { QueueSaverOptions } from "./Queue";
-import { GuildShardPayload, LavalinkSearchPlatform, ManagerUitls, MiniMap, SearchPlatform, TrackEndEvent, TrackExceptionEvent, TrackStartEvent, TrackStuckEvent, VoicePacket, VoiceServer, VoiceState, WebSocketClosedEvent } from "./Utils";
+import { ManagerQueueOptions } from "./Queue";
+import { GuildShardPayload, ManagerUitls, MiniMap, SearchPlatform, TrackEndEvent, TrackExceptionEvent, TrackStartEvent, TrackStuckEvent, VoicePacket, VoiceServer, VoiceState, WebSocketClosedEvent } from "./Utils";
 import { LavalinkNodeOptions } from "./Node";
-import { DestroyReasonsType, Player, PlayerOptions } from "./Player";
+import { DestroyReasonsType, Player, PlayerJson, PlayerOptions } from "./Player";
 import { Track, UnresolvedTrack } from "./Track";
 export interface LavalinkManager {
     nodeManager: NodeManager;
     utils: ManagerUitls;
 }
 export interface BotClientOptions {
+    /** Bot Client Id */
     id: string;
+    /** Bot Client Username */
     username?: string;
     /** So users can pass entire objects / classes */
     [x: string | number | symbol | undefined]: any;
 }
-export interface LavalinkPlayerOptions {
+export interface ManagerPlayerOptions {
     /** If the Lavalink Volume should be decremented by x number */
     volumeDecrementer?: number;
     /** How often it should update the the player Position */
@@ -39,15 +41,21 @@ export interface LavalinkPlayerOptions {
         autoPlayFunction?: (player: Player, lastPlayedTrack: Track) => Promise<void>;
         destroyAfterMs?: number;
     };
+    useUnresolvedData?: boolean;
 }
 export interface ManagerOptions {
+    /** The Node Options, for all Nodes! (on init) */
     nodes: LavalinkNodeOptions[];
-    queueOptions?: QueueSaverOptions;
+    /** @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;
-    playerOptions?: LavalinkPlayerOptions;
+    /** 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;
-    /** @async */
-    sendToShard: (guildId: string, payload: GuildShardPayload) => void;
 }
 interface LavalinkManagerEvents {
     /**
@@ -104,7 +112,7 @@ interface LavalinkManagerEvents {
      * Always emits when the player (on lavalink side) got updated
      * @event Manager#playerUpdate
      */
-    "playerUpdate": (player: Player) => void;
+    "playerUpdate": (oldPlayerJson: PlayerJson, newPlayer: Player) => void;
 }
 export interface LavalinkManager {
     options: ManagerOptions;
@@ -112,7 +120,7 @@ export interface LavalinkManager {
     emit<U extends keyof LavalinkManagerEvents>(event: U, ...args: Parameters<LavalinkManagerEvents[U]>): boolean;
 }
 export declare class LavalinkManager extends EventEmitter {
-    static DefaultSources: Record<SearchPlatform, LavalinkSearchPlatform>;
+    static DefaultSources: Record<SearchPlatform, import("./Utils").LavalinkSearchPlatform>;
     static SourceLinksRegexes: Record<import("./Utils").SourcesRegex, RegExp>;
     initiated: boolean;
     readonly players: MiniMap<string, Player>;

package/dist/cjs/structures/LavalinkManager.js

@@ -81,7 +81,7 @@ class LavalinkManager extends events_1.EventEmitter {
             const keys = Object.getOwnPropertyNames(Object.getPrototypeOf(options.queueOptions?.queueChangesWatcher));
             const requiredKeys = ["tracksAdd", "tracksRemoved", "shuffled"];
             if (!requiredKeys.every(v => keys.includes(v)) || !requiredKeys.every(v => typeof options.queueOptions?.queueChangesWatcher[v] === "function"))
-                throw new SyntaxError(`The provided ManagerOption.QueueChangesWatcher, does not have all required functions: ${requiredKeys.join(", ")}`);
+                throw new SyntaxError(`The provided ManagerOption.DefaultQueueChangesWatcher, does not have all required functions: ${requiredKeys.join(", ")}`);
         }
     }
     constructor(options) {

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

@@ -4,7 +4,7 @@ import { NodeManager } from "./NodeManager";
 import internal from "stream";
 import { InvalidLavalinkRestRequest, LavalinkPlayer, PlayerUpdateInfo, RoutePlanner, Session, Base64 } from "./Utils";
 import { DestroyReasonsType } from "./Player";
-import { TrackInfo } from "./Track";
+import { Track } from "./Track";
 /** Modifies any outgoing REST requests. */
 export type ModifyRequest = (options: Dispatcher.RequestOptions) => void;
 export interface LavalinkNodeOptions {
@@ -185,13 +185,13 @@ export declare class LavalinkNode {
          * @param encoded
          * @returns
          */
-        singleTrack: (encoded: Base64) => Promise<TrackInfo>;
+        singleTrack: (encoded: Base64, requester: unknown) => Promise<Track>;
         /**
          *
          * @param encodeds Decodes multiple tracks into their info
          * @returns
          */
-        multipleTracks: (encodeds: Base64[]) => Promise<TrackInfo[]>;
+        multipleTracks: (encodeds: Base64[], requester: unknown) => Promise<Track[]>;
     };
     /**
      * Request Lavalink statistics.

package/dist/cjs/structures/Node.js

@@ -227,25 +227,27 @@ class LavalinkNode {
          * @param encoded
          * @returns
          */
-        singleTrack: async (encoded) => {
+        singleTrack: async (encoded, requester) => {
             if (!encoded)
                 throw new SyntaxError("No encoded (Base64 string) was provided");
-            return await this.request(`/decodetrack?encodedTrack=${encoded}`);
+            // return the decoded + builded track
+            return this.NodeManager.LavalinkManager.utils.buildTrack(await this.request(`/decodetrack?encodedTrack=${encoded}`), requester);
         },
         /**
          *
          * @param encodeds Decodes multiple tracks into their info
          * @returns
          */
-        multipleTracks: async (encodeds) => {
+        multipleTracks: async (encodeds, requester) => {
             if (!Array.isArray(encodeds) || !encodeds.every(v => typeof v === "string" && v.length > 1))
                 throw new SyntaxError("You need to provide encodeds, which is an array of base64 strings");
+            // return the decoded + builded tracks
             return await this.request(`/decodetracks`, r => {
                 r.method = "POST";
                 r.body = JSON.stringify(encodeds);
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 r.headers["Content-Type"] = "application/json";
-            });
+            }).then((r) => r.map(track => this.NodeManager.LavalinkManager.utils.buildTrack(track, requester)));
         }
     };
     /**
@@ -356,7 +358,7 @@ class LavalinkNode {
                 if (data.playerOptions.filters.volume)
                     player.filterManager.data.volume = data.playerOptions.filters.volume;
                 if (data.playerOptions.filters.equalizer)
-                    player.filterManager.data.equalizer = data.playerOptions.filters.equalizer;
+                    player.filterManager.equalizerBands = data.playerOptions.filters.equalizer;
                 if (data.playerOptions.filters.karaoke)
                     player.filterManager.data.karaoke = data.playerOptions.filters.karaoke;
                 if (data.playerOptions.filters.lowPass)
@@ -439,6 +441,7 @@ class LavalinkNode {
                 const player = this.NodeManager.LavalinkManager.getPlayer(payload.guildId);
                 if (!player)
                     return;
+                const oldPlayer = player?.toJSON();
                 if (player.get("internal_updateInterval"))
                     clearInterval(player.get("internal_updateInterval"));
                 // override the position
@@ -476,7 +479,7 @@ class LavalinkNode {
                         player.filterManager.filterUpdatedState = 0;
                     }
                 }
-                this.NodeManager.LavalinkManager.emit("playerUpdate", player);
+                this.NodeManager.LavalinkManager.emit("playerUpdate", oldPlayer, player);
                 break;
             case "event":
                 this.handleEvent(payload);
@@ -523,7 +526,6 @@ class LavalinkNode {
         return this.NodeManager.LavalinkManager.emit("trackStart", player, track, payload);
     }
     async trackEnd(player, track, payload) {
-        console.log(payload.reason);
         // If there are no songs in the queue
         if (!player.queue.tracks.length && player.repeatMode === "off")
             return this.queueEnd(player, track, payload);
@@ -560,8 +562,11 @@ class LavalinkNode {
             await this.NodeManager.LavalinkManager.options?.playerOptions?.onEmptyQueue?.autoPlayFunction(player, track);
             if (player.queue.tracks.length > 0)
                 await (0, Utils_1.queueTrackEnd)(player);
-            if (player.queue.current)
+            if (player.queue.current) {
+                if (payload.type === "TrackEndEvent")
+                    this.NodeManager.LavalinkManager.emit("trackEnd", player, track, payload);
                 return player.play({ noReplace: true, paused: false });
+            }
         }
         player.queue.previous.unshift(track);
         if (payload?.reason !== "stopped") {

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

@@ -1,4 +1,4 @@
-import { FilterManager, LavalinkFilterData } from "./Filters";
+import { EQBand, FilterData, FilterManager, LavalinkFilterData } from "./Filters";
 import { LavalinkManager } from "./LavalinkManager";
 import { LavalinkNode } from "./Node";
 import { Queue } from "./Queue";
@@ -7,6 +7,27 @@ import { LavalinkPlayerVoiceOptions, SearchPlatform, SearchResult } from "./Util
 type PlayerDestroyReasons = "QueueEmpty" | "NodeDestroy" | "NodeDeleted" | "LavalinkNoVoice" | "NodeReconnectFail" | "PlayerReconnectFail" | "Disconnected" | "ChannelDeleted";
 export type DestroyReasonsType = PlayerDestroyReasons | string;
 export declare const DestroyReasons: Record<PlayerDestroyReasons, PlayerDestroyReasons>;
+export interface PlayerJson {
+    guildId: string;
+    options: PlayerOptions;
+    voiceChannelId: string;
+    textChannelId?: string;
+    position: number;
+    lastPosition: number;
+    volume: number;
+    lavalinkVolume: number;
+    repeatMode: RepeatMode;
+    paused: boolean;
+    playing: boolean;
+    createdTimeStamp?: number;
+    filters: FilterData;
+    ping: {
+        ws: number;
+        lavalink: number;
+    };
+    equalizer: EQBand[];
+    nodeId?: string;
+}
 export type RepeatMode = "queue" | "track" | "off";
 export interface PlayerOptions {
     guildId: string;
@@ -170,22 +191,6 @@ export declare class Player {
      */
     changeNode(newNode: LavalinkNode | string): Promise<string>;
     /** Converts the Player including Queue to a Json state */
-    toJSON(): {
-        guildId: string;
-        options: PlayerOptions;
-        voiceChannelId: string;
-        textChannelId: string;
-        position: number;
-        lastPosition: number;
-        volume: number;
-        lavalinkVolume: number;
-        repeatMode: RepeatMode;
-        paused: boolean;
-        playing: boolean;
-        createdTimeStamp: number;
-        filters: {};
-        equalizer: import("./Filters").EQBand[];
-        nodeId: string;
-    };
+    toJSON(): PlayerJson;
 }
 export {};

package/dist/cjs/structures/Player.js

@@ -405,6 +405,7 @@ class Player {
             filters: this.filterManager?.data || {},
             equalizer: this.filterManager?.equalizerBands || [],
             nodeId: this.node?.id,
+            ping: this.ping,
         };
     }
 }

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

@@ -1,53 +1,58 @@
 import { Track, UnresolvedTrack } from "./Track";
+import { MiniMap } from "./Utils";
 export interface StoredQueue {
     current: Track | null;
     previous: Track[];
     tracks: Track[];
 }
-export interface StoreManager extends Record<any, any> {
+export interface QueueStoreManager extends Record<string, any> {
     /** @async get a Value (MUST RETURN UNPARSED!) */
     get: (guildId: unknown) => Promise<any>;
     /** @async Set a value inside a guildId (MUST BE UNPARSED) */
     set: (guildId: unknown, value: unknown) => Promise<any>;
     /** @async Delete a Database Value based of it's guildId */
     delete: (guildId: unknown) => Promise<any>;
-    /** @async Transform the value(s) inside of the StoreManager (IF YOU DON'T NEED PARSING/STRINGIFY, then just return the value) */
+    /** @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<any>;
     /** @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 QueueSaverOptions {
-    maxPreviousTracks: number;
-    queueStore?: StoreManager;
+export interface ManagerQueueOptions {
+    maxPreviousTracks?: number;
+    queueStore?: QueueStoreManager;
     queueChangesWatcher?: QueueChangesWatcher;
 }
 export interface QueueSaver {
     /** @private */
-    _: StoreManager;
+    _: QueueStoreManager;
     /** @private */
-    options: QueueSaverOptions;
+    options: {
+        maxPreviousTracks: number;
+    };
 }
 export declare class QueueSaver {
-    constructor(options: QueueSaverOptions);
+    constructor(options: ManagerQueueOptions);
     get(guildId: string): Promise<Partial<StoredQueue>>;
     delete(guildId: string): Promise<any>;
     set(guildId: string, value: any): Promise<any>;
     sync(guildId: string): Promise<Partial<StoredQueue>>;
 }
-export declare class DefaultQueueStore {
+export declare class DefaultQueueStore implements QueueStoreManager {
     private data;
     constructor();
-    get(guildId: any): Promise<any>;
-    set(guildId: any, stringifiedValue: any): Promise<Map<any, any>>;
+    get(guildId: any): Promise<unknown>;
+    set(guildId: any, stringifiedValue: any): Promise<MiniMap<unknown, unknown>>;
     delete(guildId: any): Promise<boolean>;
     stringify(value: any): Promise<any>;
     parse(value: any): Promise<Partial<StoredQueue>>;
 }
-export declare class QueueChangesWatcher {
-    constructor();
-    tracksAdd(guildId: string, tracks: (Track | UnresolvedTrack)[], position: number, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue): void;
-    tracksRemoved(guildId: string, tracks: (Track | UnresolvedTrack)[], position: number, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue): void;
-    shuffled(guildId: string, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue): void;
+export interface QueueChangesWatcher {
+    /** get a Value (MUST RETURN UNPARSED!) */
+    tracksAdd: (guildId: string, tracks: (Track | UnresolvedTrack)[], position: number, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue) => any;
+    /** Set a value inside a guildId (MUST BE UNPARSED) */
+    tracksRemoved: (guildId: string, tracks: (Track | UnresolvedTrack)[], position: number, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue) => any;
+    /** Set a value inside a guildId (MUST BE UNPARSED) */
+    shuffled: (guildId: string, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue) => any;
 }
 export declare class Queue {
     readonly tracks: (Track | UnresolvedTrack)[];
@@ -60,7 +65,7 @@ export declare class Queue {
     private readonly QueueSaver;
     private managerUtils;
     private queueChanges;
-    constructor(guildId: string, data?: Partial<StoredQueue>, QueueSaver?: QueueSaver, queueOptions?: QueueSaverOptions);
+    constructor(guildId: string, data?: Partial<StoredQueue>, QueueSaver?: QueueSaver, queueOptions?: ManagerQueueOptions);
     private applyData;
     /**
      * Utils for a Queue
@@ -77,7 +82,7 @@ export declare class Queue {
         sync: (override?: boolean, dontSyncCurrent?: boolean) => Promise<void>;
         destroy: () => Promise<any>;
         /**
-         * @returns {{current:Track|null, previous:Track[], tracks:Track[]}}The Queue, but in a raw State, which allows easier handling for the storeManager
+         * @returns {{current:Track|null, previous:Track[], tracks:Track[]}}The Queue, but in a raw State, which allows easier handling for the QueueStoreManager
          */
         toJSON: () => StoredQueue;
         /**

package/dist/cjs/structures/Queue.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Queue = exports.QueueChangesWatcher = exports.DefaultQueueStore = exports.QueueSaver = void 0;
+exports.Queue = exports.DefaultQueueStore = exports.QueueSaver = void 0;
 const Utils_1 = require("./Utils");
 class QueueSaver {
     constructor(options) {
-        this._ = options.queueStore || new DefaultQueueStore();
+        this._ = options?.queueStore || new DefaultQueueStore();
         this.options = {
-            maxPreviousTracks: options.maxPreviousTracks
+            maxPreviousTracks: options?.maxPreviousTracks || 25,
         };
     }
     async get(guildId) {
@@ -24,9 +24,8 @@ class QueueSaver {
 }
 exports.QueueSaver = QueueSaver;
 class DefaultQueueStore {
-    data = new Map();
-    constructor() {
-    }
+    data = new Utils_1.MiniMap();
+    constructor() { }
     async get(guildId) {
         return await this.data.get(guildId);
     }
@@ -44,20 +43,6 @@ class DefaultQueueStore {
     }
 }
 exports.DefaultQueueStore = DefaultQueueStore;
-class QueueChangesWatcher {
-    constructor() {
-    }
-    tracksAdd(guildId, tracks, position, oldStoredQueue, newStoredQueue) {
-        return;
-    }
-    tracksRemoved(guildId, tracks, position, oldStoredQueue, newStoredQueue) {
-        return;
-    }
-    shuffled(guildId, oldStoredQueue, newStoredQueue) {
-        return;
-    }
-}
-exports.QueueChangesWatcher = QueueChangesWatcher;
 class Queue {
     tracks = [];
     previous = [];
@@ -111,7 +96,7 @@ class Queue {
             return await this.QueueSaver.delete(this.guildId);
         },
         /**
-         * @returns {{current:Track|null, previous:Track[], tracks:Track[]}}The Queue, but in a raw State, which allows easier handling for the storeManager
+         * @returns {{current:Track|null, previous:Track[], tracks:Track[]}}The Queue, but in a raw State, which allows easier handling for the QueueStoreManager
          */
         toJSON: () => {
             if (this.previous.length > this.options.maxPreviousTracks)

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

@@ -7,8 +7,8 @@ export declare const TrackSymbol: unique symbol;
 export declare const UnresolvedTrackSymbol: unique symbol;
 export declare const QueueSymbol: unique symbol;
 export declare const NodeSymbol: unique symbol;
-export type LavalinkSearchPlatform = "ytsearch" | "ytmsearch" | "scsearch" | "spsearch" | "sprec" | "amsearch" | "dzsearch" | "dzisrc" | "sprec" | "ymsearch" | "speak" | "tts" | "ftts";
-export type ClientSearchPlatform = "youtube" | "yt" | "yt" | "youtube music" | "youtubemusic" | "ytm" | "soundcloud" | "sc" | "am" | "apple music" | "applemusic" | "apple" | "yandex music" | "sp" | "sprec" | "spsuggestion" | "spotify" | "dz" | "deezer" | "yandex" | "yandexmusic";
+export type LavalinkSearchPlatform = "ytsearch" | "ytmsearch" | "scsearch" | "spsearch" | "sprec" | "amsearch" | "dzsearch" | "dzisrc" | "ymsearch" | "speak" | "tts" | "ftts";
+export type ClientSearchPlatform = "youtube" | "yt" | "youtube music" | "youtubemusic" | "ytm" | "soundcloud" | "sc" | "am" | "apple music" | "applemusic" | "apple" | "sp" | "spsuggestion" | "spotify" | "dz" | "deezer" | "yandex" | "yandex music" | "yandexmusic";
 export type SearchPlatform = LavalinkSearchPlatform | ClientSearchPlatform;
 export type SourcesRegex = "YoutubeRegex" | "YoutubeMusicRegex" | "SoundCloudRegex" | "SoundCloudMobileRegex" | "DeezerTrackRegex" | "DeezerArtistRegex" | "DeezerEpisodeRegex" | "DeezerMixesRegex" | "DeezerPageLinkRegex" | "DeezerPlaylistRegex" | "DeezerAlbumRegex" | "AllDeezerRegex" | "AllDeezerRegexWithoutPageLink" | "SpotifySongRegex" | "SpotifyPlaylistRegex" | "SpotifyArtistRegex" | "SpotifyEpisodeRegex" | "SpotifyShowRegex" | "SpotifyAlbumRegex" | "AllSpotifyRegex" | "mp3Url" | "m3uUrl" | "m3u8Url" | "mp4Url" | "m4aUrl" | "wavUrl" | "aacpUrl" | "tiktok" | "mixcloud" | "musicYandex" | "radiohost" | "bandcamp" | "appleMusic" | "TwitchTv" | "vimeo";
 export interface PlaylistInfo {

package/dist/cjs/structures/Utils.js

@@ -6,6 +6,8 @@ exports.TrackSymbol = Symbol("LC-Track");
 exports.UnresolvedTrackSymbol = Symbol("LC-Track-Unresolved");
 exports.QueueSymbol = Symbol("LC-Queue");
 exports.NodeSymbol = Symbol("LC-Node");
+/** @hidden */
+const escapeRegExp = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 class ManagerUitls {
     constructor(LavalinkManager) {
         this.manager = LavalinkManager;
@@ -23,7 +25,7 @@ class ManagerUitls {
                     identifier: data.info?.identifier,
                     title: data.info?.title,
                     author: data.info?.author,
-                    duration: data.info?.length,
+                    duration: data.info?.length || data.info?.duration,
                     artworkUrl: data.info?.artworkUrl || data.pluginInfo?.artworkUrl || data.plugin?.artworkUrl,
                     uri: data.info?.uri,
                     sourceName: data.info?.sourceName,
@@ -95,13 +97,21 @@ class ManagerUitls {
      * @returns
      */
     isTrack(data) {
-        return typeof data?.encoded === "string" && typeof data?.info === "object";
+        if (!data)
+            return false;
+        if (data[exports.TrackSymbol] === true)
+            return true;
+        return typeof data?.encoded === "string" && typeof data?.info === "object" && !("resolve" in data);
     }
     /**
      * Checks if the provided argument is a valid UnresolvedTrack.
      * @param track
      */
     isUnresolvedTrack(data) {
+        if (!data)
+            return false;
+        if (data[exports.UnresolvedTrackSymbol] === true)
+            return true;
         return typeof data === "object" && "info" in data && typeof data.info.title === "string" && typeof data.resolve === "function";
     }
     /**
@@ -277,6 +287,32 @@ async function queueTrackEnd(player) {
     return player.queue.current;
 }
 exports.queueTrackEnd = queueTrackEnd;
+async function applyUnresolvedData(resTrack, data, utils) {
+    if (!resTrack?.info || !data?.info)
+        return;
+    if (utils.manager.options.playerOptions?.useUnresolvedData === true) { // overwrite values
+        if (data.info.uri)
+            resTrack.info.uri = data.info.uri;
+        if (data.info.artworkUrl?.length)
+            resTrack.info.artworkUrl = data.info.artworkUrl;
+        if (data.info.title?.length)
+            resTrack.info.title = data.info.title;
+        if (data.info.author?.length)
+            resTrack.info.author = data.info.author;
+    }
+    else { // only overwrite if undefined / invalid
+        if ((resTrack.info.title == 'Unknown title' || resTrack.info.title == "Unspecified description") && resTrack.info.title != data.info.title)
+            resTrack.info.title = data.info.title;
+        if (resTrack.info.author != data.info.author)
+            resTrack.info.author = data.info.author;
+        if (resTrack.info.artworkUrl != data.info.artworkUrl)
+            resTrack.info.artworkUrl = data.info.artworkUrl;
+    }
+    for (const key of Object.keys(data.info))
+        if (typeof resTrack.info[key] === "undefined" && key !== "resolve" && data.info[key])
+            resTrack.info[key] = data.info[key]; // add non-existing values
+    return resTrack;
+}
 async function getClosestTrack(data, player, utils) {
     if (!player || !player.node)
         throw new RangeError("No player with a lavalink node was provided");
@@ -288,19 +324,35 @@ async function getClosestTrack(data, player, utils) {
         throw new SyntaxError("the track title is required for unresolved tracks");
     if (!data.requester)
         throw new SyntaxError("The requester is required");
+    // try to decode the track, if possible
     if (typeof data.encoded === "string") {
-        const r = await player.node.decode.singleTrack(data.encoded);
+        const r = await player.node.decode.singleTrack(data.encoded, data.requester);
         if (r)
-            return utils.buildTrack(r, data.requester);
+            return applyUnresolvedData(r, data, utils);
     }
+    // try to fetch the track via a uri if possible
     if (typeof data.info.uri === "string") {
         const r = await player.search({ query: data?.info?.uri }, data.requester).then(v => v.tracks[0]);
         if (r)
-            return r;
+            return applyUnresolvedData(r, data, utils);
     }
+    // search the track as closely as possible
     const query = [data.info?.title, data.info?.author].filter(str => !!str).join(" by ");
     const sourceName = data.info?.sourceName;
     return await player.search({
         query, source: sourceName !== "bandcamp" && sourceName !== "twitch" && sourceName !== "flowery-tts" ? sourceName : player.LavalinkManager.options?.playerOptions?.defaultSearchPlatform,
-    }, data.requester).then(v => v.tracks[0]);
+    }, data.requester).then(res => {
+        let trackToUse = null;
+        // try to find via author name
+        if (data.info.author && !trackToUse)
+            trackToUse = res.tracks.find(track => [data.info.author, `${data.info.author} - Topic`].some(name => new RegExp(`^${escapeRegExp(name)}$`, "i").test(track.info.author)) || new RegExp(`^${escapeRegExp(data.info.title)}$`, "i").test(track.info.title));
+        // try to find via duration
+        if (data.info.duration && !trackToUse)
+            trackToUse = res.tracks.find(track => (track.info.duration >= (data.info.duration - 1500)) && (track.info.duration <= (data.info.duration + 1500)));
+        // try to find via isrc
+        if (data.info.isrc && !trackToUse)
+            trackToUse = res.tracks.find(track => track.info.isrc === data.info.isrc);
+        // apply unresolved data and return the track
+        return applyUnresolvedData(trackToUse || res.tracks[0], data, utils);
+    });
 }

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

@@ -7,7 +7,7 @@ export declare class FilterManager {
     equalizerBands: EQBand[];
     filterUpdatedState: number;
     filters: PlayerFilters;
-    data: LavalinkFilterData;
+    data: FilterData;
     constructor(player: Player);
     applyPlayerFilters(): Promise<void>;
     /**
@@ -215,9 +215,8 @@ export interface ReverbFilter {
     delay: number;
     decay: number;
 }
-export interface LavalinkFilterData {
+export interface FilterData {
     volume?: number;
-    equalizer?: EQBand[];
     karaoke?: KaraokeFilter;
     timescale?: TimescaleFilter;
     tremolo?: FreqFilter;
@@ -229,3 +228,6 @@ export interface LavalinkFilterData {
     echo: EchoFilter;
     reverb: ReverbFilter;
 }
+export interface LavalinkFilterData extends FilterData {
+    equalizer?: EQBand[];
+}