poru 3.2.0 → 3.3.2

package/README.md

@@ -38,10 +38,12 @@ yarn add poru
 To use you need a configured [Lavalink](https://github.com/Frederikam/Lavalink) instance.
 
 - Stable client
+- support typescript
 - 100% Compatible with Lavalink
 - Object-oriented
 - 100% Customizable
 - Easy to setup
+- Inbuilt Queue System
 - Inbuilt support for spotify,apple music and deezer
 ## Implementation
 

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "poru",
-  "version": "3.2.0",
+  "version": "3.3.2",
   "description": "A stable and powerfull lavalink client around node.js",
   "main": "index.js",
+  "typings": "./typings/index.d.ts",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
@@ -34,5 +35,8 @@
     "deezer",
     "discordjs",
     "eris"
-  ]
+  ],
+  "devDependencies": {
+    "@types/node": "^18.7.18"
+  }
 }

package/src/Node.js

@@ -12,7 +12,7 @@ class Node {
     this.url = `${this.secure ? "wss" : "ws"}://${this.host}:${this.port}/`;
     this.ws = null;
     this.reconnectTimeout = node.reconnectTimeout || 5000;
-    this.reconnectTries = node.reconnectTries|| 5;
+    this.reconnectTries = node.reconnectTries || 5;
     this.reconnectAttempt = null;
     this.attempt = 0;
     this.resumeKey = node.resumeKey || null;
@@ -63,7 +63,6 @@ class Node {
     this.isConnected = false;
   }
 
-
   destroy() {
     if (!this.isConnected) return;
 
@@ -80,11 +79,11 @@ class Node {
 
   reconnect() {
     this.reconnectAttempt = setTimeout(() => {
-
-      if(this.attempt > this.reconnectTries){
-
-        throw new Error(`[Poru Websocket] Unable to connect with ${this.name} node after ${this.reconnectTries} tries`)
-A
+      if (this.attempt > this.reconnectTries) {
+        throw new Error(
+          `[Poru Websocket] Unable to connect with ${this.name} node after ${this.reconnectTries} tries`
+        );
+        A;
       }
       this.isConnected = false;
       this.ws.removeAllListeners();
@@ -92,7 +91,6 @@ A
       this.manager.emit("nodeReconnect", this);
       this.connect();
       this.attempt++;
-      
     }, this.reconnectTimeout);
   }
 
@@ -119,7 +117,6 @@ A
     return penalties;
   }
 
-
   #open() {
     if (this.reconnectAttempt) {
       clearTimeout(this.reconnectAttempt);
@@ -156,8 +153,6 @@ A
     }
   }
 
-  
-
   #message(payload) {
     const packet = JSON.parse(payload);
     if (!packet.op) return;
@@ -173,10 +168,9 @@ A
       this.name,
       `[Web Socket] Lavalink Node Update : ${packet.op}  `
     );
-   }
+  }
 
   #close(event) {
-
     this.disconnect();
     this.manager.emit("nodeDisconnect", this, event);
     this.manager.emit(
@@ -190,18 +184,17 @@ A
   }
 
   #error(event) {
-     if (!event) return "Unknown event";
+    if (!event) return "Unknown event";
 
     this.manager.emit(
       "debug",
       this.name,
-      `[Web Socket] Connection for Lavalink node has error code: ${event.code||event}`
+      `[Web Socket] Connection for Lavalink node has error code: ${
+        event.code || event
+      }`
     );
     this.manager.emit("nodeError", this, event);
   }
-
-  
 }
 
-
 module.exports = Node;

package/src/Player.js

