poru 1.1.9 → 1.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poru",
-  "version": "1.1.9",
+  "version": "1.2.2",
   "description": "A stable and powefull lavalink client with so many features",
   "main": "index.js",
   "scripts": {

package/src/Node.js

@@ -1,16 +1,15 @@
 const WebSocket = require("ws");
-const config = require("./config.json")
+const config = require("./config")
 
 class Node {
     constructor(manager,options,node) {
-
         this.manager = manager
         this.name= options.name || null;
         this.host = options.host || "localhost"
         this.port = options.port || 2333
-        this.url = `${options.secure ? 'wss' : 'ws'}://${options.host}:${options.port}`;
         this.password = options.password ||"youshallnotpass"
         this.secure = options.secure || false;
+        this.url = `${this.secure ? 'wss' : 'ws'}://${this.host}:${this.port}/`;
         this.ws = null;
         this.reconnectTime = node.reconnectTime || 5000;
         this.resumeKey = node.resumeKey || null;
@@ -37,132 +36,130 @@ class Node {
         };
 
 
- }
-
- connect() {
-    if (this.ws) this.ws.close();
-    const headers = {
-        Authorization: this.password,
-        "Num-Shards": this.manager.shards || 1,
-        "User-Id": this.manager.user,
-        "Client-Name": config.client
-   };
-   if (this.resumeKey) headers["Resume-Key"] = this.resumeKey;
-   this.ws = new WebSocket(`ws${this.secure ? "s" : ""}:${this.host}:${this.port}/`, { headers });
-   this.ws.on("open",this.#open.bind(this));
-   this.ws.on("error", this.#error.bind(this));
-   this.ws.on("message", this.#message.bind(this));
-   this.ws.on("close", this.#close.bind(this));
-  }
-
-
-#open(){
-    if (this.reconnectAttempt) {
-        clearTimeout(this.reconnectAttempt);
-        delete this.reconnectAttempt;
-    } 
-
-if (this.resumeKey){
-this.send({
-     op: "configureResuming", 
-     key: (this.resumeKey).toString(), 
-     timeout: this.resumeTimeout 
-    });
-    this.manager.emit("debug",this.name,`[Web Socket]  Resuming configured on Lavalink`)
-}
-
-this.manager.emit("nodeConnect", this);
-this.isConnected = true;
-this.manager.emit('debug', this.name, `[Web Socket] Connection ready ${this.url}`);
-      
-}
-
-#message(payload) {
-    if (Array.isArray(payload)) payload = Buffer.concat(payload);
-    else if (payload instanceof ArrayBuffer) payload = Buffer.from(payload);
+    }
 
-    const packet = JSON.parse(payload);
-    if (packet.op && packet.op === "stats") {
-        this.stats = { ...packet };
-        delete this.stats.op;
+    connect() {
+        if (this.ws) this.ws.close();
+        const headers = {
+            Authorization: this.password,
+            "Num-Shards": this.manager.shards || 1,
+            "User-Id": this.manager.user,
+            "Client-Name": config.clientName
+        };
+        if (this.resumeKey) headers["Resume-Key"] = this.resumeKey;
+        this.ws = new WebSocket(this.url, { headers });
+        this.ws.on("open",this.#open.bind(this));
+        this.ws.on("error", this.#error.bind(this));
+        this.ws.on("message", this.#message.bind(this));
+        this.ws.on("close", this.#close.bind(this));
     }
-    const player = this.manager.players.get(packet.guildId);
-    if (packet.guildId && player) player.emit(packet.op, packet);
 
-    packet.node = this;
-    this.manager.emit("debug",this.name,`[Web Socket] Lavalink Node Update : ${packet.op}  `)
-    this.manager.emit("raw", packet);
-}
 
-    #close(event) {
-    this.manager.emit("nodeDisconnect", event, this);
-    this.manager.emit("debug",this.name,`[Web Socket] Connection with Lavalink closed with Error code : ${event||"Unkwon code"}`)
-    if (event !== 1000){
+    #open(){
+        if (this.reconnectAttempt) {
+            clearTimeout(this.reconnectAttempt);
+            delete this.reconnectAttempt;
+        } 
+
+        if (this.resumeKey){
+            this.send({
+                op: "configureResuming", 
+                key: (this.resumeKey).toString(), 
+                timeout: this.resumeTimeout 
+            });
+            this.manager.emit("debug",this.name,`[Web Socket]  Resuming configured on Lavalink`)
+        }
+
+        this.manager.emit("nodeConnect", this);
+        this.isConnected = true;
+        this.manager.emit('debug', this.name, `[Web Socket] Connection ready ${this.url}`);
         
-     return this.reconnect();
     }
-}
 
+    #message(payload) {
+        if (Array.isArray(payload)) payload = Buffer.concat(payload);
+        else if (payload instanceof ArrayBuffer) payload = Buffer.from(payload);
 
-    #error(event) {
-    if (!event) return "Unknown event";
+        const packet = JSON.parse(payload);
+        if(!packet.op) return;
+        
+        if (packet.op && packet.op === "stats") {
+            this.stats = { ...packet };
+            delete this.stats.op;
+        }
+        const player = this.manager.players.get(packet.guildId);
+        if (packet.guildId && player) player.emit(packet.op, packet);
+
+        packet.node = this;
+        this.manager.emit("debug",this.name,`[Web Socket] Lavalink Node Update : ${packet.op}  `)
+        this.manager.emit("raw", packet);
+    }
 
-    this.manager.emit("debug",this.name,`[Web Socket] Connection for Lavalink node has error code: ${event.code}`)
-    this.manager.emit("nodeError", this, event);
-    return this.reconnect();
-}
+    #close(event) {
+        this.manager.emit("nodeDisconnect", event, this);
+        this.manager.emit("debug",this.name,`[Web Socket] Connection with Lavalink closed with Error code : ${event||"Unknown code"}`)
+        if (event !== 1000){
+            
+        return this.reconnect();
+        }
+    }
 
-destroy(){
-    if(!this.isConnected) return;
 
-    const players = this.manager.players.filter(p => p.node == this);
-    if (players.size) players.forEach(p => p.destroy());
-    this.ws.close(1000, "destroy");
-    this.ws.removeAllListeners();
-    this.ws = null;
-    this.reconnect = 1;
-    this.destroyed = true;
-    this.manager.nodes.delete(this.host)
-    this.manager.emit("nodeDestroy", this);
+    #error(event) {
+        if (!event) return "Unknown event";
 
+        this.manager.emit("debug",this.name,`[Web Socket] Connection for Lavalink node has error code: ${event.code}`)
+        this.manager.emit("nodeError", this, event);
+        return this.reconnect();
+    }
 
-}
+    destroy(){
+        if(!this.isConnected) return;
 
-reconnect() {
-    this.reconnectAttempt = setTimeout(() => {
-        this.isConnected = false;
+        const players = this.manager.players.filter(p => p.node == this);
+        if (players.size) players.forEach(p => p.destroy());
+        this.ws.close(1000, "destroy");
         this.ws.removeAllListeners();
         this.ws = null;
-        this.manager.emit("nodeReconnect", this);
-        this.connect();
-    }, this.reconnectTime);
-}
-
-send(payload) {
-    this.ws.send(JSON.stringify(payload), (error) => {
-        if (error) return error;
-        return null;
-    });
-}
+        this.reconnect = 1;
+        this.destroyed = true;
+        this.manager.nodes.delete(this.host)
+        this.manager.emit("nodeDestroy", this);
 
 
-
-get penalties(){
-    let penalties = 0;
-    if (!this.isConnected) return penalties;
-    penalties += this.stats.players;
-    penalties += Math.round(Math.pow(1.05, 100 * this.stats.cpu.systemLoad) * 10 - 10);
-    if (this.stats.frameStats) {
-        penalties += this.stats.frameStats.deficit;
-        penalties += this.stats.frameStats.nulled * 2;
     }
-    return penalties;
-}
 
+    reconnect() {
+        this.reconnectAttempt = setTimeout(() => {
+            this.isConnected = false;
+            this.ws.removeAllListeners();
+            this.ws = null;
+            this.manager.emit("nodeReconnect", this);
+            this.connect();
+        }, this.reconnectTime);
+    }
 
- }
-
+    send(payload) {
+        const data = JSON.stringify(payload);
+        this.ws.send(data, (error) => {
+            if (error) return error;
+            return null;
+        });
+        this.manager.emit("raw", data, this.name)
+    }
 
+    get penalties(){
+        let penalties = 0;
+        if (!this.isConnected) return penalties;
+        penalties += this.stats.players;
+        penalties += Math.round(Math.pow(1.05, 100 * this.stats.cpu.systemLoad) * 10 - 10);
+        if (this.stats.frameStats) {
+            penalties += this.stats.frameStats.deficit;
+            penalties += this.stats.frameStats.nulled * 2;
+        }
+        return penalties;
+    }
+}
 
- module.exports = Node;
+module.exports = Node;
 

package/src/Player.js

@@ -50,6 +50,7 @@ class Player extends EventEmitter {
             this.manager.emit("playerUpdate", this, packet);
         });
     }
