lnreader-plugins/plugins/english/ranobes.ts

import { CheerioAPI, load as parseHTML } from 'cheerio';
import { fetchApi, fetchFile } from '@libs/fetch';
import { FilterTypes, Filters } from '@libs/filterInputs';
import { Plugin } from '@typings/plugin';

interface ChapterEntry {
  id: number;
  title: string;
  date: string;
  link: string;
}

class RanobesPlugin implements Plugin.PagePlugin {
  id = 'ranobes';
  name = 'Ranobes';
  icon = 'src/en/ranobes/icon.png';
  site = 'https://ranobes.top';
  filters?: Filters | undefined;
  version = '1.0.0';

  async sleep(ms: number) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

  parseNovels(loadedCheerio: CheerioAPI) {
    const novels: Plugin.NovelItem[] = [];

    loadedCheerio('.short-cont').each((i, el) => {
      const novelName = loadedCheerio(el).find('h2.title').text();
      const novelUrl = loadedCheerio(el).find('h2.title a').attr('href');
      const novelCover = loadedCheerio(el)
        .find('figure')
        .attr('style')
        ?.replace(/.*url\((.*?)\)./g, '$1');

      if (!novelUrl) return;

      const novel = {
        name: novelName,
        cover: novelCover,
        path: novelUrl?.replace(this.site, ''),
      };
      novels.push(novel);
    });
    return novels;
  }

  parseChapters(data: { chapters: ChapterEntry[] }) {
    const chapter: Plugin.ChapterItem[] = [];
    data.chapters.map((item: ChapterEntry) => {
      chapter.push({
        name: item.title,
        releaseTime: new Date(item.date).toISOString(),
        path: item.link.replace(this.site, ''),
      });
    });
    return chapter.reverse();
  }

  async popularNovels(
    page: number,
    {
      showLatestNovels,
      filters,
    }: Plugin.PopularNovelsOptions<typeof this.filters>,
  ): Promise<Plugin.NovelItem[]> {
    let link = `${this.site}/novels/page/${page}/`;
    const body = await fetchApi(link).then(result => result.text());

    const loadedCheerio = parseHTML(body);
    return this.parseNovels(loadedCheerio);
  }

  async parseNovel(
    novelPath: string,
  ): Promise<Plugin.SourceNovel & { totalPages: number }> {
    const url = this.site + novelPath;
    const result = await fetchApi(url);
    const body = await result.text();

    let loadedCheerio = parseHTML(body);

    const novel: Plugin.SourceNovel & { totalPages: number } = {
      path: novelPath,
      name: loadedCheerio('.poster img').attr('alt') || 'Untitled',
      cover: this.site + loadedCheerio('.poster img').attr('src'),
      author: loadedCheerio('[itemprop="creator"]').text(),
      chapters: [],
      totalPages: 1,
    };

    novel.summary = loadedCheerio('.moreless')
      .find('br')
      .replaceWith('\n')
      .end()
      .text()
      .trim();

    novel.status =
      loadedCheerio('li:contains("Status") span').text() === 'Ongoing'
        ? 'Ongoing'
        : 'Completed';

    novel.genres = loadedCheerio('div#mc-fs-genre').text().trim();

    let chapterListUrl = loadedCheerio('.read-continue:last').attr('href');

    if (!chapterListUrl?.startsWith('http')) {
      chapterListUrl = this.site + chapterListUrl;
    }

    const chaptersHtmlToString = await fetchApi(chapterListUrl).then(r =>
      r.text(),
    );
    const pageCheerio = parseHTML(chaptersHtmlToString);

    const json = pageCheerio('#dle-content main').next().html()!;
    const data = JSON.parse(json.replace('window.__DATA__ =', ''));
    novel.totalPages = Number(data.pages_count);
    novel.chapters = this.parseChapters(data);

    return novel;
  }

  async parsePage(novelPath: string, page: string): Promise<Plugin.SourcePage> {
    const pagePath = novelPath.split('-')[0];
    const firstUrl = this.site + '/chapters' + pagePath.replace('novels/', '');
    const pageUrl = firstUrl + '/page/' + page;

    const body = await fetchApi(firstUrl).then(r => r.text());

    let loadedCheerio = parseHTML(body);
    let json = loadedCheerio('#dle-content main').next().html()!;
    let data = JSON.parse(json.replace('window.__DATA__ =', ''));

    const latestChapterUrl = data.chapters[0].link;
    const latestChapterName = data.chapters[0].title;
    const latestChapterDate = data.chapters[0].date;

    const latestChapter: Plugin.ChapterItem | undefined = latestChapterUrl
      ? {
          path: latestChapterUrl.replace(this.site, ''),
          name: latestChapterName,
          releaseTime: new Date(latestChapterDate).toISOString(),
        }
      : undefined;

    await this.sleep(1000);

    const pageBody = await fetchApi(pageUrl).then(r => r.text());
    loadedCheerio = parseHTML(pageBody);
    json = loadedCheerio('#dle-content main').next().html()!;
    data = JSON.parse(json.replace('window.__DATA__ =', ''));
    const chapters = this.parseChapters(data);
    return {
      chapters,
      latestChapter,
    };
  }

  async parseChapter(chapterPath: string): Promise<string> {
    const result = await fetchApi(this.site + chapterPath);
    const body = await result.text();

    const loadedCheerio = parseHTML(body);

    const chapterText = loadedCheerio('#arrticle').html() || '';

    return chapterText;
  }

  async searchNovels(
    searchTerm: string,
    page: number,
  ): Promise<Plugin.NovelItem[]> {
    let link = `${this.site}/search/${searchTerm}/page/${page}`;

    const body = await fetchApi(link).then(r => r.text());

    const loadedCheerio = parseHTML(body);
    return this.parseNovels(loadedCheerio);
  }

  async fetchImage(url: string): Promise<string | undefined> {
    return await fetchFile(url);
  }
}
export default new RanobesPlugin();