vdj 1.4.7 → 1.6.0

package/dist/default_implementations/youtube/service.js

@@ -1,112 +1,112 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const API = require("simple-youtube-api");
-const ytdl = require("ytdl-core");
-const song_1 = __importDefault(require("./song"));
-class YouTubeService {
-    constructor(key) {
-        this.canSearch = true;
-        this.type = 'youtube';
-        this.api = new API(key);
-    }
-    fetch(targets, logger) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fetched = [];
-            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 = yield this.api.getVideoByID(parsed.video);
-                    const seek = song_1.default.extractSeek(target);
-                    if (video)
-                        fetched.push(new song_1.default(this, video, undefined, logger, seek));
-                }
-                else if (parsed.playlist) {
-                    typeof (logger) == 'function' && logger(`[${this.type}] Fetching playlist from target ${target}.`);
-                    const playlist = yield this.api.getPlaylistByID(parsed.playlist);
-                    if (!playlist)
-                        continue;
-                    yield playlist.getVideos();
-                    fetched.push(...playlist.videos.map((v) => new song_1.default(this, v, parsed.playlist, logger)));
-                }
-            }
-            return fetched;
-        });
-    }
-    search(queries, searchType, logger) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fetched = [];
-            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 = yield this.api.searchPlaylists(query, 1);
-                    if (results.length) {
-                        const list = results[0];
-                        const videos = yield list.getVideos();
-                        fetched.push(...videos.map((v) => new song_1.default(this, v, list.id, logger)));
-                    }
-                }
-                else {
-                    typeof (logger) == 'function' && logger(`[${this.type}] Searching for a song with the input ${query}.`);
-                    const results = yield this.api.searchVideos(query, 1);
-                    if (results.length)
-                        fetched.push(new song_1.default(this, results[0], undefined, logger));
-                }
-            }
-            return fetched;
-        });
-    }
-    canFetch(target, logger) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const parsed = API.util.parseURL(target);
-            return parsed.video != undefined || parsed.playlist != undefined;
-        });
-    }
-    getSongInfo(url, logger) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const result = yield ytdl.getInfo(url);
-                return {
-                    full: true,
-                    metadataType: "youtube",
-                    imgURL: result.player_response.videoDetails.thumbnail.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: {}
-                };
-            }
-        });
-    }
-}
-exports.default = YouTubeService;
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const API = require("simple-youtube-api");
+const ytdl = require("@distube/ytdl-core");
+const song_1 = __importDefault(require("./song"));
+class YouTubeService {
+    constructor(key) {
+        this.canSearch = true;
+        this.type = 'youtube';
+        this.api = new API(key);
+    }
+    fetch(targets, logger) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fetched = [];
+            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 = yield this.api.getVideoByID(parsed.video);
+                    const seek = song_1.default.extractSeek(target);
+                    if (video)
+                        fetched.push(new song_1.default(this, video, undefined, logger, seek));
+                }
+                else if (parsed.playlist) {
+                    typeof (logger) == 'function' && logger(`[${this.type}] Fetching playlist from target ${target}.`);
+                    const playlist = yield this.api.getPlaylistByID(parsed.playlist);
+                    if (!playlist)
+                        continue;
+                    yield playlist.getVideos();
+                    fetched.push(...playlist.videos.map((v) => new song_1.default(this, v, parsed.playlist, logger)));
+                }
+            }
+            return fetched;
+        });
+    }
+    search(queries, searchType, logger) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fetched = [];
+            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 = yield this.api.searchPlaylists(query, 1);
+                    if (results.length) {
+                        const list = results[0];
+                        const videos = yield list.getVideos();
+                        fetched.push(...videos.map((v) => new song_1.default(this, v, list.id, logger)));
+                    }
+                }
+                else {
+                    typeof (logger) == 'function' && logger(`[${this.type}] Searching for a song with the input ${query}.`);
+                    const results = yield this.api.searchVideos(query, 1);
+                    if (results.length)
+                        fetched.push(new song_1.default(this, results[0], undefined, logger));
+                }
+            }
+            return fetched;
+        });
+    }
+    canFetch(target, logger) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const parsed = API.util.parseURL(target);
+            return parsed.video != undefined || parsed.playlist != undefined;
+        });
+    }
+    getSongInfo(url, logger) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield ytdl.getInfo(url);
+                return {
+                    full: true,
+                    metadataType: "youtube",
+                    imgURL: result.player_response.videoDetails.thumbnail.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: {}
+                };
+            }
+        });
+    }
+}
+exports.default = YouTubeService;

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

