poru 2.0.0 → 3.0.0

package/README.md

@@ -50,72 +50,76 @@ To use you need a configured [Lavalink](https://github.com/Frederikam/Lavalink)
 ## Example usage basic bot
 
 ```javascript
-// main file
-// Require both libraries
 const { Client } = require('discord.js');
-const { Poru } = require('poru');
-
-// Initiate both main classes
+const  { Poru } = require('poru');
+const nodes = [
+    {
+      id: "main_node",
+      hostname:"localhost",
+      port: 8080,
+      password: "iloveyou3000"
+    }
+  ]
+  
 const client = new Client();
 
-// Define some options for the node
-const nodes = [
-  {
-    host: 'localhost',
-    password: 'youshallnotpass',
-    port: 2333,
-    secure: false,
-  },
-];
-
-// Define if you want to integrate spotify
-const spotifyOptions = {
-  clientID: 'Your Client ID', // You'll find this on https://developers.spotify.com/dashboard/
-  clientSecret: 'Your Client Secret', // You'll find this on https://developers.spotify.com/dashboard/
-  playlistLimit: 10, // The amount of pages to load when a playlist is searched with each page having 50 tracks.
-  albumLimit: 5, // The amount of pages to load when a album is searched with each page having 50 tracks.
-  artistLimit: 5, // The amount of pages to load when a artist is searched with each page having 50 tracks.
-  searchMarket: 'IN', // The market from where the query should be searched from. Mainly this should contain your country.
-};
-
-// Assign Manager to the client variable
-client.poru = new Poru(client, nodes);
-
-// Emitted whenever a node connects
-client.poru.on('nodeConnect', node => {
-  console.log(`Node "${node.name}" connected.`);
-});
+client.poru = new Poru(client,nodes,PoruOptions)
+
+
 
-// Emitted whenever a node encountered an error
-client.poru.on('nodeError', (node, error) => {
-  console.log(`Node "${node.name}" encountered an error`);
+client.poru.on('trackStart', (player, track) => {
+  
+  player.textChannel.send(`Now playing \`${track.title}\``);
 });
 
