@xbibzlibrary/tiktokscrap/src/index.ts

Powerful TikTok Scraper and Downloader Library

import { TikTokScrapOptions, TikTokScrapResult, TikTokVideo, TikTokPhoto, TikTokUser, TikTokHashtag, TikTokComment, TikTokSearchOptions, TikTokUserFeedOptions, TikTokHashtagFeedOptions, TikTokDownloadOptions } from './types';
import { VideoScraper } from './scrapers/video';
import { PhotoScraper } from './scrapers/photo';
import { UserScraper } from './scrapers/user';
import { HashtagScraper } from './scrapers/hashtag';
import { VideoDownloader } from './downloaders/video';
import { PhotoDownloader } from './downloaders/photo';
import Logger from './utils/logger';

export class TikTokScrap {
  private videoScraper: VideoScraper;
  private photoScraper: PhotoScraper;
  private userScraper: UserScraper;
  private hashtagScraper: HashtagScraper;
  private videoDownloader: VideoDownloader;
  private photoDownloader: PhotoDownloader;
  private logger = Logger;

  constructor(options: TikTokScrapOptions = {}) {
    this.videoScraper = new VideoScraper(options);
    this.photoScraper = new PhotoScraper(options);
    this.userScraper = new UserScraper(options);
    this.hashtagScraper = new HashtagScraper(options);
    this.videoDownloader = new VideoDownloader();
    this.photoDownloader = new PhotoDownloader();
    
    this.logger.info('TikTokScrap initialized');
  }

  // Video methods
  public async getVideoByUrl(url: string): Promise<TikTokScrapResult<TikTokVideo>> {
    return this.videoScraper.getVideoByUrl(url);
  }

  public async getVideoById(id: string): Promise<TikTokScrapResult<TikTokVideo>> {
    try {
      const video = await this.videoScraper.getVideoById(id);
      return {
        success: true,
        data: video,
        message: 'Success'
      };
    } catch (error) {
      return {
        success: false,
        error: (error as Error).message,
        message: 'ERROR'
      };
    }
  }

  public async getVideoTrends(count: number = 20): Promise<TikTokScrapResult<TikTokVideo[]>> {
    return this.videoScraper.getVideoTrends(count);
  }

  public async getRecommendedVideos(videoId: string, count: number = 10): Promise<TikTokScrapResult<TikTokVideo[]>> {
    return this.videoScraper.getRecommendedVideos(videoId, count);
  }

  // Photo methods
  public async getPhotoByUrl(url: string): Promise<TikTokScrapResult<TikTokPhoto>> {
    return this.photoScraper.getPhotoByUrl(url);
  }

  public async getPhotoById(id: string): Promise<TikTokScrapResult<TikTokPhoto>> {
    try {
      const photo = await this.photoScraper.getPhotoById(id);
      return {
        success: true,
        data: photo,
        message: 'Success'
      };
    } catch (error) {
      return {
        success: false,
        error: (error as Error).message,
        message: 'ERROR'
      };
    }
  }

  public async getPhotoTrends(count: number = 20): Promise<TikTokScrapResult<TikTokPhoto[]>> {
    return this.photoScraper.getPhotoTrends(count);
  }

  public async getRecommendedPhotos(photoId: string, count: number = 10): Promise<TikTokScrapResult<TikTokPhoto[]>> {
    return this.photoScraper.getRecommendedPhotos(photoId, count);
  }

  // User methods
  public async getUserByUsername(username: string): Promise<TikTokScrapResult<TikTokUser>> {
    return this.userScraper.getUserByUsername(username);
  }

  public async getUserFeed(options: TikTokUserFeedOptions): Promise<TikTokScrapResult<TikTokVideo[] | TikTokPhoto[]>> {
    return this.userScraper.getUserFeed(options);
  }

  public async getUserVideos(username: string, cursor: number = 0, count: number = 20): Promise<TikTokScrapResult<TikTokVideo[]>> {
    return this.userScraper.getUserVideos(username, cursor, count);
  }

