magmastream 2.10.3-dev.2 → 2.10.3

package/dist/structures/Manager.js

@@ -21,6 +21,45 @@ function escapeRegExp(value) {
 }
 const YOUTUBE_URL_PATTERN = /(youtube\.com|youtu\.be)/;
 const BLOCKED_WORDS_PATTERN = new RegExp(`\\b(${blockedWords_1.blockedWords.map(escapeRegExp).join("|")})\\b`, "gi");
+const PORTABLE_SEARCH_PREFIXES = new Set(Object.values(Enums_1.SearchPlatform).map((source) => source.toLowerCase()));
+const NODELINK_SEARCH_PREFIXES = new Set(Object.values(Enums_1.NodeLinkSearchPlatform).map((source) => source.toLowerCase()));
+const NODELINK_RECOMMENDATION_PREFIXES = new Set(Object.values(Enums_1.NodeLinkRecommendationPlatform).map((source) => source.toLowerCase()));
+const NODELINK_ONLY_SEARCH_PREFIXES = new Set([...NODELINK_SEARCH_PREFIXES].filter((source) => !PORTABLE_SEARCH_PREFIXES.has(source)));
+const NODELINK_SEARCH_TYPE_MODIFIERS = new Set(Object.values(Enums_1.NodeLinkSearchType).map((type) => type.toLowerCase()));
+const KNOWN_LOADTRACKS_PREFIXES = new Set([
+    ...Object.values(Enums_1.SearchPlatform).map((source) => source.toLowerCase()),
+    ...NODELINK_SEARCH_PREFIXES,
+    ...NODELINK_RECOMMENDATION_PREFIXES,
+    "search",
+    "local",
+    "sprec",
+    "dzrec",
+    "tdrec",
+    "vkrec",
+    "qbrec",
+    "ymrec",
+    "ytrec",
+    "jsrec",
+    "lmrec",
+]);
+const NODELINK_ONLY_LOADTRACKS_PREFIXES = new Set(["ytrec", "jsrec", "lmrec"]);
+const SEARCH_TYPE_PATTERN = /^[A-Za-z0-9]+$/;
+function getIdentifierPrefix(identifier) {
+    const match = /^([A-Za-z0-9]+):/.exec(identifier);
+    return match?.[1]?.toLowerCase() ?? null;
+}
+function getIdentifierSearchType(identifier) {
+    const match = /^[A-Za-z0-9]+:([A-Za-z0-9]+):/.exec(identifier);
+    return match?.[1]?.toLowerCase() ?? null;
+}
+function getNodeLoad(node) {
+    const cores = node.stats.cpu?.cores ?? 0;
+    const nodeLinkLoad = node.stats.cpu?.nodelinkLoad;
+    if (typeof nodeLinkLoad === "number" && Number.isFinite(nodeLinkLoad))
+        return nodeLinkLoad * 100;
+    const load = node.stats.cpu?.lavalinkLoad ?? 0;
+    return cores > 0 && Number.isFinite(load) ? (load / cores) * 100 : 0;
+}
 /**
  * The main hub for interacting with Lavalink and using Magmastream.
  */
