vdj 1.4.7 → 1.6.0

package/dist/core/iService.d.ts

@@ -1,8 +1,8 @@
-import { SearchType, Song, SongInfo, Logger } from '.';
-export interface IService {
-    canSearch: boolean;
-    fetch(targets: string[], logger?: Logger): Promise<Song[]>;
-    search(queries: string[], searchType: SearchType, logger?: Logger): Promise<Song[]>;
-    canFetch(content: string, logger?: Logger): Promise<boolean>;
-    getSongInfo(songUrl: string, logger?: Logger): Promise<SongInfo>;
-}
+import { SearchType, Song, SongInfo, Logger } from '.';
+export interface IService {
+    canSearch: boolean;
+    fetch(targets: string[], logger?: Logger): Promise<Song[]>;
+    search(queries: string[], searchType: SearchType, logger?: Logger): Promise<Song[]>;
+    canFetch(content: string, logger?: Logger): Promise<boolean>;
+    getSongInfo(songUrl: string, logger?: Logger): Promise<SongInfo>;
+}

package/dist/core/iService.js

@@ -1,2 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/index.d.ts

@@ -1,5 +1,5 @@
-import Playlist from './playlist';
-import Song from './song';
-import { IService } from './iService';
-import { SongInfo, SearchType, PlaylistSettings, PlaylistAddType, PlaylistAddResult, Logger } from './types';
-export { Playlist, IService, Song, PlaylistSettings, PlaylistAddType, PlaylistAddResult, SearchType, SongInfo, Logger };
+import Playlist from './playlist';
+import Song from './song';
+import { IService } from './iService';
+import { SongInfo, SearchType, PlaylistSettings, PlaylistAddType, PlaylistAddResult, Logger } from './types';
+export { Playlist, IService, Song, PlaylistSettings, PlaylistAddType, PlaylistAddResult, SearchType, SongInfo, Logger };

package/dist/core/index.js

@@ -1,10 +1,10 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Song = exports.Playlist = void 0;
-const playlist_1 = __importDefault(require("./playlist"));
-exports.Playlist = playlist_1.default;
-const song_1 = __importDefault(require("./song"));
-exports.Song = song_1.default;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Song = exports.Playlist = void 0;
+const playlist_1 = __importDefault(require("./playlist"));
+exports.Playlist = playlist_1.default;
+const song_1 = __importDefault(require("./song"));
+exports.Song = song_1.default;

package/dist/core/playlist.d.ts

@@ -1,24 +1,24 @@
-import { IService, Song, SearchType, PlaylistSettings, PlaylistAddType, PlaylistAddResult, Logger } from '.';
-export default class Playlist extends Array<Song> {
-    private _pos;
-    loop: boolean;
-    autoplay: boolean;
-    services: IService[];
-    fallBackService?: IService;
-    logger?: Logger;
-    constructor(settings: PlaylistSettings);
-    get pos(): number;
-    get current(): Song;
-    clear(): void;
-    hasPrev(): boolean;
-    prev(): boolean;
-    hasNext(): boolean;
-    next(): Promise<boolean>;
-    shuffle(): this;
-    add(input: string[], { service, position, playlistAddType, searchType, }?: {
-        service?: IService;
-        position?: number;
-        playlistAddType?: PlaylistAddType;
-        searchType?: SearchType;
-    }): Promise<PlaylistAddResult>;
-}
+import { IService, Song, SearchType, PlaylistSettings, PlaylistAddType, PlaylistAddResult, Logger } from '.';
+export default class Playlist extends Array<Song> {
+    private _pos;
+    loop: boolean;
+    autoplay: boolean;
+    services: IService[];
+    fallBackService?: IService;
+    logger?: Logger;
+    constructor(settings: PlaylistSettings);
+    get pos(): number;
+    get current(): Song;
+    clear(): void;
+    hasPrev(): boolean;
+    prev(): boolean;
+    hasNext(): boolean;
+    next(): Promise<boolean>;
+    shuffle(): this;
+    add(input: string[], { service, position, playlistAddType, searchType, }?: {
+        service?: IService;
+        position?: number;
+        playlistAddType?: PlaylistAddType;
+        searchType?: SearchType;
+    }): Promise<PlaylistAddResult>;
+}

