magmastream 2.9.0-dev.32 → 2.9.0-dev.34

package/dist/index.d.ts

@@ -266,6 +266,9 @@ declare enum ManagerEventTypes {
     ChapterStarted = "chapterStarted",
     ChaptersLoaded = "chaptersLoaded",
     Debug = "debug",
+    LyricsFoundEvent = "lyricsFoundEvent",
+    LyricsLineEvent = "lyricsLineEvent",
+    LyricsNotFoundEvent = "lyricsNotFoundEvent",
     NodeConnect = "nodeConnect",
     NodeCreate = "nodeCreate",
     NodeDestroy = "nodeDestroy",
@@ -736,15 +739,40 @@ interface LavaPlayer {
     filters: Record<string, unknown>;
 }
 /**
- * Search Result
+ * Error or Empty Search Result
  */
-interface SearchResult {
+interface ErrorOrEmptySearchResult {
     /** The load type of the result. */
-    loadType: LoadTypes;
-    /** The array of tracks from the result. */
+    loadType: LoadTypes.Empty | LoadTypes.Error;
+}
+/**
+ * Track Search Result
+ */
+interface TrackSearchResult {
+    /** The load type is always 'track' */
+    loadType: LoadTypes.Track;
+    /** The track obtained */
+    tracks: [Track];
+}
+/**
+ * Search Result
+ */
+interface SearchSearchResult {
+    /** The load type is always 'search' */
+    loadType: LoadTypes.Search;
+    /** The tracks of the search result */
+    tracks: Track[];
+}
+/**
+ * Playlist Search Result
+ */
+interface PlaylistSearchResult {
+    /** The playlist load type */
+    loadType: LoadTypes.Playlist;
+    /** The tracks of the playlist */
     tracks: Track[];
-    /** The playlist info if the load type is 'playlist'. */
-    playlist?: PlaylistData;
+    /** The playlist info */
+    playlist: PlaylistData;
 }
 /**
  * Playlist Data
@@ -783,6 +811,9 @@ interface ManagerEvents {
     [ManagerEventTypes.ChapterStarted]: [player: Player, track: Track, payload: SponsorBlockChapterStarted];
     [ManagerEventTypes.ChaptersLoaded]: [player: Player, track: Track, payload: SponsorBlockChaptersLoaded];
     [ManagerEventTypes.Debug]: [info: string];
+    [ManagerEventTypes.LyricsFoundEvent]: [player: Player, track: Track, payload: LyricsFoundEvent];
+    [ManagerEventTypes.LyricsLineEvent]: [player: Player, track: Track, payload: LyricsLineEvent];
+    [ManagerEventTypes.LyricsNotFoundEvent]: [player: Player, track: Track, payload: LyricsNotFoundEvent];
     [ManagerEventTypes.NodeConnect]: [node: Node];
     [ManagerEventTypes.NodeCreate]: [node: Node];
     [ManagerEventTypes.NodeDestroy]: [node: Node];
@@ -1153,6 +1184,31 @@ interface Lyrics {
     lines: LyricsLine[];
     plugin: object[];
 }
+/**
+ * LyricsFoundEvent interface
+ */
+interface LyricsFoundEvent extends PlayerEvent {
+    type: "LyricsFoundEvent";
+    guildId: string;
+    lyrics: Lyrics;
+}
+/**
+ * LyricsNotFoundEvent interface
+ */
+interface LyricsNotFoundEvent extends PlayerEvent {
+    type: "LyricsNotFoundEvent";
+    guildId: string;
+}
+/**
+ * LyricsLineEvent interface
+ */
+interface LyricsLineEvent extends PlayerEvent {
+    type: "LyricsLineEvent";
+    guildId: string;
+    lineIndex: number;
+    line: LyricsLine;
+    skipped: boolean;
+}
 /**
  * NodeLink Get Lyrics Multiple interface
  */
@@ -1338,7 +1394,7 @@ type TrackEndReason = keyof typeof TrackEndReasonTypes;
 /**
  * Player Event Type Enum type
  */
-type PlayerEventType = "TrackStartEvent" | "TrackEndEvent" | "TrackExceptionEvent" | "TrackStuckEvent" | "WebSocketClosedEvent" | "SegmentSkipped" | "SegmentsLoaded" | "ChaptersLoaded" | "ChapterStarted";
+type PlayerEventType = "TrackStartEvent" | "TrackEndEvent" | "TrackExceptionEvent" | "TrackStuckEvent" | "WebSocketClosedEvent" | "SegmentSkipped" | "SegmentsLoaded" | "ChaptersLoaded" | "ChapterStarted" | "LyricsFoundEvent" | "LyricsNotFoundEvent" | "LyricsLineEvent";
 /**
  * Severity Types Enum type
  */
@@ -1354,7 +1410,7 @@ type SponsorBlockSegmentEventType = "SegmentSkipped" | "SegmentsLoaded" | "Chapt
 /**
  * Player Events Enum type
  */
-type PlayerEvents = TrackStartEvent | TrackEndEvent | TrackStuckEvent | TrackExceptionEvent | WebSocketClosedEvent | SponsorBlockSegmentEvents;
+type PlayerEvents = TrackStartEvent | TrackEndEvent | TrackStuckEvent | TrackExceptionEvent | WebSocketClosedEvent | SponsorBlockSegmentEvents | LyricsEvent;
 /**
  * Load Type Enum type
  */
@@ -1367,6 +1423,18 @@ type NodeLinkGetLyrics = NodeLinkGetLyricsSingle | NodeLinkGetLyricsMultiple | N
  * Voice Receiver Event Enum type
  */
 type VoiceReceiverEvent = StartSpeakingEventVoiceReceiver | EndSpeakingEventVoiceReceiver;
+/**
+ * Search Result Enum type
+ */
+type SearchResult = TrackSearchResult | SearchSearchResult | PlaylistSearchResult | ErrorOrEmptySearchResult;
+/**
+ * Lyrics Event Enum type
+ */
+type LyricsEvent = LyricsFoundEvent | LyricsNotFoundEvent | LyricsLineEvent;
+/**
+ * Lyrics Event Type Enum type
+ */
+type LyricsEventType = "LyricsFoundEvent" | "LyricsNotFoundEvent" | "LyricsLineEvent";
 
 declare class Node$1 {
     manager: Manager;
@@ -1593,14 +1661,32 @@ declare class Node$1 {
     queueEnd(player: Player, track: Track, payload: TrackEndEvent): Promise<void>;
     /**
      * Fetches the lyrics of a track from the Lavalink node.
-     * This method uses the `lavalyrics-plugin` to fetch the lyrics.
-     * If the plugin is not available, it will throw a RangeError.
+     *
+     * If the node is a NodeLink, it will use the `NodeLinkGetLyrics` method to fetch the lyrics.
+     *
+     * Requires the `lavalyrics-plugin` to be present in the Lavalink node.
+     * Requires the `lavasrc-plugin` or `java-lyrics-plugin` to be present in the Lavalink node.
      *
      * @param {Track} track - The track to fetch the lyrics for.
      * @param {boolean} [skipTrackSource=false] - Whether to skip using the track's source URL.
      * @returns {Promise<Lyrics | NodeLinkGetLyrics>} A promise that resolves with the lyrics data.
      */
     getLyrics(track: Track, skipTrackSource?: boolean): Promise<Lyrics | NodeLinkGetLyrics>;
+    /**
+     * Subscribes to lyrics for a player.
+     * @param {string} guildId - The ID of the guild to subscribe to lyrics for.
+     * @param {boolean} [skipTrackSource=false] - Whether to skip using the track's source URL.
+     * @returns {Promise<unknown>} A promise that resolves when the subscription is complete.
+     * @throws {RangeError} If the node is not connected to the lavalink server or if the java-lyrics-plugin is not available.
+     */
+    lyricsSubscribe(guildId: string, skipTrackSource?: boolean): Promise<unknown>;
+    /**
+     * Unsubscribes from lyrics for a player.
+     * @param {string} guildId - The ID of the guild to unsubscribe from lyrics for.
+     * @returns {Promise<unknown>} A promise that resolves when the unsubscription is complete.
+     * @throws {RangeError} If the node is not connected to the lavalink server or if the java-lyrics-plugin is not available.
+     */
+    lyricsUnsubscribe(guildId: string): Promise<unknown>;
     /**
      * Handles the event when a track becomes stuck during playback.
      * Stops the current track and emits a `trackStuck` event.
@@ -1662,6 +1748,30 @@ declare class Node$1 {
      * @param {SponsorBlockChapterStarted} payload - The event payload containing additional data about the chapter started event.
      */
     private sponsorBlockChapterStarted;
+    /**
+     * Emitted when lyrics for a track are found.
+     * The payload of the event will contain the lyrics.
+     * @param {Player} player - The player associated with the lyrics.
+     * @param {Track} track - The track associated with the lyrics.
+     * @param {LyricsFoundEvent} payload - The event payload containing additional data about the lyrics found event.
+     */
+    private lyricsFound;
+    /**
+     * Emitted when lyrics for a track are not found.
+     * The payload of the event will contain the track.
+     * @param {Player} player - The player associated with the lyrics.
+     * @param {Track} track - The track associated with the lyrics.
+     * @param {LyricsNotFoundEvent} payload - The event payload containing additional data about the lyrics not found event.
+     */
+    private lyricsNotFound;
+    /**
+     * Emitted when a line of lyrics for a track is received.
+     * The payload of the event will contain the lyrics line.
+     * @param {Player} player - The player associated with the lyrics line.
+     * @param {Track} track - The track associated with the lyrics line.
+     * @param {LyricsLineEvent} payload - The event payload containing additional data about the lyrics line event.
+     */
+    private lyricsLine;
     /**
      * Fetches Lavalink node information.
      * @returns {Promise<LavalinkInfo>} A promise that resolves to the Lavalink node information.
@@ -2732,6 +2842,12 @@ declare abstract class TrackUtils {
      * @returns The built Track.
      */
     static build<T = User | ClientUser>(data: TrackData, requester?: T): Track;
+    /**
+     * Validates a search result.
+     * @param result The search result to validate.
+     * @returns Whether the search result is valid.
+     */
+    static isErrorOrEmptySearchResult(result: SearchResult): result is ErrorOrEmptySearchResult;
 }
 declare abstract class AutoPlayUtils {
     private static manager;
@@ -2740,7 +2856,7 @@ declare abstract class AutoPlayUtils {
      * @param manager The manager instance to use.
      * @hidden
      */
-    static init(manager: Manager): void;
+    static init(manager: Manager): Promise<void>;
     /**
      * Gets recommended tracks for the given track.
      * @param track The track to get recommended tracks for.
@@ -2760,8 +2876,8 @@ declare abstract class AutoPlayUtils {
      * @param platform The source to get recommended tracks from.
      * @returns An array of recommended tracks.
      */
-    static getRecommendedTracksFromSource(track: Track, platform: string): Promise<Track[]>;
-    static generateTotp(): (string | number)[];
+    static getRecommendedTracksFromSource(track: Track, platform: AutoPlayPlatform): Promise<Track[]>;
+    static buildTracksFromResponse<T>(recommendedResult: LavalinkResponse, requester?: T): Track[];
 }
 /** Gets or extends structures to extend the built in, or already extended, classes to add more functionality. */
 declare abstract class Structure {
@@ -2815,4 +2931,4 @@ declare class OceanicManager extends Manager {
 }
 
 export { AutoPlayPlatform, AutoPlayUtils, AvailableFilters, DetritusManager, DiscordJSManager, ErisManager, Filters, LoadTypes, Manager, ManagerEventTypes, Node$1 as Node, OceanicManager, Player, PlayerStateEventTypes, Plugin$1 as Plugin, Queue, Rest, SearchPlatform, SeverityTypes, SponsorBlockSegment, StateStorageType, StateTypes, Structure, TrackEndReasonTypes, TrackPartial, TrackSourceTypes, TrackUtils, UseNodeOptions };
-export type { CPUStats, DiscordPacket, EndSpeakingEventVoiceReceiver, EndSpeakingEventVoiceReceiverData, EqualizerBand, Exception, Extendable, FrameStats, IQueue, LavaPlayer, LavalinkInfo, LavalinkResponse, LoadType, Lyrics, LyricsLine, ManagerEvents, ManagerInitOptions, ManagerOptions, MemoryStats, NodeLinkGetLyrics, NodeLinkGetLyricsEmpty, NodeLinkGetLyricsError, NodeLinkGetLyricsMultiple, NodeLinkGetLyricsSingle, NodeMessage, NodeOptions, NodeStats, Payload, PlayOptions, PlayerEvent, PlayerEventType, PlayerEvents, PlayerOptions, PlayerStateUpdateEvent, PlayerUpdate, PlayerUpdateVoiceState, PlaylistData, PlaylistInfoData, PlaylistRawData, RedisConfig, SearchQuery, SearchResult, Severity, Sizes, SponsorBlockChapterStarted, SponsorBlockChaptersLoaded, SponsorBlockSegmentEventType, SponsorBlockSegmentEvents, SponsorBlockSegmentSkipped, SponsorBlockSegmentsLoaded, StartSpeakingEventVoiceReceiver, StartSpeakingEventVoiceReceiverData, StateStorageOptions, Track, TrackData, TrackDataInfo, TrackEndEvent, TrackEndReason, TrackExceptionEvent, TrackPluginInfo, TrackSourceName, TrackStartEvent, TrackStuckEvent, UseNodeOption, VoicePacket, VoiceReceiverEvent, VoiceServer, VoiceServerUpdate, VoiceState, WebSocketClosedEvent };
+export type { CPUStats, DiscordPacket, EndSpeakingEventVoiceReceiver, EndSpeakingEventVoiceReceiverData, EqualizerBand, ErrorOrEmptySearchResult, Exception, Extendable, FrameStats, IQueue, LavaPlayer, LavalinkInfo, LavalinkResponse, LoadType, Lyrics, LyricsEvent, LyricsEventType, LyricsFoundEvent, LyricsLine, LyricsLineEvent, LyricsNotFoundEvent, ManagerEvents, ManagerInitOptions, ManagerOptions, MemoryStats, NodeLinkGetLyrics, NodeLinkGetLyricsEmpty, NodeLinkGetLyricsError, NodeLinkGetLyricsMultiple, NodeLinkGetLyricsSingle, NodeMessage, NodeOptions, NodeStats, Payload, PlayOptions, PlayerEvent, PlayerEventType, PlayerEvents, PlayerOptions, PlayerStateUpdateEvent, PlayerUpdate, PlayerUpdateVoiceState, PlaylistData, PlaylistInfoData, PlaylistRawData, PlaylistSearchResult, RedisConfig, SearchQuery, SearchResult, SearchSearchResult, Severity, Sizes, SponsorBlockChapterStarted, SponsorBlockChaptersLoaded, SponsorBlockSegmentEventType, SponsorBlockSegmentEvents, SponsorBlockSegmentSkipped, SponsorBlockSegmentsLoaded, StartSpeakingEventVoiceReceiver, StartSpeakingEventVoiceReceiverData, StateStorageOptions, Track, TrackData, TrackDataInfo, TrackEndEvent, TrackEndReason, TrackExceptionEvent, TrackPluginInfo, TrackSearchResult, TrackSourceName, TrackStartEvent, TrackStuckEvent, UseNodeOption, VoicePacket, VoiceReceiverEvent, VoiceServer, VoiceServerUpdate, VoiceState, WebSocketClosedEvent };

package/dist/structures/Enums.js

@@ -141,6 +141,9 @@ var ManagerEventTypes;
     ManagerEventTypes["ChapterStarted"] = "chapterStarted";
     ManagerEventTypes["ChaptersLoaded"] = "chaptersLoaded";
     ManagerEventTypes["Debug"] = "debug";
+    ManagerEventTypes["LyricsFoundEvent"] = "lyricsFoundEvent";
+    ManagerEventTypes["LyricsLineEvent"] = "lyricsLineEvent";
+    ManagerEventTypes["LyricsNotFoundEvent"] = "lyricsNotFoundEvent";
     ManagerEventTypes["NodeConnect"] = "nodeConnect";
     ManagerEventTypes["NodeCreate"] = "nodeCreate";
     ManagerEventTypes["NodeDestroy"] = "nodeDestroy";

package/dist/structures/Manager.js

@@ -47,7 +47,6 @@ class Manager extends events_1.EventEmitter {
         // Initialize structures
         Utils_1.Structure.get("Player").init(this);
         Utils_1.TrackUtils.init(this);
-        Utils_1.AutoPlayUtils.init(this);
         if (options.trackPartial) {
             Utils_1.TrackUtils.setTrackPartial(options.trackPartial);
             delete options.trackPartial;
@@ -77,6 +76,7 @@ class Manager extends events_1.EventEmitter {
             stateStorage: { type: Enums_1.StateStorageType.Collection },
             ...options,
         };
+        Utils_1.AutoPlayUtils.init(this);
         if (this.options.nodes) {
             for (const nodeOptions of this.options.nodes)
                 new Node_1.Node(this, nodeOptions);
@@ -216,7 +216,20 @@ class Manager extends events_1.EventEmitter {
                     tracks = tracks.map(processTrack);
                 }
             }
-            const result = { loadType: res.loadType, tracks, playlist };
+            let result;
+            switch (res.loadType) {
+                case Enums_1.LoadTypes.Playlist:
+                    result = { loadType: res.loadType, tracks, playlist };
+                    break;
+                case Enums_1.LoadTypes.Search:
+                    result = { loadType: res.loadType, tracks };
+                    break;
+                case Enums_1.LoadTypes.Track:
+                    result = { loadType: res.loadType, tracks: [tracks[0]] };
+                    break;
+                default:
+                    return { loadType: res.loadType };
+            }
             this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Result ${_source} search for: ${_query.query}: ${JSON.stringify(result)}`);
             return result;
         }

package/dist/structures/Node.js

@@ -485,6 +485,15 @@ class Node {
             case "ChapterStarted":
                 this.sponsorBlockChapterStarted(player, track, payload);
                 break;
+            case "LyricsFoundEvent":
+                this.lyricsFound(player, track, payload);
+                break;
+            case "LyricsNotFoundEvent":
+                this.lyricsNotFound(player, track, payload);
+                break;
+            case "LyricsLineEvent":
+                this.lyricsLine(player, track, payload);
+                break;
             default:
                 error = new Error(`Node#event unknown event '${type}'.`);
                 this.manager.emit(Enums_1.ManagerEventTypes.NodeError, this, error);
@@ -734,19 +743,28 @@ class Node {
     }
     /**
      * Fetches the lyrics of a track from the Lavalink node.
-     * This method uses the `lavalyrics-plugin` to fetch the lyrics.
-     * If the plugin is not available, it will throw a RangeError.
+     *
+     * If the node is a NodeLink, it will use the `NodeLinkGetLyrics` method to fetch the lyrics.
+     *
+     * Requires the `lavalyrics-plugin` to be present in the Lavalink node.
+     * Requires the `lavasrc-plugin` or `java-lyrics-plugin` to be present in the Lavalink node.
      *
      * @param {Track} track - The track to fetch the lyrics for.
      * @param {boolean} [skipTrackSource=false] - Whether to skip using the track's source URL.
      * @returns {Promise<Lyrics | NodeLinkGetLyrics>} A promise that resolves with the lyrics data.
      */
     async getLyrics(track, skipTrackSource = false) {
+        if (!this.connected)
+            throw new RangeError(`The node is not connected to the lavalink server: ${this.options.identifier}`);
         if (this.isNodeLink) {
             return (await this.rest.get(`/v4/lyrics?track=${encodeURIComponent(track.track)}&skipTrackSource=${skipTrackSource}`));
         }
-        if (!this.info.plugins.some((plugin) => plugin.name === "lavalyrics-plugin"))
-            throw new RangeError(`there is no lavalyrics-plugin available in the lavalink node: ${this.options.identifier}`);
+        if (!this.info.plugins.some((plugin) => plugin.name === "lavalyrics-plugin")) {
+            throw new RangeError(`The plugin "lavalyrics-plugin" must be present in the lavalink node: ${this.options.identifier}`);
+        }
+        if (!this.info.plugins.some((plugin) => plugin.name === "lavasrc-plugin" || plugin.name === "java-lyrics-plugin")) {
+            throw new RangeError(`One of the following plugins must also be present in the lavalink node: "lavasrc-plugin" or "java-lyrics-plugin" (Node: ${this.options.identifier})`);
+        }
         return ((await this.rest.get(`/v4/lyrics?track=${encodeURIComponent(track.track)}&skipTrackSource=${skipTrackSource}`)) || {
             source: null,
             provider: null,
@@ -755,6 +773,42 @@ class Node {
             plugin: [],
         });
     }
+    /**
+     * Subscribes to lyrics for a player.
+     * @param {string} guildId - The ID of the guild to subscribe to lyrics for.
+     * @param {boolean} [skipTrackSource=false] - Whether to skip using the track's source URL.
+     * @returns {Promise<unknown>} A promise that resolves when the subscription is complete.
+     * @throws {RangeError} If the node is not connected to the lavalink server or if the java-lyrics-plugin is not available.
+     */
+    async lyricsSubscribe(guildId, skipTrackSource = false) {
+        if (!this.connected)
+            throw new RangeError(`The node is not connected to the lavalink server: ${this.options.identifier}`);
+        if (this.isNodeLink)
+            throw new RangeError(`The node is a node link: ${this.options.identifier}`);
+        if (!this.info.plugins.some((plugin) => plugin.name === "lavalyrics-plugin")) {
+            throw new RangeError(`The plugin "lavalyrics-plugin" must be present in the lavalink node: ${this.options.identifier}`);
+        }
+        if (!this.info.plugins.some((plugin) => plugin.name === "lavasrc-plugin" || plugin.name === "java-lyrics-plugin")) {
+            throw new RangeError(`One of the following plugins must also be present in the lavalink node: "lavasrc-plugin" or "java-lyrics-plugin" (Node: ${this.options.identifier})`);
+        }
+        return await this.rest.post(`/v4/sessions/${this.sessionId}/players/${guildId}/lyrics/subscribe?skipTrackSource=${skipTrackSource}`, {});
+    }
+    /**
+     * Unsubscribes from lyrics for a player.
+     * @param {string} guildId - The ID of the guild to unsubscribe from lyrics for.
+     * @returns {Promise<unknown>} A promise that resolves when the unsubscription is complete.
+     * @throws {RangeError} If the node is not connected to the lavalink server or if the java-lyrics-plugin is not available.
+     */
+    async lyricsUnsubscribe(guildId) {
+        if (!this.connected)
+            throw new RangeError(`The node is not connected to the lavalink server: ${this.options.identifier}`);
+        if (this.isNodeLink)
+            throw new RangeError(`The node is a node link: ${this.options.identifier}`);
+        if (!this.info.plugins.some((plugin) => plugin.name === "java-lyrics-plugin")) {
+            throw new RangeError(`there is no java-lyrics-plugin available in the lavalink node: ${this.options.identifier}`);
+        }
+        return await this.rest.delete(`/v4/sessions/${this.sessionId}/players/${guildId}/lyrics/subscribe`);
+    }
     /**
      * Handles the event when a track becomes stuck during playback.
      * Stops the current track and emits a `trackStuck` event.
@@ -833,6 +887,36 @@ class Node {
     sponsorBlockChapterStarted(player, track, payload) {
         return this.manager.emit(Enums_1.ManagerEventTypes.ChapterStarted, player, track, payload);
     }
+    /**
+     * Emitted when lyrics for a track are found.
+     * The payload of the event will contain the lyrics.
+     * @param {Player} player - The player associated with the lyrics.
+     * @param {Track} track - The track associated with the lyrics.
+     * @param {LyricsFoundEvent} payload - The event payload containing additional data about the lyrics found event.
+     */
+    lyricsFound(player, track, payload) {
+        return this.manager.emit(Enums_1.ManagerEventTypes.LyricsFoundEvent, player, track, payload);
+    }
+    /**
+     * Emitted when lyrics for a track are not found.
+     * The payload of the event will contain the track.
+     * @param {Player} player - The player associated with the lyrics.
+     * @param {Track} track - The track associated with the lyrics.
+     * @param {LyricsNotFoundEvent} payload - The event payload containing additional data about the lyrics not found event.
+     */
+    lyricsNotFound(player, track, payload) {
+        return this.manager.emit(Enums_1.ManagerEventTypes.LyricsNotFoundEvent, player, track, payload);
+    }
+    /**
+     * Emitted when a line of lyrics for a track is received.
+     * The payload of the event will contain the lyrics line.
+     * @param {Player} player - The player associated with the lyrics line.
+     * @param {Track} track - The track associated with the lyrics line.
+     * @param {LyricsLineEvent} payload - The event payload containing additional data about the lyrics line event.
+     */
+    lyricsLine(player, track, payload) {
+        return this.manager.emit(Enums_1.ManagerEventTypes.LyricsLineEvent, player, track, payload);
+    }
     /**
      * Fetches Lavalink node information.
      * @returns {Promise<LavalinkInfo>} A promise that resolves to the Lavalink node information.

package/dist/structures/Utils.js

@@ -4,8 +4,8 @@ exports.Structure = exports.AutoPlayUtils = exports.TrackUtils = void 0;
 const tslib_1 = require("tslib");
 const axios_1 = tslib_1.__importDefault(require("axios"));
 const jsdom_1 = require("jsdom");
-const crypto_1 = tslib_1.__importDefault(require("crypto"));
 const Enums_1 = require("./Enums");
+// import playwright from "playwright";
 /** @hidden */
 const SIZES = ["0", "1", "2", "3", "default", "mqdefault", "hqdefault", "maxresdefault"];
 class TrackUtils {
@@ -129,19 +129,32 @@ class TrackUtils {
             throw new RangeError(`Argument "data" is not a valid track: ${error.message}`);
         }
     }
+    /**
+     * Validates a search result.
+     * @param result The search result to validate.
+     * @returns Whether the search result is valid.
+     */
+    static isErrorOrEmptySearchResult(result) {
+        return result.loadType === Enums_1.LoadTypes.Empty || result.loadType === Enums_1.LoadTypes.Error;
+    }
 }
 exports.TrackUtils = TrackUtils;
 class AutoPlayUtils {
     static manager;
+    // private static cachedAccessToken: string | null = null;
+    // private static cachedAccessTokenExpiresAt: number = 0;
     /**
      * Initializes the AutoPlayUtils class with the given manager.
      * @param manager The manager instance to use.
      * @hidden
      */
-    static init(manager) {
+    static async init(manager) {
         if (!manager)
             throw new Error("AutoPlayUtils.init() requires a valid Manager instance.");
         this.manager = manager;
+        // if (this.manager.options.autoPlaySearchPlatforms.includes(AutoPlayPlatform.Spotify)) {
+        // 	await this.getSpotifyAccessToken();
+        // }
     }
     /**
      * Gets recommended tracks for the given track.
@@ -190,15 +203,25 @@ class AutoPlayUtils {
                     return [];
                 }
                 const randomTrack = response.data.toptracks.track[Math.floor(Math.random() * response.data.toptracks.track.length)];
-                const res = await this.manager.search({ query: `${randomTrack.artist.name} - ${randomTrack.name}`, source: this.manager.options.defaultSearchPlatform }, track.requester);
-                if (res.loadType === Enums_1.LoadTypes.Empty || res.loadType === Enums_1.LoadTypes.Error) {
+                const searchResult = await this.manager.search({ query: `${randomTrack.artist.name} - ${randomTrack.name}`, source: this.manager.options.defaultSearchPlatform }, track.requester);
+                if (TrackUtils.isErrorOrEmptySearchResult(searchResult)) {
                     return [];
                 }
-                const filteredTracks = res.tracks.filter((t) => t.uri !== track.uri);
-                if (!filteredTracks.length) {
-                    return [];
+                let resolvedTracks;
+                switch (searchResult.loadType) {
+                    case Enums_1.LoadTypes.Playlist:
+                        resolvedTracks = searchResult.playlist.tracks;
+                        break;
+                    case Enums_1.LoadTypes.Track:
+                    case Enums_1.LoadTypes.Search:
+                        resolvedTracks = searchResult.tracks;
+                        break;
+                    default:
+                        return [];
                 }
-                return filteredTracks;
+                if (!resolvedTracks.length)
+                    return [];
+                return resolvedTracks;
             }
             if (!artist) {
                 // No artist provided, search for the track title
@@ -228,11 +251,25 @@ class AutoPlayUtils {
                 return [];
             }
             const randomTrack = retryResponse.data.toptracks.track[Math.floor(Math.random() * retryResponse.data.toptracks.track.length)];
-            const res = await this.manager.search({ query: `${randomTrack.artist.name} - ${randomTrack.name}`, source: this.manager.options.defaultSearchPlatform }, track.requester);
-            if (res.loadType === Enums_1.LoadTypes.Empty || res.loadType === Enums_1.LoadTypes.Error) {
+            const searchResult = await this.manager.search({ query: `${randomTrack.artist.name} - ${randomTrack.name}`, source: this.manager.options.defaultSearchPlatform }, track.requester);
+            if (TrackUtils.isErrorOrEmptySearchResult(searchResult)) {
                 return [];
             }
-            const filteredTracks = res.tracks.filter((t) => t.uri !== track.uri);
+            let resolvedTracks;
+            switch (searchResult.loadType) {
+                case Enums_1.LoadTypes.Playlist:
+                    resolvedTracks = searchResult.playlist.tracks;
+                    break;
+                case Enums_1.LoadTypes.Track:
+                case Enums_1.LoadTypes.Search:
+                    resolvedTracks = searchResult.tracks;
+                    break;
+                default:
+                    return [];
+            }
+            if (!resolvedTracks.length)
+                return [];
+            const filteredTracks = resolvedTracks.filter((t) => t.uri !== track.uri);
             if (!filteredTracks.length) {
                 return [];
             }
@@ -242,16 +279,25 @@ class AutoPlayUtils {
         if (!randomTrack) {
             return [];
         }
-        const res = await this.manager.search({ query: `${randomTrack.artist.name} - ${randomTrack.name}`, source: this.manager.options.defaultSearchPlatform }, track.requester);
-        if (res.loadType === Enums_1.LoadTypes.Empty || res.loadType === Enums_1.LoadTypes.Error) {
+        const searchResult = await this.manager.search({ query: `${randomTrack.artist.name} - ${randomTrack.name}`, source: this.manager.options.defaultSearchPlatform }, track.requester);
+        if (TrackUtils.isErrorOrEmptySearchResult(searchResult)) {
             return [];
         }
-        if (res.loadType === Enums_1.LoadTypes.Playlist)
-            res.tracks = res.playlist.tracks;
-        if (!res.tracks.length) {
-            return [];
+        let resolvedTracks;
+        switch (searchResult.loadType) {
+            case Enums_1.LoadTypes.Playlist:
+                resolvedTracks = searchResult.playlist.tracks;
+                break;
+            case Enums_1.LoadTypes.Track:
+            case Enums_1.LoadTypes.Search:
+                resolvedTracks = searchResult.tracks;
+                break;
+            default:
+                return [];
         }
-        return res.tracks;
+        if (!resolvedTracks.length)
+            return [];
+        return resolvedTracks;
     }
     /**
      * Gets recommended tracks from the given source.
@@ -260,157 +306,90 @@ class AutoPlayUtils {
      * @returns An array of recommended tracks.
      */
     static async getRecommendedTracksFromSource(track, platform) {
+        const requester = track.requester;
         switch (platform) {
-            case "spotify":
+            case Enums_1.AutoPlayPlatform.Spotify:
                 {
-                    try {
-                        if (!track.uri.includes("spotify")) {
-                            const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Enums_1.SearchPlatform.Spotify }, track.requester);
-                            if (res.loadType === Enums_1.LoadTypes.Empty || res.loadType === Enums_1.LoadTypes.Error) {
-                                return [];
-                            }
-                            if (res.loadType === Enums_1.LoadTypes.Playlist) {
-                                res.tracks = res.playlist.tracks;
-                            }
-                            if (!res.tracks.length) {
-                                return [];
-                            }
-                            track = res.tracks[0];
-                        }
-                        const [totp, timestamp] = this.generateTotp();
-                        const params = {
-                            reason: "init",
-                            productType: "web-player",
-                            totp: totp,
-                            totpVer: 5,
-                            ts: timestamp,
-                        };
-                        let body;
-                        try {
-                            const response = await axios_1.default.get("https://open.spotify.com/api/token", {
-                                params,
-                                headers: {
-                                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.6998.178 Spotify/1.2.65.255 Safari/537.36",
-                                    "App-Platform": "WebPlayer",
-                                    Referer: "https://open.spotify.com/",
-                                    Origin: "https://open.spotify.com",
-                                    "Accept-Language": "en",
-                                },
-                            });
-                            body = response.data;
-                        }
-                        catch (error) {
-                            const status = error.response?.status ?? "No response";
-                            console.error("[AutoPlay] Failed to get spotify access token:", status);
-                            return [];
-                        }
-                        let json;
-                        try {
-                            const response = await axios_1.default.get(`https://api.spotify.com/v1/recommendations`, {
-                                params: { limit: 10, seed_tracks: track.identifier },
-                                headers: {
-                                    Authorization: `Bearer ${body.accessToken}`,
-                                    "Content-Type": "application/json",
-                                },
-                            });
-                            json = response.data;
-                        }
-                        catch (error) {
-                            console.error("[AutoPlay] Failed to fetch spotify recommendations:", error.response?.status);
-                            return [];
-                        }
-                        if (!json.tracks || !json.tracks.length) {
-                            return [];
-                        }
-                        const recommendedTrackId = json.tracks[Math.floor(Math.random() * json.tracks.length)].id;
-                        const res = await this.manager.search({ query: `https://open.spotify.com/track/${recommendedTrackId}`, source: Enums_1.SearchPlatform.Spotify }, track.requester);
-                        if (res.loadType === Enums_1.LoadTypes.Empty || res.loadType === Enums_1.LoadTypes.Error) {
+                    if (!track.uri.includes("spotify")) {
+                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Enums_1.SearchPlatform.Spotify }, requester);
+                        if (TrackUtils.isErrorOrEmptySearchResult(res))
                             return [];
+                        let resolvedTrack;
+                        switch (res.loadType) {
+                            case Enums_1.LoadTypes.Playlist:
+                                resolvedTrack = res.playlist.tracks[0];
+                                break;
+                            case Enums_1.LoadTypes.Track:
+                            case Enums_1.LoadTypes.Search:
+                                resolvedTrack = res.tracks[0];
+                                break;
+                            default:
+                                return [];
                         }
-                        if (res.loadType === Enums_1.LoadTypes.Playlist) {
-                            res.tracks = res.playlist.tracks;
-                        }
-                        if (!res.tracks.length) {
+                        if (!resolvedTrack)
                             return [];
-                        }
-                        return res.tracks;
-                    }
-                    catch (error) {
-                        console.error("[AutoPlay] Unexpected spotify error:", error.message || error);
-                        return [];
-                    }
+                        track = resolvedTrack;
+                    }
+                    const extractSpotifyArtistID = (url) => {
+                        const regex = /https:\/\/open\.spotify\.com\/artist\/([a-zA-Z0-9]+)/;
+                        const match = url.match(regex);
+                        return match ? match[1] : null;
+                    };
+                    const identifier = `sprec:seed_artists=${extractSpotifyArtistID(track.pluginInfo.artistUrl)}&seed_tracks=${track.identifier}`;
+                    const recommendedResult = (await this.manager.useableNode.rest.get(`/v4/loadtracks?identifier=${encodeURIComponent(identifier)}`));
+                    const tracks = this.buildTracksFromResponse(recommendedResult, requester);
+                    return tracks;
                 }
                 break;
-            case "deezer":
+            case Enums_1.AutoPlayPlatform.Deezer:
                 {
                     if (!track.uri.includes("deezer")) {
-                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Enums_1.SearchPlatform.Deezer }, track.requester);
-                        if (res.loadType === Enums_1.LoadTypes.Empty || res.loadType === Enums_1.LoadTypes.Error) {
+                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Enums_1.SearchPlatform.Deezer }, requester);
+                        if (TrackUtils.isErrorOrEmptySearchResult(res))
                             return [];
+                        let resolvedTrack;
+                        switch (res.loadType) {
+                            case Enums_1.LoadTypes.Playlist:
+                                resolvedTrack = res.playlist.tracks[0];
+                                break;
+                            case Enums_1.LoadTypes.Track:
+                            case Enums_1.LoadTypes.Search:
+                                resolvedTrack = res.tracks[0];
+                                break;
+                            default:
+                                return [];
                         }
-                        if (res.loadType === Enums_1.LoadTypes.Playlist) {
-                            res.tracks = res.playlist.tracks;
-                        }
-                        if (!res.tracks.length) {
+                        if (!resolvedTrack)
                             return [];
-                        }
-                        track = res.tracks[0];
+                        track = resolvedTrack;
                     }
                     const identifier = `dzrec:${track.identifier}`;
                     const recommendedResult = (await this.manager.useableNode.rest.get(`/v4/loadtracks?identifier=${encodeURIComponent(identifier)}`));
-                    if (!recommendedResult) {
-                        return [];
-                    }
-                    let tracks = [];
-                    let playlist = null;
-                    const requester = track.requester;
-                    switch (recommendedResult.loadType) {
-                        case Enums_1.LoadTypes.Search:
-                            tracks = recommendedResult.data.map((track) => TrackUtils.build(track, requester));
-                            break;
-                        case Enums_1.LoadTypes.Track:
-                            tracks = [TrackUtils.build(recommendedResult.data, requester)];
-                            break;
-                        case Enums_1.LoadTypes.Playlist: {
-                            const playlistData = recommendedResult.data;
-                            tracks = playlistData.tracks.map((track) => TrackUtils.build(track, requester));
-                            playlist = {
-                                name: playlistData.info.name,
-                                playlistInfo: playlistData.pluginInfo,
-                                requester: requester,
-                                tracks,
-                                duration: tracks.reduce((acc, cur) => acc + (cur.duration || 0), 0),
-                            };
-                            break;
-                        }
-                    }
-                    const result = { loadType: recommendedResult.loadType, tracks, playlist };
-                    if (result.loadType === Enums_1.LoadTypes.Empty || result.loadType === Enums_1.LoadTypes.Error) {
-                        return [];
-                    }
-                    if (result.loadType === Enums_1.LoadTypes.Playlist) {
-                        result.tracks = result.playlist.tracks;
-                    }
-                    if (!result.tracks.length) {
-                        return [];
-                    }
-                    return result.tracks;
+                    const tracks = this.buildTracksFromResponse(recommendedResult, requester);
+                    return tracks;
                 }
                 break;
-            case "soundcloud":
+            case Enums_1.AutoPlayPlatform.SoundCloud:
                 {
                     if (!track.uri.includes("soundcloud")) {
-                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Enums_1.SearchPlatform.SoundCloud }, track.requester);
-                        if (res.loadType === Enums_1.LoadTypes.Empty || res.loadType === Enums_1.LoadTypes.Error) {
+                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Enums_1.SearchPlatform.SoundCloud }, requester);
+                        if (TrackUtils.isErrorOrEmptySearchResult(res))
                             return [];
+                        let resolvedTrack;
+                        switch (res.loadType) {
+                            case Enums_1.LoadTypes.Playlist:
+                                resolvedTrack = res.playlist.tracks[0];
+                                break;
+                            case Enums_1.LoadTypes.Track:
+                            case Enums_1.LoadTypes.Search:
+                                resolvedTrack = res.tracks[0];
+                                break;
+                            default:
+                                return [];
                         }
-                        if (res.loadType === Enums_1.LoadTypes.Playlist) {
-                            res.tracks = res.playlist.tracks;
-                        }
-                        if (!res.tracks.length) {
+                        if (!resolvedTrack)
                             return [];
-                        }
-                        track = res.tracks[0];
+                        track = resolvedTrack;
                     }
                     try {
                         const recommendedRes = await axios_1.default.get(`${track.uri}/recommended`).catch((err) => {
@@ -440,17 +419,22 @@ class AutoPlayUtils {
                             return [];
                         }
                         const randomUrl = urls[Math.floor(Math.random() * urls.length)];
-                        const res = await this.manager.search({ query: randomUrl, source: Enums_1.SearchPlatform.SoundCloud }, track.requester);
-                        if (res.loadType === Enums_1.LoadTypes.Empty || res.loadType === Enums_1.LoadTypes.Error) {
-                            return [];
-                        }
-                        if (res.loadType === Enums_1.LoadTypes.Playlist) {
-                            res.tracks = res.playlist.tracks;
+                        const res = await this.manager.search({ query: randomUrl, source: Enums_1.SearchPlatform.SoundCloud }, requester);
+                        let resolvedTrack;
+                        switch (res.loadType) {
+                            case Enums_1.LoadTypes.Playlist:
+                                resolvedTrack = res.playlist.tracks[0];
+                                break;
+                            case Enums_1.LoadTypes.Track:
+                            case Enums_1.LoadTypes.Search:
+                                resolvedTrack = res.tracks[0];
+                                break;
+                            default:
+                                return [];
                         }
-                        if (!res.tracks.length) {
+                        if (!resolvedTrack)
                             return [];
-                        }
-                        return res.tracks;
+                        return [resolvedTrack];
                     }
                     catch (error) {
                         console.error("[AutoPlay] Error occurred while fetching soundcloud recommendations:", error);
@@ -458,7 +442,7 @@ class AutoPlayUtils {
                     }
                 }
                 break;
-            case "youtube":
+            case Enums_1.AutoPlayPlatform.YouTube:
                 {
                     const hasYouTubeURL = ["youtube.com", "youtu.be"].some((url) => track.uri.includes(url));
                     let videoID = null;
@@ -466,8 +450,25 @@ class AutoPlayUtils {
                         videoID = track.uri.split("=").pop();
                     }
                     else {
-                        const searchResult = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Enums_1.SearchPlatform.YouTube }, track.requester);
-                        videoID = searchResult.tracks[0]?.uri.split("=").pop();
+                        const searchResult = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Enums_1.SearchPlatform.YouTube }, requester);
+                        if (TrackUtils.isErrorOrEmptySearchResult(searchResult)) {
+                            return [];
+                        }
+                        let resolvedTrack;
+                        switch (searchResult.loadType) {
+                            case Enums_1.LoadTypes.Playlist:
+                                resolvedTrack = searchResult.playlist.tracks[0];
+                                break;
+                            case Enums_1.LoadTypes.Track:
+                            case Enums_1.LoadTypes.Search:
+                                resolvedTrack = searchResult.tracks[0];
+                                break;
+                            default:
+                                return [];
+                        }
+                        if (!resolvedTrack)
+                            return [];
+                        videoID = resolvedTrack.uri.split("=").pop();
                     }
                     if (!videoID) {
                         return [];
@@ -478,200 +479,181 @@ class AutoPlayUtils {
                         randomIndex = Math.floor(Math.random() * 23) + 2;
                         searchURI = `https://www.youtube.com/watch?v=${videoID}&list=RD${videoID}&index=${randomIndex}`;
                     } while (track.uri.includes(searchURI));
-                    const res = await this.manager.search({ query: searchURI, source: Enums_1.SearchPlatform.YouTube }, track.requester);
-                    if (res.loadType === Enums_1.LoadTypes.Empty || res.loadType === Enums_1.LoadTypes.Error) {
+                    const res = await this.manager.search({ query: searchURI, source: Enums_1.SearchPlatform.YouTube }, requester);
+                    if (TrackUtils.isErrorOrEmptySearchResult(res)) {
                         return [];
                     }
-                    const filteredTracks = res.tracks.filter((t) => t.uri !== track.uri);
+                    let resolvedTracks;
+                    switch (res.loadType) {
+                        case Enums_1.LoadTypes.Playlist:
+                            resolvedTracks = res.playlist.tracks;
+                            break;
+                        case Enums_1.LoadTypes.Track:
+                        case Enums_1.LoadTypes.Search:
+                            resolvedTracks = res.tracks;
+                            break;
+                        default:
+                            return [];
+                    }
+                    const filteredTracks = resolvedTracks.filter((t) => t.uri !== track.uri);
                     return filteredTracks;
                 }
                 break;
-            case "tidal":
+            case Enums_1.AutoPlayPlatform.Tidal:
                 {
                     if (!track.uri.includes("tidal")) {
-                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Enums_1.SearchPlatform.Tidal }, track.requester);
-                        if (res.loadType === Enums_1.LoadTypes.Empty || res.loadType === Enums_1.LoadTypes.Error) {
+                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Enums_1.SearchPlatform.Tidal }, requester);
+                        if (TrackUtils.isErrorOrEmptySearchResult(res))
                             return [];
+                        let resolvedTrack;
+                        switch (res.loadType) {
+                            case Enums_1.LoadTypes.Playlist:
+                                resolvedTrack = res.playlist.tracks[0];
+                                break;
+                            case Enums_1.LoadTypes.Track:
+                            case Enums_1.LoadTypes.Search:
+                                resolvedTrack = res.tracks[0];
+                                break;
+                            default:
+                                return [];
                         }
-                        if (res.loadType === Enums_1.LoadTypes.Playlist) {
-                            res.tracks = res.playlist.tracks;
-                        }
-                        if (!res.tracks.length) {
+                        if (!resolvedTrack)
                             return [];
-                        }
-                        track = res.tracks[0];
+                        track = resolvedTrack;
                     }
                     const identifier = `tdrec:${track.identifier}`;
                     const recommendedResult = (await this.manager.useableNode.rest.get(`/v4/loadtracks?identifier=${encodeURIComponent(identifier)}`));
-                    if (!recommendedResult) {
-                        return [];
-                    }
-                    let tracks = [];
-                    let playlist = null;
-                    const requester = track.requester;
-                    switch (recommendedResult.loadType) {
-                        case Enums_1.LoadTypes.Search:
-                            tracks = recommendedResult.data.map((track) => TrackUtils.build(track, requester));
-                            break;
-                        case Enums_1.LoadTypes.Track:
-                            tracks = [TrackUtils.build(recommendedResult.data, requester)];
-                            break;
-                        case Enums_1.LoadTypes.Playlist: {
-                            const playlistData = recommendedResult.data;
-                            tracks = playlistData.tracks.map((track) => TrackUtils.build(track, requester));
-                            playlist = {
-                                name: playlistData.info.name,
-                                playlistInfo: playlistData.pluginInfo,
-                                requester: requester,
-                                tracks,
-                                duration: tracks.reduce((acc, cur) => acc + (cur.duration || 0), 0),
-                            };
-                            break;
-                        }
-                    }
-                    const result = { loadType: recommendedResult.loadType, tracks, playlist };
-                    if (result.loadType === Enums_1.LoadTypes.Empty || result.loadType === Enums_1.LoadTypes.Error) {
-                        return [];
-                    }
-                    if (result.loadType === Enums_1.LoadTypes.Playlist) {
-                        result.tracks = result.playlist.tracks;
-                    }
-                    if (!result.tracks.length) {
-                        return [];
-                    }
-                    return result.tracks;
+                    const tracks = this.buildTracksFromResponse(recommendedResult, requester);
+                    return tracks;
                 }
                 break;
-            case "vkmusic":
+            case Enums_1.AutoPlayPlatform.VKMusic:
                 {
                     if (!track.uri.includes("vk.com") && !track.uri.includes("vk.ru")) {
-                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Enums_1.SearchPlatform.VKMusic }, track.requester);
-                        if (res.loadType === Enums_1.LoadTypes.Empty || res.loadType === Enums_1.LoadTypes.Error) {
+                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Enums_1.SearchPlatform.VKMusic }, requester);
+                        if (TrackUtils.isErrorOrEmptySearchResult(res))
                             return [];
