295 lines
8.6 KiB
TypeScript
295 lines
8.6 KiB
TypeScript
import { getPlaylistVideos, getContinuationToken } from '../utils/extractor';
|
|
import { request } from '../../Request';
|
|
import { YouTubeChannel } from './Channel';
|
|
import { YouTubeVideo } from './Video';
|
|
const BASE_API = 'https://www.youtube.com/youtubei/v1/browse?key=';
|
|
/**
|
|
* YouTube Playlist Class containing vital informations about playlist.
|
|
*/
|
|
export class YouTubePlayList {
|
|
/**
|
|
* YouTube Playlist ID
|
|
*/
|
|
id?: string;
|
|
/**
|
|
* YouTube Playlist Name
|
|
*/
|
|
title?: string;
|
|
/**
|
|
* YouTube Class type. == "playlist"
|
|
*/
|
|
type: 'video' | 'playlist' | 'channel';
|
|
/**
|
|
* Total no of videos in that playlist
|
|
*/
|
|
videoCount?: number;
|
|
/**
|
|
* Time when playlist was last updated
|
|
*/
|
|
lastUpdate?: string;
|
|
/**
|
|
* Total views of that playlist
|
|
*/
|
|
views?: number;
|
|
/**
|
|
* YouTube Playlist url
|
|
*/
|
|
url?: string;
|
|
/**
|
|
* YouTube Playlist url with starting video url.
|
|
*/
|
|
link?: string;
|
|
/**
|
|
* YouTube Playlist channel data
|
|
*/
|
|
channel?: YouTubeChannel;
|
|
/**
|
|
* YouTube Playlist thumbnail Data
|
|
*/
|
|
thumbnail?: {
|
|
id: string | undefined;
|
|
width: number | undefined;
|
|
height: number | undefined;
|
|
url: string | undefined;
|
|
};
|
|
/**
|
|
* Videos array containing data of first 100 videos
|
|
*/
|
|
private videos?: YouTubeVideo[];
|
|
/**
|
|
* Map contaning data of all fetched videos
|
|
*/
|
|
private fetched_videos: Map<string, YouTubeVideo[]>;
|
|
/**
|
|
* Token containing API key, Token, ClientVersion.
|
|
*/
|
|
private _continuation: {
|
|
api?: string;
|
|
token?: string;
|
|
clientVersion?: string;
|
|
} = {};
|
|
/**
|
|
* Total no of pages count.
|
|
*/
|
|
private __count: number;
|
|
/**
|
|
* Constructor for YouTube Playlist Class
|
|
* @param data Json Parsed YouTube Playlist data
|
|
* @param searchResult If the data is from search or not
|
|
*/
|
|
constructor(data: any, searchResult = false) {
|
|
if (!data) throw new Error(`Cannot instantiate the ${this.constructor.name} class without data!`);
|
|
this.__count = 0;
|
|
this.fetched_videos = new Map();
|
|
this.type = 'playlist';
|
|
if (searchResult) this.__patchSearch(data);
|
|
else this.__patch(data);
|
|
}
|
|
/**
|
|
* Updates variable according to a normal data.
|
|
* @param data Json Parsed YouTube Playlist data
|
|
*/
|
|
private __patch(data: any) {
|
|
this.id = data.id || undefined;
|
|
this.url = data.url || undefined;
|
|
this.title = data.title || undefined;
|
|
this.videoCount = data.videoCount || 0;
|
|
this.lastUpdate = data.lastUpdate || undefined;
|
|
this.views = data.views || 0;
|
|
this.link = data.link || undefined;
|
|
this.channel = data.author || undefined;
|
|
this.thumbnail = data.thumbnail || undefined;
|
|
this.videos = data.videos || [];
|
|
this.__count++;
|
|
this.fetched_videos.set(`${this.__count}`, this.videos as YouTubeVideo[]);
|
|
this._continuation.api = data.continuation?.api ?? undefined;
|
|
this._continuation.token = data.continuation?.token ?? undefined;
|
|
this._continuation.clientVersion = data.continuation?.clientVersion ?? '<important data>';
|
|
}
|
|
/**
|
|
* Updates variable according to a searched data.
|
|
* @param data Json Parsed YouTube Playlist data
|
|
*/
|
|
private __patchSearch(data: any) {
|
|
this.id = data.id || undefined;
|
|
this.url = this.id ? `https://www.youtube.com/playlist?list=${this.id}` : undefined;
|
|
this.title = data.title || undefined;
|
|
this.thumbnail = data.thumbnail || undefined;
|
|
this.channel = data.channel || undefined;
|
|
this.videos = [];
|
|
this.videoCount = data.videos || 0;
|
|
this.link = undefined;
|
|
this.lastUpdate = undefined;
|
|
this.views = 0;
|
|
}
|
|
/**
|
|
* Parses next segment of videos from playlist and returns parsed data.
|
|
* @param limit Total no of videos to parse.
|
|
*
|
|
* Default = Infinity
|
|
* @returns Array of YouTube Video Class
|
|
*/
|
|
async next(limit = Infinity): Promise<YouTubeVideo[]> {
|
|
if (!this._continuation || !this._continuation.token) return [];
|
|
|
|
const nextPage = await request(`${BASE_API}${this._continuation.api}`, {
|
|
method: 'POST',
|
|
body: JSON.stringify({
|
|
continuation: this._continuation.token,
|
|
context: {
|
|
client: {
|
|
utcOffsetMinutes: 0,
|
|
gl: 'US',
|
|
hl: 'en',
|
|
clientName: 'WEB',
|
|
clientVersion: this._continuation.clientVersion
|
|
},
|
|
user: {},
|
|
request: {}
|
|
}
|
|
})
|
|
});
|
|
|
|
const contents =
|
|
JSON.parse(nextPage)?.onResponseReceivedActions[0]?.appendContinuationItemsAction?.continuationItems;
|
|
if (!contents) return [];
|
|
|
|
const playlist_videos = getPlaylistVideos(contents, limit);
|
|
this.fetched_videos.set(`${this.__count}`, playlist_videos);
|
|
this._continuation.token = getContinuationToken(contents);
|
|
return playlist_videos;
|
|
}
|
|
/**
|
|
* Fetches remaining data from playlist
|
|
* @param max Max no of videos to fetch
|
|
*
|
|
* Default = Infinity
|
|
* @returns
|
|
*/
|
|
async fetch(max = Infinity): Promise<YouTubePlayList> {
|
|
const continuation = this._continuation.token;
|
|
if (!continuation) return this;
|
|
if (max < 1) max = Infinity;
|
|
|
|
while (typeof this._continuation.token === 'string' && this._continuation.token.length) {
|
|
this.__count++;
|
|
const res = await this.next();
|
|
max -= res.length;
|
|
if(max <= 0) break;
|
|
if (!res.length) break;
|
|
}
|
|
|
|
return this;
|
|
}
|
|
/**
|
|
* YouTube Playlist is divided into pages.
|
|
*
|
|
* For example, if you want to get 101 - 200 songs
|
|
*
|
|
* ```ts
|
|
* const playlist = play.playlist_info('playlist url')
|
|
*
|
|
* await playlist.fetch()
|
|
*
|
|
* const result = playlist.page(2)
|
|
* ```
|
|
* @param number Page number
|
|
* @returns Array of YouTube Video Class
|
|
*/
|
|
page(number: number): YouTubeVideo[] {
|
|
if (!number) throw new Error('Page number is not provided');
|
|
if (!this.fetched_videos.has(`${number}`)) throw new Error('Given Page number is invalid');
|
|
return this.fetched_videos.get(`${number}`) as YouTubeVideo[];
|
|
}
|
|
/**
|
|
* Gets total no of pages in that playlist class.
|
|
*
|
|
* For getting all songs in a playlist
|
|
*
|
|
* ```ts
|
|
* const playlist = play.playlist_info('playlist url');
|
|
*
|
|
* await playlist.fetch();
|
|
*
|
|
* let result = [];
|
|
*
|
|
* for (let i = 0; i <= playlist.total_pages;i++) {
|
|
* result.push(playlist.page(i));
|
|
* }
|
|
* ```
|
|
*/
|
|
get total_pages() {
|
|
return this.fetched_videos.size;
|
|
}
|
|
/**
|
|
* This tells total no of videos that have been fetched so far.
|
|
*
|
|
* This can be equal to videosCount if all videos in playlist have been fetched and they are not hidden.
|
|
*/
|
|
get total_videos() {
|
|
const page_number: number = this.total_pages;
|
|
return (page_number - 1) * 100 + (this.fetched_videos.get(`${page_number}`) as YouTubeVideo[]).length;
|
|
}
|
|
/**
|
|
* Converts Playlist Class to a json parsed data.
|
|
* @returns
|
|
*/
|
|
toJSON() : PlaylistJSON {
|
|
return {
|
|
id: this.id,
|
|
title: this.title,
|
|
thumbnail: this.thumbnail,
|
|
channel: this.channel,
|
|
url: this.url,
|
|
videos: this.videos
|
|
};
|
|
}
|
|
}
|
|
|
|
interface PlaylistJSON{
|
|
/**
|
|
* YouTube Playlist ID
|
|
*/
|
|
id?: string;
|
|
/**
|
|
* YouTube Playlist Name
|
|
*/
|
|
title?: string;
|
|
/**
|
|
* Total no of videos in that playlist
|
|
*/
|
|
videoCount?: number;
|
|
/**
|
|
* Time when playlist was last updated
|
|
*/
|
|
lastUpdate?: string;
|
|
/**
|
|
* Total views of that playlist
|
|
*/
|
|
views?: number;
|
|
/**
|
|
* YouTube Playlist url
|
|
*/
|
|
url?: string;
|
|
/**
|
|
* YouTube Playlist url with starting video url.
|
|
*/
|
|
link?: string;
|
|
/**
|
|
* YouTube Playlist channel data
|
|
*/
|
|
channel?: YouTubeChannel;
|
|
/**
|
|
* YouTube Playlist thumbnail Data
|
|
*/
|
|
thumbnail?: {
|
|
id: string | undefined;
|
|
width: number | undefined;
|
|
height: number | undefined;
|
|
url: string | undefined;
|
|
};
|
|
/**
|
|
* first 100 videos in that playlist
|
|
*/
|
|
videos? : YouTubeVideo[]
|
|
} |