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

package/dist/classes/Reply.d.ts

@@ -0,0 +1,38 @@
+import { Base, ChannelCompact, Video, BaseAttributes, Comment } from ".";
+import { YoutubeRawData } from "../common";
+/** @hidden */
+interface ReplyAttributes extends BaseAttributes {
+    comment: Comment;
+    video: Video;
+    author: ChannelCompact;
+    content: string;
+    publishDate: string;
+    likeCount: number;
+    isAuthorChannelOwner: boolean;
+}
+/** Represents a Reply */
+export default class Reply extends Base implements ReplyAttributes {
+    /** The comment this reply belongs to */
+    comment: Comment;
+    /** The video this reply belongs to */
+    video: Video;
+    /** The comment's author */
+    author: ChannelCompact;
+    /** The content of this comment */
+    content: string;
+    /** The publish date of the comment */
+    publishDate: string;
+    /** How many likes does this comment have */
+    likeCount: number;
+    /** Whether the comment is posted by the video uploader / owner */
+    isAuthorChannelOwner: boolean;
+    /** @hidden */
+    constructor(reply?: Partial<ReplyAttributes>);
+    /**
+     * Load this instance with raw data from Youtube
+     *
+     * @hidden
+     */
+    load(data: YoutubeRawData): Reply;
+}
+export {};

package/dist/classes/Reply.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = require(".");
+/** Represents a Reply */
+class Reply extends _1.Base {
+    /** @hidden */
+    constructor(reply = {}) {
+        super();
+        Object.assign(this, reply);
+    }
+    /**
+     * Load this instance with raw data from Youtube
+     *
+     * @hidden
+     */
+    load(data) {
+        const { authorText, authorThumbnail, authorEndpoint, contentText, publishedTimeText, commentId, likeCount, authorIsChannelOwner, } = data;
+        // Basic information
+        this.id = commentId;
+        this.content = contentText.runs.map((r) => r.text).join("");
+        this.publishDate = publishedTimeText.runs.shift().text;
+        this.likeCount = likeCount;
+        this.isAuthorChannelOwner = authorIsChannelOwner;
+        // Author
+        const { browseId } = authorEndpoint.browseEndpoint;
+        this.author = new _1.ChannelCompact({
+            id: browseId,
+            name: authorText.simpleText,
+            thumbnails: new _1.Thumbnails().load(authorThumbnail.thumbnails),
+            client: this.client,
+        });
+        return this;
+    }
+}
+exports.default = Reply;

package/dist/classes/SearchResult.d.ts

@@ -1,28 +1,72 @@
-import { SearchResultType, SearchOptions } from "./client";
+import { ChannelCompact, PlaylistCompact, VideoCompact, ClientTypes, Client } from ".";
+export declare type SearchResultType<T> = T extends "video" | VideoCompact ? VideoCompact : T extends "channel" | ChannelCompact ? ChannelCompact : T extends "playlist" | PlaylistCompact ? PlaylistCompact : VideoCompact | ChannelCompact | PlaylistCompact;
+/**
+ * Represents search result, usually returned from `client.search();`.
+ *
+ * {@link SearchResult} is a subclass of [Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)
+ * with {@link SearchResult.next} method to navigate through pagination
+ *
+ * @example
+ * ```ts
+ * const searchResult = await youtube.search("Keyword");
+ *
+ * console.log(searchResult); // search result from first page
+ *
+ * let nextSearchResult = await searchResult.next();
+ * console.log(nextSearchResult); // search result from second page
+ *
+ * nextSearchResult = await searchResult.next();
+ * console.log(nextSearchResult); // search result from third page
+ *
+ * console.log(searchResult); // search result from first, second, and third page.
+ * ```
+ *
+ * @noInheritDoc
+ */
 export default class SearchResult<T> extends Array<SearchResultType<T>> {
-    private latestContinuationToken;
+    /** The estimated search result count */
+    estimatedResults: number;
+    continuation?: string;
+    private client;
+    /** @hidden */
     constructor();
+    /**
+     * Load this instance
+     *
+     * @hidden
+     */
+    load(client: Client): SearchResult<T>;
     /**
      * Initialize data from search
      *
      * @param query Search query
      * @param options Search Options
+     * @hidden
      */
-    init(query: string, options: SearchOptions): Promise<SearchResult<T>>;
+    init(query: string, options: ClientTypes.SearchOptions): Promise<SearchResult<T>>;
     /**
-     * Load next search data
+     * Load next search data. Youtube returns inconsistent amount of search result, it usually varies from 18 to 20
+     *
+     * @example
+     * ```js
+     * const videos = await youtube.search("keyword", { type: "video" });
+     * console.log(videos) // first 18-20 videos from the search result
+     *
+     * let newVideos = await videos.next();
+     * console.log(newVideos) // 18-20 loaded videos
+     * console.log(videos) // 36-40 first videos from the search result
+     * ```
      *
      * @param count How many times to load the next data
      */
     next(count?: number): Promise<Array<SearchResultType<T>>>;
-    /**
-     * Load videos data from youtube
-     */
-    private loadVideos;
+    /** Load videos data from youtube */
+    private loadSearchResult;
     /**
      * Get type query value
      *
      * @param type Search type
+     * @hidden
      */
     static getSearchTypeParam(type: "video" | "playlist" | "channel" | "all"): string;
 }

