youtubei 0.0.1-rc.3 → 0.0.1-rc.32

package/dist/classes/LiveVideo.js

@@ -0,0 +1,94 @@
+"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 events_1 = require("events");
+const common_1 = require("../common");
+const _1 = require(".");
+const constants_1 = require("../constants");
+/** Represents a video that's currently live, usually returned from `client.getVideo()` */
+class LiveVideo extends _1.BaseVideo {
+    /** @hidden */
+    constructor(video = {}) {
+        super();
+        this._delay = 0;
+        this._timeoutMs = 0;
+        this._isChatPlaying = false;
+        this._chatQueue = [];
+        Object.assign(this, video);
+    }
+    /**
+     * Load this instance with raw data from Youtube
+     *
+     * @hidden
+     */
+    load(data) {
+        var _a;
+        super.load(data);
+        const videoInfo = _1.BaseVideo.parseRawData(data);
+        this.watchingCount = +videoInfo.viewCount.videoViewCountRenderer.viewCount.runs
+            .map((r) => r.text)
+            .join(" ")
+            .replace(/[^0-9]/g, "");
+        this.chatContinuation = (_a = data[3].response.contents.twoColumnWatchNextResults.conversationBar.liveChatRenderer) === null || _a === void 0 ? void 0 : _a.continuations[0].reloadContinuationData.continuation;
+        return this;
+    }
+    /**
+     * Start polling for get live chat request
+     *
+     * @param delay chat delay in millisecond
+     */
+    playChat(delay = 0) {
+        if (this._isChatPlaying)
+            return;
+        this._delay = delay;
+        this._isChatPlaying = true;
+        this.pollChatContinuation();
+    }
+    /** Stop request polling for live chat */
+    stopChat() {
+        if (!this._chatRequestPoolingTimeout)
+            return;
+        this._isChatPlaying = false;
+        clearTimeout(this._chatRequestPoolingTimeout);
+    }
+    /** Start request polling */
+    pollChatContinuation() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.client.http.post(constants_1.LIVE_CHAT_END_POINT, {
+                data: { continuation: this.chatContinuation },
+            });
+            if (!response.data.continuationContents)
+                return;
+            this.parseChat(response.data);
+            const continuation = response.data.continuationContents.liveChatContinuation.continuations[0];
+            const continuationData = continuation.timedContinuationData || continuation.invalidationContinuationData;
+            this._timeoutMs = continuationData.timeoutMs;
+            this.chatContinuation = continuationData.continuation;
+            this._chatRequestPoolingTimeout = setTimeout(() => this.pollChatContinuation(), this._timeoutMs);
+        });
+    }
+    /** Parse chat data from Youtube and add to chatQueue */
+    parseChat(data) {
+        var _a;
+        const chats = ((_a = data.continuationContents.liveChatContinuation.actions) === null || _a === void 0 ? void 0 : _a.flatMap((a) => { var _a; return ((_a = a.addChatItemAction) === null || _a === void 0 ? void 0 : _a.item.liveChatTextMessageRenderer) || []; })) || [];
+        for (const rawChatData of chats) {
+            const chat = new _1.Chat({ client: this.client }).load(rawChatData);
+            if (this._chatQueue.find((c) => c.id === chat.id))
+                continue;
+            this._chatQueue.push(chat);
+            setTimeout(() => {
+                this.emit("chat", chat);
+            }, chat.timestamp / 1000 - (new Date().getTime() - this._delay));
+        }
+    }
+}
+common_1.applyMixins(LiveVideo, [events_1.EventEmitter]);
+exports.default = LiveVideo;

package/dist/classes/MixPlaylist.d.ts