+                        let resolvedTrack;
+                        switch (res.loadType) {
+                            case Enums_1.LoadTypes.Playlist:
+                                resolvedTrack = res.playlist.tracks[0];
+                                break;
+                            case Enums_1.LoadTypes.Track:
+                            case Enums_1.LoadTypes.Search:
+                                resolvedTrack = res.tracks[0];
+                                break;
+                            default:
+                                return [];
                         }
-                        if (res.loadType === Enums_1.LoadTypes.Playlist) {
-                            res.tracks = res.playlist.tracks;
-                        }
-                        if (!res.tracks.length) {
+                        if (!resolvedTrack)
                             return [];
-                        }
-                        track = res.tracks[0];
+                        track = resolvedTrack;
                     }
                     const identifier = `vkrec:${track.identifier}`;
                     const recommendedResult = (await this.manager.useableNode.rest.get(`/v4/loadtracks?identifier=${encodeURIComponent(identifier)}`));
-                    if (!recommendedResult) {
-                        return [];
-                    }
-                    let tracks = [];
-                    let playlist = null;
-                    const requester = track.requester;
-                    switch (recommendedResult.loadType) {
-                        case Enums_1.LoadTypes.Search:
-                            tracks = recommendedResult.data.map((track) => TrackUtils.build(track, requester));
-                            break;
-                        case Enums_1.LoadTypes.Track:
-                            tracks = [TrackUtils.build(recommendedResult.data, requester)];
-                            break;
-                        case Enums_1.LoadTypes.Playlist: {
-                            const playlistData = recommendedResult.data;
-                            tracks = playlistData.tracks.map((track) => TrackUtils.build(track, requester));
-                            playlist = {
-                                name: playlistData.info.name,
-                                playlistInfo: playlistData.pluginInfo,
-                                requester: requester,
-                                tracks,
-                                duration: tracks.reduce((acc, cur) => acc + (cur.duration || 0), 0),
-                            };
-                            break;
-                        }
-                    }
-                    const result = { loadType: recommendedResult.loadType, tracks, playlist };
-                    if (result.loadType === Enums_1.LoadTypes.Empty || result.loadType === Enums_1.LoadTypes.Error) {
-                        return [];
-                    }
-                    if (result.loadType === Enums_1.LoadTypes.Playlist) {
-                        result.tracks = result.playlist.tracks;
-                    }
-                    if (!result.tracks.length) {
-                        return [];
-                    }
-                    return result.tracks;
+                    const tracks = this.buildTracksFromResponse(recommendedResult, requester);
+                    return tracks;
                 }
                 break;