-// Listen for when the client becomes ready
-client.once('ready', () => {
+
+client.on('ready', () => {
+  console.log('Ready!');
   client.poru.init(client);
-  console.log(`Logged in as ${client.user.tag}`);
 });
 
-// this event used to make connections upto date with lavalink
-client.on('raw', async d => await client.poru.packetUpdate(d));
-
-// Finally login at the END of your code
-client.login('your bot token here');
-```
 
-```javascript
-// creating player
-const player = await client.poru.createConnection({
-  guild: message.guild.id,
-  voiceChannel: message.member.voice.channel.id,
-  textChannel: message.channel,
-  selfDeaf: true,
-  selfMute: false,
+client.on('interactionCreate', async interaction => {
+  if (!interaction.isCommand()) return;
+  if (!interaction.member.voice.channel) return interaction.reply({ content: `Please connect with voice channel `, ephemeral: true });
+
+  const track = interaction.options.getString('track');
+
+  const res = await client.poru.resolve(track);
+
+  if (res.loadType === "LOAD_FAILED") {
+    return interaction.reply(`Failed to load track`);
+  } else if (res.loadType === "NO_MATCHES") {
+    return interaction.reply('No source found!');
+  }
+
+//create connection with discord voice channnel
+  const player = client.poru.createConnection({
+    guildId: interaction.guild.id,
+    voiceChannel: interaction.member.voice.channelId,
+    textChannel: interaction.channel,
+    deaf: true
+  });
+  
+ 
+  if (res.loadType === 'PLAYLIST_LOADED') {
+    for (const track of res.tracks) {
+      trackk.info.requester = interaction.user;
+      player.queue.add(track);
+    }
+
+    interaction.reply(`${res.playlistInfo.name} has been loaded with ${res.tracks.length}`);
+  } else {
+    const track = res.tracks[0];
+    track.info.requester = interaction.user;
+    player.queue.add(track);
+    interacton.reply(`Queued Track \n \`${track.title}\``);
+  }
+
+  if (!player.isPlaying && player.isConnected) player.play();
 });
-// Getting tracks
-const resolve = await client.poru.resolve('Ignite', 'yt');
-```
+
+client.login('TOKEN');```
 
 ## Need Help?
 

package/index.js

@@ -1,20 +1,16 @@
+
 module.exports = {
     Node: require("./src/Node"),
     Player: require("./src/Player"),
-    Poru: require("./src/Poru")
+    Poru: require("./src/Poru"),
+    Spotify : require("./src/platform/Spotify"),
+    Deezer : require("./src/platform/Deezer"),
+    AppleMusic : require("./src/platform/AppleMusic"),
+    Queue : require("./src/guild/Queue"),
+    Filter : require("./src/guild/Filter"),
+    Track: require("./src/guild/Track"),
+    PoruTrack : require("./src/guild/PoruTrack")
+    
+    
+
 }
-process.on('unhandledRejection', error => {
-    if (error.code === '10008' || error.code === '10062') return;
-    console.log(error.stack);
-  });
-  process.on('uncaughtException', (err, origin) => {
-    console.log(err, origin);
-  });
-  
-  process.on('uncaughtExceptionMonitor', (err, origin) => {
-    console.log(err, origin);
-  });
-  
-  process.on('multipleResolves', (type, promise, reason) => {
-    console.log(type, promise, reason);
-  });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poru",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "description": "A stable and powefull lavalink client with so many features",
   "main": "index.js",
   "scripts": {
@@ -17,9 +17,12 @@
   },
   "homepage": "https://github.com/parasop/poru#readme",
   "dependencies": {
-    "node-fetch": "^3.2.6",
+    "undici": "^5.7.0",
     "ws": "^8.8.0"
   },
+  "engines": {
+		"node": ">=16.9.0"
+	},
   "keywords": [
     "music",
     "lavalink",

package/src/Node.js

@@ -55,6 +55,17 @@ class Node {
         this.ws.on("close", this.#close.bind(this));
     }
 
+    disconnect(){
+        if(!this.isConnected) return;
+
+        this.ws?.removeAllListeners();
+        this.ws?.close();
+        this.ws = null;
+        this.isConnected = false;
+
+
+    }
+
 
     #open(){
         if (this.reconnectAttempt) {
@@ -74,35 +85,46 @@ class Node {
         this.manager.emit("nodeConnect", this);
         this.isConnected = true;
         this.manager.emit('debug', this.name, `[Web Socket] Connection ready ${this.url}`);
+
+        if(config.autoResume){
+          
+            for (const player of this.manager.players.values()) {
+                if (player.node === this) {
+                  player.restart();
+                }
+              }
+
+
+
+
+
+
+        }
         
     }
 
     #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) 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;
+         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.disconnect();
+        this.manager.emit("nodeDisconnect",this,event);
         this.manager.emit("debug",this.name,`[Web Socket] Connection with Lavalink closed with Error code : ${event||"Unknown code"}`)
         if (event !== 1000){
             
-        return this.reconnect();
-        }
+       }
     }
 
 

package/src/Player.js

@@ -2,7 +2,7 @@ const { EventEmitter } = require("events");
 const Queue = require("./guild/Queue");
 const Filters = require("./guild/Filter")
 class Player extends EventEmitter {
-    constructor(manager,node, options) {
+    constructor(manager, node, options) {
         super();
 
         this.manager = manager;
@@ -11,19 +11,23 @@ class Player extends EventEmitter {
 
         this.node = node;
 
+        this.options = options;
+
         this.filters = new Filters(this, this.node)
 
-        this.guild = options.guild.id || options.guild;
+        this.guildId = options.guildId;
 
         this.voiceChannel = options.voiceChannel.id || options.voiceChannel;
 
         this.textChannel = options.textChannel || null;
 
-        this.isConnectd = false;
+        this.shardId = options.shardId || 1;
+
+        this.isConnected = false;
 
         this.isPlaying = false;
 
-        this.isPause = false;
+        this.isPaused = false;
 
         this.trackRepeat = false;
 
@@ -45,28 +49,30 @@ class Player extends EventEmitter {
 
         this.on("event", (data) => (this.lavalinkEvent(data).bind(this))());
         this.on("playerUpdate", (packet) => {
-            this.isConnectd = packet.state.connected,
+            this.isConnected = packet.state.connected,
                 this.position = packet.state.position
             this.manager.emit("playerUpdate", this, packet);
         });
     }
 
-    async play() {
+    async play(options = {}) {
 
         if (!this.queue.length) {
-            return nulll;
+            return null;
         }
-        this.currentTrack = this.queue.shift();
-        if(!this.currentTrack.track){
-          this.currentTrack = await this.currentTrack.resolve(this.manager);
+
+        this.currentTrack = this.queue.shift()
+
+        if (!this.currentTrack.track) {
+            this.currentTrack = await this.currentTrack.resolve(this.manager);
         }
+
         this.isPlaying = true;
-        this.timestamp = Date.now();
         this.node.send({
             op: "play",
-            guildId: this.guild,
+            guildId: this.guildId,
             track: this.currentTrack.track,
-            volume: this.volume || 100,
+            noReplace: options.noReplace || true,
         });
         this.position = 0;
         return this;
@@ -76,11 +82,11 @@ class Player extends EventEmitter {
     stop() {
 
         this.position = 0;
-        this.isConnectd = false
+        this.isConnected = false
         this.isPlaying = false;
         this.node.send({
             op: "stop",
-            guildId: this.guild
+            guildId: this.guildId
         });
         return this;
     }
@@ -90,11 +96,11 @@ class Player extends EventEmitter {
 
         this.node.send({
             op: "pause",
-            guildId: this.guild,
+            guildId: this.guildId,
             pause,
         });
         this.isPlaying = !pause;
-        this.isPause = pause;
+        this.isPaused = pause;
 
         return this;
     }
@@ -104,97 +110,100 @@ class Player extends EventEmitter {
         this.position = position;
         this.node.send({
             op: "seek",
-            guildId: this.guild,
+            guildId: this.guildId,
             position,
         });
         return this;
     }
 
-    async setVolume(volume) {
+    setVolume(volume) {
         if (Number.isNaN(volume)) throw new RangeError("Volume level must be a number.");
-         this.volume = volume;
+        this.volume = volume;
         this.node.send({
             op: "volume",
-            guildId: this.guild,
+            guildId: this.guildId,
             volume: this.volume,
         });
         return this;
 
     }
 
-    async TrackRepeat() {
+    TrackRepeat() {
         this.loop = 1;
         this.trackRepeat = true;
         this.queueRepeat = false;
         return this;
     }
 
-    async QueueRepeat() {
+
+    QueueRepeat() {
         this.loop = 2;
         this.queueRepeat = true;
         this.trackRepeat = false;
         return this;
     }
 
-    async DisableRepeat() {
+    DisableRepeat() {
         this.loop = 0;
         this.trackRepeat = false;
         this.queueRepeat = false;
-
-
         return this;
     }
 
-    async setTextChannel(channel) {
+    setTextChannel(channel) {
         if (typeof channel !== "string") throw new RangeError("Channel must be a string.");
         this.textChannel = channel;
         return this;
     }
 
-    async setVoiceChannel(channel) {
+    setVoiceChannel(channel) {
         if (typeof channel !== "string") throw new RangeError("Channel must be a string.");
         this.voiceChannel = channel;
         return this;
     }
 
-    async connect(data) {
+    connect(options) {
+
+        let { guildId, voiceChannel, deaf, mute } = options;
+        this.send({ guild_id: guildId, channel_id: voiceChannel, self_deaf: deaf || true, self_mute: mute || false }, true);
+        this.isConnected = true;
+
+    }
+
+    updateSession(data) {
         if (data) {
             this.voiceUpdateState = data;
             this.node.send({
                 op: "voiceUpdate",
-                guildId: this.guild,
+                guildId: this.guildId,
                 ...data,
             });
         }
         return this;
+
     }
 
-    async reconnect() {
+    reconnect() {
         if (this.voiceChannel === null) return null;
-        this.node.send({
-            op: 4,
-            d: {
-                guild_id: this.guild,
+        this.send({
+                guild_id: this.guildId,
                 channel_id: this.voiceChannel,
                 self_mute: false,
                 self_deaf: false,
-            },
-        });
+            })
+            
         return this;
     }
 
-    async disconnect() {
+    disconnect() {
         if (this.voiceChannel === null) return null;
         this.pause(true);
-        this.isConnectd = false;
-        this.manager.sendData({
-            op: 4,
-            d: {
-                guild_id: this.guild,
-                channel_id: null,
-                self_mute: false,
-                self_deaf: false,
-            },
+        this.isConnected = false;
+        this.send({
+            guild_id: this.guildId,
+            channel_id: null,
+            self_mute: false,
+            self_deaf: false,
         });
         this.voiceChannel = null;
         return this;
@@ -204,10 +213,28 @@ class Player extends EventEmitter {
         this.disconnect();
         this.node.send({
             op: "destroy",
-            guildId: this.guild,
+            guildId: this.guildId,
         });
         this.manager.emit("playerDestroy", this);
-        this.manager.players.delete(this.guild);
+        this.manager.players.delete(this.guildId);
+    }
+
+    restart() {
+        this.filters.updateFilters();
+        if (this.currentTrack) {
+
+            this.isPlaying = true;
+            this.node.send({
+                op: "play",
+                startTime: this.position,
+                noReplace: true,
+                guildId: this.guildId,
+                track: this.currentTrack.track,
+                pause: this.isPaused
+            });
+
+
+        }
     }
 
     async autoplay(toggle = false) {
@@ -217,7 +244,7 @@ class Player extends EventEmitter {
             if (!this.previousTrack) return this.stop();
             let data = `https://www.youtube.com/watch?v=${this.previousTrack.info.identifier}&list=RD${this.previousTrack.info.identifier}`;
 
-            let response = await this.manager.resolve(data);
+            let response = await this.manager.resolve(data,this.manager.options.defaultPlatform || "ytsearch");
 
             if (!response || !response.tracks || ["LOAD_FAILED", "NO_MATCHES"].includes(response.loadType)) return this.stop();
 
@@ -236,6 +263,11 @@ class Player extends EventEmitter {
 
     }
 
+    send(data) {
+
+        this.manager.sendData({ op: 4, d: data });
+    }
+
 
     lavalinkEvent(data) {
         const events = {
@@ -277,22 +309,16 @@ class Player extends EventEmitter {
             },
             TrackExceptionEvent() {
                 this.queue.shift();
-                /**
-                 * Fire up when there's an error while playing the track
-                 * @event trackError
-                 */
                 this.manager.emit("trackError", this, this.track, data);
             },
             WebSocketClosedEvent() {
                 if ([4015, 4009].includes(data.code)) {
-                    this.manager.sendData({
-                        op: 4,
-                        d: {
-                            guild_id: data.guildId,
-                            channel_id: this.voiceChannel.id || this.voiceChannel,
-                            self_mute: this.options.selfMute || false,
-                            self_deaf: this.options.selfDeaf || false,
-                        },
+                    this.send({
+                        guild_id: data.guildId,
+                        channel_id: this.voiceChannel.id || this.voiceChannel,
+                        self_mute: this.options.mute || false,
+                        self_deaf: this.options.deaf || false,
+
                     });
                 }
                 this.manager.emit("socketClosed", this, data);

package/src/Poru.js

@@ -1,7 +1,5 @@
 const { EventEmitter } = require("events");
-const fetch = (...args) => import('node-fetch').then(({
-    default: fetch
-}) => fetch(...args));
+const { fetch } = require("undici")
 const config = require("./config")
 const Player = require("./Player");
 const Node = require("./Node");
@@ -12,23 +10,49 @@ 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!")
+        if (!client) throw new Error("[Poru Error] You didn't provide a valid client");
+        if (!nodes) throw new Error("[Poru Error] You did't provide a lavalink node");
+
         this.client = client;
         this._nodes = nodes;
         this.nodes = new Map();
         this.players = new Map();
         this.voiceStates = new Map();
         this.voiceServers = new Map();
+        this.isReady = false;
         this.user = null;
         this.options = options
         this.shards = options.shards || 1;
         this.sendData = null;
         this.version = config.version
+        this.spotify = new Spotify(this, this.options);
+        this.apple = new AppleMusic(this, this.options)
+        this.apple.requestToken();
+        this.deezer = new Deezer(this, this.options)
+
     }
 
 
+    init(client) {
+
+        if (this.isReady) return this;
+
+        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));
+    }
+
+
+
 
     //create a node and connect it with lavalink
     addNode(options) {
@@ -45,66 +69,89 @@ class Poru extends EventEmitter {
 
     //remove node and destroy web socket connection
     removeNode(identifier) {
+        if (!identifier) throw new Error(`[Poru Error] Provide identifier as a parameter of removeNode`)
         const node = this.nodes.get(identifier);
         if (!node) return;
         node.destroy();
         this.nodes.delete(identifier)
     }
-    //create  connection with discord voice channel
-    createConnection(data = {}) {
-        const player = this.players.get(data.guild.id || data.guild);
-        if (player) {
-            return player;
-        }
-        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);
+
+    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;
+            });
     }
 
 
+    getNode(identifier = "best") {
+        if (!this.nodes.size) throw new Error(`No nodes avaliable currently`)
+        if (identifier === "best") return this.leastUsedNodes();
 
-    init(client) {
+        const node = this.nodes.get(indetifier);
+        if (!node) throw new Error('The node identifier you provided is not found');
+        if (!node.isConnected) node.connect();
+        return node;
+    }
 
-        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));
+    createConnection(options) {
+        this.checkConnection(options)
+        const player = this.players.get(options.guildId);
+        if (player) return player;
+
+        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");
+
+        return this.#createPlayer(node, options);
 
 
-        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 AppleMusic(this, this.options)
-            this.apple.requestToken();
-        }
-        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)
-       
-        }
-        console.log(`Thanks for using Poru`)
     }
 
+    removeConnection(guildId) {
+        this.players.get(guildId)?.destroy();
+    }
+
+
+    checkConnection(options) {
+
+        let { guildId, voiceChannel, textChannel, shardId } = options;
+        if (!guildId) throw new Error(`[Poru Connection] you have to Provide guildId`)
+        if (!voiceChannel) throw new Error(`[Poru Connection] you have to  Provide voiceChannel`)
+        if (!textChannel) throw new Error(`[Poru Connection] you have to  Provide texteChannel`);
+        //  if(shardId == null) throw new Error(`[Poru Connection] You must have to Provide shardId`);
+
+
+        if (typeof guildId !== "string") throw new Error(`[Poru Connection] guildId must be provided as a string`);
+        if (typeof voiceChannel !== "string") throw new Error(`[Poru Connection] voiceChannel must be provided as a string`);
+        if (typeof textChannel !== "string") throw new Error(`[Poru Connection] textChannel must be provided as a string`);
+        //   if(typeof shardId !=="number") throw new Error(`[Poru Connection] shardId must be provided as a number`);
+
+
+
+    }
+
+
+    #createPlayer(node, options) {
+
+        if (this.players.has(options.guildId)) return this.players.get(options.guildId);
+
+        const player = new Player(this, node, options);
+        this.players.set(options.guildId, player);
+        player.connect(options)
+        return player;
+    }
+
+
+
+
+
+
 
     setServersUpdate(data) {
         let guild = data.guild_id
@@ -115,7 +162,7 @@ class Poru extends EventEmitter {
         const player = this.players.get(guild);
         if (!player) return false;
 
-        player.connect({
+        player.updateSession({
             sessionId: state ? state.session_id : player.voiceUpdateState.sessionId,
             event: server,
         });
@@ -134,8 +181,7 @@ class Poru extends EventEmitter {
             if (!server) return false;
             const player = this.players.get(guild);
             if (!player) return false;
-
-            player.connect({
+            player.updateSession({
                 sessionId: state ? state.session_id : player.voiceUpdateState.sessionId,
                 event: server,
             });
@@ -161,61 +207,65 @@ class Poru extends EventEmitter {
 
 
 
-    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(query, source) {
 
+        const node = this.leastUsedNodes[0];
+        if (!node) throw new Error("No nodes are available.");
+        const regex = /^https?:\/\//;
 
+        if (regex.test(query)) {
+            return this.fetchURL(node, query, source)
+        } else {
+            return this.fetchTrack(node, query, source)
+        }
 
-    async resolve(track,source) {
+    }
 
-        const node = this.leastUsedNodes[0];
-        if (!node) throw new Error("No nodes are available.");
+    async fetchURL(node, track, source) {
 
-        if (this.spotify && this.spotify.check(track)) {
+        if (this.spotify.check(track)) {
             return await this.spotify.resolve(track);
-        }else if (this.apple && this.apple.check(track)) {
+        } else if (this.apple.check(track)) {
             return await this.apple.resolve(track);
-        }else if (this.deezer && this.deezer.check(track)) {
+        } else if (this.deezer.check(track)) {
             return await this.deezer.resolve(track);
+        } else {
+            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 fetchTrack(node, query, source) {
+        switch (source) {
+
+            case "spotify": {
+                return this.spotify.fetch(query)
+            }
+            case "applemusic": {
+                return this.apple.fetch(query)
+            }
+            case "deezer": {
+                return this.deezer.fetch(query);
+            }
+            default:
+                {
+                    let track = `${source || "ytsearch"}:${query}`;
+                    const result = await this.#fetch(node, "loadtracks", `identifier=${encodeURIComponent(track)}`);
+                    if (!result) throw new Error("[Poru Error] No tracks found.");
+                    return new Response(result);
+
+
+                }
 
-        const regex = /^https?:\/\//;
-        if (!regex.test(track)) {
-            // eslint-disable-next-line no-param-reassign
-            track = `${source || "ytsearch"}:${track}`;
         }
-        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];

package/src/config.js

@@ -1,5 +1,6 @@
 module.exports = {
     clientName: "Poru",
+    autoResume : true,
     version :"2.0",
     OPCodes: {
         CONFIGURE_RESUMING : 'configureResuming',

package/src/guild/Filter.js

@@ -5,7 +5,6 @@ class Filters {
         this.bassboost = options.bassboost || null;
         this.player = player;
         this.node = player.node
-        this.volume = player.volume ?? 1.0 ;
         this.equalizer = options.equalizer || [];
         this.karaoke = options.karaoke || null;
         this.timescale = options.timescale || null;
@@ -69,14 +68,14 @@ class Filters {
     }
 
     setFilters(options) {
-        this.player.filters = new Filters(options);
+        this.player.filters = new Filters(this.player,options);
         this.updateFilters();
         return this;
     }
 
     clearFilters() {
-        this.player.filters = new Filters();
-        this.node.send({
+        this.player.filters = new Filters(this.player);
+        this.player.node.send({
             op: "filters",
             guildId: this.player.guild
         });
@@ -131,7 +130,7 @@ class Filters {
         if (!this.player) return;
         this.bassboost = !!val;
         this.bassboost = val / 100;
-        this.player.setEqualizer(
+        this.setEqualizer(
           val
             ? Array(6)
                 .fill(0.22)
@@ -141,11 +140,10 @@ class Filters {
       }
 
     updateFilters(){
-        const { volume, equalizer, karaoke, timescale, tremolo, vibrato, rotation, distortion, channelMix, lowPass } = this;
+        const {equalizer, karaoke, timescale, tremolo, vibrato, rotation, distortion, channelMix, lowPass } = this;
         this.node.send({
             op:"filters",
-            guildId: this.player.guild,
-            volume,
+            guildId: this.player.guildId,
             equalizer,
             karaoke,
             timescale,

package/src/guild/PoruTrack.js

@@ -21,7 +21,7 @@ class PoruTrack {
     const query = [this.info.author, this.info.title].filter((x) => !!x).join(' - ');
 
 
-    const result = await manager.resolve(query);
+    const result = await manager.resolve(query,manager.options.defaultPlatform || "ytsearch");
     if (!result || !result.tracks.length) return;
 
     if (this.info.author) {

package/src/guild/Track.js

@@ -21,7 +21,7 @@ class Track {
     const query = [this.info.author, this.info.title].filter((x) => !!x).join(' - ');
 
 
-    const result = await manager.resolve(query);
+    const result = await manager.resolve(query,manager.options.defaultPlatform || "ytsearch");
     if (!result || !result.tracks.length) return;
 
     if (this.info.author) {

package/src/platform/AppleMusic.js

@@ -1,6 +1,4 @@
-const fetch = (...args) => import('node-fetch').then(({
-  default: fetch
-}) => fetch(...args));
+const {fetch} = require("undici")
 const PoruTrack = require("../guild/PoruTrack")
 let baseURL = /(?:https:\/\/music\.apple\.com\/)(?:.+)?(artist|album|music-video|playlist)\/([\w\-\.]+(\/)+[\w\-\.]+|[^&]+)\/([\w\-\.]+(\/)+[\w\-\.]+|[^&]+)/;
 
@@ -8,12 +6,12 @@ class AppleMusic {
   constructor(manager, options) {
     this.manager = manager;
     this.options = {
-      playlistLimit: options.apple.playlistLimit || null,
-      albumLimit: options.apple.albumLimit || null,
-      artistLimit: options.apple.artistLimit || null,
-      searchMarket: options.apple.searchMarket || "us",
-      imageHeight: options.apple.imageHeight || 500,
-      imageWeight: options.apple.imageWeight || 500,
+      playlistLimit: options.playlistLimit || null,
+      albumLimit: options.albumLimit || null,
+      artistLimit: options.artistLimit || null,
+      searchMarket: options.searchMarket || "us",
+      imageHeight: options.imageHeight || 500,
+      imageWeight: options.imageWeight || 500,
     }
     this.url = `https://amp-api.music.apple.com/v1/catalog/${this.options.searchMarket}`
     this.token = null;
@@ -109,14 +107,13 @@ class AppleMusic {
       let query = new URL(url).pathname.split('/');
       let id = query.pop();
       let playlist = await this.requestData(`/playlists/${id}`)
-      let name = playlist.data.attributes.name
+       let name = playlist.data[0].attributes.name
 
       const limitedTracks = this.options.playlistLimit
         ? playlist.data[0].relationships.tracks.data.slice(0, this.options.playlistLimit * 100)
         : playlist.data[0].relationships.tracks.data;
 
       let tracks = await Promise.all(limitedTracks.map(x => this.buildUnresolved(x)))
-
       return this.buildResponse('PLAYLIST_LOADED', tracks, name);
     } catch (e) {
       return this.buildResponse(
@@ -242,3 +239,8 @@ class AppleMusic {
 
 }
 module.exports = AppleMusic
+
+
+const apple = new AppleMusic("",{apple:{}})
+
+apple.resolve("https://music.apple.com/us/playlist/bollywood-hits/pl.d60caf02fcce4d7e9788fe01243b7c2c")

package/src/platform/Deezer.js

@@ -1,6 +1,5 @@
-const fetch = (...args) => import('node-fetch').then(({
-  default: fetch
-}) => fetch(...args));
+const {fetch} = require("undici")
+
 let REGEX = /^(?:https?:\/\/|)?(?:www\.)?deezer\.com\/(?:\w{2}\/)?(track|album|playlist|artist)\/(\d+)/
 
 const PoruTrack = require("../guild/PoruTrack")
@@ -12,9 +11,9 @@ class Deezer {
     this.manager = manager;
     this.baseURL = 'https://api.deezer.com';
     this.options = {
-      playlistLimit: options.deezer.playlistLimit || null,
-      albumLimit: options.deezer.albumLimit || null,
-      artistLimit: options.deezer.artistLimit || null
+      playlistLimit: options.playlistLimit || null,
+      albumLimit: options.albumLimit || null,
+      artistLimit: options.artistLimit || null
 
     }
   }
@@ -230,4 +229,4 @@ module.exports = Deezer;
 let deezer = new Deezer("", { deezer: { playlistLimit: 10 } })
 
 
-deezer.resolve("https://www.deezer.com/en/playlist/4404579662")
+deezer.resolve("https://www.deezer.com/en/playlist/4404579662")

package/src/platform/Spotify.js

@@ -1,6 +1,5 @@
-const fetch = (...args) => import('node-fetch').then(({
-  default: fetch
-}) => fetch(...args));
+const {fetch} = require("undici")
+
 let spotifyPattern =
 /^(?:https:\/\/open\.spotify\.com\/(?:user\/[A-Za-z0-9]+\/)?|spotify:)(album|playlist|track|artist)(?:[/:])([A-Za-z0-9]+).*$/;
 
@@ -11,21 +10,43 @@ class Spotify {
     this.manager = manager;
     this.baseURL = 'https://api.spotify.com/v1';
     this.options ={
-    clientID : manager.options.spotify.clientID,
-    clientSecret : manager.options.spotify.clientSecret,
-    playlistLimit : manager.options.spotify.playlistLimit,
-    albumLimit : manager.options.spotify.albumLimit,
-    artistLimit : manager.options.spotify.artistLimit,
-    searchMarket : manager.options.spotify.searchMarket
+   
+    playlistLimit : manager.options.playlistLimit,
+    albumLimit : manager.options.albumLimit,
+    artistLimit : manager.options.artistLimit,
+    searchMarket : manager.options.searchMarket
     }
     this.authorization = Buffer.from(`${this.options.clientID}:${this.options.clientSecret}`).toString('base64');
     this.interval = 0;
   }
 
   check(url) {
+
     return spotifyPattern.test(url);
   }
 
+
+  async requestToken() {
+    try{
+    const data = await fetch('https://open.spotify.com/get_access_token?reason=transport&productType=embed', {
+      headers: {
+        'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/97.0.4692.99 Safari/537.36'
+      }
+    })
+
+    const body = await data.json();
+    this.token = `Bearer ${body.accessToken}`;
+    this.interval =  body.accessTokenExpirationTimestampMs * 1000;
+
+  } catch (e) {
+    if (e.status === 400) {
+      throw new Error('Invalid Spotify client.');
+    }
+
+   }
+  }
+
+   /*
   async requestToken() {
     
     try {
@@ -47,7 +68,7 @@ class Spotify {
       }
     }
   }
-
+*/
   async renew() {
     if (Date.now() >= this.interval) {
       await this.requestToken();
@@ -65,7 +86,7 @@ class Spotify {
   }
 
   async resolve(url) {
-    if (!this.token) await this.requestToken();
+      if (!this.token) await this.requestToken();
     const [, type, id] = spotifyPattern.exec(url) ?? [];
 
     switch (type) {
@@ -81,7 +102,6 @@ class Spotify {
       case 'artist': {
         return this.fetchArtist(id);
       }
-
   
     }
   }

package/typings/index.d.ts

@@ -2,7 +2,6 @@ import { EventEmitter, WebSocket } from "ws";
 
 declare module'Poru' {
 
-    import { EventEmitter } from 'events';
 
     export class Poru extends EventEmitter {
         constructor(client: typeof EventEmitter| any,nodes:[],options:{})
@@ -108,7 +107,7 @@ export class Player extends EventEmitter {
 
         public  isPlaying:boolean;
 
-        public  isPause:boolean;
+        public  isPaused:boolean;
 
         public  trackRepeat:boolean;
 
@@ -157,4 +156,4 @@ export class Player extends EventEmitter {
 
         autoplay(toggle:Boolean)
 
-}
+}