package/dist/core/playlist.js

@@ -1,126 +1,126 @@
-"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 });
-class Playlist extends Array {
-    constructor(settings) {
-        super();
-        this._pos = 0;
-        if (settings) {
-            this.loop = settings.loop || false;
-            this.autoplay = settings.autoplay || false;
-            this.services = settings.services;
-            this.fallBackService = settings.fallBackService;
-            this.logger = settings.logger;
-        }
-        else {
-            this.loop = false;
-            this.autoplay = false;
-            this.services = [];
-        }
-    }
-    get pos() {
-        return this._pos;
-    }
-    get current() {
-        return this[this._pos];
-    }
-    clear() {
-        this.splice(0, this.length);
-        this._pos = 0;
-    }
-    hasPrev() {
-        return this._pos > 0;
-    }
-    prev() {
-        if (this.hasPrev()) {
-            this._pos -= 1;
-            return true;
-        }
-        if (this.loop) {
-            this._pos = this.length - 1;
-            return true;
-        }
-        return false;
-    }
-    hasNext() {
-        return this._pos < this.length - 1;
-    }
-    next() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.current && this.current.loop)
-                return true;
-            if (this.hasNext()) {
-                this._pos += 1;
-                return true;
-            }
-            if (this.loop) {
-                this._pos = 0;
-                return true;
-            }
-            return false;
-        });
-    }
-    shuffle() {
-        for (let i = this.length - 1; i > 0; i--) {
-            const j = Math.floor(Math.random() * (i + 1));
-            const temp = this[i];
-            this[i] = this[j];
-            this[j] = temp;
-        }
-        return this;
-    }
-    add(input, { service = undefined, position = Infinity, playlistAddType = 'urls', searchType = 'song', } = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const services = service ? [service] : this.services;
-            var added = [];
-            var notFound = [];
-            if (playlistAddType != 'searches') {
-                for (const url of input) {
-                    var fetched = [];
-                    for (const service of services) {
-                        if (yield service.canFetch(url, this.logger)) {
-                            fetched = yield service.fetch([url], this.logger);
-                            if (fetched.length)
-                                break;
-                        }
-                    }
-                    if (!fetched.length && this.fallBackService) {
-                        if (typeof (this.logger) == 'function')
-                            this.logger("Couldn't fetch with services, using fallbackService.");
-                        fetched = yield this.fallBackService.fetch([url]);
-                    }
-                    if (!fetched.length)
-                        notFound.push(url);
-                    added = added.concat(fetched);
-                }
-            }
-            else {
-                for (const query of input) {
-                    for (const service of services) {
-                        if (service.canSearch) {
-                            var found = yield service.search([query], searchType, this.logger);
-                            if (!found.length)
-                                continue;
-                            added = added.concat(found);
-                            break;
-                        }
-                    }
-                }
-            }
-            this.splice(position, 0, ...added);
-            return {
-                added: added,
-                notFound: notFound
-            };
-        });
-    }
-}
-exports.default = Playlist;
+"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 });
+class Playlist extends Array {
+    constructor(settings) {
+        super();
+        this._pos = 0;
+        if (settings) {
+            this.loop = settings.loop || false;
+            this.autoplay = settings.autoplay || false;
+            this.services = settings.services;
+            this.fallBackService = settings.fallBackService;
+            this.logger = settings.logger;
+        }
+        else {
+            this.loop = false;
+            this.autoplay = false;
+            this.services = [];
+        }
+    }
+    get pos() {
+        return this._pos;
+    }
+    get current() {
+        return this[this._pos];
+    }
+    clear() {
+        this.splice(0, this.length);
+        this._pos = 0;
+    }
+    hasPrev() {
+        return this._pos > 0;
+    }
+    prev() {
+        if (this.hasPrev()) {
+            this._pos -= 1;
+            return true;
+        }
+        if (this.loop) {
+            this._pos = this.length - 1;
+            return true;
+        }
+        return false;
+    }
+    hasNext() {
+        return this._pos < this.length - 1;
+    }
+    next() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.current && this.current.loop)
+                return true;
+            if (this.hasNext()) {
+                this._pos += 1;
+                return true;
+            }
+            if (this.loop) {
+                this._pos = 0;
+                return true;
+            }
+            return false;
+        });
+    }
+    shuffle() {
+        for (let i = this.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            const temp = this[i];
+            this[i] = this[j];
+            this[j] = temp;
+        }
+        return this;
+    }
+    add(input_1) {
+        return __awaiter(this, arguments, void 0, function* (input, { service = undefined, position = Infinity, playlistAddType = 'urls', searchType = 'song', } = {}) {
+            const services = service ? [service] : this.services;
+            var added = [];
+            var notFound = [];
+            if (playlistAddType != 'searches') {
+                for (const url of input) {
+                    var fetched = [];
+                    for (const service of services) {
+                        if (yield service.canFetch(url, this.logger)) {
+                            fetched = yield service.fetch([url], this.logger);
+                            if (fetched.length)
+                                break;
+                        }
+                    }
+                    if (!fetched.length && this.fallBackService) {
+                        if (typeof (this.logger) == 'function')
+                            this.logger("Couldn't fetch with services, using fallbackService.");
+                        fetched = yield this.fallBackService.fetch([url]);
+                    }
+                    if (!fetched.length)
+                        notFound.push(url);
+                    added = added.concat(fetched);
+                }
+            }
+            else {
+                for (const query of input) {
+                    for (const service of services) {
+                        if (service.canSearch) {
+                            var found = yield service.search([query], searchType, this.logger);
+                            if (!found.length)
+                                continue;
+                            added = added.concat(found);
+                            break;
+                        }
+                    }
+                }
+            }
+            this.splice(position, 0, ...added);
+            return {
+                added: added,
+                notFound: notFound
+            };
+        });
+    }
+}
+exports.default = Playlist;

