poru 1.2.3 → 2.0.2

package/src/config.js

@@ -0,0 +1,20 @@
+module.exports = {
+    clientName: "Poru",
+    autoResume : true,
+    version :"2.0",
+    OPCodes: {
+        CONFIGURE_RESUMING : 'configureResuming',
+        DESTROY : 'destroy',
+        FILTERS : 'filters',
+        EVENT : 'event',
+        PAUSE : 'pause',
+        PLAY : 'play',
+        PLAYER_UPDATE : 'playerUpdate',
+        SEEK : 'seek',
+        STATS : 'stats',
+        STOP : 'stop',
+        VOICE_UPDATE : 'voiceUpdate',
+        VOLUME : 'volume'
+      
+     }
+}

package/src/guild/Filter.js

@@ -29,8 +29,8 @@ class Filters {
         return this;
     }
     setTimescale(timescale) {
-        this.updateFilters();
         this.timescale = timescale || null;
+        this.updateFilters();
         return this;
     }
     setTremolo(tremolo) {
@@ -90,7 +90,7 @@ class Filters {
           this.doubleTime = false;
           this.vaporwave = false;
         }
-        return this
+        return val;
       }
 
       setSlowmode(val) {
@@ -141,7 +141,6 @@ class Filters {
       }
 
     updateFilters(){
-        console.log(this.node.send)
         const { volume, equalizer, karaoke, timescale, tremolo, vibrato, rotation, distortion, channelMix, lowPass } = this;
         this.node.send({
             op:"filters",
@@ -165,4 +164,4 @@ class Filters {
 
 
 
-module.exports = Filters;
+module.exports = Filters;

package/src/guild/PoruTrack.js

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

package/src/guild/Track.js

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

package/src/platform/AppleMusic.js

@@ -0,0 +1,248 @@
+const fetch = (...args) => import('node-fetch').then(({
+  default: fetch
+}) => fetch(...args));
+const PoruTrack = require("../guild/PoruTrack")
+let baseURL = /(?:https:\/\/music\.apple\.com\/)(?:.+)?(artist|album|music-video|playlist)\/([\w\-\.]+(\/)+[\w\-\.]+|[^&]+)\/([\w\-\.]+(\/)+[\w\-\.]+|[^&]+)/;
+
+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,
+    }
+    this.url = `https://amp-api.music.apple.com/v1/catalog/${this.options.searchMarket}`
+    this.token = null;
+
+  }
+
+  check(url) {
+    return baseURL.test(url);
+  }
+
+
+  async requestToken() {
+    try {
+
+      let req = await fetch('https://music.apple.com/us/browse');
+      let json = await req.text();
+      let config = /<meta name="desktop-music-app\/config\/environment" content="(.*?)">/.exec(json);
+
+      let key = config = JSON.parse(decodeURIComponent(config[1]));
+      let { token } = key?.MEDIA_API
+
+      if (!token) throw new Error("No acess key found for apple music")
+
+      this.token = `Bearer ${token}`;
+    } catch (e) {
+      if (e.status === 400) {
+        throw new Error(`[Poru Apple Music]:${e}`);
+      }
+    }
+  }
+
+
+  async requestData(param) {
+    if (!this.token) await this.requestToken();
+
+    let req = await fetch(`${this.url}${param}`, {
+      headers: {
+        Authorization: `${this.token}`,
+        origin: 'https://music.apple.com'
+      }
+    })
+
+    let body = await req.json();
+
+    return body;
+  }
+
+
+
+
+
+  async resolve(url) {
+    let [, type, id] = await baseURL.exec(url)
+
+    switch (type) {
+      case "playlist": {
+        return this.fetchPlaylist(url);
+      }
+      case "album": {
+        return this.fetchAlbum(url);
+      }
+      case "artist": {
+        return this.fetchArtist(url);
+      }
+    }
+  }
+
+  async fetch(query) {
+    if (this.check(query)) return this.resolve(query);
+
+    try {
+
+      let tracks = await this.requestData(`/search?types=songs&term=${query}`)
+
+      let track = await this.buildUnresolved(tracks.results.songs.data[0])
+
+      return this.buildResponse('TRACK_LOADED', [track]);
+
+    } catch (e) {
+      return this.buildResponse(
+        'LOAD_FAILED',
+        [],
+        undefined,
+        e.body?.error.message ?? e.message,
+      );
+
+    }
+
+  }
+
+  async fetchPlaylist(url) {
+    try {
+      let query = new URL(url).pathname.split('/');
+      let id = query.pop();
+      let playlist = await this.requestData(`/playlists/${id}`)
+       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(
+        'LOAD_FAILED',
+        [],
+        undefined,
+        e.body?.error.message ?? e.message,
+      );
+    }
+  }
+
+
+
+  async fetchAlbum(url) {
+
+    try {
+      let query = new URL(url).pathname.split('/');
+      let id = query.pop();
+      let album = await this.requestData(`/albums/${id}`)
+
+
+      const limitedTracks = this.options.albumLimit
+        ? album.data[0].relationships.tracks.data.slice(0, this.options.albumLimit * 100)
+        : album.data[0].relationships.tracks.data;
+
+
+      let name = album.data[0].attributes.name
+      let tracks = await Promise.all(limitedTracks.map(x => this.buildUnresolved(x)));
+      return this.buildResponse('PLAYLIST_LOADED', tracks, name);
+    } catch (e) {
+      return this.buildResponse(
+        'LOAD_FAILED',
+        [],
+        undefined,
+        e.body?.error.message ?? e.message,
+      );
+
+    }
+  }
+
+  async fetchArtist(url) {
+
+    try {
+      let query = new URL(url).pathname.split('/');
+      let id = query.pop();
+      let artist = await this.requestData(`/attists/${id}`)
+      let name = artistdata[0].attributes.name
+
+      const limitedTracks = this.options.artistLimit
+        ? artist.data[0].relationships.tracks.data.slice(0, this.options.artist * 100)
+        : artist.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(
+        'LOAD_FAILED',
+        [],
+        undefined,
+        e.body?.error.message ?? e.message,
+      );
+
+    }
+  }
+
+
+
+
+
+
+
+  async buildUnresolved(track) {
+    if (!track) throw new ReferenceError('The Apple track object was not provided');
+
+    return new PoruTrack({
+      track: '',
+      info: {
+        sourceName: 'Apple Music',
+        identifier: track.id,
+        isSeekable: true,
+        author: track.attributes.artistName ? track.attributes.artistName : 'Unknown',
+        length: track.attributes.durationInMillis,
+        isStream: false,
+        title: track.attributes.name,
+        uri: track.attributes.url,
+        image: track.attributes.artwork.url.replace("{w}", this.options.imageWeight).replace("{h}", this.options.imageHeight)
+      },
+    });
+  }
+
+  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 = AppleMusic
+
+
+const apple = new AppleMusic("",{apple:{}})
+
+apple.resolve("https://music.apple.com/us/playlist/bollywood-hits/pl.d60caf02fcce4d7e9788fe01243b7c2c")

package/src/platform/Deezer.js

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