@@ -202,19 +241,27 @@ class Manager extends events_1.EventEmitter {
      * @returns The search result.
      */
     async search(query, requester) {
-        const node = this.useableNode;
+        const _query = typeof query === "string" ? { query } : query;
+        const _source = _query.source ?? this.options.defaultSearchPlatform ?? Enums_1.SearchPlatform.YouTube;
+        const isUrl = /^https?:\/\//.test(_query.query);
+        const isPrefixedIdentifier = this.isPrefixedLoadTracksIdentifier(_query.query);
+        const searchType = this.normalizeSearchType(_query.searchType);
+        const search = this.buildLoadTracksIdentifier(_source, _query.query, searchType, isUrl, isPrefixedIdentifier);
+        const node = this.getSearchNode(_source, search, searchType);
         if (!node) {
             throw new MagmastreamError_1.MagmaStreamError({
                 code: Enums_1.MagmaStreamErrorCode.MANAGER_NO_NODES,
-                message: "No available nodes to perform the search.",
+                message: this.requiresNodeLinkSearchNode(_source, search, searchType)
+                    ? "No available NodeLink nodes to perform the NodeLink-specific search."
+                    : this.requiresLavalinkSearchNode(search)
+                        ? "No available Lavalink nodes to perform the Lavalink-specific search."
+                        : "No available nodes to perform the search.",
                 context: { query, requester },
             });
         }
-        const _query = typeof query === "string" ? { query } : query;
-        const _source = _query.source ?? this.options.defaultSearchPlatform;
-        const isUrl = /^https?:\/\//.test(_query.query);
-        const search = isUrl ? _query.query : `${_source}:${_query.query}`;
-        this.emit(Enums_1.ManagerEventTypes.Debug, isUrl ? `[MANAGER] Performing search for: ${_query.query}` : `[MANAGER] Performing ${_source} search for: ${_query.query}`);
+        this.emit(Enums_1.ManagerEventTypes.Debug, isUrl || isPrefixedIdentifier
+            ? `[MANAGER] Performing search on ${node.options.identifier} for: ${search}`
+            : `[MANAGER] Performing ${_source}${searchType ? `:${searchType}` : ""} search on ${node.options.identifier} for: ${_query.query}`);
         try {
             const lavalinkResponse = (await node.rest.get(`/v4/loadtracks?identifier=${encodeURIComponent(search)}`));
             if (!lavalinkResponse) {
@@ -231,6 +278,7 @@ class Manager extends events_1.EventEmitter {
                     result = { loadType: lavalinkResponse.loadType, tracks };
                     break;
                 }
+                case Enums_1.LoadTypes.Episode:
                 case Enums_1.LoadTypes.Short:
                 case Enums_1.LoadTypes.Track: {
                     const track = Utils_1.TrackUtils.build(lavalinkResponse.data, requester);
@@ -250,7 +298,8 @@ class Manager extends events_1.EventEmitter {
                         tracks,
                         playlist: {
                             name: playlistData.info.name,
-                            playlistInfo: playlistData.pluginInfo,
+                            playlistInfo: playlistData.info,
+                            pluginInfo: playlistData.pluginInfo,
                             requester: requester,
                             tracks,
                             duration: tracks.reduce((acc, cur) => acc + (cur.duration || 0), 0),
@@ -263,7 +312,7 @@ class Manager extends events_1.EventEmitter {
             }
             if (this.options.normalizeYouTubeTitles && "tracks" in result) {
                 const processTrack = (track) => {
-                    if (!YOUTUBE_URL_PATTERN.test(track.uri))
+                    if (!track.uri || !YOUTUBE_URL_PATTERN.test(track.uri))
                         return track;
                     const { cleanTitle, cleanAuthor } = this.parseYouTubeTitle(track.title, track.author);
                     track.title = cleanTitle;
@@ -406,23 +455,21 @@ class Manager extends events_1.EventEmitter {
      */
     async decodeTracks(tracks) {
         this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Decoding tracks: ${Utils_1.JSONUtils.safe(tracks, 2)}`);
-        return new Promise(async (resolve, reject) => {
-            const node = this.useableNode;
-            if (!node) {
-                throw new MagmastreamError_1.MagmaStreamError({
-                    code: Enums_1.MagmaStreamErrorCode.MANAGER_NO_NODES,
-                    message: "No available nodes to decode tracks.",
-                });
-            }
-            const decodedTrackData = (await node.rest.post("/v4/decodetracks", Utils_1.JSONUtils.safe(tracks, 2)).catch((err) => reject(err)));
-            if (!decodedTrackData) {
-                throw new MagmastreamError_1.MagmaStreamError({
-                    code: Enums_1.MagmaStreamErrorCode.REST_REQUEST_FAILED,
-                    message: "No decoded tracks returned from node.",
-                });
-            }
-            return resolve(decodedTrackData);
-        });
+        const node = this.useableNode;
+        if (!node) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.MANAGER_NO_NODES,
+                message: "No available nodes to decode tracks.",
+            });
+        }
+        const decodedTrackData = await node.rest.decodeTracks(tracks);
+        if (!decodedTrackData) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.REST_REQUEST_FAILED,
+                message: "No decoded tracks returned from node.",
+            });
+        }
+        return decodedTrackData;
     }
     /**
      * Decodes a base64 encoded track and returns a TrackData.
@@ -607,14 +654,28 @@ class Manager extends events_1.EventEmitter {
         const filterActions = {
             bassboost: () => player.filters.bassBoost(state.filters.bassBoostlevel),
             distort: (isEnabled) => player.filters.distort(isEnabled),
+            pluginFilters: () => player.filters.setPluginFilters(state.filters.pluginFilters),
+            setChannelMix: () => player.filters.setChannelMix(state.filters.channelMix),
             setDistortion: () => player.filters.setDistortion(state.filters.distortion),
             eightD: (isEnabled) => player.filters.eightD(isEnabled),
             setKaraoke: () => player.filters.setKaraoke(state.filters.karaoke),
+            setLowPass: () => player.filters.setLowPass(state.filters.lowPass),
+            setHighPass: () => player.filters.setHighPass(state.filters.highpass),
+            setEcho: () => player.filters.setEcho(state.filters.echo),
+            setReverb: () => player.filters.setReverb(state.filters.reverb),
+            setChorus: () => player.filters.setChorus(state.filters.chorus),
+            setCompressor: () => player.filters.setCompressor(state.filters.compressor),
+            setFlanger: () => player.filters.setFlanger(state.filters.flanger),
+            setPhaser: () => player.filters.setPhaser(state.filters.phaser),
+            setPhonograph: () => player.filters.setPhonograph(state.filters.phonograph),
+            setSpatial: () => player.filters.setSpatial(state.filters.spatial),
+            setTape: () => player.filters.setTape(state.filters.tape),
             nightcore: (isEnabled) => player.filters.nightcore(isEnabled),
             slowmo: (isEnabled) => player.filters.slowmo(isEnabled),
             soft: (isEnabled) => player.filters.soft(isEnabled),
             trebleBass: (isEnabled) => player.filters.trebleBass(isEnabled),
             setTimescale: () => player.filters.setTimescale(state.filters.timescale),
+            setTremolo: () => player.filters.setTremolo(state.filters.tremolo),
             tv: (isEnabled) => player.filters.tv(isEnabled),
             vibrato: () => player.filters.setVibrato(state.filters.vibrato),
             vaporwave: (isEnabled) => player.filters.vaporwave(isEnabled),
@@ -717,6 +778,87 @@ class Manager extends events_1.EventEmitter {
         this.emit(Enums_1.ManagerEventTypes.Debug, "[MANAGER] Finished loading saved players.");
         this.emit(Enums_1.ManagerEventTypes.RestoreComplete, node);
     }
+    normalizeSearchType(searchType) {
+        if (searchType === undefined || searchType === null)
+            return null;
+        if (typeof searchType !== "string" || !SEARCH_TYPE_PATTERN.test(searchType)) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.MANAGER_SEARCH_FAILED,
+                message: 'Search option "searchType" must be an alphanumeric NodeLink search type modifier.',
+                context: { searchType },
+            });
+        }
+        return searchType.toLowerCase();
+    }
+    buildLoadTracksIdentifier(source, query, searchType, isUrl, isPrefixedIdentifier) {
+        if (isUrl)
+            return query;
+        if (isPrefixedIdentifier) {
+            if (!searchType || this.hasNodeLinkSearchTypeModifier(query))
+                return query;
+            const prefix = getIdentifierPrefix(query);
+            if (!prefix)
+                return query;
+            return `${prefix}:${searchType}:${query.slice(prefix.length + 1)}`;
+        }
+        return searchType ? `${source}:${searchType}:${query}` : `${source}:${query}`;
+    }
+    isNodeLinkSearchSource(source) {
+        return typeof source === "string" && (NODELINK_ONLY_SEARCH_PREFIXES.has(source.toLowerCase()) || NODELINK_RECOMMENDATION_PREFIXES.has(source.toLowerCase()));
+    }
+    isPrefixedLoadTracksIdentifier(identifier) {
+        const prefix = getIdentifierPrefix(identifier);
+        return prefix !== null && KNOWN_LOADTRACKS_PREFIXES.has(prefix);
+    }
+    hasNodeLinkSearchTypeModifier(identifier) {
+        const prefix = getIdentifierPrefix(identifier);
+        const searchType = getIdentifierSearchType(identifier);
+        return prefix !== null && searchType !== null && KNOWN_LOADTRACKS_PREFIXES.has(prefix) && NODELINK_SEARCH_TYPE_MODIFIERS.has(searchType);
+    }
+    requiresNodeLinkSearchNode(source, identifier, searchType) {
+        if (searchType)
+            return true;
+        if (this.isNodeLinkSearchSource(source))
+            return true;
+        const prefix = getIdentifierPrefix(identifier);
+        if (prefix === null)
+            return false;
+        if (NODELINK_ONLY_SEARCH_PREFIXES.has(prefix) || NODELINK_ONLY_LOADTRACKS_PREFIXES.has(prefix))
+            return true;
+        if (this.hasNodeLinkSearchTypeModifier(identifier))
+            return true;
+        const normalizedIdentifier = identifier.toLowerCase();
+        return prefix === "sprec" && !normalizedIdentifier.startsWith("sprec:mix:");
+    }
+    requiresLavalinkSearchNode(identifier) {
+        return identifier.toLowerCase().startsWith("sprec:mix:");
+    }
+    getSearchNode(source, identifier, searchType) {
+        if (this.requiresLavalinkSearchNode(identifier)) {
+            return this.getPreferredNode((node) => !node.isNodeLink);
+        }
+        if (this.requiresNodeLinkSearchNode(source, identifier, searchType)) {
+            return this.getPreferredNode((node) => node.isNodeLink);
+        }
+        return this.useableNode ?? null;
+    }
+    getPreferredNode(predicate) {
+        const nodes = this.nodes.filter((node) => node.connected && !node.options.isBackup && predicate(node));
+        if (!nodes.size)
+            return null;
+        if (this.options.enablePriorityMode) {
+            const priorityNodes = nodes.filter((node) => node.options.nodePriority > 0);
+            return (priorityNodes.size ? priorityNodes : nodes).sort((a, b) => b.options.nodePriority - a.options.nodePriority).first() ?? null;
+        }
+        if (this.options.useNode === Enums_1.UseNodeOptions.LeastLoad) {
+            return nodes
+                .sort((a, b) => {
+                return getNodeLoad(a) - getNodeLoad(b);
+            })
+                .first();
+        }
+        return nodes.sort((a, b) => a.stats.players - b.stats.players).first();
+    }
     /**
      * Returns the node to use based on the configured `useNode` and `enablePriorityMode` options.
      * If `enablePriorityMode` is true, the node is chosen based on priority, otherwise it is chosen based on the `useNode` option.
@@ -1097,10 +1239,7 @@ class Manager extends events_1.EventEmitter {
         return this.nodes
             .filter((node) => node.connected && !node.options.isBackup)
             .sort((a, b) => {
-            const aload = a.stats.cpu ? (a.stats.cpu.lavalinkLoad / a.stats.cpu.cores) * 100 : 0;
-            const bload = b.stats.cpu ? (b.stats.cpu.lavalinkLoad / b.stats.cpu.cores) * 100 : 0;
-            // Sort the nodes by their load in ascending order
-            return aload - bload;
+            return getNodeLoad(a) - getNodeLoad(b);
         });
     }
     /**

package/dist/structures/Node.d.ts

@@ -2,7 +2,7 @@ import { Manager } from "./Manager";
 import { Player } from "./Player";
 import { Rest } from "./Rest";
 import WebSocket from "ws";
-import { LavalinkInfo, Lyrics, NodeLinkGetLyrics, NodeOptions, NodeStats, PlayerEvent, PlayerEvents, Track, TrackEndEvent, TrackExceptionEvent, TrackStartEvent, TrackStuckEvent, WebSocketClosedEvent } from "./Types";
+import { LavalinkInfo, Lyrics, NodeLinkGetLyrics, NodeLinkChapter, NodeLinkEvent, NodeLinkMix, NodeLinkMeaningResult, NodeLinkSponsorBlockSegment, NodeLinkSponsorBlockUpdate, NodeOptions, NodeStats, NodeLinkSponsorBlockState, PlayerEvent, Track, TrackEndEvent, TrackExceptionEvent, TrackStartEvent, TrackStuckEvent, WebSocketClosedEvent } from "./Types";
 import { SponsorBlockSegment } from "./Enums";
 export declare class Node {
     manager: Manager;
@@ -151,13 +151,18 @@ export declare class Node {
      * @private
      */
     protected message(messagePayload: Buffer | string): Promise<void>;
+    private normalizeStats;
+    private handlePlayerUpdate;
     /**
      * Handles an event emitted from the Lavalink node.
      * @param {PlayerEvent & PlayerEvents} payload The event emitted from the node.
      * @returns {Promise<void>} A promise that resolves when the event has been handled.
      * @private
      */
-    protected handleEvent(payload: PlayerEvent & PlayerEvents): Promise<void>;
+    protected handleEvent(payload: NodeLinkEvent | PlayerEvent): Promise<void>;
+    private markAsNodeLink;
+    private resolveEventTrack;
+    private handleNodeLinkEvent;
     /**
      * Emitted when a new track starts playing.
      * @param {Player} player The player that started playing the track.
@@ -247,6 +252,20 @@ export declare class Node {
      * @returns {Promise<Lyrics | NodeLinkGetLyrics>} A promise that resolves with the lyrics data.
      */
     getLyrics(track: Track, skipTrackSource?: boolean, language?: string): Promise<Lyrics | NodeLinkGetLyrics>;
+    /**
+     * Loads chapters for a track using NodeLink.
+     * @param {Track} track - The track to load chapters for.
+     * @returns {Promise<NodeLinkChapter[]>} A promise that resolves with the chapter list.
+     */
+    getChapters(track: Track): Promise<NodeLinkChapter[]>;
+    /**
+     * Loads chapters for a track using NodeLink.
+     * @param {Track} track - The track to load chapters for.
+     * @returns {Promise<NodeLinkChapter[]>} A promise that resolves with the chapter list.
+     */
+    getNodeLinkChapters(track: Track): Promise<NodeLinkChapter[]>;
+    /** Loads NodeLink meaning/background information for a track. */
+    getNodeLinkMeaning(track: Track, language?: string): Promise<NodeLinkMeaningResult>;
     /**
      * Subscribes to lyrics for a player.
      * @param {string} guildId - The ID of the guild to subscribe to lyrics for.
@@ -359,6 +378,74 @@ export declare class Node {
      * @throws {RangeError} If the sponsorblock-plugin is not available in the Lavalink node.
      */
     getSponsorBlock(player: Player): Promise<SponsorBlockSegment[]>;
+    /** Returns the complete NodeLink SponsorBlock state for a player. */
+    getNodeLinkSponsorBlockState(player: Player): Promise<NodeLinkSponsorBlockState>;
+    /** Updates NodeLink SponsorBlock behavior for a player. */
+    updateNodeLinkSponsorBlock(player: Player, update: NodeLinkSponsorBlockUpdate): Promise<NodeLinkSponsorBlockState>;
+    /** Replaces the NodeLink SponsorBlock segment list for a player. */
+    setNodeLinkSponsorBlockSegments(player: Player, segments: NodeLinkSponsorBlockSegment[]): Promise<NodeLinkSponsorBlockState>;
+    /**
+     * Adds a NodeLink audio mix layer to the player.
+     * @param {Player} player - The player to add the mix to.
+     * @param {Track} track - The track to mix over the current playback.
+     * @param {number} [volume] - The mix volume in the 0-1 range.
+     * @returns {Promise<NodeLinkMix>} The created mix layer.
+     */
+    addMix(player: Player, track: Track, volume?: number): Promise<NodeLinkMix>;
+    /**
+     * Adds a NodeLink audio mix layer to the player.
+     * @param {Player} player - The player to add the mix to.
+     * @param {Track} track - The track to mix over the current playback.
+     * @param {number} [volume] - The mix volume in the 0-1 range.
+     * @returns {Promise<NodeLinkMix>} The created mix layer.
+     */
+    addNodeLinkMix(player: Player, track: Track, volume?: number): Promise<NodeLinkMix>;
+    /**
+     * Gets the active NodeLink audio mix layers for the player.
+     * @param {Player} player - The player to fetch mixes for.
+     * @returns {Promise<NodeLinkMix[]>} The active mix layers.
+     */
+    getMixes(player: Player): Promise<NodeLinkMix[]>;
+    /**
+     * Gets the active NodeLink audio mix layers for the player.
+     * @param {Player} player - The player to fetch mixes for.
+     * @returns {Promise<NodeLinkMix[]>} The active mix layers.
+     */
+    getNodeLinkMixes(player: Player): Promise<NodeLinkMix[]>;
+    /**
+     * Updates a NodeLink audio mix layer volume.
+     * @param {Player} player - The player that owns the mix.
+     * @param {string} mixId - The mix layer id.
+     * @param {number} volume - The mix volume in the 0-1 range.
+     * @returns {Promise<void>}
+     */
+    updateMix(player: Player, mixId: string, volume: number): Promise<void>;
+    /**
+     * Updates a NodeLink audio mix layer volume.
+     * @param {Player} player - The player that owns the mix.
+     * @param {string} mixId - The mix layer id.
+     * @param {number} volume - The mix volume in the 0-1 range.
+     * @returns {Promise<void>}
+     */
+    updateNodeLinkMix(player: Player, mixId: string, volume: number): Promise<void>;
+    /**
+     * Removes a NodeLink audio mix layer.
+     * @param {Player} player - The player that owns the mix.
+     * @param {string} mixId - The mix layer id.
+     * @returns {Promise<void>}
+     */
+    removeMix(player: Player, mixId: string): Promise<void>;
+    /**
+     * Removes a NodeLink audio mix layer.
+     * @param {Player} player - The player that owns the mix.
+     * @param {string} mixId - The mix layer id.
+     * @returns {Promise<void>}
+     */
+    removeNodeLinkMix(player: Player, mixId: string): Promise<void>;
+    private assertNodeLinkFeature;
+    private assertMixVolume;
+    private assertNodeLinkSponsorBlockUpdate;
+    private isValidNodeLinkSponsorBlockSegment;
     /**
      * Sets the sponsorblock segments for a player.
      * @param {Player} player - The player to set the sponsor blocks for.