poru 1.2.3 → 2.0.2

package/src/platform/Spotify.js

@@ -1,258 +1,252 @@
 const fetch = (...args) => import('node-fetch').then(({
-    default: fetch
+  default: fetch
 }) => fetch(...args));
-class Spotify {
-    constructor(manager) {
-        this.manager = manager;
-        this.baseURL = "https://api.spotify.com/v1"
-        this.spotifyPattern = /^(?:https:\/\/open\.spotify\.com\/(?:user\/[A-Za-z0-9]+\/)?|spotify:)(album|playlist|track|artist)(?:[/:])([A-Za-z0-9]+).*$/
-        this.clientID = manager.options.spotify.clientID;
-        this.clientSecret = manager.options.spotify.clientSecret
-        this.authorization = Buffer
-            .from(`${this.clientID}:${this.clientSecret}`)
-            .toString("base64");
-        this.interval = 0;
-    }
-
-    check(url) {
-        return this.spotifyPattern.test(url);
-    }
-
-    async requestToken() {
-        if (this.nextRequest) return;
-
-        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 body = await data.json();
-
-           this.token = `Bearer ${body.access_token}`;
-            this.interval = body.expires_in * 1000
-        } catch (e) {
-            if (e.status === 400) {
-                throw new Error("Invalid Spotify client.")
-            }
-        }
-    }
-
-    async renew() {
-        if (Date.now() >= this.interval) {
-            await this.requestToken();
-        }
-    }
-
-    async requestData(endpoint) {
-        await this.renew();
-
-        const req = await fetch(`${this.baseURL}${/^\//.test(endpoint) ? endpoint : `/${endpoint}`}`, {
-            headers: { Authorization: this.token }
-        })
-        const data = await req.json()
-        return data
-    }
-
-
-    async resolve(url) {
-        if (!this.token) await this.requestToken()
-        const [, type, id] = await this.spotifyPattern.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);
-                }
-
-            default: {
-                return this.manager.resolve(url)
-            }
-        }
-
-    }
-
-    async fetchPlaylist(id) {
-        try {
-            const playlist = await this.requestData(`/playlists/${id}`)
-            await this.fetchPlaylistTracks(playlist);
-            const unresolvedPlaylistTracks = playlist.tracks.items.map(x => this.buildUnresolved(x.track));
-
-
-            return this.buildResponse(
-                "PLAYLIST_LOADED",
-                (await Promise.all(unresolvedPlaylistTracks.map(x => x.then((a) => a.resolve())))).filter(Boolean),
-                playlist.name
-            );
-
-        } catch (e) {
-            return this.buildResponse(e.status === 404 ? "NO_MATCHES" : "LOAD_FAILED", [], undefined, e.body?.error.message ?? e.message);
-        }
-    }
-
-    async fetchAlbum(id) {
-        try{
-        const album = await this.requestData(`/albums/${id}`)
-
-        const unresolvedPlaylistTracks = album.tracks.map(x => this.buildUnresolved(x));
-        return this.buildResponse(
-            "PLAYLIST_LOADED",
-            (await Promise.all(unresolvedPlaylistTracks.map(x => x.then((a) => a.resolve())))).filter(Boolean),
-            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 fetchArtist(id) {
-        try{
-        const artist = await this.requestData(`/artists/${id}`)
-
-        const data = await this.requestData(`/artists/${id}/top-tracks?market=US`)
-        const unresolvedPlaylistTracks = data.tracks.map(x => this.buildUnresolved(x));
-
-        return this.buildResponse(
-            "PLAYLIST_LOADED",
-            (await Promise.all(unresolvedPlaylistTracks.map(x => x.then((a) => a.resolve())))).filter(Boolean),
-            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 fetchTrack(id) {
-        try{
-        const data = await this.requestData(`/tracks/${id}`)
-        const unresolvedTrack = this.buildUnresolved(data);
-
-        return this.buildResponse(
-            "TRACK_LOADED",
-            [await unresolvedTrack.then((a) => a.resolve())]
-        );
-        }catch(e){
-            return this.buildResponse(e.body?.error.message === "invalid id" ? "NO_MATCHES" : "LOAD_FAILED", [], undefined, e.body?.error.message ?? e.message);
-        }
-    }
-
-    async fetchByWords(query) {
-            try{
-        const data = await this.requestData(`/search/?q="${query}"&type=artist,album,track`)
-       
-        const unresolvedTrack = this.buildUnresolved(data.tracks.items[0]);
-
-        return this.buildResponse(
-            "TRACK_LOADED",
-            [await unresolvedTrack.then((a) => a.resolve())]
-        );
-            }catch(e){
-                return this.buildResponse(e.body?.error.message === "invalid id" ? "NO_MATCHES" : "LOAD_FAILED", [], undefined, e.body?.error.message ?? e.message);
-            }
-    }
-
-    async fetchPlaylistTracks(spotifyPlaylist) {
-        let nextPage = spotifyPlaylist.tracks.next;
-        let pageLoaded = 1;
-        while (nextPage) {
-            if (!nextPage) break;
-    const req = await fetch(nextPage, {
-                headers: { Authorization: this.token }
-        })
-        const body = await req.json() 
-            if (body.error) break;
-            spotifyPlaylist.tracks.items.push(...body.items);
-
-            nextPage = body.next;
-            pageLoaded++;
-        }
-    }
-
-
-
-    async buildUnresolved(track) {
-        if (!track) throw new ReferenceError("The Spotify track object was not provided");
-   //     if (!track.artists) throw new ReferenceError("The track artists array was not provided");
-        if (!track.name) throw new ReferenceError("The track name was not provided");
-        if (!Array.isArray(track.artists)) throw new TypeError(`The track artists must be an array, received type ${typeof track.artists}`);
-        if (typeof track.name !== "string") throw new TypeError(`The track name must be a string, received type ${typeof track.name}`);
-
-        const _this = this;
-        return {
-            track: "",
-            info: {
-                sourceName: 'spotify',
-                identifier: track.id,
-                isSeekable: true,
-                author: track.artists[0] ? track.artists[0].name : 'Unknown',
-                length: track.duration_ms,
-                isStream: false,
-                title: track.name,
-                uri: `https://open.spotify.com/track/${track.id}`,
-                image: track.album?.images[0]?.url,
-            },
-            resolve() {
-                return _this.buildTrack(this)
-            }
-        }
-
-
-
-    }
-
-    async fetchMetaData(track) {
-
-        const fetch = await this.manager.resolve(`${track.info.title} ${track.info.author}`)
-        return fetch.tracks[0];
-    }
-
-    async buildTrack(unresolvedTrack) {
-        const lavaTrack = await this.fetchMetaData(unresolvedTrack);
-        if(lavaTrack){
-        unresolvedTrack.track = lavaTrack.track;
-        unresolvedTrack.info.identifier = lavaTrack.info.identifier
-        return unresolvedTrack
-        }
-    }
-
-
-    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" } } : {});
-    }
+let spotifyPattern =
+/^(?:https:\/\/open\.spotify\.com\/(?:user\/[A-Za-z0-9]+\/)?|spotify:)(album|playlist|track|artist)(?:[/:])([A-Za-z0-9]+).*$/;
 
+const Track = require("../guild/Track")
 
+class Spotify {
+  constructor(manager) {
+    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
+    }
+    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://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();
+
+      this.token = `Bearer ${body.access_token}`;
+      this.interval = body.expires_in * 1000;
+    } catch (e) {
+      if (e.status === 400) {
+        throw new Error('Invalid Spotify client.');
+      }
+    }
+  }
+
+  async renew() {
+    if (Date.now() >= this.interval) {
+      await this.requestToken();
+    }
+  }
+
+  async requestData(endpoint) {
+    await this.renew();
+
+    const req = await fetch(`${this.baseURL}${/^\//.test(endpoint) ? endpoint : `/${endpoint}`}`, {
+      headers: { Authorization: this.token },
+    });
+    const data = await req.json();
+    return data;
+  }
+
+  async resolve(url) {
+    if (!this.token) await this.requestToken();
+    const [, type, id] = spotifyPattern.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(`/playlists/${id}`);
+      await this.fetchPlaylistTracks(playlist);
+
+      const limitedTracks = this.options.playlistLimit
+        ? playlist.tracks.items.slice(0, this.options.playlistLimit * 100)
+        : playlist.tracks.items;
+
+      const unresolvedPlaylistTracks = await Promise.all(limitedTracks.map(x => this.buildUnresolved(x.track)));
+
+      return this.buildResponse('PLAYLIST_LOADED', unresolvedPlaylistTracks, playlist.name);
+    } catch (e) {
+      return this.buildResponse(
+        e.status === 404 ? 'NO_MATCHES' : 'LOAD_FAILED',
+        [],
+        undefined,
+        e.body?.error.message ?? e.message,
+      );
+    }
+  }
+
+  async fetchAlbum(id) {
+    try {
+      const album = await this.requestData(`/albums/${id}`);
+
+      const limitedTracks = this.options.albumLimit ? album.tracks.items.slice(0, this.options.albumLimit * 100) : album.tracks.items;
+
+      const unresolvedPlaylistTracks = await Promise.all(limitedTracks.map(x => this.buildUnresolved(x)));
+      return this.buildResponse('PLAYLIST_LOADED', unresolvedPlaylistTracks, 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 fetchArtist(id) {
+    try {
+      const artist = await this.requestData(`/artists/${id}`);
+
+      const data = await this.requestData(`/artists/${id}/top-tracks?market=${this.searchMarket ?? 'US'}`);
+
+      const limitedTracks = this.options.artistLimit ? data.tracks.slice(0, this.options.artistLimit * 100) : data.tracks;
+
+      const unresolvedPlaylistTracks = await Promise.all(limitedTracks.map(x => this.buildUnresolved(x)));
+
+      return this.buildResponse('PLAYLIST_LOADED', unresolvedPlaylistTracks, 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 fetchTrack(id) {
+    try {
+      const data = await this.requestData(`/tracks/${id}`);
+      const unresolvedTrack = await this.buildUnresolved(data);
+      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 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'}`,
+      );
+
+      const unresolvedTrack = await this.buildUnresolved(data.tracks.items[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 fetchPlaylistTracks(spotifyPlaylist) {
+    let nextPage = spotifyPlaylist.tracks.next;
+    let pageLoaded = 1;
+    while (nextPage) {
+      if (!nextPage) break;
+      const req = await fetch(nextPage, {
+        headers: { Authorization: this.token },
+      });
+      const body = await req.json();
+      if (body.error) break;
+      spotifyPlaylist.tracks.items.push(...body.items);
+
+      nextPage = body.next;
+      pageLoaded++;
+    }
+  }
+
+  async buildUnresolved(track) {
+    if (!track) throw new ReferenceError('The Spotify track object was not provided');
+
+    return new Track({
+      track: '',
+      info: {
+        sourceName: 'spotify',
+        identifier: track.id,
+        isSeekable: true,
+        author: track.artists[0] ? track.artists[0].name : 'Unknown',
+        length: track.duration_ms,
+        isStream: false,
+        title: track.name,
+        uri: `https://open.spotify.com/track/${track.id}`,
+        image: track.album?.images[0]?.url,
+      },
+    });
+  }
+
+  async fetchMetaData(track) {
+    const fetch = await this.manager.resolve(`${track.info.title} ${track.info.author}`);
+    return fetch.tracks[0];
+  }
+
+  async buildTrack(unresolvedTrack) {
+    const lavaTrack = await this.fetchMetaData(unresolvedTrack);
+    if (lavaTrack) {
+      unresolvedTrack.track = lavaTrack.track;
+      unresolvedTrack.info.identifier = lavaTrack.info.identifier;
+      return unresolvedTrack;
+    }
+  }
+
+  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 = Spotify
+module.exports = Spotify;

package/typings/index.d.ts

@@ -1,8 +1,7 @@
-import { EventEmitter } from "ws";
+import { EventEmitter, WebSocket } from "ws";
 
 declare module'Poru' {
 
-    import { EventEmitter } from 'events';
 
     export class Poru extends EventEmitter {
         constructor(client: typeof EventEmitter| any,nodes:[],options:{})
@@ -56,48 +55,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 +103,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  isPaused:boolean;
 
-        public  trackRepeat:Boolean;
+        public  trackRepeat:boolean;
 
-        public  queueRepeat:Boolean;
+        public  queueRepeat:boolean;
 
         public  loop:Number;
 
@@ -127,9 +123,7 @@ export class Player extends EventEmitter {
 
         public  previousTrack:Object;
 
-        public  voiceUpdateState = any;
-
-
+        public  voiceUpdateState:any;
 
 
         play()
@@ -158,24 +152,8 @@ export class Player extends EventEmitter {
 
         disconnect()
 
-
         destroy()
 
         autoplay(toggle:Boolean)
 
-        
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-}
+}

package/src/config.json

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