lavalink-client 2.9.11 → 2.10.0

package/dist/index.mjs

@@ -339,9 +339,6 @@ var NodeLinkExclusiveEvents = [
   "LyricsNotFoundEvent"
 ];
 
-// src/structures/NodeManager.ts
-import { EventEmitter } from "events";
-
 // src/structures/Node.ts
 import { isAbsolute } from "path";
 import WebSocket from "ws";
@@ -354,6 +351,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
 import { URL as URL2 } from "url";
@@ -525,12 +527,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 URL2(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)
@@ -1184,7 +1188,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 */
@@ -1258,7 +1262,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;
   }
   /**
@@ -1328,16 +1332,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)
@@ -2280,20 +2285,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
@@ -3066,13 +3073,13 @@ var LavalinkNode = class _LavalinkNode {
 
 // 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.
@@ -3413,6 +3420,7 @@ var NodeLinkNode = class extends LavalinkNode {
 LavalinkNode._NodeLinkClass = NodeLinkNode;
 
 // src/structures/NodeManager.ts
+import { EventEmitter } from "events";
 var NodeManager = class extends EventEmitter {
   /**
    * Emit an event
@@ -3474,9 +3482,7 @@ var NodeManager = class extends 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
@@ -3537,9 +3543,21 @@ var NodeManager = class extends 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;
   }
@@ -3548,48 +3566,57 @@ var NodeManager = class extends 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;
     }
@@ -3622,13 +3649,22 @@ var NodeManager = class extends 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;
   }
 };
@@ -6267,9 +6303,11 @@ var LavalinkManager = class _LavalinkManager extends EventEmitter2 {
       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));
@@ -6325,48 +6363,50 @@ var LavalinkManager = class _LavalinkManager extends EventEmitter2 {
    *       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
    *       }
    *     }
-   *   ]
+   *   }
    * })
    * ```
    */
@@ -6774,6 +6814,7 @@ export {
   NodeLinkNode,
   NodeManager,
   NodeSymbol,
+  NodeType,
   Player,
   Queue,
   QueueSaver,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "lavalink-client",
-    "version": "2.9.11",
+    "version": "2.10.0",
     "description": "Easy, flexible and feature-rich lavalink@v4 Client. Both for Beginners and Proficients. - Supports NodeLink@v3 too.",
     "keywords": [
         "advanced",