-            case "qobuz":
+            case Enums_1.AutoPlayPlatform.Qobuz:
                 {
                     if (!track.uri.includes("qobuz.com")) {
-                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Enums_1.SearchPlatform.Qobuz }, track.requester);
-                        if (res.loadType === Enums_1.LoadTypes.Empty || res.loadType === Enums_1.LoadTypes.Error) {
+                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Enums_1.SearchPlatform.Qobuz }, requester);
+                        if (TrackUtils.isErrorOrEmptySearchResult(res))
                             return [];
+                        let resolvedTrack;
+                        switch (res.loadType) {
+                            case Enums_1.LoadTypes.Playlist:
+                                resolvedTrack = res.playlist.tracks[0];
+                                break;
+                            case Enums_1.LoadTypes.Track:
+                            case Enums_1.LoadTypes.Search:
+                                resolvedTrack = res.tracks[0];
+                                break;
+                            default:
+                                return [];
                         }
-                        if (res.loadType === Enums_1.LoadTypes.Playlist) {
-                            res.tracks = res.playlist.tracks;
-                        }
-                        if (!res.tracks.length) {
+                        if (!resolvedTrack)
                             return [];
-                        }
-                        track = res.tracks[0];
+                        track = resolvedTrack;
                     }
                     const identifier = `qbrec:${track.identifier}`;
                     const recommendedResult = (await this.manager.useableNode.rest.get(`/v4/loadtracks?identifier=${encodeURIComponent(identifier)}`));