package/dist/classes/SearchResult.js

@@ -1,17 +1,4 @@
 "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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -27,145 +14,137 @@ 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 SearchResult_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-var constants_1 = require("../constants");
-var common_1 = require("../common");
-var __1 = require("..");
-var SearchResult = /** @class */ (function (_super) {
-    __extends(SearchResult, _super);
-    function SearchResult() {
-        return _super.call(this) || this;
+const constants_1 = require("../constants");
+const common_1 = require("../common");
+const _1 = require(".");
+/**
+ * Represents search result, usually returned from `client.search();`.
+ *
+ * {@link SearchResult} is a subclass of [Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)
+ * with {@link SearchResult.next} method to navigate through pagination
+ *
+ * @example
+ * ```ts
+ * const searchResult = await youtube.search("Keyword");
+ *
+ * console.log(searchResult); // search result from first page
+ *
+ * let nextSearchResult = await searchResult.next();
+ * console.log(nextSearchResult); // search result from second page
+ *
+ * nextSearchResult = await searchResult.next();
+ * console.log(nextSearchResult); // search result from third page
+ *
+ * console.log(searchResult); // search result from first, second, and third page.
+ * ```
+ *
+ * @noInheritDoc
+ */
+let SearchResult = SearchResult_1 = class SearchResult extends Array {
+    /** @hidden */
+    constructor() {
+        super();
+    }
+    /**
+     * Load this instance
+     *
+     * @hidden
+     */
+    load(client) {
+        this.client = client;
+        return this;
     }
-    SearchResult_1 = SearchResult;
     /**
      * Initialize data from search
      *
      * @param query Search query
      * @param options Search Options
+     * @hidden
      */
-    SearchResult.prototype.init = function (query, options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var response;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, common_1.axios.post(constants_1.I_END_POINT + "/search", {
-                            query: query,
-                            params: SearchResult_1.getSearchTypeParam(options.type),
-                        })];
-                    case 1:
-                        response = _a.sent();
-                        this.loadVideos(response.data.contents.twoColumnSearchResultsRenderer.primaryContents
-                            .sectionListRenderer.contents);
-                        return [2 /*return*/, this];
-                }
+    init(query, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.client.http.post(`${constants_1.I_END_POINT}/search`, {
+                data: {
+                    query,
+                    params: options.params || SearchResult_1.getSearchTypeParam(options.type || "all"),
+                },
             });
+            this.estimatedResults = +response.data.estimatedResults;
+            if (this.estimatedResults > 0) {
+                this.loadSearchResult(response.data.contents.twoColumnSearchResultsRenderer.primaryContents
+                    .sectionListRenderer.contents);
+            }
+            return this;
         });
-    };
+    }
     /**
-     * Load next search data
+     * Load next search data. Youtube returns inconsistent amount of search result, it usually varies from 18 to 20
+     *
+     * @example
+     * ```js
+     * const videos = await youtube.search("keyword", { type: "video" });
+     * console.log(videos) // first 18-20 videos from the search result
+     *
+     * let newVideos = await videos.next();
+     * console.log(newVideos) // 18-20 loaded videos
+     * console.log(videos) // 36-40 first videos from the search result
+     * ```
      *
      * @param count How many times to load the next data
      */
-    SearchResult.prototype.next = function (count) {
-        if (count === void 0) { count = 1; }
-        return __awaiter(this, void 0, void 0, function () {
-            var newVideo, i, response;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        newVideo = [];
-                        i = 0;
-                        _a.label = 1;
-                    case 1:
-                        if (!(i < count)) return [3 /*break*/, 4];
-                        if (!this.latestContinuationToken)
-                            return [3 /*break*/, 4];
-                        return [4 /*yield*/, common_1.axios.post(constants_1.I_END_POINT + "/search", {
-                                continuation: this.latestContinuationToken,
-                            })];
-                    case 2:
-                        response = _a.sent();
-                        newVideo.push.apply(newVideo, this.loadVideos(response.data.onResponseReceivedCommands[0].appendContinuationItemsAction
-                            .continuationItems));
-                        _a.label = 3;
-                    case 3:
-                        i++;
-                        return [3 /*break*/, 1];
-                    case 4: return [2 /*return*/, newVideo];
-                }
-            });
+    next(count = 1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const newSearchResults = [];
+            for (let i = 0; i < count; i++) {
+                if (!this.continuation)
+                    break;
+                const response = yield this.client.http.post(`${constants_1.I_END_POINT}/search`, {
+                    data: { continuation: this.continuation },
+                });
+                newSearchResults.push(...this.loadSearchResult(response.data.onResponseReceivedCommands[0].appendContinuationItemsAction
+                    .continuationItems));
+            }
+            this.push(...newSearchResults);
+            return newSearchResults;
         });