  public async getUserPhotos(username: string, cursor: number = 0, count: number = 20): Promise<TikTokScrapResult<TikTokPhoto[]>> {
    return this.userScraper.getUserPhotos(username, cursor, count);
  }

  public async getUserLikedVideos(username: string, cursor: number = 0, count: number = 20): Promise<TikTokScrapResult<TikTokVideo[]>> {
    return this.userScraper.getUserLikedVideos(username, cursor, count);
  }

  public async getUserLikedPhotos(username: string, cursor: number = 0, count: number = 20): Promise<TikTokScrapResult<TikTokPhoto[]>> {
    return this.userScraper.getUserLikedPhotos(username, cursor, count);
  }

  // Hashtag methods
  public async getHashtagByName(hashtag: string): Promise<TikTokScrapResult<TikTokHashtag>> {
    return this.hashtagScraper.getHashtagByName(hashtag);
  }

  public async getHashtagFeed(options: TikTokHashtagFeedOptions): Promise<TikTokScrapResult<TikTokVideo[] | TikTokPhoto[]>> {
    return this.hashtagScraper.getHashtagFeed(options);
  }

  public async getHashtagVideos(hashtag: string, cursor: number = 0, count: number = 20): Promise<TikTokScrapResult<TikTokVideo[]>> {
    return this.hashtagScraper.getHashtagVideos(hashtag, cursor, count);
  }

  public async getHashtagPhotos(hashtag: string, cursor: number = 0, count: number = 20): Promise<TikTokScrapResult<TikTokPhoto[]>> {
    return this.hashtagScraper.getHashtagPhotos(hashtag, cursor, count);
  }

  public async getTrendingHashtags(count: number = 20): Promise<TikTokScrapResult<TikTokHashtag[]>> {
    return this.hashtagScraper.getTrendingHashtags(count);
  }

  // Download methods
  public async downloadVideo(video: TikTokVideo, options: TikTokDownloadOptions = {}): Promise<TikTokScrapResult<string>> {
    return this.videoDownloader.downloadVideo(video, options);
  }

  public async downloadVideoByUrl(url: string, options: TikTokDownloadOptions = {}): Promise<TikTokScrapResult<string>> {
    return this.videoDownloader.downloadVideoByUrl(url, options);
  }

  public async downloadVideoCover(video: TikTokVideo, options: TikTokDownloadOptions = {}): Promise<TikTokScrapResult<string>> {
    return this.videoDownloader.downloadVideoCover(video, options);
  }

  public async downloadPhoto(photo: TikTokPhoto, options: TikTokDownloadOptions = {}): Promise<TikTokScrapResult<string[]>> {
    return this.photoDownloader.downloadPhoto(photo, options);
  }

  public async downloadPhotoByUrl(url: string, options: TikTokDownloadOptions = {}): Promise<TikTokScrapResult<string[]>> {
    return this.photoDownloader.downloadPhotoByUrl(url, options);
  }

  // Utility methods
  public updateOptions(options: Partial<TikTokScrapOptions>): void {
    this.videoScraper.updateOptions(options);
    this.photoScraper.updateOptions(options);
    this.userScraper.updateOptions(options);
    this.hashtagScraper.updateOptions(options);
  }

  public getOptions(): TikTokScrapOptions {
    return this.videoScraper.getOptions();
  }

  public setLogLevel(level: 0 | 1 | 2 | 3 | 4): void {
    this.logger.setLogLevel(level);
  }
}

// Export all types and classes
export * from './types';
export * from './errors';
export { VideoScraper } from './scrapers/video';
export { PhotoScraper } from './scrapers/photo';
export { UserScraper } from './scrapers/user';
export { HashtagScraper } from './scrapers/hashtag';
export { VideoDownloader } from './downloaders/video';
export { PhotoDownloader } from './downloaders/photo';
export { Logger } from './utils/logger';
export { HttpClient } from './utils/http';
export { Parser } from './utils/parser';
export { Validator } from './utils/validator';

// Default export
export default TikTokScrap;