@@ -1,20 +1,19 @@
-/// <reference types="node" />
-import { Readable as ReadableStream } from 'stream';
-import { Video } from 'simple-youtube-api';
-import { Song, SongInfo, Logger } from '../../core';
-import YouTubeService from './service';
-export default class YouTubeSong extends Song {
-    readonly type: string;
-    readonly title: string;
-    readonly playlistID?: string;
-    readonly trackID: string;
-    readonly streamURL: string;
-    readonly URL: string;
-    readonly live: boolean;
-    info: SongInfo;
-    logger?: Logger;
-    constructor(service: YouTubeService, video: Video, playlistID?: string, logger?: Logger, seek?: number);
-    getSongInfo(): Promise<SongInfo>;
-    static extractSeek(url: string): number;
-    stream(): ReadableStream | null;
-}
+import { Readable as ReadableStream } from 'stream';
+import { Video } from 'simple-youtube-api';
+import { Song, SongInfo, Logger } from '../../core';
+import YouTubeService from './service';
+export default class YouTubeSong extends Song {
+    readonly type: string;
+    readonly title: string;
+    readonly playlistID?: string;
+    readonly trackID: string;
+    readonly streamURL: string;
+    readonly URL: string;
+    readonly live: boolean;
+    info: SongInfo;
+    logger?: Logger;
+    constructor(service: YouTubeService, video: Video, playlistID?: string, logger?: Logger, seek?: number);
+    getSongInfo(): Promise<SongInfo>;
+    static extractSeek(url: string): number;
+    stream(): ReadableStream | null;
+}

package/dist/default_implementations/youtube/song.js