-    };
-    /**
-     * Load videos data from youtube
-     */
-    SearchResult.prototype.loadVideos = function (sectionListContents) {
-        var _a, _b;
-        var contents = sectionListContents
-            .filter(function (c) { return "itemSectionRenderer" in c; })
+    }
+    /** Load videos data from youtube */
+    loadSearchResult(sectionListContents) {
+        const contents = sectionListContents
+            .filter((c) => "itemSectionRenderer" in c)
             .pop().itemSectionRenderer.contents;
-        var continuationToken = (_b = (_a = sectionListContents
-            .filter(function (c) { return "continuationItemRenderer" in c; })
-            .pop().continuationItemRenderer) === null || _a === void 0 ? void 0 : _a.continuationEndpoint) === null || _b === void 0 ? void 0 : _b.continuationCommand.token;
-        this.latestContinuationToken = continuationToken;
-        var newContent = [];
-        for (var _i = 0, contents_1 = contents; _i < contents_1.length; _i++) {
-            var content = contents_1[_i];
+        this.continuation = common_1.getContinuationFromItems(sectionListContents);
+        const newContent = [];
+        for (const content of contents) {
             if ("playlistRenderer" in content)
-                newContent.push(new __1.PlaylistCompact().load(content.playlistRenderer));
+                newContent.push(new _1.PlaylistCompact({ client: this.client }).load(content.playlistRenderer));
             else if ("videoRenderer" in content)
-                newContent.push(new __1.VideoCompact().load(content.videoRenderer));
+                newContent.push(new _1.VideoCompact({ client: this.client }).load(content.videoRenderer));
             else if ("channelRenderer" in content)
-                newContent.push(new __1.Channel().load(content.channelRenderer));
+                newContent.push(new _1.ChannelCompact({ client: this.client }).load(content.channelRenderer));
         }
-        this.push.apply(this, newContent);
+        this.push(...newContent);
         return newContent;
-    };
+    }
     /**
      * Get type query value
      *
      * @param type Search type
+     * @hidden
      */
-    SearchResult.getSearchTypeParam = function (type) {
-        var searchType = {
+    static getSearchTypeParam(type) {
+        const searchType = {
             video: "EgIQAQ%3D%3D",
             playlist: "EgIQAw%3D%3D",
             channel: "EgIQAg%3D%3D",
             all: "",
         };
         return type in searchType ? searchType[type] : "";
-    };
-    var SearchResult_1;
-    SearchResult = SearchResult_1 = __decorate([
-        common_1.extendsBuiltIn()
-    ], SearchResult);
-    return SearchResult;
-}(Array));
+    }
+};
+SearchResult = SearchResult_1 = __decorate([
+    common_1.extendsBuiltIn()
+], SearchResult);
 exports.default = SearchResult;

package/dist/classes/Thumbnails.d.ts

@@ -0,0 +1,42 @@
+interface Thumbnail {
+    url: string;
+    width: number;
+    height: number;
+}
+/**
+ * Represents Thumbnails, usually found inside Playlist / Channel / Video, etc.
+ *
+ * {@link Thumbnails} is an array of {@link Thumbnail}
+ *
+ * @noInheritDoc
+ */
+export default class Thumbnails extends Array<Thumbnail> {
+    /** @hidden */
+    constructor();
+    /**
+     * Returns thumbnail with the lowest resolution, usually the first element of the Thumbnails array
+     *
+     * @example
+     * ```js
+     * const min = video.thumbnails.min;
+     * ```
+     */
+    get min(): string | undefined;
+    /**
+     * Returns thumbnail with the highest resolution, usually the last element of the Thumbnails array
+     *
+     * @example
+     * ```js
+     * const min = video.thumbnails.min;
+     * ```
+     */
+    get best(): string | undefined;
+    /**
+     * Load this instance with raw data from Youtube
+     *
+     * @hidden
+     */
+    load(thumbnails: Thumbnail[]): Thumbnails;
+    private static parseThumbnailUrl;
+}
+export {};

package/dist/classes/Thumbnails.js

