poru 1.0.9 → 1.1.2

package/README.md

@@ -85,7 +85,7 @@ client.once("ready", () => {
   console.log(`Logged in as ${client.user.tag}`);
 });
 
-// THIS IS REQUIRED. Send raw events to Erela.js
+// 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

package/package.json

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

package/src/Node.js

@@ -2,7 +2,7 @@ const WebSocket = require("ws");
 const config = require("./config.json")
 
 class Node {
-    constructor(manager, options = { }) {
+    constructor(manager,options,node) {
 
         this.manager = manager
         this.name= options.name || null;
@@ -12,13 +12,13 @@ class Node {
         this.password = options.password ||"youshallnotpass"
         this.secure = options.secure || false;
         this.ws = null;
-        this.reconnectTime = 50000;
-        this.resumeKey = options.resumeKey || null;
-        this._resumeTimeout = options.resumeTimeout || 60;
+        this.reconnectTime = node.reconnectTime || 5000;
+        this.resumeKey = node.resumeKey || null;
+        this.resumeTimeout = node.resumeTimeout || 60;
         this.reconnectAttempt;
         this.reconnects = 0;
-        this.queue = [];
         this.isConnected = false;
+        this.destroyed = null;
         this.stats = {
             players: 0,
             playingPlayers: 0,
@@ -49,29 +49,36 @@ class Node {
    };
    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));
- }
+   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(){
+#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.queue =[];
-if (this.resumeKey) this.send({ op: "configureResuming", key: (this.resumeKey).toString(), timeout: this._resumeTimeout });
- this.manager.emit("nodeConnect", this);
+this.manager.emit("nodeConnect", this);
 this.isConnected = true;
+this.manager.emit('debug', this.name, `[Web Socket] Connection ready ${this.url}`);
+      
 }
 
-message(payload) {
-    // eslint-disable-next-line no-param-reassign
+#message(payload) {
     if (Array.isArray(payload)) payload = Buffer.concat(payload);
-    // eslint-disable-next-line no-param-reassign
     else if (payload instanceof ArrayBuffer) payload = Buffer.from(payload);
 
     const packet = JSON.parse(payload);
@@ -83,14 +90,13 @@ message(payload) {
     if (packet.guildId && player) player.emit(packet.op, packet);
 
     packet.node = this;
-    /**
-     * Fire up when raw packets / or sending raw data
-     */
+    this.manager.emit("debug",this.name,`[Web Socket] Lavalink Node Update : ${packet.op}  `)
     this.manager.emit("raw", packet);
 }
 
-    close(event) {
-    this.manager.emit("nodeClose", event, this);
+    #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){
         
      return this.reconnect();
@@ -98,13 +104,10 @@ message(payload) {
 }
 
 
-    error(event) {
+    #error(event) {
     if (!event) return "Unknown event";
 
-    /**
-     * Fire up when node return an error
-     * @event nodeError
-     */
+    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();
 }
@@ -118,6 +121,7 @@ destroy(){
     this.ws.removeAllListeners();
     this.ws = null;
     this.reconnect = 1;
+    this.destroyed = true;
     this.manager.nodes.delete(this.host)
     this.manager.emit("nodeDestroy", this);
 
@@ -143,6 +147,19 @@ send(payload) {
 
 
 
+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;
+}
+
+
  }
 
 

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(node, options, manager) {
+    constructor(manager,node, options) {
         super();
 
         this.manager = manager;
@@ -13,53 +13,40 @@ class Player extends EventEmitter {
 
         this.filters = new Filters(this, this.node)
 
-
         this.guild = options.guild.id || options.guild;
 
         this.voiceChannel = options.voiceChannel.id || options.voiceChannel;
 
         this.textChannel = options.textChannel || null;
 
-        this.state = { volume: 100, equalizer: [] };
-
         this.isConnectd = false;
 
+        this.isPlaying = false;
+
+        this.isPause = false;
+
         this.trackRepeat = false;
 
         this.queueRepeat = false;
 
         this.loop = 0;
 
-
-        this.playing = false;
-
-        this.timestamp = Date.now();
-
-        this.paused = false;
         this.position = 0;
 
-
+        this.volume = 100;
 
         this.currentTrack = {};
 
         this.previousTrack = {};
 
-
         this.voiceUpdateState = null;
 
 
 
         this.on("event", (data) => (this.lavalinkEvent(data).bind(this))());
-        this.on("event", (data) => this.manager.emit("debug", data))
         this.on("playerUpdate", (packet) => {
             this.isConnectd = packet.state.connected,
                 this.position = packet.state.position
-            this.state = {
-                volume: this.state.volume,
-                equalizer: this.state.equalizer,
-                ...packet.state,
-
-            };
             this.manager.emit("playerUpdate", this, packet);
         });
     }
@@ -82,11 +69,11 @@ class Player extends EventEmitter {
     }
 
 
-    async stop() {
+     stop() {
 
         this.position = 0;
         this.isConnectd = false
-        this.playing = false;
+        this.isPlaying = false;
         this.node.send({
             op: "stop",
             guildId: this.guild
@@ -102,8 +89,8 @@ class Player extends EventEmitter {
             guildId: this.guild,
             pause,
         });
-        this.playing = !pause;
-        this.paused = pause;
+        this.isPlaying = !pause;
+        this.isPause = pause;
 
         return this;
     }
@@ -121,7 +108,7 @@ class Player extends EventEmitter {
 
     async 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,
@@ -167,12 +154,14 @@ class Player extends EventEmitter {
     }
 
     async connect(data) {
-        this.voiceUpdateState = data;
-        this.node.send({
-            op: "voiceUpdate",
-            guildId: this.guild,
-            ...data,
-        });
+        if (data) {
+            this.voiceUpdateState = data;
+            this.node.send({
+                op: "voiceUpdate",
+                guildId: this.guild,
+                ...data,
+            });
+        }
         return this;
     }
 
@@ -197,7 +186,7 @@ class Player extends EventEmitter {
         if (this.voiceChannel === null) return null;
         this.pause(true);
         this.isConnectd = false;
-        this.manager.sendWS({
+        this.manager.sendData({
             op: 4,
             d: {
                 guild_id: this.guild,
@@ -250,7 +239,7 @@ class Player extends EventEmitter {
     lavalinkEvent(data) {
         const events = {
             TrackStartEvent() {
-                this.playing = true;
+                this.isPlaying = true;
                 this.paused = false;
                 this.manager.emit("trackStart", this, this.currentTrack, data);
             },
@@ -262,18 +251,20 @@ class Player extends EventEmitter {
                 if (this.currentTrack && this.loop === 1) {
 
                     this.queue.unshift(this.previousTrack)
+                    this.manager.emit("trackEnd", this, this.currentTrack, data)
                     return this.play();
                 } else if (this.currentTrack && this.loop === 2) {
 
                     this.queue.push(this.previousTrack)
+                    this.manager.emit("trackEnd", this, this.currentTrack, data)
+
                     return this.play();
                 }
 
                 if (this.queue.length === 0) {
                     return this.manager.emit("queueEnd", this, this.track, data);
-                    // this.destroy();
                 } else if (this.queue.length > 0) {
-
+                    this.manager.emit("trackEnd", this, this.currentTrack, data)
                     return this.play();
                 }
                 this.manager.emit("queueEnd", this, this.track, data);
@@ -293,7 +284,7 @@ class Player extends EventEmitter {
             },
             WebSocketClosedEvent() {
                 if ([4015, 4009].includes(data.code)) {
-                    this.manager.sendWS({
+                    this.manager.sendData({
                         op: 4,
                         d: {
                             guild_id: data.guildId,

package/src/Poru.js

@@ -1,33 +1,35 @@
 const { EventEmitter } = require("events");
 const fetch = (...args) => import('node-fetch').then(({
     default: fetch
-}) => fetch(...args));const Player = require("./Player");
+}) => fetch(...args));
+const Player = require("./Player");
 const Node = require("./Node");
 const Response = require("./guild/Response");
+const config = require("./config.json")
 
 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.player = options.player || Player;
         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.sendWS = null;
+        this.sendData = null;
     }
 
 
 
     //create a node and connect it with lavalink
-    createNode(options) {
-        const node = new Node(this, options);
+    addNode(options) {
+        const node = new Node(this, options,this.options);
         if (options.name) {
             this.nodes.set(options.name || options.host, node);
             node.connect();
@@ -38,83 +40,100 @@ class Poru extends EventEmitter {
         return node;
     }
 
-    deleteNode(identifier){
+    //remove node and destroy web socket connection
+    removeNode(identifier){
         const node = this.nodes.get(identifier);
         if (!node) return;
         node.destroy();
         this.nodes.delete(identifier)
       }
     //create  connection with discord voice channel
-    createConnection(data = {}, options = {}) {
+    createConnection(data = {}) {
         const player = this.players.get(data.guild.id || data.guild);
         if (player){
             return player;
         }
-        this.sendWS({
+        this.sendData({
             op: 4,
             d: {
                 guild_id: data.guild.id || data.guild,
                 channel_id: data.voiceChannel.id || data.voiceChannel,
-                self_mute: options.selfMute || false,
-                self_deaf: options.selfDeaf || true,
+                self_mute: data.selfMute || false,
+                self_deaf: data.selfDeaf || true,
             },
         });
-        return this.Player(data);
+        return this.#Player(data);
     }
 
 
 
     init(client) {
 
-        this.user =client.user.id;
-        this.sendWS = (data) => {
+        this.user = client.user.id;
+        this.sendData = (data) => {
             const guild = client.guilds.cache.get(data.d.guild_id);
             if (guild) guild.shard.send(data);
         }
-           // eslint-disable-next-line no-underscore-dangle
-        this._nodes.forEach((node) => this.createNode(node));
+        client.on("raw",async packet =>{
+            await this.#packetUpdate(packet);
+        })
+        this._nodes.forEach((node) => this.addNode(node));
         console.log(`Thanks for using Poru`)
     }
 
-    voiceServersUpdate(data) {
-        this.voiceServers.set(data.guild_id, data);
-        return this.connectionProcess(data.guild_id);
-    }
+    setServersUpdate(data) {
+            let guild = data.guild_id
+            this.voiceServers.set(guild, 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;
+         } 
 
-    voiceStateUpdate(data) {
+    setStateUpdate(data) {
         if (data.user_id !== this.user) return;
         if (data.channel_id) {
+            const guild = data.guild_id;
+     
             this.voiceStates.set(data.guild_id, data);
-            // eslint-disable-next-line consistent-return
-            return this.connectionProcess(data.guild_id);
+            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);
     }
 
-    packetUpdate(packet) {
+    #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.voiceServersUpdate(packet.d);
+                   this.setServersUpdate(packet.d);
         }
-
-        if (packet.t === "VOICE_STATE_UPDATE"){
-             this.voiceStateUpdate(packet.d);
+         if (packet.t === "VOICE_STATE_UPDATE"){
+             this.setStateUpdate(packet.d);
         }
     }
 
-    connectionProcess(guildId) {
-        const server = this.voiceServers.get(guildId);
-        const state = this.voiceStates.get(guildId);
-        if (!server) return false;
-        const player = this.players.get(guildId);
-        if (!player) return false;
-
-        player.connect({
-            sessionId: state ? state.session_id : player.voiceUpdateState.sessionId,
-            event: server,
-        });
-        return true;
-    }
 
 
     get leastUsedNodes() {
@@ -127,7 +146,7 @@ class Poru extends EventEmitter {
             });
     }
 
-    Player(data) {
+    #Player(data) {
         const guild = data.guild.id || data.guild;
         const Nodes = this.nodes.get(guild);
         if (Nodes) return Nodes;
@@ -137,25 +156,13 @@ class Poru extends EventEmitter {
         if (!node) throw new Error("[Poru Error] No nodes are avalible");
 
         // eslint-disable-next-line new-cap
-        const player = new this.player(node, data, this);
+        const player = new Player(this,node, data);
         this.players.set(guild, player);
-
+        player.connect()
         return player;
     }
 
-    async search(track, source) {
-        const node = this.leastUsedNodes[0];
-        if (!node) throw new Error("No nodes are available.");
-        const regex = /^https?:\/\//;
-        if (!regex.test(track)) {
-            // eslint-disable-next-line no-param-reassign
-            track = `${source || "yt"}search:${track}`;
-        }
-        const result = await this.request(node, "loadtracks", `identifier=${encodeURIComponent(track)}`);
-      //  this.emit("error", result);
-        if (!result) throw new Error("No tracks found.");
-        return new Response(result);
-    }
+
 
 
     async resolve(track, source) {
@@ -166,9 +173,9 @@ class Poru extends EventEmitter {
             // eslint-disable-next-line no-param-reassign
             track = `${source || "yt"}search:${track}`;
         }
-        const result = await this.request(node, "loadtracks", `identifier=${encodeURIComponent(track)}`);
-      //  this.emit("error", result);
-        if (!result) throw new Error("No tracks found.");
+        const result = await this.#fetch(node, "loadtracks", `identifier=${encodeURIComponent(track)}`);
+     
+        if (!result) throw new Error("[Poru Error] No tracks found.");
         return new Response(result);
     }
 
@@ -176,21 +183,21 @@ class Poru extends EventEmitter {
     async decodeTrack(track) {
         const node = this.leastUsedNodes[0];
         if (!node) throw new Error("No nodes are available.");
-        const result = await this.request(node, "decodetrack", `track=${track}`);
-        this.emit("error", result);
+        const result = await this.#fetch(node, "decodetrack", `track=${track}`);
         if (result.status === 500) return null;
         return result;
     }
 
-    request(node, endpoint, param) {
+    #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 request to the lavalink.\n  error: ${e}`);
+                throw new Error(`[Poru Error] Failed to fetch from the lavalink.\n  error: ${e}`);
             });
     }
 
@@ -199,4 +206,4 @@ class Poru extends EventEmitter {
     }
 }
 
-module.exports = Poru
+module.exports = Poru

package/src/guild/Queue.js

@@ -2,21 +2,11 @@ class Queue extends Array{
     constructor() {
         super(...arguments);
     }
-        get duration() {
-            return this.reduce((acc, val) => acc + val.info.length, 0);
-        }
-    
-        get totalSize() {
-            return this.length  + (this.current ? 1 : 0);
-        }
-    
+     
         get size() {
             return this.length 
         }
     
-        get empty() {
-            return this.length / 2 < 1;
-        }
     
         first() {
             return this ? this[0] : 0;
@@ -27,10 +17,7 @@ class Queue extends Array{
             return this;
            }
     
-        removeFirst() {
-            return this.shift();
-        }
-    
+      
         remove(index) {
             return this.splice(index, 1)[0];
         }
@@ -47,4 +34,4 @@ class Queue extends Array{
         }
     }
 
-module.exports = Queue;
+module.exports = Queue;

package/src/guild/Track.js

@@ -1,15 +1,20 @@
 class Track {
     constructor(data) {
-      this.uri = data.info.uri;
-      this.title = data.info.title;
-      this.author = data.info.author;
-      this.duration = data.info.length;
-      this.identifier = data.info.identifier;
-      this.isStream = data.info.isStream;
-      this.isSeekable = data.info.isSeekable;
-      this.track = data.track;
-      this.thumbnail = `https://i.ytimg.com/vi/${data.info.identifier}/maxresdefault.jpg` || null;
-    }
+      this.track = data.track
+      this.info = {
+        identifier : data.info.identifier,
+        isSeekable : data.info.isSeekable,
+        author : data.info.author,
+        length : data.info.length,
+        isStream : data.info.isStream,
+        position : data.info.position,
+        sourceName:data.info.sourceName,
+        title : data.info.title,
+        uri : data.info.uri,
+        image : `https://i.ytimg.com/vi/${data.info.identifier}/maxresdefault.jpg` || null
+    
+      }
+      }
 }
 
-module.exports = Track;
+module.exports = Track;

package/typings/index.d.ts

@@ -0,0 +1,179 @@
+declare module'Poru' {
+
+    import { EventEmitter } from 'events';
+
+    export class Poru extends EventEmitter {
+        constructor(client: typeof EventEmitter| any,nodes:[],options:{})
+
+        public  client :typeof EventEmitter | any
+        public  nodes :typeof Map
+        public  players :typeof Map 
+        public  voiceStates :typeof Map
+        public  voiceServers :typeof Map 
+        public  user : String
+        public  options: Object | any
+        public  shards :Number
+        public  sendData : Function
+      
+
+    
+
+    public  on(event: 'nodeConnect' | 'nodeReconnect', listener: (node: Object) => void): this
+    public  on(event: 'nodeDisconnect', listener: (event: any, node: Object) => void): this
+    public  on(event: 'nodeError', listener: (node: Object, event: any) => void): this
+    public  on(event: 'queueEnd', listener: (player:typeof EventEmitter |any,track:Object,data:Object|any ) => void): this
+    public  on(event: 'trackStart' | 'trackEnd', listener: (player:typeof EventEmitter |any,track:Object,data:Object|any) => void): this
+    public  on(event: 'trackEnd' | 'trackEnd', listener: (player:typeof EventEmitter |any,track:Object,data:Object|any) => void): this
+    public  on(event: 'trackStuck' | 'trackError', listener: (player:typeof EventEmitter |any,track:Object,data:Object|any) => void): this
+    public  on(event: 'socketClosed', listener: (player:typeof EventEmitter |any,data:Object|any) => void): this
+
+
+
+    addNode(options:Object)
+
+    removeNode(identifier:String)
+
+    createConnection(data:Object)
+
+    init(client:typeof EventEmitter|any)
+
+    leastUsedNodes()
+
+    resolve(track:String, source:String)
+    
+    decodeTrack(tarck:String)
+
+    get(guildID:String)
+
+  }
+
+}
+
+
+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 stats:Object
+
+
+        connect():void
+
+        destroy()
+
+        reconnect()
+
+        send(playload:any)
+
+        get penalties():Number
+
+
+
+}
+
+
+export class Player extends EventEmitter {
+        constructor(manager:EventEmitter,node:Map|Object, options:Object)
+
+
+        
+        public  manager:EventEmitter
+
+        public  queue:Array |any
+
+        public  node: Map|Object|Any;
+
+        public  filters: any
+
+        public  guild:String
+
+        public  voiceChannel:any
+
+        public  textChannel:any;
+
+        public  isConnectd = Boolean;
+
+        public  isPlaying:Boolean;
+
+        public  isPause:Boolean;
+
+        public  trackRepeat:Boolean;
+
+        public  queueRepeat:Boolean;
+
+        public  loop:Number;
+
+        public  position :Number;
+
+        public  volume :Number;
+
+        public  currentTrack:Object
+
+        public  previousTrack:Object;
+
+        public  voiceUpdateState = any;
+
+
+
+
+        play()
+        
+        stop()
+
+        pause(pause:Boolean)
+
+        seekTo(position:Number)
+
+        setVolume(volume:Number)
+
+        TrackRepeat();
+
+        QueueRepeat();
+
+        DisableRepeat();
+
+        setTextChannel(channel:any)
+
+        setVoiceChannel(channel:any)
+
+        connect(data:any)
+
+        reconnect()
+
+        disconnect()
+
+
+        destroy()
+
+        autoplay(toggle:Boolean)
+
+        
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}

package/.gitpod.yml

@@ -1,8 +0,0 @@
-# This configuration file was automatically generated by Gitpod.
-# Please adjust to your needs (see https://www.gitpod.io/docs/config-gitpod-file)
-# and commit this file to your remote git repository to share the goodness with others.
-
-tasks:
-  - init: npm install
-
-