lavalink-client 2.9.11 → 2.10.1

package/README.md

@@ -111,8 +111,16 @@ pnpm add tomato6966/lavalink-client
 
 This client can be used with nodelink too, but because nodelink's websocket is different than the one from lavalink, you need to disable a few things on the NODE OPTIONS / NODE PROPERTIES:
 
+Import the NodeType Enum:
+
+```
+import { NodeType } from "lavalink-client"
+```
+
+// You must assign NodeLink enum to nodeType of the node options, before creating the node.
+
 ```ts
-nodeOptions.nodeType = "NodeLink";
+nodeOptions.nodeType = NodeType.NodeLink;
 ```
 
 this can be done directly when creating the node in the lavalinkmanager.
@@ -122,7 +130,7 @@ client.lavalink = new LavalinkManager({
     nodes: [
         {
             host: "localhost",
-            nodeType: "NodeLink",
+            nodeType: NodeType.NodeLink, // provide nodeType "nodelink" to it.
         },
     ],
 });
@@ -135,8 +143,10 @@ client.lavalink = new LavalinkManager({
             port: 2333,
             id: "Main Node",
             // set to nodeLink
-            nodeType: "NodeLink",
+            nodeType: NodeType.NodeLink, // provide it here
         },
+        // you can also use the util like this, and it will return a valid node option object. must start with: lavalink:// | nodelink://
+        // parseLavalinkConnUrl("nodelink://<nodeId>:<nodeAuthorization(Password)>@<NodeHost>:<NodePort>")
     ],
     // A function to send voice server updates to the Lavalink client
     sendToShard: (guildId, payload) => {
@@ -171,6 +181,8 @@ const node = client.lavalink.lavalinkManager.getNode("id") as NodeLinkNode;
 node.addMixerLayer()
 ```
 
+⚠️ NODELINK does not really require you to run "instaUpdateFiltersFix" on player creation.
+
 ### NodeLink Specific Methods
 
 - **`node.getYoutubeOAUTH(refreshToken)`**: Exchange a Refresh Token for an Access Token. [Docs](https://nodelink.js.org/docs/api/nodelink-features#oauth)
@@ -392,6 +404,8 @@ client.lavalink = new LavalinkManager({
             port: 2333,
             id: "Main Node",
         },
+        // you can also use the util like this, and it will return a valid node option object.
+        // parseLavalinkConnUrl("nodelink://<nodeId>:<nodeAuthorization(Password)>@<NodeHost>:<NodePort>")
     ],
     // A function to send voice server updates to the Lavalink client
     sendToShard: (guildId, payload) => {
@@ -448,6 +462,8 @@ client.lavalink = new LavalinkManager({
             retryAmount: 5,
             retryDelay: 10_000, // 10 seconds
         },
+        // you can also use the util like this, and it will return a valid node option object. must start with: lavalink:// | nodelink://
+        // parseLavalinkConnUrl("lavalink://<nodeId>:<nodeAuthorization(Password)>@<NodeHost>:<NodePort>")
     ],
     sendToShard: (guildId, payload) => client.guilds.cache.get(guildId)?.shard?.send(payload),
     autoSkip: true, // automatically play the next song of the queue, on: trackend, trackerror, trackexception

package/dist/index.cjs

@@ -45,6 +45,7 @@ __export(index_exports, {
   NodeLinkNode: () => NodeLinkNode,
   NodeManager: () => NodeManager,
   NodeSymbol: () => NodeSymbol,
+  NodeType: () => NodeType,
   Player: () => Player,
   Queue: () => Queue,
   QueueSaver: () => QueueSaver,
@@ -403,9 +404,6 @@ var NodeLinkExclusiveEvents = [
   "LyricsNotFoundEvent"
 ];
 
-// src/structures/NodeManager.ts
-var import_node_events = require("events");
-
 // src/structures/Node.ts
 var import_node_path = require("path");
 var import_ws = __toESM(require("ws"), 1);
@@ -418,6 +416,11 @@ var ReconnectionState = /* @__PURE__ */ ((ReconnectionState2) => {
   ReconnectionState2["DESTROYING"] = "DESTROYING";
   return ReconnectionState2;
 })(ReconnectionState || {});
+var NodeType = /* @__PURE__ */ ((NodeType2) => {
+  NodeType2["Lavalink"] = "Lavalink";
+  NodeType2["NodeLink"] = "NodeLink";
+  return NodeType2;
+})(NodeType || {});
 
 // src/structures/Utils.ts
 var import_node_url = require("url");
@@ -589,12 +592,14 @@ var QueueSymbol = /* @__PURE__ */ Symbol("LC-Queue");
 var NodeSymbol = /* @__PURE__ */ Symbol("LC-Node");
 var escapeRegExp = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 function parseLavalinkConnUrl(connectionUrl) {
-  if (!connectionUrl.startsWith("lavalink://") && !connectionUrl.startsWith("nodelink://"))
+  if (!connectionUrl) throw new Error("ConnectionUrl is required");
+  const lowered = connectionUrl.toLowerCase();
+  if (!lowered.startsWith("lavalink://") && !lowered.startsWith("nodelink://"))
     throw new Error(`ConnectionUrl (${connectionUrl}) must start with 'lavalink://' or 'nodelink://'`);
   const parsed = new import_node_url.URL(connectionUrl);
   return {
     authorization: parsed.password,
-    nodeType: connectionUrl.startsWith("lavalink://") ? "Lavalink" : "NodeLink",
+    nodeType: lowered.startsWith("lavalink://") ? "Lavalink" /* Lavalink */ : "NodeLink" /* NodeLink */,
     id: parsed.username,
     host: parsed.hostname,
     port: Number(parsed.port)
@@ -1248,7 +1253,7 @@ var LavalinkNode = class _LavalinkNode {
   heartBeatPongTimestamp = 0;
   heartBeatInterval;
   pingTimeout;
-  nodeType = "Lavalink";
+  nodeType = "Lavalink" /* Lavalink */;
   isAlive = false;
   static _NodeLinkClass = null;
   /** The provided Options of the Node */
@@ -1322,7 +1327,7 @@ var LavalinkNode = class _LavalinkNode {
    * Returns wether the plugin validations are enabled or not
    */
   get _checkForPlugins() {
-    if (this.nodeType === "NodeLink") return false;
+    if (this.nodeType === "NodeLink" /* NodeLink */) return false;
     return !!this.options?.autoChecks?.pluginValidations;
   }
   /**
@@ -1392,16 +1397,17 @@ var LavalinkNode = class _LavalinkNode {
       heartBeatInterval: 3e4,
       enablePingOnStatsCheck: true,
       closeOnError: true,
+      nodeType: "Lavalink" /* Lavalink */,
       ...options,
       autoChecks: {
         sourcesValidations: options?.autoChecks?.sourcesValidations ?? true,
         pluginValidations: options?.autoChecks?.pluginValidations ?? true
       }
     };
-    if (this.options.nodeType === "NodeLink" && this.constructor.name === "LavalinkNode" && _LavalinkNode._NodeLinkClass) {
+    if (this.options.nodeType === "NodeLink" /* NodeLink */ && this.constructor.name === "LavalinkNode" && _LavalinkNode._NodeLinkClass) {
       return new _LavalinkNode._NodeLinkClass(options, manager);
     }
-    this.nodeType = this.options.nodeType || "Lavalink";
+    this.nodeType = this.options.nodeType;
     this.NodeManager = manager;
     this.validate();
     if (this.options.secure && this.options.port !== 443)
@@ -1540,10 +1546,8 @@ var LavalinkNode = class _LavalinkNode {
     if (Query.source) this._LManager.utils.validateSourceString(this, Query.source);
     if (/^https?:\/\//.test(Query.query))
       return this.search({ query: Query.query, source: Query.source }, requestUser);
-    if (!["spsearch", "sprec", "amsearch", "dzsearch", "dzisrc", "ytmsearch", "ytsearch"].includes(Query.source))
-      throw new SyntaxError(
-        `Query.source must be a source from LavaSrc: "spsearch" | "sprec" | "amsearch" | "dzsearch" | "dzisrc" | "ytmsearch" | "ytsearch"`
-      );
+    if (!this.isLavaSrcSource(Query.source))
+      throw new SyntaxError(`Query.source must be an available source from LavaSrc`);
     if (this._checkForPlugins && !this.info?.plugins?.find?.((v) => v.name === "lavasearch-plugin"))
       throw new RangeError(`there is no lavasearch-plugin available in the lavalink node: ${this.id}`);
     if (this._checkForPlugins && !this.info?.plugins?.find?.((v) => v.name === "lavasrc-plugin"))
@@ -1969,7 +1973,10 @@ var LavalinkNode = class _LavalinkNode {
         throw new RangeError(
           `there is no lyrics source (via lavasrc-plugin / java-lyrics-plugin) available in the lavalink node (required for lyrics): ${this.id}`
         );
-      const url = `/lyrics?track=${track.encoded}&skipTrackSource=${skipTrackSource}`;
+      let url = `/lyrics?track=${track.encoded}&skipTrackSource=${skipTrackSource}`;
+      if (this.nodeType === "NodeLink" /* NodeLink */) {
+        url = `/loadlyrics?encodedTrack=${track.encoded}`;
+      }
       return await this.request(url);
     },
     /**
@@ -1995,7 +2002,10 @@ var LavalinkNode = class _LavalinkNode {
         throw new RangeError(
           `there is no lyrics source (via lavasrc-plugin / java-lyrics-plugin) available in the lavalink node (required for lyrics): ${this.id}`
         );
-      const url = `/sessions/${this.sessionId}/players/${guildId}/track/lyrics?skipTrackSource=${skipTrackSource}`;
+      let url = `/sessions/${this.sessionId}/players/${guildId}/track/lyrics?skipTrackSource=${skipTrackSource}`;
+      if (this.nodeType === "NodeLink" /* NodeLink */) {
+        url = `/loadlyrics?encodedTrack=${this._LManager.getPlayer(guildId)?.queue.current?.encoded}`;
+      }
       return await this.request(url);
     },
     /**
@@ -2344,20 +2354,22 @@ var LavalinkNode = class _LavalinkNode {
       throw new SyntaxError("LavalinkNode.autoChecks.pluginValidations must be either false | true aka boolean");
     if (this.options.regions !== void 0 && (!Array.isArray(this.options.regions) || !this.options.regions.every((r) => typeof r === "string")))
       throw new SyntaxError("LavalinkNode.regions must be an Array of strings");
+    if (this.options.nodeType && !NodeType[this.options.nodeType])
+      throw new SyntaxError("LavalinkNode.nodeType must be a valid NodeType enum value");
   }
   /**
    * Checks if the node is a NodeLink node
    * @returns true if the node is a NodeLink node
    */
   isNodeLink() {
-    return this.nodeType === "NodeLink";
+    return this.nodeType === "NodeLink" /* NodeLink */;
   }
   /**
    * Checks if the node is a Lavalink node
    * @returns true if the node is a Lavalink node
    */
   isLavalinkNode() {
-    return this.nodeType === "Lavalink";
+    return this.nodeType === "Lavalink" /* Lavalink */;
   }
   /**
    * Sync the data of the player you make an action to lavalink to
@@ -3126,17 +3138,36 @@ var LavalinkNode = class _LavalinkNode {
     this._LManager.emit("LyricsNotFound", player, track, payload);
     return;
   }
+  /**
+   * @private
+   * util function to check if a provided source is valid with current node.
+   * @param {LavalinkSearchPlatform} src
+   * @returns {boolean} True if provided source is valid.
+   */
+  isLavaSrcSource(src) {
+    const source = /* @__PURE__ */ new Set([]);
+    if (this.info?.sourceManagers.includes("spotify")) source.add("spsearch").add("sprec");
+    if (this.info?.sourceManagers.includes("applemusic")) source.add("amsearch");
+    if (this.info?.sourceManagers.includes("deezer")) source.add("dzsearch").add("dzrec").add("dzisrc");
+    if (this.info?.sourceManagers.includes("yandexmusic")) source.add("ymsearch").add("ymrec");
+    if (this.info?.sourceManagers.includes("vkmusic")) source.add("vksearch").add("vkrec");
+    if (this.info?.sourceManagers.includes("tidal")) source.add("tdsearch").add("tdrec");
+    if (this.info?.sourceManagers.includes("qobuz")) source.add("qbsearch").add("qbisrc").add("qbrec");
+    if (this.info?.sourceManagers.includes("pandora")) source.add("pdsearch").add("pdisrc").add("pdrec");
+    if (this.info?.sourceManagers.includes("youtube")) source.add("ytsearch").add("ytmsearch");
+    return typeof src === "string" && source.has(src);
+  }
 };
 
 // src/structures/NodeLink.ts
 var NodeLinkNode = class extends LavalinkNode {
-  nodeType = "NodeLink";
+  nodeType = "NodeLink" /* NodeLink */;
   constructor(options, manager) {
     super(options, manager);
-    if (this.options.nodeType === "Lavalink" && this.constructor.name === "NodeLink") {
+    if (this.options.nodeType === "Lavalink" /* Lavalink */ && (this.constructor.name === "NodeLinkNode" || this.constructor.name === "NodeLink")) {
       return new LavalinkNode(options, manager);
     }
-    this.nodeType = "NodeLink";
+    this.nodeType = "NodeLink" /* NodeLink */;
   }
   /**
    * Uses the gapless feature to set the next track to be played.
@@ -3477,6 +3508,7 @@ var NodeLinkNode = class extends LavalinkNode {
 LavalinkNode._NodeLinkClass = NodeLinkNode;
 
 // src/structures/NodeManager.ts
+var import_node_events = require("events");
 var NodeManager = class extends import_node_events.EventEmitter {
   /**
    * Emit an event
@@ -3538,9 +3570,7 @@ var NodeManager = class extends import_node_events.EventEmitter {
     super();
     this.LavalinkManager = LavalinkManager2;
     if (this.LavalinkManager.options.nodes)
-      this.LavalinkManager.options.nodes.forEach((node) => {
-        this.createNode(node);
-      });
+      this.LavalinkManager.options.nodes.forEach((node) => this.createNode(node));
   }
   /**
    * Disconnects all Nodes from lavalink ws sockets
@@ -3601,9 +3631,21 @@ var NodeManager = class extends import_node_events.EventEmitter {
    * @returns The node that was created
    */
   createNode(options) {
+    if (options instanceof NodeLinkNode) {
+      const preExistingNode = this.nodes.get(options.id);
+      if (preExistingNode) return preExistingNode;
+      this.nodes.set(options.id, options);
+      return options;
+    }
+    if (options instanceof LavalinkNode) {
+      const preExistingNode = this.nodes.get(options.id);
+      if (preExistingNode) return preExistingNode;
+      this.nodes.set(options.id, options);
+      return options;
+    }
     if (this.nodes.has(options.id || `${options.host}:${options.port}`))
       return this.nodes.get(options.id || `${options.host}:${options.port}`);
-    const newNode = options.nodeType === "NodeLink" ? new NodeLinkNode(options, this) : new LavalinkNode(options, this);
+    const newNode = options.nodeType === "NodeLink" /* NodeLink */ ? new NodeLinkNode(options, this) : new LavalinkNode(options, this);
     this.nodes.set(newNode.id, newNode);
     return newNode;
   }
@@ -3612,48 +3654,57 @@ var NodeManager = class extends import_node_events.EventEmitter {
    * @param sortType The type of sorting to use
    * @returns
    */
-  leastUsedNodes(sortType = "players") {
+  leastUsedNodes(sortType = "players", filterForNodeTypes) {
+    const normalizedFilterForNodeTypes = filterForNodeTypes?.length ? filterForNodeTypes : ["Lavalink" /* Lavalink */, "NodeLink" /* NodeLink */];
     const connectedNodes = Array.from(this.nodes.values()).filter((node) => node.connected);
+    const normalizedNodeTypes = new Set(
+      normalizedFilterForNodeTypes.map(
+        (nodeTypeFilter) => Object.values(NodeType).includes(nodeTypeFilter) ? nodeTypeFilter : nodeTypeFilter.nodeType
+      )
+    );
+    const filteredConnectedNodes = connectedNodes.filter((node) => normalizedNodeTypes.has(node.nodeType));
     switch (sortType) {
       case "memory":
         {
-          return connectedNodes.sort((a, b) => (a.stats?.memory?.used || 0) - (b.stats?.memory?.used || 0));
+          return filteredConnectedNodes.sort(
+            (a, b) => (a.stats?.memory?.used || 0) - (b.stats?.memory?.used || 0)
+          );
         }
         break;
       case "cpuLavalink":
         {
-          return connectedNodes.sort(
+          return filteredConnectedNodes.sort(
             (a, b) => (a.stats?.cpu?.lavalinkLoad || 0) - (b.stats?.cpu?.lavalinkLoad || 0)
           );
         }
         break;
       case "cpuSystem":
         {
-          return connectedNodes.sort(
+          return filteredConnectedNodes.sort(
             (a, b) => (a.stats?.cpu?.systemLoad || 0) - (b.stats?.cpu?.systemLoad || 0)
           );
         }
         break;
       case "calls":
         {
-          return connectedNodes.sort((a, b) => a.calls - b.calls);
+          return filteredConnectedNodes.sort((a, b) => a.calls - b.calls);
         }
         break;
       case "playingPlayers":
         {
-          return connectedNodes.sort(
+          return filteredConnectedNodes.sort(
             (a, b) => (a.stats?.playingPlayers || 0) - (b.stats?.playingPlayers || 0)
           );
         }
         break;
       case "players":
         {
-          return connectedNodes.sort((a, b) => (a.stats?.players || 0) - (b.stats?.players || 0));
+          return filteredConnectedNodes.sort((a, b) => (a.stats?.players || 0) - (b.stats?.players || 0));
         }
         break;
       default:
         {
-          return connectedNodes.sort((a, b) => (a.stats?.players || 0) - (b.stats?.players || 0));
+          return filteredConnectedNodes.sort((a, b) => (a.stats?.players || 0) - (b.stats?.players || 0));
         }
         break;
     }
@@ -3686,13 +3737,22 @@ var NodeManager = class extends import_node_events.EventEmitter {
   }
   /**
    * Get a node from the nodeManager
-   * @param node The node to get
+   * @param node The node to get either by idetnifier, by class or by enum
    * @returns The node that was retrieved
    */
   getNode(node) {
+    if (!!node && Object.values(NodeType).includes(node)) {
+      return this.leastUsedNodes().filter((node2) => node2.nodeType === node2)[0];
+    }
+    if (!!node && node instanceof NodeLinkNode) {
+      return this.leastUsedNodes().filter((node2) => node2 instanceof NodeLinkNode)[0];
+    }
+    if (!!node && node instanceof LavalinkNode) {
+      return this.leastUsedNodes().filter((node2) => node2 instanceof LavalinkNode)[0];
+    }
     const decodeNode = typeof node === "string" ? this.nodes.get(node) : node;
     if (!decodeNode) return void 0;
-    if (decodeNode.nodeType === "NodeLink") return decodeNode;
+    if (decodeNode.nodeType === "NodeLink" /* NodeLink */) return decodeNode;
     return decodeNode;
   }
 };
@@ -6055,7 +6115,7 @@ var Player = class {
         );
       if (this.queue.current || this.queue.tracks.length) {
         const trackSources = new Set(
-          [this.queue.current, ...this.queue.tracks].map((track) => track.info.sourceName)
+          [this.queue.current, ...this.queue.tracks].map((track) => track?.info?.sourceName).filter(Boolean)
         );
         const missingSources = [...trackSources].filter(
           (source) => !updateNode.info?.sourceManagers.includes(source)
@@ -6331,9 +6391,11 @@ var LavalinkManager = class _LavalinkManager extends import_node_events2.EventEm
       throw new SyntaxError("ManagerOption.autoSkipOnResolveError must be either false | true aka boolean");
     if (options?.emitNewSongsOnly && typeof options?.emitNewSongsOnly !== "boolean")
       throw new SyntaxError("ManagerOption.emitNewSongsOnly must be either false | true aka boolean");
-    if (!options?.nodes || !Array.isArray(options?.nodes) || !options?.nodes.every((node) => this.utils.isNodeOptions(node)))
+    if (!options?.nodes || !Array.isArray(options?.nodes) || !options?.nodes.every(
+      (node) => node instanceof NodeLinkNode || node instanceof LavalinkNode || this.utils.isNodeOptions(node)
+    ))
       throw new SyntaxError(
-        "ManagerOption.nodes must be an Array of NodeOptions and is required of at least 1 Node"
+        "ManagerOption.nodes must be an Array of NodeOptions or the Node-Classes 'NodeLinkNode' or 'LavalinkNode' and is required of at least 1 Node"
       );
     if (options?.queueOptions?.queueStore) {
       const keys = Object.getOwnPropertyNames(Object.getPrototypeOf(options?.queueOptions?.queueStore));
@@ -6389,48 +6451,50 @@ var LavalinkManager = class _LavalinkManager extends import_node_events2.EventEm
    *       port: 2333,
    *       id: "testnode"
    *     },
+   *     // you can also use the util like this, and it will return a valid node option object. must start with: lavalink:// | nodelink://
+   *     // parseLavalinkConnUrl("nodelink://<nodeId>:<nodeAuthorization(Password)>@<NodeHost>:<NodePort>")
    *     sendToShard(guildId, payload) => client.guilds.cache.get(guildId)?.shard?.send(payload),
-   *     client: {
-   *       id: process.env.CLIENT_ID,
-   *       username: "TESTBOT"
-   *     },
-   *     // optional Options:
-   *     autoSkip: true,
-   *     playerOptions: {
-   *       applyVolumeAsFilter: false,
-   *       clientBasedPositionUpdateInterval: 150,
-   *       defaultSearchPlatform: "ytmsearch",
-   *       allowCustomSources: false,
-   *       volumeDecrementer: 0.75,
-   *       //requesterTransformer: YourRequesterTransformerFunction,
-   *       onDisconnect: {
-   *         autoReconnect: true,
-   *         destroyPlayer: false
-   *       },
-   *       onEmptyQueue: {
-   *         destroyAfterMs: 30_000,
-   *         //autoPlayFunction: YourAutoplayFunction,
-   *       },
-   *       useUnresolvedData: true
+   *   ],
+   *   client: {
+   *     id: process.env.CLIENT_ID,
+   *     username: "TESTBOT"
+   *   },
+   *   // optional Options:
+   *   autoSkip: true,
+   *   playerOptions: {
+   *     applyVolumeAsFilter: false,
+   *     clientBasedPositionUpdateInterval: 150,
+   *     defaultSearchPlatform: "ytmsearch",
+   *     allowCustomSources: false,
+   *     volumeDecrementer: 0.75,
+   *     //requesterTransformer: YourRequesterTransformerFunction,
+   *     onDisconnect: {
+   *       autoReconnect: true,
+   *       destroyPlayer: false
    *     },
-   *     queueOptions: {
-   *       maxPreviousTracks: 25,
-   *       //queueStore: yourCustomQueueStoreManagerClass,
-   *       //queueChangesWatcher: yourCustomQueueChangesWatcherClass
+   *     onEmptyQueue: {
+   *       destroyAfterMs: 30_000,
+   *       //autoPlayFunction: YourAutoplayFunction,
    *     },
-   *     linksBlacklist: [],
-   *     linksWhitelist: [],
-   *     advancedOptions: {
-   *       maxFilterFixDuration: 600_000,
-   *       debugOptions: {
-   *         noAudio: false,
-   *         playerDestroy: {
-   *           dontThrowError: false,
-   *           debugLogs: false
-   *         }
+   *     useUnresolvedData: true
+   *   },
+   *   queueOptions: {
+   *     maxPreviousTracks: 25,
+   *     //queueStore: yourCustomQueueStoreManagerClass,
+   *     //queueChangesWatcher: yourCustomQueueChangesWatcherClass
+   *   },
+   *   linksBlacklist: [],
+   *   linksWhitelist: [],
+   *   advancedOptions: {
+   *     maxFilterFixDuration: 600_000,
+   *     debugOptions: {
+   *       noAudio: false,
+   *       playerDestroy: {
+   *         dontThrowError: false,
+   *         debugLogs: false
    *       }
    *     }
-   *   ]
+   *   }
    * })
    * ```
    */
@@ -6839,6 +6903,7 @@ var LavalinkManager = class _LavalinkManager extends import_node_events2.EventEm
   NodeLinkNode,
   NodeManager,
   NodeSymbol,
+  NodeType,
   Player,
   Queue,
   QueueSaver,