vdj 1.1.6 → 1.4.0

package/dist/default_implementations/youtube/song.d.ts

@@ -17,5 +17,5 @@ export default class YouTubeSong extends Song {
     constructor(service: YouTubeService, video: Video, playlistID?: string, logger?: Logger, seek?: number);
     getSongInfo(): Promise<SongInfo>;
     static extractSeek(url: string): number;
-    stream(): ReadableStream;
+    stream(): ReadableStream | null;
 }

package/dist/default_implementations/youtube/song.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const ytdl = require("ytdl-core");
+const youtube_dl_exec_1 = require("youtube-dl-exec");
 const core_1 = require("../../core");
 class YouTubeSong extends core_1.Song {
     constructor(service, video, playlistID, logger, seek = 0) {
@@ -60,19 +60,14 @@ class YouTubeSong extends core_1.Song {
         return 0;
     }
     stream() {
-        const options = {};
-        if (this.live) {
-            options.quality = [128, 127, 120, 96, 95, 94, 93];
-        }
-        else {
-            options.filter = 'audioonly';
-            options.range = {
-                start: this.seek > 0 ? this.seek : 0
-            };
-        }
-        if (typeof (this.logger) == 'function')
-            this.logger(`[${this.type}] Fetching stream url for ${this.URL}.`);
-        return ytdl(this.trackID, options);
+        const stream = youtube_dl_exec_1.exec(this.streamURL, {
+            output: '-',
+            format: 'bestaudio[ext=webm+acodec=opus+tbr>100]/bestaudio[ext=webm+acodec=opus]/bestaudio/best',
+            limitRate: '1M',
+            rmCacheDir: true,
+            verbose: true,
+        }, { stdio: ['ignore', 'pipe', 'ignore'] });
+        return stream.stdout;
     }
 }
 exports.default = YouTubeSong;

package/dist/default_implementations/youtubedl/service.js

@@ -31,13 +31,13 @@ class YoutubedlService {
     }
     canFetch(target, logger) {
         return __awaiter(this, void 0, void 0, function* () {
-            var res = yield youtube_dl_exec_1.default(target, { j: true }, {});
+            var res = yield youtube_dl_exec_1.default(target, { dumpJson: true }, {});
             return !!res;
         });
     }
     getSongInfo(url, logger) {
         return __awaiter(this, void 0, void 0, function* () {
-            var res = yield youtube_dl_exec_1.default(url, { j: true, "no-check-certificate": true, "add-metadata": true }, {});
+            var res = yield youtube_dl_exec_1.default(url, { dumpJson: true, noCheckCertificate: true, addMetadata: true }, {});
             return {
                 full: true,
                 metadataType: "youtubedl",

package/dist/default_implementations/youtubedl/song.js

@@ -33,9 +33,14 @@ class YoutubedlSong extends core_1.Song {
         });
     }
     stream() {
-        if (typeof (this.logger) == 'function')
-            this.logger(`[${this.type}] Fetching stream for ${this.URL}.`);
-        return youtube_dl_exec_1.raw(this.streamURL, { _: ['-f', 'bestaudio/best[height<=?480]', '-o', '-'] }, {}).stdout;
+        const stream = youtube_dl_exec_1.exec(this.streamURL, {
+            output: '-',
+            format: 'bestaudio[ext=webm+acodec=opus+tbr>100]/bestaudio[ext=webm+acodec=opus]/bestaudio/best',
+            limitRate: '1M',
+            rmCacheDir: true,
+            verbose: true,
+        }, { stdio: ['ignore', 'pipe', 'ignore'] });
+        return stream.stdout;
     }
 }
 exports.default = YoutubedlSong;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vdj",
-  "version": "1.1.6",
+  "version": "1.4.0",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -19,7 +19,7 @@
     "@types/node": "^12.19.2",
     "got": "^11.8.0",
     "simple-youtube-api": "^5.2.1",
-    "youtube-dl-exec": "^1.2.13",
-    "ytdl-core": "^4.11.0"
+    "youtube-dl-exec": "^2.1.5",
+    "ytdl-core": "^4.11.2"
   }
 }

package/src/default_implementations/youtube/service.ts