@@ -0,0 +1,66 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var Thumbnails_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("../common");
+/**
+ * Represents Thumbnails, usually found inside Playlist / Channel / Video, etc.
+ *
+ * {@link Thumbnails} is an array of {@link Thumbnail}
+ *
+ * @noInheritDoc
+ */
+let Thumbnails = Thumbnails_1 = class Thumbnails extends Array {
+    /** @hidden */
+    constructor() {
+        super();
+    }
+    /**
+     * Returns thumbnail with the lowest resolution, usually the first element of the Thumbnails array
+     *
+     * @example
+     * ```js
+     * const min = video.thumbnails.min;
+     * ```
+     */
+    get min() {
+        return Thumbnails_1.parseThumbnailUrl(this[0]);
+    }
+    /**
+     * Returns thumbnail with the highest resolution, usually the last element of the Thumbnails array
+     *
+     * @example
+     * ```js
+     * const min = video.thumbnails.min;
+     * ```
+     */
+    get best() {
+        return Thumbnails_1.parseThumbnailUrl(this[this.length - 1]);
+    }
+    /**
+     * Load this instance with raw data from Youtube
+     *
+     * @hidden
+     */
+    load(thumbnails) {
+        this.push(...thumbnails);
+        return this;
+    }
+    static parseThumbnailUrl({ url }) {
+        if (url.startsWith("//"))
+            return `https:${url}`;
+        if (!url.startsWith("https://"))
+            return `https://${url}`;
+        else
+            return url;
+    }
+};
+Thumbnails = Thumbnails_1 = __decorate([
+    common_1.extendsBuiltIn()
+], Thumbnails);
+exports.default = Thumbnails;

package/dist/classes/Video.d.ts

@@ -1,45 +1,52 @@
-import { PlaylistCompact, VideoCompact, Channel } from ".";
+import { BaseVideo, BaseVideoAttributes, Comment } from ".";
 import { YoutubeRawData } from "../common";
-interface VideoAttributes {
-    id: string;
-    title: string;
-    duration: number | null;
-    thumbnail: string;
-    description: string;
-    channel: Channel;
-    uploadDate: string;
-    viewCount: number | null;
-    likeCount: number | null;
-    dislikeCount: number | null;
-    isLiveContent: boolean;
-    tags: string[];
-    upNext: VideoCompact | PlaylistCompact;
-    related: (VideoCompact | PlaylistCompact)[];
+/** @hidden */
+interface VideoAttributes extends BaseVideoAttributes {
+    duration: number;
+    comments: Comment[];
+    commentContinuation?: string;
 }
-/**
- * Represent a Video
- */
-export default class Video implements VideoAttributes {
-    id: string;
-    title: string;
-    duration: number | null;
-    thumbnail: string;
-    description: string;
-    channel: Channel;
-    uploadDate: string;
-    viewCount: number | null;
-    likeCount: number | null;
-    dislikeCount: number | null;
-    isLiveContent: boolean;
-    tags: string[];
-    upNext: VideoCompact | PlaylistCompact;
-    related: (VideoCompact | PlaylistCompact)[];
+/** Represents a Video, usually returned from `client.getVideo()`  */
+export default class Video extends BaseVideo implements VideoAttributes {
+    /** The duration of this video in second */
+    duration: number;
+    /**
+     * Comments of this video
+     *
+     * You need to load the comment first by calling `video.nextComments()` as youtube doesn't send any comments data when loading the video (from `client.getVideo()`)
+     */
+    comments: Comment[];
+    /** Current continuation token to load next comments  */
+    commentContinuation?: string;
+    /** @hidden */
     constructor(video?: Partial<VideoAttributes>);
     /**
-     * Load instance attributes from youtube raw data
+     * Load this instance with raw data from Youtube
+     *
+     * @hidden
+     */
+    load(data: YoutubeRawData): Video;
+    /**
+     * Load next 20 comments of the video, and push the loaded comments to {@link Video.comments}
+     * You can only load up to 2000 comments from a video, this is due to the limitation from Youtube
+     *
+     * @example
+     * ```js
+     * const video = await youtube.getVideo(VIDEO_ID);
+     * await video.nextComments();
+     * console.log(video.comments) // first 20 comments
+     *
+     * let newComments = await video.nextComments();
+     * console.log(newComments) // 20 loaded comments
+     * console.log(video.comments) // first 40 comments
+     *
+     * await video.nextComments(0); // load the rest of the comments in the video
+     * ```
+     *
+     * @param count How many times to load the next comments. Set 0 to load all comments (might take a while on a video with many comments!)
      *
-     * @param youtubeRawData raw object from youtubei
+     * @returns Loaded comments
      */
-    load(youtubeRawData: YoutubeRawData): Video;
+    nextComments(count?: number): Promise<Comment[]>;
 }
 export {};