vdj 1.2.0 → 1.4.1

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/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, { dumpSingleJson: 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, { dumpSingleJson: 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/best',
+            limitRate: '1M',
+            rmCacheDir: true,
+            verbose: true,
+        }, { stdio: ['ignore', 'pipe', 'ignore'] });
+        return stream.stdout;
     }
 }
 exports.default = YoutubedlSong;

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 import { Playlist, PlaylistSettings, IService, Song } from './core';
+import YouTubeService from './default_implementations/youtube/service';
+import YouTubeSong from './default_implementations/youtube/song';
 import YoutubedlService from './default_implementations/youtubedl/service';
 import YoutubedlSong from './default_implementations/youtubedl/song';
-export { Playlist, PlaylistSettings, IService, Song, YoutubedlService, YoutubedlSong, };
+export { Playlist, PlaylistSettings, IService, Song, YouTubeService, YouTubeSong, YoutubedlService, YoutubedlSong, };

package/dist/index.js

@@ -3,11 +3,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.YoutubedlSong = exports.YoutubedlService = exports.Song = exports.Playlist = void 0;
+exports.YoutubedlSong = exports.YoutubedlService = exports.YouTubeSong = exports.YouTubeService = exports.Song = exports.Playlist = void 0;
 const core_1 = require("./core");
 Object.defineProperty(exports, "Playlist", { enumerable: true, get: function () { return core_1.Playlist; } });
 Object.defineProperty(exports, "Song", { enumerable: true, get: function () { return core_1.Song; } });
-const service_1 = __importDefault(require("./default_implementations/youtubedl/service"));
-exports.YoutubedlService = service_1.default;
-const song_1 = __importDefault(require("./default_implementations/youtubedl/song"));
-exports.YoutubedlSong = song_1.default;
+const service_1 = __importDefault(require("./default_implementations/youtube/service"));
+exports.YouTubeService = service_1.default;
+const song_1 = __importDefault(require("./default_implementations/youtube/song"));
+exports.YouTubeSong = song_1.default;
+const service_2 = __importDefault(require("./default_implementations/youtubedl/service"));
+exports.YoutubedlService = service_2.default;
+const song_2 = __importDefault(require("./default_implementations/youtubedl/song"));
+exports.YoutubedlSong = song_2.default;

package/package.json

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

package/src/default_implementations/youtube/service.ts

@@ -0,0 +1,99 @@
+import API = require('simple-youtube-api');
+import ytdl = require('ytdl-core');
+
+import { IService, SearchType, SongInfo, Logger } from '../../core/';
+import YouTubeSong from './song';
+
+export default class YouTubeService implements IService {
+    public readonly api: API;
+    public canSearch: boolean = true;
+    public type: string = 'youtube';
+
+    constructor(key: string) {
+        this.api = new API(key);
+    }
+
+    public async fetch(targets: string[], logger?: Logger): Promise<YouTubeSong[]> {
+        const fetched: YouTubeSong[] = [];
+
+        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}.`);
+
+                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}.`);
+
+                const playlist = await this.api.getPlaylistByID(parsed.playlist);
+                if (!playlist) continue;
+                await playlist.getVideos();
+                fetched.push(...playlist.videos.map((v) => new YouTubeSong(this, v, parsed.playlist, logger)));
+            }
+        }
+
+        return fetched;
+    }
+
+    public async search(queries: string[], searchType: SearchType, logger?: Logger): Promise<YouTubeSong[]> {
+        const fetched: YouTubeSong[] = [];
+
+        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}.`);
+
+                const results = await this.api.searchPlaylists(query, 1);
+                if (results.length) {
+                    const list = results[0];
+                    const videos = await list.getVideos();
+                    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}.`);
+
+                const results = await this.api.searchVideos(query, 1);
+                if (results.length) fetched.push(new YouTubeSong(this, results[0], undefined, logger));
+            }
+        }
+
+        return fetched;
+    }
+
+    public async canFetch(target: string, logger?: Logger): Promise<boolean> {
+        const parsed = API.util.parseURL(target);
+        return parsed.video != undefined || parsed.playlist != undefined;
+    }
+
+    public async getSongInfo(url: string, logger?: Logger): Promise<SongInfo> {
+        try {
+            const result: ytdl.videoInfo = await ytdl.getInfo(url);
+            return {
+                full: true,
+                metadataType: "youtube",
+                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,
+                artist: [result.videoDetails.author.name],
+                date: new Date(result.videoDetails.publishDate),
+                custom: result
+            };
+        } catch (e) {
+            typeof (logger) == 'function' && logger(`Failed to get song info for url '${url}', error ${e}`);
+            return {
+                full: true,
+                metadataType: "youtube",
+                imgURL: "",
+                title: url,
+                duration: 0,
+                url: url,
+                artist: [],
+                date: new Date(),
+                custom: {}
+            };
+        }
+    }
+}

package/src/default_implementations/youtube/song.ts