@@ -19,13 +19,13 @@ export default class YouTubeService implements IService {
         for (const target of targets) {
             var parsed = API.util.parseURL(target);
             if (parsed.video) {
-                typeof(logger) == 'function' && logger(`[${this.type}] Fetching video from target ${target}.`);
+                typeof (logger) == 'function' && logger(`[${this.type}] Fetching video from target ${target}.`);
 
                 const video = await this.api.getVideoByID(parsed.video);
                 const seek = YouTubeSong.extractSeek(target);
                 if (video) fetched.push(new YouTubeSong(this, video, undefined, logger, seek));
             } else if (parsed.playlist) {
-                typeof(logger) == 'function' && logger(`[${this.type}] Fetching playlist from target ${target}.`);
+                typeof (logger) == 'function' && logger(`[${this.type}] Fetching playlist from target ${target}.`);
 
                 const playlist = await this.api.getPlaylistByID(parsed.playlist);
                 if (!playlist) continue;
@@ -43,8 +43,8 @@ export default class YouTubeService implements IService {
         if (!this.canSearch) return fetched;
         for (const query of queries) {
             if (searchType === 'playlist') {
-                typeof(logger) == 'function' && logger(`[${this.type}] Searching for a playlist with the input ${query}.`);
-                
+                typeof (logger) == 'function' && logger(`[${this.type}] Searching for a playlist with the input ${query}.`);
+
                 const results = await this.api.searchPlaylists(query, 1);
                 if (results.length) {
                     const list = results[0];
@@ -52,13 +52,13 @@ export default class YouTubeService implements IService {
                     fetched.push(...videos.map((v) => new YouTubeSong(this, v, list.id, logger)));
                 }
             } else {
-                typeof(logger) == 'function' && logger(`[${this.type}] Searching for a song with the input ${query}.`);
-                
+                typeof (logger) == 'function' && logger(`[${this.type}] Searching for a song with the input ${query}.`);
+
                 const results = await this.api.searchVideos(query, 1);
                 if (results.length) fetched.push(new YouTubeSong(this, results[0], undefined, logger));
             }
         }
-        
+
         return fetched;
     }
 
@@ -73,7 +73,7 @@ export default class YouTubeService implements IService {
             return {
                 full: true,
                 metadataType: "youtube",
-                imgURL: result.player_response.videoDetails.thumbnail.thumbnails[0].url,
+                imgURL: ((result.player_response.videoDetails as any).thumbnail as ytdl.VideoDetails).thumbnails[0].url,
                 title: result.videoDetails.title,
                 duration: Number(result.videoDetails.lengthSeconds),
                 url: result.videoDetails.video_url,
@@ -81,8 +81,8 @@ export default class YouTubeService implements IService {
                 date: new Date(result.videoDetails.publishDate),
                 custom: result
             };
-        } catch(e) {
-            typeof(logger) == 'function' && logger(`Failed to get song info for url '${url}', error ${e}`);
+        } catch (e) {
+            typeof (logger) == 'function' && logger(`Failed to get song info for url '${url}', error ${e}`);
             return {
                 full: true,
                 metadataType: "youtube",

package/src/default_implementations/youtube/song.ts

@@ -1,6 +1,6 @@
 import { Readable as ReadableStream } from 'stream';
 import { Video } from 'simple-youtube-api';
-import ytdl = require('ytdl-core');
+import { exec as ytdlexec } from 'youtube-dl-exec';
 
 import { Song, SongInfo, Logger } from '../../core';
 import YouTubeService from './service';
@@ -62,20 +62,19 @@ export default class YouTubeSong extends Song {
     return 0;
   }
 
-  public stream(): ReadableStream {
-    const options: any = {};
-    
-    if(this.live) {
-        options.quality = [128,127,120,96,95,94,93];
-    } else {
-        options.filter = 'audioonly';
-        
-        options.range = {
-          start: this.seek > 0 ? this.seek : 0
-        }
-    }
-    
-    if (typeof(this.logger) == 'function') this.logger(`[${this.type}] Fetching stream url for ${this.URL}.`);
-    return ytdl(this.trackID, options);
+  public stream(): ReadableStream | null {
+    const stream = ytdlexec(
+      this.streamURL,
+      {
+        output: '-',
+        format:
+          'bestaudio[ext=webm+acodec=opus+tbr>100]/bestaudio[ext=webm+acodec=opus]/bestaudio/best',
+        limitRate: '1M',
+        rmCacheDir: true,
+        verbose: true,
+      },
+      { stdio: ['ignore', 'pipe', 'ignore'] }
+    );
+    return stream.stdout;
   }
 }

package/src/default_implementations/youtubedl/service.ts

@@ -15,12 +15,12 @@ export default class YoutubedlService implements IService {
     }
 
     public async canFetch(target: string, logger?: Logger): Promise<boolean> {
-        var res = await youtubedl(target, {j: true}, {});
+        var res = await youtubedl(target, { dumpJson: true }, {});
         return !!res;
     }
 
     public async getSongInfo(url: string, logger?: Logger): Promise<SongInfo> {
-        var res = await youtubedl(url, {j: true, "no-check-certificate": true, "add-metadata": true}, {});
+        var res = await youtubedl(url, { dumpJson: true, noCheckCertificate: true, addMetadata: true }, {});
         return {
             full: true,
             metadataType: "youtubedl",
@@ -38,10 +38,10 @@ export default class YoutubedlService implements IService {
         if (!dateString) {
             return undefined;
         }
-        const year = dateString.slice(0,4);
-        const month = dateString.slice(4,6);
-        const day = dateString.slice(6,8);
-        
+        const year = dateString.slice(0, 4);
+        const month = dateString.slice(4, 6);
+        const day = dateString.slice(6, 8);
+
         return new Date(`${year} ${month} ${day}`)
     }
 }

package/src/default_implementations/youtubedl/song.ts

@@ -1,6 +1,6 @@
 import { Readable as ReadableStream } from 'stream';
 import { Song, SongInfo, Logger } from '../../core';
-import { raw as youtubedl } from 'youtube-dl-exec';
+import { exec as ytdlexec } from 'youtube-dl-exec';
 import YoutubedlService from './service';
 
 export default class YoutubedlSong extends Song {
@@ -30,7 +30,18 @@ export default class YoutubedlSong extends Song {
   }
 
   public stream(): ReadableStream | null {
-    if (typeof (this.logger) == 'function') this.logger(`[${this.type}] Fetching stream for ${this.URL}.`);
-    return youtubedl(this.streamURL, { _: ['-f', 'bestaudio/best[height<=?480]', '-o', '-'] }, {}).stdout;
+    const stream = ytdlexec(
+      this.streamURL,
+      {
+        output: '-',
+        format:
+          'bestaudio[ext=webm+acodec=opus+tbr>100]/bestaudio[ext=webm+acodec=opus]/bestaudio/best',
+        limitRate: '1M',
+        rmCacheDir: true,
+        verbose: true,
+      },
+      { stdio: ['ignore', 'pipe', 'ignore'] }
+    );
+    return stream.stdout;
   }
 }

package/test/test.js

@@ -1,6 +1,6 @@
-require('dotenv').config({ path: './test/.env' });
-const assert = require('chai').assert;
-const vdj = require('../dist');
+require("dotenv").config({ path: "./test/.env" });
+const assert = require("chai").assert;
+const vdj = require("../dist");
 
 var playlist,
     youtubeService = new vdj.YouTubeService(process.env.GOOGLE_API_KEY),
@@ -15,166 +15,179 @@ function sortOfDeepEqual(actual, expected) {
     return assert.deepEqual(strippedActual, expected);
 }
 
-describe('Playlist', function () {
+describe("Playlist", function () {
     before(function () {
         playlist = new vdj.Playlist({
-            services: []
+            services: [],
         });
     });
 
-    describe('#add', function () {
-        it('should return the not found targets', async function () {
-            const input = ['first', 'second'];
+    describe("#add", function () {
+        it("should return the not found targets", async function () {
+            const input = ["first", "second"];
             const result = await playlist.add(input);
             assert.deepEqual(result.notFound, input);
         });
     });
 
-    describe('Youtube', function () {
+    describe("Youtube", function () {
         before(function () {
             playlist = new vdj.Playlist({
-                services: [youtubeService]
-
+                services: [youtubeService],
             });
         });
 
-        describe('#add', function () {
-            it('should return a YouTubeSong from working youtube video link', async function () {
-                const input = ['https://www.youtube.com/watch?v=FtsefkeIE7k'];
+        describe("#add", function () {
+            it("should return a YouTubeSong from working youtube video link", async function () {
+                const input = ["https://www.youtube.com/watch?v=FtsefkeIE7k"];
                 const expected = {
-                    "added": [
+                    added: [
                         {
-                            "URL": input[0],
-                            "info": {
-                                "duration": 282,
-                                "full": false,
-                                "metadataType": "youtube",
-                                "title": "楽園ベイベー - RIP SLYME(Cover) / KMNZ",
-                                "url": input[0]
+                            URL: input[0],
+                            info: {
+                                duration: 282,
+                                full: false,
+                                metadataType: "youtube",
+                                title: "楽園ベイベー - RIP SLYME(Cover) / KMNZ",
+                                url: input[0],
                             },
-                            "live": false,
-                            "logger": undefined,
-                            "loop": false,
-                            "playlistID": undefined,
-                            "seek": 0,
-                            "service": playlist.services[0],
-                            "streamURL": input[0],
-                            "title": "楽園ベイベー - RIP SLYME(Cover) / KMNZ",
-                            "trackID": "FtsefkeIE7k",
-                            "type": "youtube",
-                        }
+                            live: false,
+                            logger: undefined,
+                            loop: false,
+                            playlistID: undefined,
+                            seek: 0,
+                            service: playlist.services[0],
+                            streamURL: input[0],
+                            title: "楽園ベイベー - RIP SLYME(Cover) / KMNZ",
+                            trackID: "FtsefkeIE7k",
+                            type: "youtube",
+                        },
                     ],
-                    "notFound": []
+                    notFound: [],
                 };
                 const result = await playlist.add(input);
                 assert.deepEqual(result, expected);
             });
-            it('should return multiple YouTubeSongs from multiple working youtube video links', async function () {
-                const input = ['https://www.youtube.com/watch?v=fmrA-gxJxgQ', 'https://www.youtube.com/watch?v=DDjcqu9uvUE', 'https://www.youtube.com/watch?v=lBnAY4VH9T4'];
+            it("should return multiple YouTubeSongs from multiple working youtube video links", async function () {
+                const input = [
+                    "https://www.youtube.com/watch?v=fmrA-gxJxgQ",
+                    "https://www.youtube.com/watch?v=DDjcqu9uvUE",
+                    "https://www.youtube.com/watch?v=lBnAY4VH9T4",
+                ];
                 const expected = input.length;
                 const result = (await playlist.add(input)).added.length;
                 assert.equal(result, expected);
             });
-            it('should return a YouTubeSong from working shortened youtube video link', async function () {
-                const input = ['https://youtu.be/LoK17z6xDwI'];
+            it("should return a YouTubeSong from working shortened youtube video link", async function () {
+                const input = ["https://youtu.be/LoK17z6xDwI"];
                 const expected = "https://www.youtube.com/watch?v=LoK17z6xDwI";
                 const result = (await playlist.add(input)).added[0].URL;
                 assert.deepEqual(result, expected);
             });
-            it('should return a YouTubeSong from live youtube video link', async function () {
-                const input = ['https://www.youtube.com/watch?v=5qap5aO4i9A'];
+            it("should return a YouTubeSong from live youtube video link", async function () {
+                const input = ["https://www.youtube.com/watch?v=jfKfPfyJRdk"];
                 const result = (await playlist.add(input)).added[0].live;
                 assert.isTrue(result);
             });
-            it('should return a YouTubeSong with seek from working youtube video link with timestamp parameter', async function () {
-                const input = ['https://www.youtube.com/watch?v=tMKrECxEpq8&t=64'];
+            it("should return a YouTubeSong with seek from working youtube video link with timestamp parameter", async function () {
+                const input = ["https://www.youtube.com/watch?v=tMKrECxEpq8&t=64"];
                 const expected = 64;
                 const result = (await playlist.add(input)).added[0].seek;
                 assert.equal(result, expected);
             });
-            it('should return multiple YouTubeSongs from youtube playlist link', async function () {
-                const input = ['https://www.youtube.com/playlist?list=PLFJU3fqbXA2e1_wAqOn7IoRB02nCfsAVh'];
+            it("should return multiple YouTubeSongs from youtube playlist link", async function () {
+                const input = ["https://www.youtube.com/playlist?list=PLD80CC3FEBE323161"];
+                const expected = 21;
                 const result = (await playlist.add(input)).added.length;
-                assert.isAbove(result, 1);
+                assert.equal(result, expected);
             });
-            it('should return one YouTubeSong from youtube video link with playlist parameter', async function () {
-                const input = ['https://www.youtube.com/watch?v=wSCEC0lYTzk&list=PLFJU3fqbXA2e1_wAqOn7IoRB02nCfsAVh&index=67'];
+            it("should return one YouTubeSong from youtube video link with playlist parameter", async function () {
+                const input = ["https://www.youtube.com/watch?v=wSCEC0lYTzk&list=PLFJU3fqbXA2e1_wAqOn7IoRB02nCfsAVh&index=67"];
                 const expected = 1;
                 const result = (await playlist.add(input)).added.length;
                 assert.equal(result, expected);
             });
-            it('should return YouTubeSongs from search queries', async function () {
-                const input = ['globglogabgalab', 'yooooooooo'];
+            it("should return YouTubeSongs from search queries", async function () {
+                const input = ["globglogabgalab", "yooooooooo"];
                 const expected = 2;
-                const result = (await playlist.add(input, {
-                    playlistAddType: 'searches'
-                })).added.length;
+                const result = (
+                    await playlist.add(input, {
+                        playlistAddType: "searches",
+                    })
+                ).added.length;
                 assert.equal(result, expected);
             });
         });
+        describe("#getSongInfo", function () {
+            it("should return a lot more information from working youtube video link", async function () {
+                const input = "https://www.youtube.com/watch?v=FtsefkeIE7k";
+                const expected = {
+                    full: true,
+                    metadataType: "youtube",
+                    url: input,
+                    title: "楽園ベイベー - RIP SLYME(Cover) / KMNZ",
+                    duration: 282,
+                    artist: ["KMNZ LITA"],
+                    date: new Date(1566950400000),
+                };
+                const result = await youtubeService.getSongInfo(input, console.log);
+                sortOfDeepEqual(result, expected);
+            });
+        });
     });
-    describe('Youtubedl', function () {
+    describe("Youtubedl", function () {
         before(function () {
             playlist = new vdj.Playlist({
-                services: [youtubedlService]
+                services: [youtubedlService],
             });
         });
-        describe('#add', function () {
+        describe("#add", function () {
             this.timeout(5000);
-            it('should return a YoutubedlSong from working ogg link', async function () {
-                const input = ['https://upload.wikimedia.org/wikipedia/commons/d/de/Lorem_ipsum.ogg'];
+            it("should return a YoutubedlSong from working ogg link", async function () {
+                const input = ["https://upload.wikimedia.org/wikipedia/commons/d/de/Lorem_ipsum.ogg"];
                 const expected = {
-                    "added": [
+                    added: [
                         {
-                            "URL": input[0],
-                            "info": {
-                                "full": false,
-                                "metadataType": "youtubedl",
-                                "url": input[0]
+                            URL: input[0],
+                            info: {
+                                full: false,
+                                metadataType: "youtubedl",
+                                url: input[0],
                             },
-                            "logger": undefined,
-                            "loop": false,
-                            "service": playlist.services[0],
-                            "streamURL": input[0],
-                            "type": "youtubedl",
-                        }
+                            logger: undefined,
+                            loop: false,
+                            service: playlist.services[0],
+                            streamURL: input[0],
+                            type: "youtubedl",
+                        },
                     ],
-                    "notFound": []
+                    notFound: [],
                 };
                 const result = await playlist.add(input);
                 assert.deepEqual(result, expected);
             });
         });
-    });
-});
-
-
-describe('Service', function () {
-    describe('Youtube', function () {
-        describe('#getSongInfo', function () {
-            it('should return a lot more information from working youtube video link', async function () {
-                const input = 'https://www.youtube.com/watch?v=FtsefkeIE7k';
+        describe("#getSongInfo", function () {
+            this.timeout(5000);
+            it("should return a lot more information from working youtube link", async function () {
+                const input = "https://www.youtube.com/watch?v=232fF5ECnGo";
                 const expected = {
                     full: true,
-                    metadataType: "youtube",
+                    metadataType: "youtubedl",
                     url: input,
-                    title: "楽園ベイベー - RIP SLYME(Cover) / KMNZ",
-                    duration: 282,
-                    artist: [
-                        "KMNZ LITA"
-                    ],
-                    date: new Date(1566950400000)
+                    title: "Rap God in the style of @Linkin Park​ (Feat. @Jonathan Young)",
+                    duration: 371,
+                    artist: [],
+                    date: new Date(1660773600000),
                 };
-                const result = await youtubeService.getSongInfo(input, console.log);
+                const result = await youtubedlService.getSongInfo(input, console.log);
                 sortOfDeepEqual(result, expected);
             });
         });
-    });
-    describe('Youtubedl', function () {
-        describe('#getSongInfo', function () {
+        describe("#getSongInfo", function () {
             this.timeout(5000);
-            it('should return a lot more information from working soundcloud link', async function () {
-                const input = 'https://soundcloud.com/bionicelcor/wakusei-abnormal';
+            it("should return a lot more information from working soundcloud link", async function () {
+                const input = "https://soundcloud.com/bionicelcor/wakusei-abnormal";
                 const expected = {
                     full: true,
                     metadataType: "youtubedl",
@@ -182,7 +195,7 @@ describe('Service', function () {
                     title: "ふこうぶつ -- Wakusei Abnormal",
                     duration: 164.638,
                     artist: [],
-                    date: new Date(1512946800000)
+                    date: new Date(1512946800000),
                 };
                 const result = await youtubedlService.getSongInfo(input, console.log);
                 sortOfDeepEqual(result, expected);
@@ -208,4 +221,4 @@ describe('Service', function () {
         });
         */
     });
-});
+});