@@ -0,0 +1,32 @@
+import { Base, BaseAttributes, VideoCompact } from ".";
+import { YoutubeRawData } from "../common";
+/** @hidden */
+interface PlaylistAttributes extends BaseAttributes {
+    title: string;
+    videoCount: number;
+    videos: VideoCompact[];
+}
+/** Represents a MixPlaylist, usually returned from `client.getPlaylist()` */
+export default class MixPlaylist extends Base implements PlaylistAttributes {
+    /** The title of this playlist */
+    title: string;
+    /** How many videos in this playlist */
+    videoCount: number;
+    /** How many viewers does this playlist have */
+    videos: VideoCompact[];
+    /** @hidden */
+    constructor(playlist?: Partial<MixPlaylist>);
+    /**
+     * Load this instance with raw data from Youtube
+     *
+     * @hidden
+     */
+    load(data: YoutubeRawData): MixPlaylist;
+    /**
+     * Get compact videos
+     *
+     * @param MixplaylistContents raw object from youtubei
+     */
+    private static parseVideos;
+}
+export {};

package/dist/classes/MixPlaylist.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = require(".");
+/** Represents a MixPlaylist, usually returned from `client.getPlaylist()` */
+class MixPlaylist extends _1.Base {
+    /** @hidden */
+    constructor(playlist = {}) {
+        super();
+        /** How many viewers does this playlist have */
+        this.videos = [];
+        Object.assign(this, playlist);
+    }
+    /**
+     * Load this instance with raw data from Youtube
+     *
+     * @hidden
+     */
+    load(data) {
+        const twoColumnWatchNextResults = data.contents.twoColumnWatchNextResults;
+        const playlist = twoColumnWatchNextResults.playlist.playlist;
+        this.title = playlist.titleText.simpleText;
+        this.id = playlist.playlistId;
+        this.videoCount = playlist.contents.length;
+        this.videos = MixPlaylist.parseVideos(playlist.contents, this);
+        return this;
+    }
+    /**
+     * Get compact videos
+     *
+     * @param MixplaylistContents raw object from youtubei
+     */
+    static parseVideos(MixplaylistContents, playlist) {
+        const videosRenderer = MixplaylistContents.map((c) => c.playlistPanelVideoRenderer);
+        const videos = [];
+        for (const videoRenderer of videosRenderer) {
+            if (!videoRenderer)
+                continue;
+            const video = new _1.VideoCompact({ client: playlist.client }).load(videoRenderer);
+            videos.push(video);
+        }
+        return videos;
+    }
+}
+exports.default = MixPlaylist;

package/dist/classes/Playlist.d.ts

@@ -1,36 +1,53 @@
+import { BaseAttributes, VideoCompact, ChannelCompact, Base } from ".";
 import { YoutubeRawData } from "../common";