-                    if (!recommendedResult) {
-                        return [];
-                    }
-                    let tracks = [];
-                    let playlist = null;
-                    const requester = track.requester;
-                    switch (recommendedResult.loadType) {
-                        case Enums_1.LoadTypes.Search:
-                            tracks = recommendedResult.data.map((track) => TrackUtils.build(track, requester));
-                            break;
-                        case Enums_1.LoadTypes.Track:
-                            tracks = [TrackUtils.build(recommendedResult.data, requester)];
-                            break;
-                        case Enums_1.LoadTypes.Playlist: {
-                            const playlistData = recommendedResult.data;
-                            tracks = playlistData.tracks.map((track) => TrackUtils.build(track, requester));
-                            playlist = {
-                                name: playlistData.info.name,
-                                playlistInfo: playlistData.pluginInfo,
-                                requester: requester,
-                                tracks,
-                                duration: tracks.reduce((acc, cur) => acc + (cur.duration || 0), 0),
-                            };
-                            break;
-                        }
-                    }
-                    const result = { loadType: recommendedResult.loadType, tracks, playlist };
-                    if (result.loadType === Enums_1.LoadTypes.Empty || result.loadType === Enums_1.LoadTypes.Error) {
-                        return [];
-                    }
-                    if (result.loadType === Enums_1.LoadTypes.Playlist) {
-                        result.tracks = result.playlist.tracks;
-                    }
-                    if (!result.tracks.length) {
-                        return [];
-                    }
-                    return result.tracks;
+                    const tracks = this.buildTracksFromResponse(recommendedResult, requester);
+                    return tracks;
                 }
                 break;
             default:
                 return [];
         }
     }