@@ -33,6 +33,8 @@ class Player extends EventEmitter {
 
     this.volume = 100;
 
+    this.ping = 0;
+
     this.currentTrack = null;
 
     this.previousTrack = null;
@@ -42,9 +44,9 @@ class Player extends EventEmitter {
     this.on("event", (data) => this.lavalinkEvent(data).bind(this)());
     this.on("playerUpdate", (packet) => {
       (this.isConnected = packet.state.connected),
-        (this.position = packet.state.position);
+        (this.position = packet.state.position),
+        (this.ping = packet.state.ping);
       this.manager.emit("playerUpdate", this, packet);
-
     });
 
     this.manager.emit("playerCreate", this);
@@ -53,7 +55,6 @@ class Player extends EventEmitter {
       this.guildId,
       `[Poru Player] SuccessFully player created`
     );
-
   }
 
   async play(options = {}) {
@@ -82,7 +83,6 @@ class Player extends EventEmitter {
       `[Poru Player] Track :\n ${this.currentTrack.info.title} is started to playing`
     );
 
-
     return this;
   }
 
@@ -136,37 +136,34 @@ class Player extends EventEmitter {
     return this;
   }
 
+  setLoop(mode) {
+    if (!mode)
+      throw new Error(
+        `[Poru Player] You must have to provide loop mode as argument of setLoop`
+      );
 
-setLoop(mode){
-
-if(!mode) throw new Error(`[Poru Player] You must have to provide loop mode as argument of setLoop`)
+    if (!["NONE", "TRACK", "QUEUE"].includes(mode))
+      throw new Error(
+        `[Poru Player] setLoop arguments are NONE,TRACK AND QUEUE`
+      );
 
-if(!['NONE','TRACK','QUEUE'].includes(mode)) throw new Error(`[Poru Player] setLoop arguments are NONE,TRACK AND QUEUE`)
+    switch (mode) {
+      case "NONE": {
+        this.loop = "NONE";
+        break;
+      }
+      case "TRACK": {
+        this.loop = "TRACK";
+        break;
+      }
+      case "QUEUE": {
+        this.loop = "QUEUE";
+        break;
+      }
+    }
 
-switch(mode){
-  case "NONE":
-  {
-    this.loop = "NONE";
-    break;
-  }
-  case "TRACK":
-  {
-    this.loop = "TRACK";
-    break;
-  }
-  case "QUEUE":
-  {
-    this.loop ="QUEUE";
-    break;
+    return this;
   }
- }
-
- return this;
-}
-
-
-
-
 
   setTextChannel(channel) {
     if (typeof channel !== "string")
@@ -176,16 +173,14 @@ switch(mode){
   }
 
   setVoiceChannel(channel) {
-
     if (typeof channel !== "string")
       throw new RangeError("Channel must be a string.");
-      
+
     this.voiceChannel = channel;
     return this;
   }
 
   connect(options = this) {
-
     let { guildId, voiceChannel, deaf, mute } = options;
     this.send(
       {
@@ -196,14 +191,13 @@ switch(mode){
       },
       true
     );
-    
+
     this.isConnected = true;
     this.manager.emit(
       "debug",
       this.guildID,
       `[Poru Player] Player has been connected`
     );
-
   }
 
   updateSession(data) {
@@ -261,7 +255,6 @@ switch(mode){
     this.manager.players.delete(this.guildId);
   }
 
-
   restart() {
     this.filters.updateFilters();
     if (this.currentTrack) {

package/src/Poru.js

@@ -40,7 +40,7 @@ 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);
     });
@@ -99,16 +99,14 @@ class Poru extends EventEmitter {
     return node;
   }
 
-
   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`);
+      throw new Error(`[Poru Connection] you have to  Provide textChannel`);
     //  if(shardId == null) throw new Error(`[Poru Connection] You must have to Provide shardId`);
 
     if (typeof guildId !== "string")
@@ -124,10 +122,7 @@ class Poru extends EventEmitter {
     //   if(typeof shardId !=="number") throw new Error(`[Poru Connection] shardId must be provided as a number`);
   }
 
-
-
   createConnection(options) {
-
     this.checkConnection(options);
     const player = this.players.get(options.guildId);
     if (player) return player;
@@ -146,9 +141,6 @@ class Poru extends EventEmitter {
     this.players.get(guildId)?.destroy();
   }
 
-
-
-
   #createPlayer(node, options) {
     if (this.players.has(options.guildId))
       return this.players.get(options.guildId);
@@ -159,7 +151,6 @@ class Poru extends EventEmitter {
     return player;
   }
 
-  
   setServersUpdate(data) {
     let guild = data.guild_id;
     this.voiceServers.set(guild, data);
@@ -200,7 +191,8 @@ class Poru extends EventEmitter {
   }
 
   packetUpdate(packet) {
-    if (!["VOICE_STATE_UPDATE", "VOICE_SERVER_UPDATE"].includes(packet.t)) return;
+    if (!["VOICE_STATE_UPDATE", "VOICE_SERVER_UPDATE"].includes(packet.t))
+      return;
     const player = this.players.get(packet.d.guild_id);
     if (!player) return;
 
@@ -212,21 +204,19 @@ class Poru extends EventEmitter {
     }
   }
 
-  
-
   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);
+      return this.fetchURL(node, query);
     } else {
       return this.fetchTrack(node, query, source);
     }
   }
 
-  async fetchURL(node, track, source) {
+  async fetchURL(node, track) {
     if (this.spotify.check(track)) {
       return await this.spotify.resolve(track);
     } else if (this.apple.check(track)) {
@@ -278,7 +268,8 @@ class Poru extends EventEmitter {
 
   #fetch(node, endpoint, param) {
     return fetch(
-      `http${node.secure ? "s" : ""}://${node.host}:${node.port
+      `http${node.secure ? "s" : ""}://${node.host}:${
+        node.port
       }/${endpoint}?${param}`,
       {
         headers: {

package/src/guild/Track.js

@@ -11,9 +11,7 @@ class Track {
       sourceName: data.info.sourceName,
       title: data.info.title,
       uri: data.info.uri,
-      image:
-        `https://i.ytimg.com/vi/${data.info.identifier}/maxresdefault.jpg` ||
-        null,
+      image: `https://i.ytimg.com/vi/${data.info.identifier}/1.jpg` || null,
     };
   }
 
@@ -41,7 +39,7 @@ class Track {
       );
       if (officialAudio) {
         this.info.identifier = officialAudio.info.identifier;
-        this.image = `https://i.ytimg.com/vi/${this.info.identifier}/maxresdefault.jpg`;
+        this.image = `https://i.ytimg.com/vi/${this.info.identifier}/1.jpg`;
         this.track = officialAudio.track;
         return this;
       }
@@ -54,13 +52,13 @@ class Track {
       );
       if (sameDuration) {
         this.info.identifier = sameDuration.info.identifier;
-        this.image = `https://i.ytimg.com/vi/${this.info.identifier}/maxresdefault.jpg`;
+        this.image = `https://i.ytimg.com/vi/${this.info.identifier}/1.jpg`;
         this.track = sameDuration.track;
         return this;
       }
     }
     this.info.identifier = result.tracks[0].info.identifier;
-    this.image = `https://i.ytimg.com/vi/${this.info.identifier}/maxresdefault.jpg`;
+    this.image = `https://i.ytimg.com/vi/${this.info.identifier}/1.jpg`;
     this.track = result.tracks[0].track;
     return this;
   }

package/src/platform/Spotify.js

@@ -15,7 +15,7 @@ class Spotify {
       artistLimit: manager.options.artistLimit,
       searchMarket: manager.options.searchMarket,
       clientID: manager.options.clientID || null,
-      clientSecret: manager.options.clientSecret || null
+      clientSecret: manager.options.clientSecret || null,
     };
 
     this.authorization = Buffer.from(
@@ -50,19 +50,21 @@ class Spotify {
     }
   }
 
-
   async requestToken() {
-
-    if (!this.options.clientID && !this.options.clientSecret) return this.requestAnonymousToken()
+    if (!this.options.clientID && !this.options.clientSecret)
+      return this.requestAnonymousToken();
 
     try {
-      const data = await fetch('https://accounts.spotify.com/api/token?grant_type=client_credentials', {
-        method: 'POST',
-        headers: {
-          Authorization: `Basic ${this.authorization}`,
-          'Content-Type': 'application/x-www-form-urlencoded',
-        },
-      });
+      const data = await fetch(
+        "https://accounts.spotify.com/api/token?grant_type=client_credentials",
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Basic ${this.authorization}`,
+            "Content-Type": "application/x-www-form-urlencoded",
+          },
+        }
+      );
 
       const body = await data.json();
 
@@ -70,13 +72,11 @@ class Spotify {
       this.interval = body.expires_in * 1000;
     } catch (e) {
       if (e.status === 400) {
-        throw new Error('Invalid Spotify client.');
+        throw new Error("Invalid Spotify client.");
       }
     }
   }
 
-
-
   async renew() {
     if (Date.now() >= this.interval) {
       await this.requestToken();
@@ -217,13 +217,13 @@ class Spotify {
     }
   }
 
-  
   async fetch(query) {
     try {
       if (this.check(query)) return this.resolve(query);
 
       const data = await this.requestData(
-        `/search/?q="${query}"&type=artist,album,track&market=${this.options.searchMarket ?? "US"
+        `/search/?q="${query}"&type=artist,album,track&market=${
+          this.options.searchMarket ?? "US"
         }`
       );
 

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "target": "ESNext",
+    "sourceMap": true,
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "allowSyntheticDefaultImports": true,
+    "skipLibCheck": true,
+    "skipDefaultLibCheck": true,
+    "declaration": true,
+  }
+}

package/typings/index.d.ts

@@ -0,0 +1,323 @@
+import { EventEmitter } from "node:events";
+
+export interface PlaylistInfo {
+  name: string;
+  selectedTrack: number;
+}
+
+export interface ResolveResponse {
+  loadType:
+    | "TRACK_LOADED"
+    | "PLAYLIST_LOADED"
+    | "SEARCH_RESULT"
+    | "NO_MATCHES"
+    | "LOAD_FAILED";
+  tracks: Track[];
+  playlistInfo: PlaylistInfo;
+}
+
+export class Track {
+  constructor(data: string): this;
+  track: string;
+  info: {
+    identifier: string;
+    isSeekable: boolean;
+    author: string;
+    length: number;
+    isStream: boolean;
+    sourceName: string;
+    title: string;
+    uri: string;
+    requester?: object | string | null;
+    image: string | null;
+  };
+  resolve: (manager: Poru) => Promise<ResolveResponse>;
+}
+
+export class Queue extends Array<Track> {
+  constructor(...args: any[]): this;
+  get size(): number;
+  first: () => Track;
+  add: (track: Track) => Queue;
+  remove: (index: number) => Queue;
+  clear: () => Queue;
+  shuffle: () => void;
+}
+
+export interface FiltersOptions {
+  _8d?: boolean;
+  bassboost?: number;
+  equalizer?: {
+    band: number;
+    gain: number;
+  }[];
+  karaoke?: boolean;
+  timescale?: boolean;
+  tremolo?: boolean;
+  vibrato?: boolean;
+  rotation?: boolean;
+  distortion?: boolean;
+  channelMix?: boolean;
+  lowPass?: boolean;
+}
+
+export class Filters {
+  constructor(player: Player, options: FiltersOptions): this;
+  _8d: boolean | null;
+  bassboost: number | null;
+  player: Player;
+  node: Node;
+  equalizer: { bands: number; gain: number }[] | null;
+  karaoke: boolean | null;
+  timescale: boolean | null;
+  tremolo: boolean | null;
+  vibrato: boolean | null;
+  rotation: boolean | null;
+  distortion: boolean | null;
+  channelMix: boolean | null;
+  lowPass: boolean | null;
+
+  setEqualizer: (bands: number, gain: number) => void;
+  setKaraoke: (value: boolean) => Filters;
+  setTimescale: (value: boolean) => Filters;
+  setTremolo: (value: boolean) => Filters;
+  setVibrato: (value: boolean) => Filters;
+  setRotation: (value: boolean) => Filters;
+  setDistortion: (value: boolean) => Filters;
+  setChannelMix: (value: boolean) => Filters;
+  setLowPass: (value: boolean) => Filters;
+  setFilters: (options: any) => Filters;
+  clearFilters: () => Filters;
+  setNightcore: (value: boolean) => boolean;
+  setSlowmode: (value: boolean) => void;
+  setVaporwave: (value: boolean) => void;
+  set8D: (value: boolean) => void;
+  setBassboost: (value: number) => void;
+  updateFilters: () => void;
+}
+
+export interface NodeStats {
+  players: number;
+  playingPlayers: number;
+  uptime: number;
+  memory: {
+    free: number;
+    used: number;
+    allocated: number;
+    reservable: number;
+  };
+  cpu: {
+    cores: number;
+    systemLoad: number;
+    lavalinkLoad: number;
+  };
+}
+
+export interface NodeOptions {
+  name?: string;
+  host?: string;
+  port?: number;
+  password?: string;
+  secure?: boolean;
+}
+
+export interface PoruOptions {
+  reconnectTimeout?: number;
+  reconnectTries?: number;
+  resumeKey?: string;
+  resumeTimeout?: number;
+  defaultPlatform?: string;
+  playlistLimit?: number;
+  albumLimit?: number;
+  artistLimit?: number;
+  searchMarket?: string;
+}
+
+export class Node implements INode {
+  constructor(manager: Poru, options: NodeOptions, node: PoruOptions): this;
+  name: string | null;
+  host: string;
+  port: number;
+  password: string;
+  secure: boolean;
+  manager: Poru;
+  url: string;
+  reconnectTimeout: number;
+  reconnectTries: number;
+  reconnectAttempt: boolean;
+  attempt: number;
+  resumeKey: string | null;
+  resumeTimeout: string;
+  reconnects: number;
+  isConnected: boolean;
+  destroyed: boolean | null;
+  stats: NodeStats;
+  connect: () => void;
+  disconnect: () => void;
+  destroy: () => void;
+  reconnect: () => void;
+  send: (payload: any) => void;
+  get penalties(): number;
+}
+
+interface PoruEvents {
+  nodeConnect: (node: Node) => void;
+  nodeClose: (node: Node) => void;
+  nodeError: (node: Node, event: any) => void;
+  trackStart: (player: Player, track: Track, payload: LavalinkEvents) => void;
+  playerUpdate: (
+    player: Player,
+    data: {
+      op: "playerUpdate";
+      guildId: string;
+      state: {
+        time: number;
+        position: number;
+        connected: boolean;
+        ping: number;
+      };
+    }
+  ) => void;
+  trackEnd: (player: Player, track: Track, payload: LavalinkEvents) => void;
+  trackError: (player: Player, track: Track, payload: LavalinkEvents) => void;
+  socketClosed: (
+    player: Player,
+    data: {
+      op: "event";
+      type: "WebSocketClosedEvent";
+      guildId: string;
+      code: number;
+      reason: string;
+      byRemote: boolean;
+    }
+  ) => void;
+  queueEnd: (player: Player, track: Track, payload: LavalinkEvents) => void;
+}
+
+export class Poru extends EventEmitter {
+  constructor(client: any, nodes: NodeOptions[], options?: PoruOptions): this;
+  on<U extends keyof PoruEvents>(event: U, listener: PoruEvents[U]): this;
+  emit<U extends keyof PoruEvents>(
+    event: U,
+    ...args: Parameters<PoruEvents[U]>
+  ): boolean;
+
+  client: any;
+  _nodes: Node[];
+  nodes: Map<string, Node>;
+  players: Map<string, Player>;
+  voiceStates: Map<string, any>;
+  voiceServers: Map<string, any>;
+  isReady: boolean;
+  user: string | null;
+  options: PoruOptions;
+  sendData: null;
+  version: string;
+  spotify: any;
+  apple: any;
+  deezer: any;
+  init: (client: any) => void;
+  addNode: (options: NodeOptions) => Node;
+  removeNode: (name: string) => void;
+  get leastUsedNodes(): Node[];
+  getNode: (name: "best" | string) => Node;
+  checkConnection: (options: {
+    guildId: string;
+    voiceChannel: string;
+    textChannel: string;
+  }) => void;
+  createConnection: (options: {
+    guildId: string;
+    voiceChannel: string;
+    textChannel?: string;
+    deaf?: boolean;
+    mute?: boolean;
+  }) => Player;
+  removeConnection: (guildId: string) => void;
+  setServersUpdate: (data: { guild_id: string }) => boolean;
+  setStateUpdate: (data: {
+    user_id?: string;
+    channel_id?: string;
+    guild_id: string;
+  }) => void;
+  packetUpdate: (packet: {
+    t: string;
+    d: {
+      guild_id: string;
+    };
+  }) => void;
+  resolve: (query: string, source?: string) => Promise<ResolveResponse>;
+  fetchURL: (node: Node, track: Track) => Promise<ResolveResponse>;
+  fetchTrack: (
+    node: Node,
+    query: string,
+    source?: string
+  ) => Promise<ResolveResponse>;
+  decodeTrack: (track: Track) => Promise<Track>;
+  get: (identifier: string) => Player;
+}
+
+export type PlayerLoopModes = "NONE" | "TRACK" | "QUEUE";
+export type LavalinkEvents =
+  | "TrackStartEvent"
+  | "TrackEndEvent"
+  | "TrackExceptionEvent"
+  | "TrackStuckEvent"
+  | "WebSocketClosedEvent";
+
+export interface PlayerOptions {
+  guildId: string;
+  voiceChannel:
+    | {
+        id: string;
+      }
+    | string;
+  textChannel?: string;
+  mute?: boolean;
+  deaf?: boolean;
+}
+
+export class Player extends EventEmitter {
+  constructor(manager: Poru, node: Node, options: PlayerOptions): this;
+  manager: Poru;
+  queue: Queue;
+  node: Node;
+  options: PlayerOptions;
+  filters: Filters;
+  guildId: string;
+  voiceChannel: string;
+  textChannel: string;
+  isConnected: boolean;
+  isPlaying: boolean;
+  isPaused: boolean;
+  loop: PlayerLoopModes;
+  position: number;
+  ping: number;
+  volume: number;
+  currentTrack: Track | null;
+  previousTracks: Track;
+  voiceUpdateState: any;
+
+  play: (options?: { noReplace?: boolean }) => Promise<Player>;
+  stop: () => Player;
+  pause: (pause: boolean) => Player;
+  seekTo: (position: number) => Promise<Player>;
+  setVolume: (volume: number) => Player;
+  setLoop: (mode: PlayerLoopModes) => Player;
+  setTextChannel: (channel: string) => Player;
+  setVoiceChannel: (channel: string) => Player;
+  connect: (options: {
+    guildId: string;
+    voiceChannel: string;
+    deaf: boolean;
+    mute: boolean;
+  }) => void;
+  updateSession: (data: any) => Player;
+  reconnect: () => Player;
+  disconnect: () => Player;
+  destroy: () => void;
+  restart: () => void;
+  autoplay: (option: boolean) => void;
+  send: (payload: any) => void;
+  lavalinkEvent: (data: LavalinkEvents) => void;
+}