+
     async play() {
 
         if (!this.queue.length) {
@@ -72,7 +73,7 @@ class Player extends EventEmitter {
     }
 
 
-     stop() {
+    stop() {
 
         this.position = 0;
         this.isConnectd = false
@@ -182,9 +183,6 @@ class Player extends EventEmitter {
         return this;
     }
 
-
-
-
     async disconnect() {
         if (this.voiceChannel === null) return null;
         this.pause(true);
@@ -221,7 +219,7 @@ class Player extends EventEmitter {
 
             let response = await this.manager.resolve(data);
 
-            if (!response || !response.tracks || ["LOAD_FAILED", "NO_MATCHES"].includes(response.type)) return this.stop();
+            if (!response || !response.tracks || ["LOAD_FAILED", "NO_MATCHES"].includes(response.loadType)) return this.stop();
 
             let track = response.tracks[Math.floor(Math.random() * Math.floor(response.tracks.length))];
 
@@ -306,7 +304,6 @@ class Player extends EventEmitter {
         return events[data.type] || events.default;
     }
 
-
 }
 
 module.exports = Player;

package/src/Poru.js

@@ -3,29 +3,30 @@ const { fetch } = require('undici');
 const Player = require("./Player");
 const Node = require("./Node");
 const Response = require("./guild/Response");
-const config = require("./config.json")
 const Spotify = require("./platform/Spotify")
 const Apple = require("./platform/Apple")
-
+const Deezer = require("./platform/Deezer")
 class Poru extends EventEmitter {
-  constructor(client, nodes, options = {}) {
-    super();
-    if (!client) throw new Error("[Poru Error] you did't provide a valid client");
-    if (!nodes) throw new Error("[Poru Error] you did't provide a lavalink nodes");
-    if (!options) throw new Error('[Poru Error] options must be provided!');
-    this.client = client;
-    this._nodes = nodes;
-    this.nodes = new Map();
-    this.players = new Map();
-    this.voiceStates = new Map();
-    this.voiceServers = new Map();
-    this.user = null;
-    this.options = options;
-    this.shards = options.shards || 1;
-    this.sendData = null;
-  }
-
-//create a node and connect it with lavalink
+    constructor(client, nodes, options = {}) {
+        super();
+        if (!client) throw new Error("[Poru Error] you did't provide a valid client");
+        if (!nodes) throw new Error("[Poru Error] you did't provide a lavalink nodes");
+        if (!options) throw new Error("[Poru Error] options must be provided!")
+        this.client = client;
+        this._nodes = nodes;
+        this.nodes = new Map();
+        this.players = new Map();
+        this.voiceStates = new Map();
+        this.voiceServers = new Map();
+        this.user = null;
+        this.options = options
+        this.shards = options.shards || 1;
+        this.sendData = null;
+    }
+
+
+
+    //create a node and connect it with lavalink
     addNode(options) {
         const node = new Node(this, options, this.options);
         if (options.name) {
@@ -72,27 +73,33 @@ class Poru extends EventEmitter {
             const guild = client.guilds.cache.get(data.d.guild_id);
             if (guild) guild.shard.send(data);
         }
+        
         client.on("raw", async packet => {
             await this.packetUpdate(packet);
         })
-        
+
         this._nodes.forEach((node) => this.addNode(node));
 
 
- if (this.options.spotify && this.options.spotify.clientID && this.options.spotify.clientSecret) {
-            this.spotify = new Spotify(this, {
-                clientID: this.options.clientID,
-                clientSecret: this.options.clientSecret 
-                })
+        if (this.options.spotify && this.options.spotify.clientID && this.options.spotify.clientSecret) {
+            this.spotify = new Spotify(this, this.options)
+        }
+        if (this.options.apple) {
+            if (!this.options.apple.playlistLimit) {
+                throw new Error("[Poru Apple Music] playlistLimit must be provided")
+            }
+            this.apple = new Apple(this, this.options)
+        }
+        if (this.options.deezer) {
+            if (!this.options.deezer.playlistLimit) {
+                throw new Error("[Poru Deezer Music] playlistLimit must be provided")
+
+            }
+            this.deezer = new Deezer(this, this.options)
+       
         }
-if(this.options.apple){
-    if(!this.options.apple.playlistLimit){
-        throw new Error("[Poru Apple Music] playlistLimit must be provided")
-      }
-    this.apple = new Apple(this,this.options)
-}
         console.log(`Thanks for using Poru`)
-}
+    }
 
 
     setServersUpdate(data) {
@@ -110,100 +117,93 @@ if(this.options.apple){
         });
 
         return true;
-   
-    this.sendData({
-      op: 4,
-      d: {
-        guild_id: data.guild.id || data.guild,
-        channel_id: data.voiceChannel.id || data.voiceChannel,
-        self_mute: data.selfMute || false,
-        self_deaf: data.selfDeaf || true,
-      },
-    });
-    return this.#Player(data);
-  }
-
-  init(client) {
-    this.user = client.user.id;
-    this.sendData = data => {
-      const guild = client.guilds.cache.get(data.d.guild_id);
-      if (guild) guild.shard.send(data);
-    };
-    client.on('raw', async packet => {
-      await this.#packetUpdate(packet);
-    });
-
-    this._nodes.forEach(node => this.addNode(node));
-
-    if (this.options.spotify && this.options.spotify.clientID && this.options.spotify.clientSecret) {
-      this.spotify = new Spotify(this, {
-        clientID: this.options.clientID,
-        clientSecret: this.options.clientSecret,
-        playlistLimit: this.options.playlistLimit,
-        albumLimit: this.options.albumLimit,
-        artistLimit: this.options.artistLimit,
-        searchMarket: this.options.searchMarket,
-      });
     }
-    this.voiceServers.delete(data.guild_id);
-    this.voiceStates.delete(data.guild_id);
-  }
 
-  #packetUpdate(packet) {
-    if (!['VOICE_STATE_UPDATE', 'VOICE_SERVER_UPDATE'].includes(packet.t)) return;
-    const player = this.players.get(packet.d.guild_id);
-    if (!player) return;
+    setStateUpdate(data) {
+        if (data.user_id !== this.user) return;
+        if (data.channel_id) {
+            const guild = data.guild_id;
 
-    if (packet.t === 'VOICE_SERVER_UPDATE') {
-      this.setServersUpdate(packet.d);
+            this.voiceStates.set(data.guild_id, data);
+            const server = this.voiceServers.get(guild);
+            const state = this.voiceStates.get(guild);
+            if (!server) return false;
+            const player = this.players.get(guild);
+            if (!player) return false;
+
+            player.connect({
+                sessionId: state ? state.session_id : player.voiceUpdateState.sessionId,
+                event: server,
+            });
+
+            return true;
+        }
+        this.voiceServers.delete(data.guild_id);
+        this.voiceStates.delete(data.guild_id);
     }
-    if (packet.t === 'VOICE_STATE_UPDATE') {
-      this.setStateUpdate(packet.d);
+
+    packetUpdate(packet) {
+        if (!['VOICE_STATE_UPDATE', 'VOICE_SERVER_UPDATE'].includes(packet.t)) return;
+        const player = this.players.get(packet.d.guild_id);
+        if (!player) return;
+
+        if (packet.t === "VOICE_SERVER_UPDATE") {
+            this.setServersUpdate(packet.d);
+        }
+        if (packet.t === "VOICE_STATE_UPDATE") {
+            this.setStateUpdate(packet.d);
+        }
     }
-  }
-
-  get leastUsedNodes() {
-    return [...this.nodes.values()]
-      .filter(node => node.isConnected)
-      .sort((a, b) => {
-        const aLoad = a.stats.cpu ? (a.stats.cpu.systemLoad / a.stats.cpu.cores) * 100 : 0;
-        const bLoad = b.stats.cpu ? (b.stats.cpu.systemLoad / b.stats.cpu.cores) * 100 : 0;
-        return aLoad - bLoad;
-      });
-  }
-
-  #Player(data) {
-    const guild = data.guild.id || data.guild;
-    const Nodes = this.nodes.get(guild);
-    if (Nodes) return Nodes;
-    if (this.leastUsedNodes.length === 0) throw new Error('[Poru Error] No nodes are avaliable');
-    const node = this.nodes.get(this.leastUsedNodes[0].name || this.leastUsedNodes[0].host);
-    if (!node) throw new Error('[Poru Error] No nodes are avalible');
-
-    // eslint-disable-next-line new-cap
-    const player = new Player(this, node, data);
-    this.players.set(guild, player);
-    player.connect();
-    return player;
-  }
+
+
+
+    get leastUsedNodes() {
+        return [...this.nodes.values()]
+            .filter((node) => node.isConnected)
+            .sort((a, b) => {
+                const aLoad = a.stats.cpu ? (a.stats.cpu.systemLoad / a.stats.cpu.cores) * 100 : 0;
+                const bLoad = b.stats.cpu ? (b.stats.cpu.systemLoad / b.stats.cpu.cores) * 100 : 0;
+                return aLoad - bLoad;
+            });
+    }
+
+    #Player(data) {
+        const guild = data.guild.id || data.guild;
+        const Nodes = this.nodes.get(guild);
+        if (Nodes) return Nodes;
+        if (this.leastUsedNodes.length === 0) throw new Error("[Poru Error] No nodes are avaliable");
+        const node = this.nodes.get(this.leastUsedNodes[0].name
+            || this.leastUsedNodes[0].host);
+        if (!node) throw new Error("[Poru Error] No nodes are avalible");
+
+        // eslint-disable-next-line new-cap
+        const player = new Player(this, node, data);
+        this.players.set(guild, player);
+        player.connect()
+        return player;
+    }
+
+
+
 
     async resolve(track, source) {
-        
+
         const node = this.leastUsedNodes[0];
         if (!node) throw new Error("No nodes are available.");
-        if(this.spotify &&  this.spotify.check(track)){
-             return await this.spotify.resolve(track);
-        }
-        
-        if(this.apple &&  this.apple.check(track)){
+        if (this.spotify && this.spotify.check(track)) {
+            return await this.spotify.resolve(track);
+        }else if (this.apple && this.apple.check(track)) {
             return await this.apple.resolve(track);
-       }
-      
+        }else if (this.deezer && this.deezer.check(track)) {
+            return await this.deezer.resolve(track);
+        }
+
+
 
         const regex = /^https?:\/\//;
         if (!regex.test(track)) {
             // eslint-disable-next-line no-param-reassign
-            track = `${source || "yt"}search:${track}`;
+            track = `${source || "ytsearch"}:${track}`;
         }
         const result = await this.#fetch(node, "loadtracks", `identifier=${encodeURIComponent(track)}`);
 
@@ -219,40 +219,23 @@ if(this.options.apple){
         if (result.status === 500) return null;
         return result;
     }
-    const regex = /^https?:\/\//;
-    if (!regex.test(track)) {
-      // eslint-disable-next-line no-param-reassign
-      track = `${source || 'yt'}search:${track}`;
+
+    #fetch(node, endpoint, param) {
+        return fetch(`http${node.secure ? "s" : ""}://${node.host}:${node.port}/${endpoint}?${param}`, {
+            headers: {
+                Authorization: node.password,
+
+            },
+        })
+            .then((r) => r.json())
+            .catch((e) => {
+                throw new Error(`[Poru Error] Failed to fetch from the lavalink.\n  error: ${e}`);
+            });
+    }
+
+    get(guildId) {
+        return this.players.get(guildId);
     }
-    const result = await this.#fetch(node, 'loadtracks', `identifier=${encodeURIComponent(track)}`);
-
-    if (!result) throw new Error('[Poru Error] No tracks found.');
-    return new Response(result);
-  }
-
-  async decodeTrack(track) {
-    const node = this.leastUsedNodes[0];
-    if (!node) throw new Error('No nodes are available.');
-    const result = await this.#fetch(node, 'decodetrack', `track=${track}`);
-    if (result.status === 500) return null;
-    return result;
-  }
-
-  #fetch(node, endpoint, param) {
-    return fetch(`http${node.secure ? 's' : ''}://${node.host}:${node.port}/${endpoint}?${param}`, {
-      headers: {
-        Authorization: node.password,
-      },
-    })
-      .then(r => r.json())
-      .catch(e => {
-        throw new Error(`[Poru Error] Failed to fetch from the lavalink.\n  error: ${e}`);
-      });
-  }
-
-  get(guildId) {
-    return this.players.get(guildId);
-  }
 }
 
-module.exports = Poru;
+module.exports = Poru

package/src/config.js

@@ -0,0 +1,3 @@
+module.exports = {
+    clientName: "Poru"
+}

package/src/guild/DeezerTrack.js

@@ -0,0 +1,61 @@
+const escapeRegExp = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+class DeezerTrack {
+  constructor(data) {
+    this.track = data.track
+    this.info = {
+      identifier: null,
+      isSeekable: data.info.isSeekable,
+      author: data.info.author,
+      length: data.info.length,
+      isStream: data.info.isStream,
+      sourceName: data.info.sourceName,
+      title: data.info.title,
+      uri: data.info.uri,
+      image: data.image || null
+
+    }
+  }
+
+  async resolve(manager) {
+
+    const query = [this.info.author, this.info.title].filter((x) => !!x).join(' - ');
+
+
+    const result = await manager.resolve(query);
+    if (!result || !result.tracks.length) return;
+
+    if (this.info.author) {
+      const author = [this.info.author, `${this.info.author} - Topic`];
+      const officialAudio = result.tracks.find(
+        (track) =>
+          author.some((name) => new RegExp(`^${escapeRegExp(name)}$`, 'i').test(track.info.author)) ||
+          new RegExp(`^${escapeRegExp(this.info.title)}$`, 'i').test(track.info.title),
+      );
+      if (officialAudio) {
+        this.info.identifier = officialAudio.info.identifier
+        this.track = officialAudio.track;
+        this.length = officialAudio.info.length
+        return this
+      }
+    }
+    if (this.info.length) {
+      const sameDuration = result.tracks.find(
+        (track) =>
+          track.info.length >= (this.info.length ? this.length : 0) - 2000 &&
+          track.info.length <= (this.info.length ? this.length : 0) + 2000,
+      );
+      if (sameDuration) {
+        this.info.identifier = sameDuration.info.identifier
+        this.track = sameDuration.track;
+        this.length = officialAudio.info.length
+        return this
+      }
+    }
+    this.info.identifier = result.tracks[0].info.identifier
+    this.track = result.tracks[0].track;
+    this.length = officialAudio.info.length
+    return this
+  }
+}
+
+module.exports = DeezerTrack;

package/src/platform/Apple.js

@@ -1,4 +1,4 @@
-const { fetch } = require('undici');
+const {fetch} = require("undici")
 const Track = require("../guild/Track")
 const cheerio = require("cheerio")
 
@@ -8,9 +8,10 @@ class Apple {
         this.baseURL = /(?:https:\/\/music\.apple\.com\/)(?:.+)?(artist|album|music-video|playlist)\/([\w\-\.]+(\/)+[\w\-\.]+|[^&]+)\/([\w\-\.]+(\/)+[\w\-\.]+|[^&]+)/;
         this.applePattern =  /(?:https:\/\/music\.apple\.com\/)(?:\w{2}\/)?(track|album|playlist)/g;
         this.REGEX = /(?:https:\/\/music\.apple\.com\/)(?:\w{2}\/)?(track|album|playlist)/g;
-        this.playlistLimit = options.playlistLimit || null;
+        this.playlistLimit = options.apple.playlistLimit || null;
   }
 
+
     check(url) {
         return this.baseURL.test(url);
     }
@@ -232,4 +233,5 @@ class Apple {
 
 
 }
+
 module.exports = Apple

package/src/platform/Deezer.js

@@ -0,0 +1,201 @@
+const { fetch } = require('undici');
+const DeezerTrack = require("../guild/DeezerTrack")
+
+class Deezer {
+  constructor(manager, options) {
+
+
+    this.manager = manager;
+    this.baseURL = 'https://api.deezer.com';
+    this.REGEX = /^(?:https?:\/\/|)?(?:www\.)?deezer\.com\/(?:\w{2}\/)?(track|album|playlist|artist)\/(\d+)/
+    this.playlistLimit = options.deezer.playlistLimit || null;
+
+  }
+
+
+  check(url) {
+    return this.REGEX.test(url);
+  }
+
+  async requestData(endpoint) {
+    const req = await fetch(`${this.baseURL}/${endpoint}`, {
+    });
+    const data = await req.json();
+    return data;
+  }
+
+
+  async resolve(url) {
+    const [, type, id] = this.REGEX.exec(url) ?? [];
+    switch (type) {
+      case 'playlist': {
+        return this.fetchPlaylist(id);
+      }
+      case 'track': {
+        return this.fetchTrack(id);
+      }
+      case 'album': {
+        return this.fetchAlbum(id);
+      }
+      case 'artist': {
+        return this.fetchArtist(id);
+      }
+
+    }
+
+
+
+  }
+
+
+  async fetchPlaylist(id) {
+    try {
+      const playlist = await this.requestData(`/playlist/${id}`);
+      const unresolvedPlaylistTracks = await Promise.all(playlist.tracks.data.map(x => this.buildUnresolved(x)));
+      return this.buildResponse('PLAYLIST_LOADED', unresolvedPlaylistTracks, playlist.name);
+
+    } catch (e) {
+      return this.buildResponse(
+        e.body?.error.message === 'invalid id' ? 'NO_MATCHES' : 'LOAD_FAILED',
+        [],
+        undefined,
+        e.body?.error.message ?? e.message,
+      );
+
+    }
+  }
+
+  async fetchAlbum(id) {
+    try {
+      const album = await this.requestData(`/album/${id}`)
+
+      const unresolvedAlbumTracks = await Promise.all(playlist.tracks.data.map(x => this.buildUnresolved(x)));
+
+      return this.buildResponse('PLAYLIST_LOADED', unresolvedAlbumTracks, album.name);
+    } catch (e) {
+      return this.buildResponse(
+        e.body?.error.message === 'invalid id' ? 'NO_MATCHES' : 'LOAD_FAILED',
+        [],
+        undefined,
+        e.body?.error.message ?? e.message,
+      );
+
+    }
+  }
+
+  async fetchTrack(id) {
+
+    try {
+      const track = await this.requestData(`/track/${id}`)
+
+      const unresolvedTrack = await Promise.all(this.buildUnresolved(track));
+      return this.buildResponse('TRACK_LOADED', [unresolvedTrack]);
+    } catch (e) {
+      return this.buildResponse(
+        e.body?.error.message === 'invalid id' ? 'NO_MATCHES' : 'LOAD_FAILED',
+        [],
+        undefined,
+        e.body?.error.message ?? e.message,
+      );
+
+    }
+  }
+
+  async fetchArtist(id) {
+
+    try {
+      const artist = await this.requestData(`/artist/${id}/top`);
+      await this.fetchArtistTracks(artist)
+      const unresolvedArtistTracks = await Promise.all(artist.data.map(x => this.buildUnresolved(x)
+      ));
+
+
+
+      return this.buildResponse('PLAYLIST_LOADED', unresolvedArtistTracks, artist.name);
+    } catch (e) {
+      return this.buildResponse(
+        e.body?.error.message === 'invalid id' ? 'NO_MATCHES' : 'LOAD_FAILED',
+        [],
+        undefined,
+        e.body?.error.message ?? e.message,
+      );
+
+    }
+  }
+
+  async fetchArtistTracks(deezerArtist) {
+    let nextPage = deezerArtist.next;
+    let pageLoaded = 1;
+    while (nextPage) {
+      if (!nextPage) break;
+      const req = await fetch(nextPage)
+      const json = await req.json()
+
+      deezerArtist.data.push(...json.data);
+
+      nextPage = json.next;
+      pageLoaded++;
+    }
+  }
+
+  async fetch(query) {
+    try {
+      if (this.check(query)) return this.resolve(query)
+      let tracks = await this.requestData(`/search?q="${query}"`)
+
+      const unresolvedTrack = await Promise.all(this.buildUnresolved(tracks.data[0]));
+      return this.buildResponse('TRACK_LOADED', [unresolvedTrack]);
+    } catch (e) {
+      return this.buildResponse(
+        e.body?.error.message === 'invalid id' ? 'NO_MATCHES' : 'LOAD_FAILED',
+        [],
+        undefined,
+        e.body?.error.message ?? e.message,
+      );
+
+
+    }
+  }
+
+
+  async buildUnresolved(track) {
+    if (!track) throw new ReferenceError('The Deezer track object was not provided');
+
+    return new DeezerTrack({
+      track: '',
+      info: {
+        sourceName: 'deezer',
+        identifier: track.id,
+        isSeekable: true,
+        author: track.artist ? track.artist.name : 'Unknown',
+        length: track.duration,
+        isStream: false,
+        title: track.title,
+        uri: track.link,
+        image: track.album.cover_medium
+      },
+    });
+  }
+
+
+  compareValue(value) {
+    return typeof value !== 'undefined' ? value !== null : typeof value !== 'undefined';
+  }
+
+  buildResponse(loadType, tracks, playlistName, exceptionMsg) {
+    return Object.assign(
+      {
+        loadType,
+        tracks,
+        playlistInfo: playlistName ? { name: playlistName } : {},
+      },
+      exceptionMsg ? { exception: { message: exceptionMsg, severity: 'COMMON' } } : {},
+    );
+  }
+
+
+
+
+}
+
+module.exports = Deezer;

package/src/platform/Spotify.js

@@ -78,9 +78,7 @@ class Spotify {
         return this.fetchArtist(id);
       }
 
-      default: {
-        return this.manager.resolve(url);
-      }
+  
     }
   }
 
@@ -90,7 +88,7 @@ class Spotify {
       await this.fetchPlaylistTracks(playlist);
 
       const limitedTracks = this.playlistLimit
-        ? playlist.tracks.items.slice(0, this.playlistLimit * 50)
+        ? playlist.tracks.items.slice(0, this.playlistLimit * 100)
         : playlist.tracks.items;
 
       const unresolvedPlaylistTracks = await Promise.all(limitedTracks.map(x => this.buildUnresolved(x.track)));
@@ -110,7 +108,7 @@ class Spotify {
     try {
       const album = await this.requestData(`/albums/${id}`);
 
-      const limitedTracks = this.albumLimit ? album.tracks.items.slice(0, this.albumLimit * 50) : album.tracks.items;
+      const limitedTracks = this.albumLimit ? album.tracks.items.slice(0, this.albumLimit * 100) : album.tracks.items;
 
       const unresolvedPlaylistTracks = await Promise.all(limitedTracks.map(x => this.buildUnresolved(x)));
       return this.buildResponse('PLAYLIST_LOADED', unresolvedPlaylistTracks, album.name);
@@ -130,7 +128,7 @@ class Spotify {
 
       const data = await this.requestData(`/artists/${id}/top-tracks?market=${this.searchMarket ?? 'US'}`);
 
-      const limitedTracks = this.artistLimit ? data.tracks.slice(0, this.artistLimit * 50) : data.tracks;
+      const limitedTracks = this.artistLimit ? data.tracks.slice(0, this.artistLimit * 100) : data.tracks;
 
       const unresolvedPlaylistTracks = await Promise.all(limitedTracks.map(x => this.buildUnresolved(x)));
 

package/typings/index.d.ts

@@ -1,4 +1,4 @@
-import { EventEmitter } from "ws";
+import { EventEmitter, WebSocket } from "ws";
 
 declare module'Poru' {
 
@@ -56,48 +56,45 @@ export class Node {
         constructor(manager:typeof EventEmitter|any,options:object,node:object)
 
         public manager: EventEmitter
-        public name: String
-        public host: String
-        public port : Number
-        public url : String
-        public password: String
-        public secure: Boolean
-        public ws = any
-        public reconnectTime : Number
-        public resumeKey:String|Number;
-        public resumeTimeout =Number
-        public reconnectAttempt:Number;
-        public reconnects:Number;
-        public isConnected:Boolean;
-        public destroyed:Boolean;
+        public name: string
+        public host: string
+        public port : number
+        public url : string
+        public password: string
+        public secure: boolean
+        public ws: WebSocket
+        public reconnectTime : number
+        public resumeKey:string|number;
+        public resumeTimeout: number
+        public reconnectAttempt:number;
+        public reconnects:number;
+        public isConnected:boolean;
+        public destroyed:boolean;
         public stats:Object
 
 
         connect():void
 
-        destroy()
+        destroy(): void
 
-        reconnect()
+        reconnect(): void
 
-        send(playload:any)
+        send(playload:Object): void | Object | String
 
         get penalties():Number
 
-
-
 }
 
 
 export class Player extends EventEmitter {
-        constructor(manager:EventEmitter,node:Map|Object, options:Object)
-
+        constructor(manager:EventEmitter,node:Map<any, any>|Object, options:Object)
 
         
         public  manager:EventEmitter
 
-        public  queue:Array |any
+        public  queue:Array<any> |any
 
-        public  node: Map|Object|Any;
+        public  node: Map<any, any>|Object|Any;
 
         public  filters: any
 
@@ -107,15 +104,15 @@ export class Player extends EventEmitter {
 
         public  textChannel:any;
 
-        public  isConnectd = Boolean;
+        public  isConnected: boolean;
 
-        public  isPlaying:Boolean;
+        public  isPlaying:boolean;
 
-        public  isPause:Boolean;
+        public  isPause:boolean;
 
-        public  trackRepeat:Boolean;
+        public  trackRepeat:boolean;
 
-        public  queueRepeat:Boolean;
+        public  queueRepeat:boolean;
 
         public  loop:Number;
 
@@ -127,9 +124,7 @@ export class Player extends EventEmitter {
 
         public  previousTrack:Object;
 
-        public  voiceUpdateState = any;
-
-
+        public  voiceUpdateState:any;
 
 
         play()
@@ -158,24 +153,8 @@ export class Player extends EventEmitter {
 
         disconnect()
 
-
         destroy()
 
         autoplay(toggle:Boolean)
 
-        
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 }

package/src/config.json

@@ -1,3 +0,0 @@
-{
-    "client" :"Poru"
-}