-    static generateTotp() {
-        const TOTP_SECRET = new Uint8Array([
-            53, 53, 48, 55, 49, 52, 53, 56, 53, 51, 52, 56, 55, 52, 57, 57, 53, 57, 50, 50, 52, 56, 54, 51, 48, 51, 50, 57, 51, 52, 55,
-        ]);
-        const hmac = crypto_1.default.createHmac("sha1", TOTP_SECRET);
-        const counter = Math.floor(Date.now() / 30000);
-        const counterBuffer = Buffer.alloc(8);
-        counterBuffer.writeBigInt64BE(BigInt(counter));
-        hmac.update(counterBuffer);
-        const hmacResult = hmac.digest();
-        const offset = hmacResult[hmacResult.length - 1] & 15;
-        const truncatedValue = ((hmacResult[offset] & 127) << 24) | ((hmacResult[offset + 1] & 255) << 16) | ((hmacResult[offset + 2] & 255) << 8) | (hmacResult[offset + 3] & 255);
-        const totp = (truncatedValue % 1000000).toString().padStart(6, "0");
-        return [totp, counter * 30000];
+    // static async getSpotifyAccessToken() {
+    // 	const timeoutMs = 15000;
+    // 	let browser;
+    // 	let timeout;
+    // 	try {
+    // 		browser = await playwright.chromium.launch({ headless: true, args: ["--no-sandbox", "--disable-gpu", "--disable-dev-shm-usage"] });
+    // 		const page = await browser.newPage();
+    // 		let tokenCaptured = false;
+    // 		timeout = setTimeout(async () => {
+    // 			if (!tokenCaptured) {
+    // 				console.warn("[Spotify] Token request timeout — did Spotify change their internals?");
+    // 				await browser?.close();
+    // 			}
+    // 		}, timeoutMs);
+    // 		page.on("requestfinished", async (request) => {
+    // 			if (!request.url().includes("/api/token")) return;
+    // 			tokenCaptured = true;
+    // 			try {
+    // 				const response = await request.response();
+    // 				if (response && response.ok()) {
+    // 					const data = await response.json();
+    // 					this.cachedAccessToken = data?.accessToken ?? null;
+    // 					this.cachedAccessTokenExpiresAt = data?.accessTokenExpirationTimestampMs ?? 0;
+    // 				}
+    // 			} catch (err) {
+    // 				console.error("[Spotify] Error reading token response:", err);
+    // 			}
+    // 			clearTimeout(timeout);
+    // 			page.removeAllListeners();
+    // 			await browser.close();
+    // 		});
+    // 		try {
+    // 			await page.goto("https://open.spotify.com/", { waitUntil: "domcontentloaded" });
+    // 		} catch (err) {
+    // 			clearTimeout(timeout);
+    // 			await browser.close();
+    // 			console.error("[Spotify] Failed to navigate:", err);
+    // 			return [];
+    // 		}
+    // 	} catch (err) {
+    // 		clearTimeout(timeout);
+    // 		await browser?.close();
+    // 		console.error("[Spotify] Failed to launch Playwright:", err);
+    // 	}
+    // }
+    static buildTracksFromResponse(recommendedResult, requester) {
+        if (!recommendedResult)
+            return [];
+        if (TrackUtils.isErrorOrEmptySearchResult(recommendedResult))
+            return [];
+        switch (recommendedResult.loadType) {
+            case Enums_1.LoadTypes.Search: {
+                const tracks = recommendedResult.data.map((t) => TrackUtils.build(t, requester));
+                return tracks;
+            }
+            case Enums_1.LoadTypes.Track: {
+                const track = TrackUtils.build(recommendedResult.data, requester);
+                return [track];
+            }
+            case Enums_1.LoadTypes.Playlist: {
+                const playlistData = recommendedResult.data;
+                const tracks = playlistData.tracks.map((t) => TrackUtils.build(t, requester));
+                return tracks;
+            }
+            default:
+                throw new Error(`Unsupported loadType: ${recommendedResult.loadType}`);
+        }
     }
 }
 exports.AutoPlayUtils = AutoPlayUtils;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "magmastream",
-	"version": "2.9.0-dev.32",
+	"version": "2.9.0-dev.34",
 	"description": "A user-friendly Lavalink client designed for NodeJS.",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",