@@ -1,73 +1,73 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-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) {
-        super(service);
-        this.type = 'youtube';
-        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;
-    }
-    getSongInfo() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.info.full)
-                return this.info;
-            this.info = yield this.service.getSongInfo(this.URL);
-            return this.info;
-        });
-    }
-    static extractSeek(url) {
-        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;
-    }
-    stream() {
-        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;
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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) {
+        super(service);
+        this.type = 'youtube';
+        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;
+    }
+    getSongInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.info.full)
+                return this.info;
+            this.info = yield this.service.getSongInfo(this.URL);
+            return this.info;
+        });
+    }
+    static extractSeek(url) {
+        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;
+    }
+    stream() {
+        const stream = (0, 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.d.ts

@@ -1,11 +1,11 @@
-import { IService, SongInfo, Logger } from '../../core/';
-import YoutubedlSong from './song';
-export default class YoutubedlService implements IService {
-    canSearch: boolean;
-    type: string;
-    fetch(targets: string[], logger?: Logger): Promise<YoutubedlSong[]>;
-    search(): Promise<YoutubedlSong[]>;
-    canFetch(target: string, logger?: Logger): Promise<boolean>;
-    getSongInfo(url: string, logger?: Logger): Promise<SongInfo>;
-    private parseDate;
-}
+import { IService, SongInfo, Logger } from '../../core/';
+import YoutubedlSong from './song';
+export default class YoutubedlService implements IService {
+    canSearch: boolean;
+    type: string;
+    fetch(targets: string[], logger?: Logger): Promise<YoutubedlSong[]>;
+    search(): Promise<YoutubedlSong[]>;
+    canFetch(target: string, logger?: Logger): Promise<boolean>;
+    getSongInfo(url: string, logger?: Logger): Promise<SongInfo>;
+    private parseDate;
+}

package/dist/default_implementations/youtubedl/service.js

@@ -1,64 +1,77 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const song_1 = __importDefault(require("./song"));
-const youtube_dl_exec_1 = __importDefault(require("youtube-dl-exec"));
-class YoutubedlService {
-    constructor() {
-        this.canSearch = false;
-        this.type = 'youtubedl';
-    }
-    fetch(targets, logger) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return targets.map(x => new song_1.default(this, x, logger));
-        });
-    }
-    search() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return [];
-        });
-    }
-    canFetch(target, logger) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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, { dumpSingleJson: true, noCheckCertificates: true, addMetadata: true }, {});
-            return {
-                full: true,
-                metadataType: "youtubedl",
-                imgURL: res.thumbnail,
-                title: res.title || url,
-                duration: res.duration,
-                url: url,
-                artist: res.artist ? [res.artist] : [],
-                date: this.parseDate(res.upload_date),
-                custom: {}
-            };
-        });
-    }
-    parseDate(dateString) {
-        if (!dateString) {
-            return undefined;
-        }
-        const year = dateString.slice(0, 4);
-        const month = dateString.slice(4, 6);
-        const day = dateString.slice(6, 8);
-        return new Date(`${year} ${month} ${day}`);
-    }
-}
-exports.default = YoutubedlService;
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const song_1 = __importDefault(require("./song"));
+const youtube_dl_exec_1 = __importDefault(require("youtube-dl-exec"));
+class YoutubedlService {
+    constructor() {
+        this.canSearch = false;
+        this.type = 'youtubedl';
+    }
+    fetch(targets, logger) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return targets.map(x => new song_1.default(this, x, logger));
+        });
+    }
+    search() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [];
+        });
+    }
+    canFetch(target, logger) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var res = yield (0, youtube_dl_exec_1.default)(target, { dumpSingleJson: true }, {});
+            return !!res;
+        });
+    }
+    getSongInfo(url, logger) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var res = yield (0, youtube_dl_exec_1.default)(url, { dumpSingleJson: true, noCheckCertificates: true, addMetadata: true }, {});
+            if (typeof res === 'string') {
+                return {
+                    full: false,
+                    metadataType: "youtubedl",
+                    imgURL: undefined,
+                    title: url,
+                    duration: undefined,
+                    url: url,
+                    artist: [],
+                    date: undefined,
+                    custom: {}
+                };
+            }
+            return {
+                full: true,
+                metadataType: "youtubedl",
+                imgURL: res.thumbnail,
+                title: res.title || url,
+                duration: res.duration,
+                url: url,
+                artist: [],
+                date: this.parseDate(res.upload_date),
+                custom: {}
+            };
+        });
+    }
+    parseDate(dateString) {
+        if (!dateString) {
+            return undefined;
+        }
+        const year = dateString.slice(0, 4);
+        const month = dateString.slice(4, 6);
+        const day = dateString.slice(6, 8);
+        return new Date(`${year} ${month} ${day}`);
+    }
+}
+exports.default = YoutubedlService;

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

@@ -1,14 +1,13 @@
-/// <reference types="node" />
-import { Readable as ReadableStream } from 'stream';
-import { Song, SongInfo, Logger } from '../../core';
-import YoutubedlService from './service';
-export default class YoutubedlSong extends Song {
-    readonly type: string;
-    readonly streamURL: string;
-    readonly URL: string;
-    info: SongInfo;
-    logger?: Logger;
-    constructor(service: YoutubedlService, url: string, logger?: Logger);
-    getSongInfo(): Promise<SongInfo>;
-    stream(): ReadableStream | null;
-}
+import { Readable as ReadableStream } from 'stream';
+import { Song, SongInfo, Logger } from '../../core';
+import YoutubedlService from './service';
+export default class YoutubedlSong extends Song {
+    readonly type: string;
+    readonly streamURL: string;
+    readonly URL: string;
+    info: SongInfo;
+    logger?: Logger;
+    constructor(service: YoutubedlService, url: string, logger?: Logger);
+    getSongInfo(): Promise<SongInfo>;
+    stream(): ReadableStream | null;
+}