@@ -0,0 +1,79 @@
+import { Readable as ReadableStream } from 'stream';
+import { Video } from 'simple-youtube-api';
+import { exec as ytdlexec } from 'youtube-dl-exec';
+
+import { Song, SongInfo, Logger } from '../../core';
+import YouTubeService from './service';
+
+export default class YouTubeSong extends Song {
+  public readonly type: string = 'youtube';
+  public readonly title: string;
+  public readonly playlistID?: string;
+  public readonly trackID: string;
+  public readonly streamURL: string;
+  public readonly URL: string;
+  public readonly live: boolean;
+  public info: SongInfo;
+  public seek: number;
+  public logger?: Logger;
+
+  constructor(service: YouTubeService, video: Video, playlistID?: string, logger?: Logger, seek: number = 0) {
+    super(service);
+    this.title = video.title;
+    this.trackID = video.id;
+    this.streamURL = video.url;
+    this.URL = video.url;
+    this.playlistID = playlistID;
+    this.live = video.raw.snippet.liveBroadcastContent == "live";
+    this.seek = seek;
+    this.info = {
+      full: false,
+      metadataType: this.type,
+      title: this.title,
+      url: this.URL,
+      duration: video.durationSeconds
+    }
+    this.logger = logger;
+  }
+
+  public async getSongInfo(): Promise<SongInfo> {
+    if (this.info.full) return this.info;
+    this.info = await this.service.getSongInfo(this.URL);
+    return this.info;
+  }
+
+  public static extractSeek(url: string): number {
+    var lookFor = ["&t=", "?t="];
+    for (var i in lookFor) {
+      var key = lookFor[i];
+      var start = url.indexOf(key);
+      if (start === -1) continue;
+      start += key.length;
+      var time = "";
+      var char = "";
+      for (var j = start; j < url.length; j++) {
+        char = url[j];
+        if (isNaN(Number(char)))
+          break;
+        time += char;
+      }
+      return Number(time);
+    }
+    return 0;
+  }
+
+  public stream(): ReadableStream | null {
+    const stream = ytdlexec(
+      this.streamURL,
+      {
+        output: '-',
+        format: '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, { dumpSingleJson: 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, { dumpSingleJson: 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,17 @@ 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/best',
+        limitRate: '1M',
+        rmCacheDir: true,
+        verbose: true,
+      },
+      { stdio: ['ignore', 'pipe', 'ignore'] }
+    );
+    return stream.stdout;
   }
 }

package/src/index.ts

@@ -1,4 +1,6 @@
 import { Playlist, PlaylistSettings, IService, Song } from './core';
+import YouTubeService from './default_implementations/youtube/service'
+import YouTubeSong from './default_implementations/youtube/song'
 import YoutubedlService from './default_implementations/youtubedl/service';
 import YoutubedlSong from './default_implementations/youtubedl/song';
 
@@ -9,6 +11,9 @@ export {
   IService,
   Song,
 
+  YouTubeService,
+  YouTubeSong,
+
   YoutubedlService,
   YoutubedlSong,
 };

package/test/test.js

@@ -1,8 +1,9 @@
-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),
     youtubedlService = new vdj.YoutubedlService();
 
 function sortOfDeepEqual(actual, expected) {
@@ -14,63 +15,162 @@ 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('Youtubedl', function () {
+    describe("Youtube", function () {
         before(function () {
             playlist = new vdj.Playlist({
-                services: [youtubedlService]
+                services: [youtubeService],
             });
         });
-        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'];
+
+        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": {
-                                "full": false,
-                                "metadataType": "youtubedl",
-                                "url": input[0]
+                            URL: input[0],
+                            info: {
+                                duration: 282,
+                                full: false,
+                                metadataType: "youtube",
+                                title: "楽園ベイベー - RIP SLYME(Cover) / KMNZ",
+                                url: input[0],
                             },
-                            "logger": undefined,
-                            "loop": false,
-                            "service": playlist.services[0],
-                            "streamURL": input[0],
-                            "type": "youtubedl",
-                        }
+                            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",
+                ];
+                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"];
+                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=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"];
+                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=PLD80CC3FEBE323161"];
+                const expected = 21;
+                const result = (await playlist.add(input)).added.length;
+                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"];
+                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"];
+                const expected = 2;
+                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('Service', function () {
-    describe('Youtubedl', function () {
-        describe('#getSongInfo', function () {
+    describe("Youtubedl", function () {
+        before(function () {
+            playlist = new vdj.Playlist({
+                services: [youtubedlService],
+            });
+        });
+        describe("#add", 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';
+            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: [
+                        {
+                            URL: input[0],
+                            info: {
+                                full: false,
+                                metadataType: "youtubedl",
+                                url: input[0],
+                            },
+                            logger: undefined,
+                            loop: false,
+                            service: playlist.services[0],
+                            streamURL: input[0],
+                            type: "youtubedl",
+                        },
+                    ],
+                    notFound: [],
+                };
+                const result = await playlist.add(input);
+                assert.deepEqual(result, expected);
+            });
+        });
+        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: "youtubedl",
@@ -78,16 +178,16 @@ describe('Service', function () {
                     title: "Rap God in the style of @Linkin Park​ (Feat. @Jonathan Young)",
                     duration: 371,
                     artist: [],
-                    date: new Date(1660773600000)
+                    date: new Date(1660773600000),
                 };
                 const result = await youtubedlService.getSongInfo(input, console.log);
                 sortOfDeepEqual(result, expected);
             });
         });
-        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",
@@ -95,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);
@@ -121,4 +221,4 @@ describe('Service', function () {
         });
         */
     });
-});
+});