magmastream 2.5.8 → 2.5.10

package/dist/index.d.ts

@@ -265,6 +265,11 @@ declare class Player {
      * @param botUser
      */
     setAutoplay(autoplayState: boolean, botUser: object): this;
+    /**
+     * Gets recommended tracks and returns an array of tracks.
+     * @param track
+     */
+    getRecommended(track: Track): Promise<any[]>;
     /**
      * Sets the player volume.
      * @param volume
@@ -483,6 +488,8 @@ declare class Node {
     protected handleEvent(payload: PlayerEvent & PlayerEvents): Promise<void>;
     protected trackStart(player: Player, track: Track, payload: TrackStartEvent): void;
     protected trackEnd(player: Player, track: Track, payload: TrackEndEvent): Promise<void>;
+    extractSpotifyTrackID(url: string): string | null;
+    extractSpotifyArtistID(url: string): string | null;
     private handleAutoplay;
     private handleFailedTrack;
     private handleRepeatedTrack;
@@ -556,6 +563,29 @@ interface FrameStats {
     /** The amount of deficit frames. */
     deficit?: number;
 }
+interface LavalinkInfo {
+    version: {
+        semver: string;
+        major: number;
+        minor: number;
+        patch: number;
+        preRelease: string;
+    };
+    buildTime: number;
+    git: {
+        branch: string;
+        commit: string;
+        commitTime: number;
+    };
+    jvm: string;
+    lavaplayer: string;
+    sourceManagers: string[];
+    filters: string[];
+    plugins: {
+        name: string;
+        version: string;
+    }[];
+}
 
 declare abstract class TrackUtils {
     static trackPartial: string[] | null;
@@ -846,7 +876,7 @@ interface ManagerOptions {
      */
     send(id: string, payload: Payload): void;
 }
-type SearchPlatform = "deezer" | "soundcloud" | "youtube music" | "youtube";
+type SearchPlatform = "deezer" | "soundcloud" | "youtube music" | "youtube" | "spotify" | "jiosaavn" | "tidal" | "applemusic" | "bandcamp";
 interface SearchQuery {
     /** The source to search from. */
     source?: SearchPlatform | string;
@@ -907,4 +937,4 @@ interface ManagerEvents {
     trackError: [player: Player, track: Track | UnresolvedTrack, payload: TrackExceptionEvent];
 }
 
-export { type CPUStats, type EqualizerBand, type Exception, type Extendable, type FrameStats, type LavalinkResponse, type LoadType, Manager, type ManagerEvents, type ManagerOptions, type MemoryStats, Node, type NodeMessage, type NodeOptions, type NodeStats, type Payload, type PlayOptions, Player, type PlayerEvent, type PlayerEventType, type PlayerEvents, type PlayerOptions, type PlayerUpdate, type PlaylistData, type PlaylistRawData, Plugin, Queue, type SearchPlatform, type SearchQuery, type SearchResult, type Severity, type Sizes, type State, Structure, type Track, type TrackData, type TrackDataInfo, type TrackEndEvent, type TrackEndReason, type TrackExceptionEvent, type TrackPluginInfo, type TrackSourceName, type TrackStartEvent, type TrackStuckEvent, TrackUtils, type UnresolvedQuery, type UnresolvedTrack, type VoicePacket, type VoiceServer, type VoiceState, type WebSocketClosedEvent };
+export { type CPUStats, type EqualizerBand, type Exception, type Extendable, type FrameStats, type LavalinkInfo, type LavalinkResponse, type LoadType, Manager, type ManagerEvents, type ManagerOptions, type MemoryStats, Node, type NodeMessage, type NodeOptions, type NodeStats, type Payload, type PlayOptions, Player, type PlayerEvent, type PlayerEventType, type PlayerEvents, type PlayerOptions, type PlayerUpdate, type PlaylistData, type PlaylistRawData, Plugin, Queue, type SearchPlatform, type SearchQuery, type SearchResult, type Severity, type Sizes, type State, Structure, type Track, type TrackData, type TrackDataInfo, type TrackEndEvent, type TrackEndReason, type TrackExceptionEvent, type TrackPluginInfo, type TrackSourceName, type TrackStartEvent, type TrackStuckEvent, TrackUtils, type UnresolvedQuery, type UnresolvedTrack, type VoicePacket, type VoiceServer, type VoiceState, type WebSocketClosedEvent };

package/dist/structures/Manager.js

@@ -17,8 +17,13 @@ class Manager extends events_1.EventEmitter {
     static DEFAULT_SOURCES = {
         "youtube music": "ytmsearch",
         youtube: "ytsearch",
+        spotify: "spsearch",
+        jiosaavn: "jssearch",
         soundcloud: "scsearch",
         deezer: "dzsearch",
+        tidal: "tdsearch",
+        applemusic: "amsearch",
+        bandcamp: "bcsearch",
     };
     /** The map of players. */
     players = new collection_1.Collection();

package/dist/structures/Node.js

@@ -247,15 +247,59 @@ class Node {
             await this.queueEnd(player, track, payload);
         }
     }
+    extractSpotifyTrackID(url) {
+        const regex = /https:\/\/open\.spotify\.com\/track\/([a-zA-Z0-9]+)/;
+        const match = url.match(regex);
+        return match ? match[1] : null;
+    }
+    extractSpotifyArtistID(url) {
+        const regex = /https:\/\/open\.spotify\.com\/artist\/([a-zA-Z0-9]+)/;
+        const match = url.match(regex);
+        return match ? match[1] : null;
+    }
     // Handle autoplay
     async handleAutoplay(player, track) {
         const previousTrack = player.queue.previous;
         if (!player.isAutoplay || !previousTrack)
             return;
+        const hasSpotifyURL = ["spotify.com", "open.spotify.com"].some((url) => previousTrack.uri.includes(url));
+        if (hasSpotifyURL) {
+            const node = this.manager.useableNodes;
+            const res = await node.rest.get(`/v4/info`);
+            const info = res;
+            const isSpotifyPluginEnabled = info.plugins.some((plugin) => plugin.name === "lavasrc-plugin");
+            const isSpotifySourceManagerEnabled = info.sourceManagers.includes("spotify");
+            if (isSpotifyPluginEnabled && isSpotifySourceManagerEnabled) {
+                const trackID = this.extractSpotifyTrackID(previousTrack.uri);
+                const artistID = this.extractSpotifyArtistID(previousTrack.pluginInfo.artistUrl);
+                let identifier = "";
+                if (trackID && artistID) {
+                    identifier = `sprec:seed_artists=${artistID}&seed_tracks=${trackID}`;
+                }
+                else if (trackID) {
+                    identifier = `sprec:seed_tracks=${trackID}`;
+                }
+                else if (artistID) {
+                    identifier = `sprec:seed_artists=${artistID}`;
+                }
+                if (identifier) {
+                    const recommendedResult = (await node.rest.get(`/v4/loadtracks?identifier=${encodeURIComponent(identifier)}`));
+                    if (recommendedResult.loadType === "playlist") {
+                        const playlistData = recommendedResult.data;
+                        const recommendedTrack = playlistData.tracks[0];
+                        if (recommendedTrack) {
+                            player.queue.add(Utils_1.TrackUtils.build(recommendedTrack, player.get("Internal_BotUser")));
+                            player.play();
+                            return;
+                        }
+                    }
+                }
+            }
+        }
         const hasYouTubeURL = ["youtube.com", "youtu.be"].some((url) => previousTrack.uri.includes(url));
         let videoID = previousTrack.uri.substring(previousTrack.uri.indexOf("=") + 1);
         if (!hasYouTubeURL) {
-            const res = await player.search(`${previousTrack.author} - ${previousTrack.title}`);
+            const res = await player.search(`${previousTrack.author} - ${previousTrack.title}`, player.get("Internal_BotUser"));
             videoID = res.tracks[0].uri.substring(res.tracks[0].uri.indexOf("=") + 1);
         }
         let randomIndex;
@@ -273,6 +317,15 @@ class Node {
         }
         const foundTrack = tracks.sort(() => Math.random() - 0.5).find((shuffledTrack) => shuffledTrack.uri !== track.uri);
         if (foundTrack) {
+            if (this.manager.options.replaceYouTubeCredentials) {
+                foundTrack.author = foundTrack.author.replace("- Topic", "");
+                foundTrack.title = foundTrack.title.replace("Topic -", "");
+                if (foundTrack.title.includes("-")) {
+                    const [author, title] = foundTrack.title.split("-").map((str) => str.trim());
+                    foundTrack.author = author;
+                    foundTrack.title = title;
+                }
+            }
             player.queue.add(foundTrack);
             player.play();
         }

package/dist/structures/Player.js

@@ -231,6 +231,90 @@ class Player {
         this.set("Internal_BotUser", botUser);
         return this;
     }
+    /**
+     * Gets recommended tracks and returns an array of tracks.
+     * @param track
+     */
+    async getRecommended(track) {
+        const node = this.manager.useableNodes;
+        if (!node) {
+            throw new Error("No available nodes.");
+        }
+        const hasSpotifyURL = ["spotify.com", "open.spotify.com"].some((url) => track.uri.includes(url));
+        const hasYouTubeURL = ["youtube.com", "youtu.be"].some((url) => track.uri.includes(url));
+        if (hasSpotifyURL) {
+            const res = await node.rest.get(`/v4/info`);
+            const info = res;
+            const isSpotifyPluginEnabled = info.plugins.some((plugin) => plugin.name === "lavasrc-plugin");
+            const isSpotifySourceManagerEnabled = info.sourceManagers.includes("spotify");
+            if (isSpotifyPluginEnabled && isSpotifySourceManagerEnabled) {
+                const trackID = node.extractSpotifyTrackID(track.uri);
+                const artistID = node.extractSpotifyArtistID(track.pluginInfo.artistUrl);
+                let identifier = "";
+                if (trackID && artistID) {
+                    identifier = `sprec:seed_artists=${artistID}&seed_tracks=${trackID}`;
+                }
+                else if (trackID) {
+                    identifier = `sprec:seed_tracks=${trackID}`;
+                }
+                else if (artistID) {
+                    identifier = `sprec:seed_artists=${artistID}`;
+                }
+                if (identifier) {
+                    const recommendedResult = (await node.rest.get(`/v4/loadtracks?identifier=${encodeURIComponent(identifier)}`));
+                    if (recommendedResult.loadType === "playlist") {
+                        const playlistData = recommendedResult.data;
+                        const recommendedTracks = playlistData.tracks;
+                        if (recommendedTracks) {
+                            const spotifyArray = [];
+                            recommendedTracks.forEach((song) => {
+                                const track = {
+                                    track: song.encoded,
+                                    title: song.info.title,
+                                    identifier: song.info.title,
+                                    author: song.info.author,
+                                    duration: song.info.length,
+                                    uri: song.info.uri,
+                                    artworkUrl: song.info.artworkUrl,
+                                    sourceName: song.info.sourceName,
+                                    requester: undefined,
+                                    plugininfo: song.pluginInfo,
+                                };
+                                spotifyArray.push(track);
+                            });
+                            return spotifyArray;
+                        }
+                    }
+                }
+            }
+        }
+        let videoID = track.uri.substring(track.uri.indexOf("=") + 1);
+        if (!hasYouTubeURL) {
+            const res = await this.manager.search(`${track.author} - ${track.title}`);
+            videoID = res.tracks[0].uri.substring(res.tracks[0].uri.indexOf("=") + 1);
+        }
+        const searchURI = `https://www.youtube.com/watch?v=${videoID}&list=RD${videoID}`;
+        const res = await this.manager.search(searchURI);
+        if (res.loadType === "empty" || res.loadType === "error")
+            return;
+        let tracks = res.tracks;
+        if (res.loadType === "playlist") {
+            tracks = res.playlist.tracks;
+        }
+        const filteredTracks = tracks.filter((track) => track.uri !== `https://www.youtube.com/watch?v=${videoID}`);
+        if (this.manager.options.replaceYouTubeCredentials) {
+            for (const track of filteredTracks) {
+                track.author = track.author.replace("- Topic", "");
+                track.title = track.title.replace("Topic -", "");
+                if (track.title.includes("-")) {
+                    const [author, title] = track.title.split("-").map((str) => str.trim());
+                    track.author = author;
+                    track.title = title;
+                }
+            }
+        }
+        return filteredTracks;
+    }
     /**
      * Sets the player volume.
      * @param volume

package/dist/structures/Utils.js

@@ -157,7 +157,9 @@ class TrackUtils {
             if (sameDuration)
                 return sameDuration;
         }
-        return res.tracks[0];
+        const finalTrack = res.tracks[0];
+        finalTrack.customData = unresolvedTrack.customData;
+        return finalTrack;
     }
 }
 exports.TrackUtils = TrackUtils;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "magmastream",
-	"version": "2.5.8",
+	"version": "2.5.10",
 	"description": "A user-friendly Lavalink client designed for NodeJS.",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -15,11 +15,11 @@
 	},
 	"devDependencies": {
 		"@favware/rollup-type-bundler": "^3.3.0",
-		"@types/lodash": "^4.17.6",
-		"@types/node": "^20.14.10",
-		"@types/ws": "^8.5.10",
-		"@typescript-eslint/eslint-plugin": "^7.16.0",
-		"@typescript-eslint/parser": "^7.16.0",
+		"@types/lodash": "^4.17.7",
+		"@types/node": "^20.14.14",
+		"@types/ws": "^8.5.12",
+		"@typescript-eslint/eslint-plugin": "^7.18.0",
+		"@typescript-eslint/parser": "^7.18.0",
 		"eslint": "^8.57.0",
 		"npm-run-all": "^4.1.5",
 		"typedoc": "^0.25.13",
@@ -28,7 +28,7 @@
 	},
 	"dependencies": {
 		"@discordjs/collection": "^2.1.0",
-		"axios": "^1.7.2",
+		"axios": "^1.7.3",
 		"events": "^3.3.0",
 		"lodash": "^4.17.21",
 		"tslib": "^2.6.3",