-import Channel from "./Channel";
-import VideoCompact from "./VideoCompact";
-interface PlaylistAttributes {
-    id: string;
+/** @hidden */
+interface PlaylistAttributes extends BaseAttributes {
     title: string;
     videoCount: number;
     viewCount: number;
     lastUpdatedAt: string;
-    channel?: Channel;
+    channel?: ChannelCompact;
     videos: VideoCompact[];
+    continuation?: string;
 }
-/**
- * Represent a Playlist
- */
-export default class Playlist implements PlaylistAttributes {
-    id: string;
+/** Represents a Playlist, usually returned from `client.getPlaylist()` */
+export default class Playlist extends Base implements PlaylistAttributes {
+    /** The title of this playlist */
     title: string;
+    /** How many videos in this playlist */
     videoCount: number;
+    /** How many viewers does this playlist have */
     viewCount: number;
+    /** Last time this playlist is updated */
     lastUpdatedAt: string;
-    channel?: Channel;
+    /** The channel that made this playlist */
+    channel?: ChannelCompact;
+    /** Videos in the playlist */
     videos: VideoCompact[];
-    private latestContinuationToken;
+    /** Current continuation token to load next videos  */
+    continuation: string | undefined;
+    /** @hidden */
     constructor(playlist?: Partial<Playlist>);
     /**
-     * Load instance attributes from youtube raw data
+     * Load this instance with raw data from Youtube
      *
-     * @param youtubeRawData raw object from youtubei
+     * @hidden
      */
-    load(youtubeRawData: YoutubeRawData): Playlist;
+    load(data: YoutubeRawData): Playlist;
     /**
-     * Load next videos of the playlist
+     * Load next 100 videos of the playlist, and push the loaded videos to {@link Playlist.videos}
+     *
+     * @example
+     * ```js
+     * const playlist = await youtube.getPlaylist(PLAYLIST_ID);
+     * console.log(playlist.videos) // first 100 videos
+     *
+     * let newVideos = await playlist.next();
+     * console.log(newVideos) // 100 loaded videos
+     * console.log(playlist.videos) // first 200 videos
+     *
+     * await playlist.next(0); // load the rest of the videos in the playlist
+     * ```
      *
      * @param count How many times to load the next videos. Set 0 to load all videos (might take a while on a large playlist!)
      */
@@ -40,7 +57,7 @@ export default class Playlist implements PlaylistAttributes {
      *
      * @param playlistContents raw object from youtubei
      */
-    private getVideos;
-    private getSideBarInfo;
+    private static parseVideos;
+    private static parseSideBarInfo;
 }
 export {};

package/dist/classes/Playlist.js

@@ -8,160 +8,124 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var common_1 = require("../common");
-var constants_1 = require("../constants");
-var Channel_1 = __importDefault(require("./Channel"));
-var VideoCompact_1 = __importDefault(require("./VideoCompact"));
-/**
- * Represent a Playlist
- */
-var Playlist = /** @class */ (function () {
-    function Playlist(playlist) {
-        if (playlist === void 0) { playlist = {}; }
+const _1 = require(".");
+const common_1 = require("../common");
+const constants_1 = require("../constants");
+/** Represents a Playlist, usually returned from `client.getPlaylist()` */
+class Playlist extends _1.Base {
+    /** @hidden */
+    constructor(playlist = {}) {
+        super();
+        /** Videos in the playlist */
+        this.videos = [];
         Object.assign(this, playlist);
     }
     /**
-     * Load instance attributes from youtube raw data
+     * Load this instance with raw data from Youtube
      *
-     * @param youtubeRawData raw object from youtubei
+     * @hidden
      */
-    Playlist.prototype.load = function (youtubeRawData) {
-        var _a, _b;
-        var sidebarRenderer = youtubeRawData.sidebar.playlistSidebarRenderer.items;
-        var primaryRenderer = sidebarRenderer[0].playlistSidebarPrimaryInfoRenderer;
+    load(data) {
+        var _a, _b, _c;
+        const sidebarRenderer = data.sidebar.playlistSidebarRenderer.items;
+        const primaryRenderer = sidebarRenderer[0].playlistSidebarPrimaryInfoRenderer;
+        const metadata = data.metadata.playlistMetadataRenderer;
         // Basic information
-        this.id = primaryRenderer.title.runs[0].navigationEndpoint.watchEndpoint.playlistId;
-        this.title = primaryRenderer.title.runs[0].text;
-        var stats = primaryRenderer.stats;
+        this.id = (_a = Object.values(metadata)
+            .find((v) => v.includes("playlist?list="))) === null || _a === void 0 ? void 0 : _a.split("=")[1];
+        this.title = metadata.title;
+        const { stats } = primaryRenderer;
         if (primaryRenderer.stats.length === 3) {
-            this.videoCount = this.getSideBarInfo(stats[0], true);
-            this.viewCount = this.getSideBarInfo(stats[1], true);
-            this.lastUpdatedAt = this.getSideBarInfo(stats[2], false);
+            this.videoCount = Playlist.parseSideBarInfo(stats[0], true);
+            this.viewCount = Playlist.parseSideBarInfo(stats[1], true);
+            this.lastUpdatedAt = Playlist.parseSideBarInfo(stats[2], false);
         }
         else if (stats.length === 2) {
-            this.videoCount = this.getSideBarInfo(stats[0], true);
-            this.lastUpdatedAt = this.getSideBarInfo(stats[1], false);
+            this.videoCount = Playlist.parseSideBarInfo(stats[0], true);
+            this.lastUpdatedAt = Playlist.parseSideBarInfo(stats[1], false);
         }
-        // Videos
-        var playlistContents = youtubeRawData.contents.twoColumnBrowseResultsRenderer.tabs[0].tabRenderer.content
+        const playlistContents = ((_b = data.contents.twoColumnBrowseResultsRenderer.tabs[0].tabRenderer.content
             .sectionListRenderer.contents[0].itemSectionRenderer.contents[0]
-            .playlistVideoListRenderer.contents;
-        var videos = this.getVideos(playlistContents);
+            .playlistVideoListRenderer) === null || _b === void 0 ? void 0 : _b.contents) || [];
         // Video Continuation Token
-        this.latestContinuationToken = (_a = playlistContents[100]) === null || _a === void 0 ? void 0 : _a.continuationItemRenderer.continuationEndpoint.continuationCommand.token;
-        this.videos = videos;
+        this.continuation = common_1.getContinuationFromItems(playlistContents);
         // Channel
-        var videoOwner = ((_b = sidebarRenderer[1]) === null || _b === void 0 ? void 0 : _b.playlistSidebarSecondaryInfoRenderer.videoOwner) || undefined;
+        const videoOwner = (_c = sidebarRenderer[1]) === null || _c === void 0 ? void 0 : _c.playlistSidebarSecondaryInfoRenderer.videoOwner;
         if (videoOwner) {
-            var _c = videoOwner.videoOwnerRenderer, title = _c.title, thumbnail = _c.thumbnail;
-            this.channel = new Channel_1.default({
+            const { title, thumbnail } = videoOwner.videoOwnerRenderer;
+            this.channel = new _1.ChannelCompact({
                 id: title.runs[0].navigationEndpoint.browseEndpoint.browseId,
                 name: title.runs[0].text,
-                thumbnails: thumbnail.thumbnails,
-                url: "https://www.youtube.com" +
-                    title.runs[0].navigationEndpoint.commandMetadata.webCommandMetadata.url,
+                thumbnails: new _1.Thumbnails().load(thumbnail.thumbnails),
+                client: this.client,
             });
         }
+        // Videos
+        this.videos = Playlist.parseVideos(playlistContents, this);
         return this;
-    };
+    }
     /**
-     * Load next videos of the playlist
+     * Load next 100 videos of the playlist, and push the loaded videos to {@link Playlist.videos}
+     *
+     * @example
+     * ```js
+     * const playlist = await youtube.getPlaylist(PLAYLIST_ID);
+     * console.log(playlist.videos) // first 100 videos
+     *
+     * let newVideos = await playlist.next();
+     * console.log(newVideos) // 100 loaded videos
+     * console.log(playlist.videos) // first 200 videos
+     *
+     * await playlist.next(0); // load the rest of the videos in the playlist
+     * ```
      *
      * @param count How many times to load the next videos. Set 0 to load all videos (might take a while on a large playlist!)
      */
-    Playlist.prototype.next = function (count) {
-        var _a;
-        if (count === void 0) { count = 1; }
-        return __awaiter(this, void 0, void 0, function () {
-            var newVideos, i, response, playlistContents;
-            var _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        newVideos = [];
-                        i = 0;
-                        _c.label = 1;
-                    case 1:
-                        if (!(i < count || count == 0)) return [3 /*break*/, 4];
-                        if (!this.latestContinuationToken)
-                            return [3 /*break*/, 4];
-                        return [4 /*yield*/, common_1.axios.post(constants_1.I_END_POINT + "/browse", {
-                                continuation: this.latestContinuationToken,
-                            })];
-                    case 2:
-                        response = _c.sent();
-                        playlistContents = response.data.onResponseReceivedActions[0].appendContinuationItemsAction
-                            .continuationItems;
-                        newVideos.push.apply(newVideos, this.getVideos(playlistContents));
-                        this.latestContinuationToken = (_a = playlistContents[100]) === null || _a === void 0 ? void 0 : _a.continuationItemRenderer.continuationEndpoint.continuationCommand.token;
-                        _c.label = 3;
-                    case 3:
-                        i++;
-                        return [3 /*break*/, 1];
-                    case 4:
-                        (_b = this.videos).push.apply(_b, newVideos);
-                        return [2 /*return*/, newVideos];
-                }
-            });
+    next(count = 1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const newVideos = [];
+            for (let i = 0; i < count || count == 0; i++) {
+                if (!this.continuation)
+                    break;
+                const response = yield this.client.http.post(`${constants_1.I_END_POINT}/browse`, {
+                    data: { continuation: this.continuation },
+                });
+                const playlistContents = response.data.onResponseReceivedActions[0].appendContinuationItemsAction
+                    .continuationItems;
+                const videos = common_1.mapFilter(playlistContents, "playlistVideoRenderer");
+                newVideos.push(...videos.map((video) => new _1.VideoCompact({ client: this.client }).load(video)));
+                this.continuation = common_1.getContinuationFromItems(playlistContents);
+            }
+            this.videos.push(...newVideos);
+            return newVideos;
         });
-    };
+    }
     /**
      * Get compact videos
      *
      * @param playlistContents raw object from youtubei
      */
-    Playlist.prototype.getVideos = function (playlistContents) {
-        var videosRenderer = playlistContents.map(function (c) { return c.playlistVideoRenderer; });
-        var videos = [];
-        for (var _i = 0, videosRenderer_1 = videosRenderer; _i < videosRenderer_1.length; _i++) {
-            var videoRenderer = videosRenderer_1[_i];
+    static parseVideos(playlistContents, playlist) {
+        const videosRenderer = playlistContents.map((c) => c.playlistVideoRenderer);
+        const videos = [];
+        for (const videoRenderer of videosRenderer) {
             if (!videoRenderer)
                 continue;
-            videos.push(new VideoCompact_1.default().load(videoRenderer));
+            const video = new _1.VideoCompact({ client: playlist.client }).load(videoRenderer);
+            videos.push(video);
         }
         return videos;
-    };
-    Playlist.prototype.getSideBarInfo = function (stats, parseInt) {
-        var data;
+    }
+    static parseSideBarInfo(stats, parseInt) {
+        let data;
         if ("runs" in stats)
-            data = stats.runs.map(function (r) { return r.text; }).join("");
+            data = stats.runs.map((r) => r.text).join("");
         else
             data = stats.simpleText.replace(/[^0-9]/g, "");
         if (parseInt)
             data = +data.replace(/[^0-9]/g, "");
         return data;
-    };
-    return Playlist;
-}());
+    }
+}
 exports.default = Playlist;

package/dist/classes/PlaylistCompact.d.ts

@@ -1,26 +1,38 @@
-import { Thumbnail, YoutubeRawData } from "../common";
-import BaseCompact from "./BaseCompact";
-import Channel from "./Channel";
-interface PlaylistCompactAttributes {
-    id: string;
+import { Thumbnails, BaseAttributes, Base, Playlist, ChannelCompact } from ".";
+import { YoutubeRawData } from "../common";
+/** @hidden */
+interface PlaylistCompactAttributes extends BaseAttributes {
     title: string;
-    thumbnails: Thumbnail[];
-    channel?: Channel;
+    thumbnails: Thumbnails;
+    channel?: ChannelCompact;
     videoCount: number;
 }
-/**
- * Represent a Compact Playlist (e.g. from search result, upNext / related of a video)
- */
-export default class PlaylistCompact extends BaseCompact implements PlaylistCompactAttributes {
+/** Represents a Compact Playlist (e.g. from search result, upNext / related of a video) */
+export default class PlaylistCompact extends Base implements PlaylistCompactAttributes {
+    /** The playlist's title */
     title: string;
-    channel?: Channel;
+    /** Thumbnails of the playlist with different sizes */
+    thumbnails: Thumbnails;
+    /** The channel that made this playlist */
+    channel?: ChannelCompact;
+    /** How many videos in this playlist */
     videoCount: number;
+    /** @hidden */
     constructor(playlist?: Partial<PlaylistCompactAttributes>);
     /**
-     * Load instance attributes from youtube raw data
+     * Load this instance with raw data from Youtube
      *
-     * @param youtubeRawData raw object from youtubei
+     * @hidden
      */
-    load(youtubeRawData: YoutubeRawData): PlaylistCompact;
+    load(data: YoutubeRawData): PlaylistCompact;
+    /**
+     * Get {@link Playlist} object based on current playlist id
+     *
+     * Equivalent to
+     * ```js
+     * client.getPlaylist(playlistCompact.id);
+     * ```
+     */
+    getPlaylist(): Promise<Playlist | undefined>;
 }
 export {};

package/dist/classes/PlaylistCompact.js

@@ -1,63 +1,59 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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 });
-var BaseCompact_1 = __importDefault(require("./BaseCompact"));
-var Channel_1 = __importDefault(require("./Channel"));
-/**
- * Represent a Compact Playlist (e.g. from search result, upNext / related of a video)
- */
-var PlaylistCompact = /** @class */ (function (_super) {
-    __extends(PlaylistCompact, _super);
-    function PlaylistCompact(playlist) {
-        if (playlist === void 0) { playlist = {}; }
-        var _this = _super.call(this) || this;
-        Object.assign(_this, playlist);
-        return _this;
+const _1 = require(".");
+const common_1 = require("../common");
+/** Represents a Compact Playlist (e.g. from search result, upNext / related of a video) */
+class PlaylistCompact extends _1.Base {
+    /** @hidden */
+    constructor(playlist = {}) {
+        super();
+        Object.assign(this, playlist);
     }
     /**
-     * Load instance attributes from youtube raw data
+     * Load this instance with raw data from Youtube
      *
-     * @param youtubeRawData raw object from youtubei
+     * @hidden
      */
-    PlaylistCompact.prototype.load = function (youtubeRawData) {
+    load(data) {
         var _a;
-        var playlistId = youtubeRawData.playlistId, title = youtubeRawData.title, thumbnail = youtubeRawData.thumbnail, shortBylineText = youtubeRawData.shortBylineText, videoCount = youtubeRawData.videoCount, videoCountShortText = youtubeRawData.videoCountShortText;
+        const { playlistId, title, thumbnail, shortBylineText, videoCount, videoCountShortText, } = data;
         this.id = playlistId;
         this.title = title.simpleText || title.runs[0].text;
-        this.videoCount =
-            +((_a = (videoCount !== null && videoCount !== void 0 ? videoCount : videoCountShortText.simpleText)) === null || _a === void 0 ? void 0 : _a.replace(/[^0-9]/g, "")) || 0;
+        this.videoCount = common_1.stripToInt(videoCount || videoCountShortText.simpleText) || 0;
         // Thumbnail
-        var thumbnails = youtubeRawData.thumbnails;
-        if (!thumbnails)
-            thumbnails = thumbnail.thumbnails;
-        else
-            thumbnails = thumbnails[0].thumbnails;
-        this.thumbnails = thumbnails;
+        this.thumbnails = new _1.Thumbnails().load(((_a = data.thumbnails) === null || _a === void 0 ? void 0 : _a[0].thumbnails) || thumbnail.thumbnails);
         // Channel
         if (shortBylineText && shortBylineText.simpleText !== "YouTube") {
-            this.channel = new Channel_1.default({
-                id: shortBylineText.runs[0].navigationEndpoint.browseEndpoint.browseId,
-                name: shortBylineText.runs[0].text,
-                url: "https://www.youtube.com" + shortBylineText.runs[0].navigationEndpoint.commandMetadata.webCommandMetadata.url,
+            const shortByLine = shortBylineText.runs[0];
+            this.channel = new _1.ChannelCompact({
+                id: shortByLine.navigationEndpoint.browseEndpoint.browseId,
+                name: shortByLine.text,
+                client: this.client,
             });
         }
         return this;
-    };
-    return PlaylistCompact;
-}(BaseCompact_1.default));
+    }
+    /**
+     * Get {@link Playlist} object based on current playlist id
+     *
+     * Equivalent to
+     * ```js
+     * client.getPlaylist(playlistCompact.id);
+     * ```
+     */
+    getPlaylist() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.client.getPlaylist(this.id));
+        });
+    }
+}
 exports.default = PlaylistCompact;