package/dist/core/song.d.ts

@@ -1,19 +1,18 @@
-/// <reference types="node" />
-import { Readable as ReadableStream } from 'stream';
-import { IService, SongInfo } from '.';
-export default abstract class Song {
-    readonly service: IService;
-    loop: boolean;
-    live: boolean;
-    seek: number;
-    abstract readonly type: string;
-    abstract readonly streamURL: string;
-    abstract readonly URL: string;
-    abstract info?: SongInfo;
-    readonly title?: string;
-    readonly playlistID?: string | number;
-    constructor(service: IService);
-    abstract getSongInfo(): Promise<SongInfo>;
-    abstract stream(): Promise<ReadableStream> | ReadableStream | null;
-    toggleLoop(): boolean;
-}
+import { Readable as ReadableStream } from 'stream';
+import { IService, SongInfo } from '.';
+export default abstract class Song {
+    readonly service: IService;
+    loop: boolean;
+    live: boolean;
+    seek: number;
+    abstract readonly type: string;
+    abstract readonly streamURL: string;
+    abstract readonly URL: string;
+    abstract info?: SongInfo;
+    readonly title?: string;
+    readonly playlistID?: string | number;
+    constructor(service: IService);
+    abstract getSongInfo(): Promise<SongInfo>;
+    abstract stream(): Promise<ReadableStream> | ReadableStream | null;
+    toggleLoop(): boolean;
+}

package/dist/core/song.js

@@ -1,16 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class Song {
-    constructor(service) {
-        this.loop = false;
-        this.live = false;
-        this.seek = 0;
-        this.service = service;
-        Object.defineProperty(this, 'service', { value: service });
-    }
-    toggleLoop() {
-        return this.loop = !this.loop;
-    }
-    ;
-}
-exports.default = Song;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Song {
+    constructor(service) {
+        this.loop = false;
+        this.live = false;
+        this.seek = 0;
+        this.service = service;
+        Object.defineProperty(this, 'service', { value: service });
+    }
+    toggleLoop() {
+        return this.loop = !this.loop;
+    }
+    ;
+}
+exports.default = Song;

package/dist/core/types.d.ts

@@ -1,40 +1,39 @@
-/// <reference types="node" />
-import { IService, Song } from ".";
-export declare type SongInfo = {
-    full: boolean;
-    metadataType: string;
-    url: string;
-    custom?: any;
-    title?: string;
-    duration?: number;
-    artist?: string[];
-    album?: string;
-    albumartist?: string[];
-    disk?: {
-        no: number;
-        of: number;
-    };
-    track?: {
-        no: number;
-        of: number;
-    };
-    date?: Date | string;
-    genre?: string[];
-    img?: Buffer;
-    imgURL?: string;
-    imgFormat?: string;
-};
-export declare type Logger = (x: string) => any;
-export declare type SearchType = 'song' | 'playlist';
-export declare type PlaylistAddType = 'searches' | 'urls';
-export declare type PlaylistAddResult = {
-    added: Song[];
-    notFound: string[];
-};
-export declare type PlaylistSettings = {
-    services: IService[];
-    loop?: boolean;
-    autoplay?: boolean;
-    fallBackService?: IService;
-    logger?: Logger;
-};
+import { IService, Song } from ".";
+export type SongInfo = {
+    full: boolean;
+    metadataType: string;
+    url: string;
+    custom?: any;
+    title?: string;
+    duration?: number;
+    artist?: string[];
+    album?: string;
+    albumartist?: string[];
+    disk?: {
+        no: number;
+        of: number;
+    };
+    track?: {
+        no: number;
+        of: number;
+    };
+    date?: Date | string;
+    genre?: string[];
+    img?: Buffer;
+    imgURL?: string;
+    imgFormat?: string;
+};
+export type Logger = (x: string) => any;
+export type SearchType = 'song' | 'playlist';
+export type PlaylistAddType = 'searches' | 'urls';
+export type PlaylistAddResult = {
+    added: Song[];
+    notFound: string[];
+};
+export type PlaylistSettings = {
+    services: IService[];
+    loop?: boolean;
+    autoplay?: boolean;
+    fallBackService?: IService;
+    logger?: Logger;
+};

package/dist/core/types.js

@@ -1,2 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,13 +1,13 @@
-import API = require('simple-youtube-api');
-import { IService, SearchType, SongInfo, Logger } from '../../core/';
-import YouTubeSong from './song';
-export default class YouTubeService implements IService {
-    readonly api: API;
-    canSearch: boolean;
-    type: string;
-    constructor(key: string);
-    fetch(targets: string[], logger?: Logger): Promise<YouTubeSong[]>;
-    search(queries: string[], searchType: SearchType, logger?: Logger): Promise<YouTubeSong[]>;
-    canFetch(target: string, logger?: Logger): Promise<boolean>;
-    getSongInfo(url: string, logger?: Logger): Promise<SongInfo>;
-}
+import API = require('simple-youtube-api');
+import { IService, SearchType, SongInfo, Logger } from '../../core/';
+import YouTubeSong from './song';
+export default class YouTubeService implements IService {
+    readonly api: API;
+    canSearch: boolean;
+    type: string;
+    constructor(key: string);
+    fetch(targets: string[], logger?: Logger): Promise<YouTubeSong[]>;
+    search(queries: string[], searchType: SearchType, logger?: Logger): Promise<YouTubeSong[]>;
+    canFetch(target: string, logger?: Logger): Promise<boolean>;
+    getSongInfo(url: string, logger?: Logger): Promise<SongInfo>;
+}