lnreader-plugins/plugins/vietnamese/Truyenconect.ts

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

interface VolumeData {
  story: string;
  navigation: string;
  value: string;
}

interface ChapterSelect {
  chap_selector: string;
  eps_selector: boolean | string;
}

interface VolumeList {
  chapters: Plugin.ChapterItem[];
  volumes?: VolumeData[];
}

class TruyenConect implements Plugin.PagePlugin {
  id = 'truyenconect';
  name = 'Truyen Conect';
  icon = 'src/vi/truyenconect/icon.png';
  site = 'https://truyenconect.com';
  version = '1.0.0';
  async sleep(ms: number) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
  parseNovels(loadedCheerio: CheerioAPI, selector: string) {
    const novels: Plugin.NovelItem[] = [];
    loadedCheerio(selector).each((idx, ele) => {
      const url = loadedCheerio(ele).find('a').attr('href');
      if (url) {
        novels.push({
          name: loadedCheerio(ele).find('img').attr('alt') || '',
          path: url.replace(this.site, ''),
          cover: loadedCheerio(ele).find('img').attr('data-src'),
        });
      }
    });
    return novels;
  }
  async popularNovels(
    pageNo: number,
    {
      filters,
      showLatestNovels,
    }: Plugin.PopularNovelsOptions<typeof this.filters>,
  ): Promise<Plugin.NovelItem[]> {
    let link = this.site;
    let selector = '.c-page__content > .grid9.block .item-thumb.c-image-hover';

    if (showLatestNovels) {
      selector =
        '.c-page__content .page-content-listing.item-big_thumbnail .item-thumb.c-image-hover';
    } else if (filters.category.value) {
      link += '/' + filters.category.value;
      selector =
        'table.manga-shortcodes.manga-chapters-listing td[width="10%"]';
      if (filters.category.value === 'the-loai') {
        selector = '.item-thumb.hover-details.c-image-hover';
        link += '/' + filters.genre.value;
      }
      link += '?page=' + pageNo;
    }

    const body = await fetch(link).then(r => r.text());
    const loadedCheerio = parseHTML(body);
    return this.parseNovels(loadedCheerio, selector);
  }
  parseChapters(loadedCheerio: CheerioAPI) {
    const chapters: Plugin.ChapterItem[] = [];
    loadedCheerio('option').each((idx, ele) => {
      let url = ele.attribs['value'];
      if (!url) return;
      const chapterId = url.match(/\/(\d+)-/)?.[1];
      if (chapterId) {
        url = url.replace(chapterId + '-', '') + '-' + chapterId;
      }
      let num = url.match(/chuong-(\d+)/)?.[1];
      chapters.push({
        path: url.replace(this.site, ''),
        name: loadedCheerio(ele).text().trim(),
        chapterNumber: Number(num) || undefined,
      });
    });
    return chapters.reverse();
  }
  parseVolumes(loadedCheerio: CheerioAPI) {
    const volumes: VolumeData[] = [];
    loadedCheerio('option').each((idx, ele) => {
      volumes.push({
        story: ele.attribs['data-story'],
        navigation: ele.attribs['data-navigation'],
        value: ele.attribs['value'],
      });
    });
    return volumes;
  }
  async getVolumes(firstChapterUrl: string) {
    const chapterId = firstChapterUrl.match(/-(\d+)$/)?.[1];
    if (!chapterId) throw new Error('Không tìm thấy chương');
    const url = this.site + '/truyen/get-chap-selector?chap=' + chapterId;
    const data: ChapterSelect = await fetch(url).then(r => r.json());
    const volumeList: VolumeList = {
      chapters: this.parseChapters(parseHTML(data.chap_selector)),
    };
    if (data.eps_selector) {
      volumeList.volumes = this.parseVolumes(
        parseHTML(data.eps_selector as string),
      );
    }
    return volumeList;
  }
  async parseNovel(
    novelPath: string,
  ): Promise<Plugin.SourceNovel & { totalPages: number }> {
    const url = this.site + novelPath;
    const result = await fetch(url);
    const body = await result.text();

    let loadedCheerio = parseHTML(body);

    const novel: Plugin.SourceNovel & { totalPages: number } = {
      name: loadedCheerio('.post-title > h1').text().trim(),
      path: novelPath,
      chapters: [],
      totalPages: 1,
    };

    novel.cover = loadedCheerio('.summary_image > a > img').attr('data-src');

    loadedCheerio('.post-content_item').each(function () {
      const detailName = loadedCheerio(this)
        .find('.summary-heading > h5')
        .text()
        .trim();
      const detail = loadedCheerio(this).find('.summary-content').html();

      if (!detail) return;

      switch (detailName) {
        case 'Thể loại':
          novel.genres = loadedCheerio(detail)
            .children('a')
            .map((i, el) => loadedCheerio(el).text())
            .toArray()
            .join(',');
          break;
        case 'Tác giả':
          novel.author = loadedCheerio(detail).text().trim();
          break;
        case 'Hoạ sĩ':
          novel.artist = loadedCheerio(detail).text().trim();
          break;
        case 'Trạng thái':
          const status = detail.trim();
          if (status === 'Full') novel.status = NovelStatus.Completed;
          else if (status === 'Tạm ngưng') novel.status = NovelStatus.OnHiatus;
          else if (status === 'Đang tiến hành')
            novel.status = NovelStatus.Ongoing;
          else novel.status = NovelStatus.Unknown;
          break;
      }
    });

    loadedCheerio('.description-summary > div.summary__content > div').remove();

    novel.summary = loadedCheerio('.description-summary > div.summary__content')
      .text()
      .trim();
    const firstChapLink = loadedCheerio('#init-links > a').first().attr('href');
    if (!firstChapLink) throw new Error('Không tìm thấy truyện');
    await this.sleep(1000);
    const volumeList = await this.getVolumes(firstChapLink);
    if (volumeList.volumes) {
      novel.totalPages = volumeList.volumes.length;
      novel.chapters = volumeList.chapters;
    } else {
      novel.totalPages = 1;
      novel.chapters = volumeList.chapters;
    }
    return novel;
  }
  async parsePage(novelPath: string, page: string): Promise<Plugin.SourcePage> {
    const url = this.site + novelPath;
    const result = await fetch(url);
    const body = await result.text();
    let loadedCheerio = parseHTML(body);
    const firstChapLink = loadedCheerio('#init-links > a').first().attr('href');
    if (!firstChapLink) throw new Error('Không tìm thấy truyện');
    await this.sleep(1000);
    const volumeList = await this.getVolumes(firstChapLink);
    const volumeIndex = Number(page) - 1;
    if (!volumeList.volumes) throw new Error('Không tìm thấy truyện');
    if (volumeIndex >= volumeList.volumes.length)
      throw new Error('Không tìm thấy volume');
    const volume = volumeList.volumes[volumeIndex];
    const query = `dataEpisodes=${volume.value}&datastory=${volume.story}&dataNavigation=${encodeURIComponent(volume.navigation)}`;
    const chaptersUrl = `${this.site}/truyen/getreadingchapAction?${query}`;
    await this.sleep(1000);
    const res: { err: number; html: string } = await fetch(chaptersUrl).then(
      r => r.json(),
    );
    if (res.err) throw new Error(res.html);
    return {
      chapters: this.parseChapters(parseHTML(res.html)),
    };
  }
  async parseChapter(chapterPath: string): Promise<string> {
    const result = await fetch(this.site + chapterPath);
    const body = await result.text();

    const loadedCheerio = parseHTML(body);
    let chapterText = loadedCheerio('.reading-content').html() || '';

    return chapterText;
  }
  async searchNovels(
    searchTerm: string,
    pageNo: number,
  ): Promise<Plugin.NovelItem[]> {
    const url = `${this.site}?key=${searchTerm}&page=${pageNo}`;
    const result = await fetch(url);
    const body = await result.text();

    const loadedCheerio = parseHTML(body);

    const novels: Plugin.NovelItem[] = [];

    loadedCheerio('.tab-thumb.c-image-hover > a').each((idx, ele) => {
      const novelName = ele.attribs['title'];
      const novelCover = loadedCheerio(ele).find('img').first().attr('src');
      const novelUrl = ele.attribs['href'];

      if (!novelUrl) return;

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

    return novels;
  }
  async fetchImage(url: string): Promise<string | undefined> {
    return fetchFile(url);
  }
  filters = {
    category: {
      label: 'Lọc theo',
      value: '',
      type: FilterTypes.Picker,
      options: [
        { label: '', value: '' },
        { label: 'Thể loại', value: 'the-loai' },
        { label: 'Truyện dịch', value: 'truyen-dich' },
        { label: 'Truyện convert', value: 'convert' },
      ],
    },
    genre: {
      label: 'Thể loại',
      value: 'action',
      type: FilterTypes.Picker,
      options: [
        { label: 'Action', value: 'action' },
        { label: 'Adult', value: 'adult' },
        { label: 'Adventure', value: 'adventure' },
        { label: 'Chinese novel', value: 'chinese-novel' },
        { label: 'Chuyển Sinh', value: 'chuyen-sinh' },
        { label: 'English Novel', value: 'english-novel' },
        { label: 'Harem', value: 'harem' },
        { label: 'Ecchi', value: 'ecchi' },
        { label: 'Fantasy', value: 'fantasy' },
        { label: 'Drama', value: 'drama' },
        { label: 'Game', value: 'game' },
        { label: 'Tiên hiệp', value: 'tien-hiep' },
        { label: 'Kiếm Hiệp', value: 'kiem-hiep' },
        { label: 'Ngôn Tình', value: 'ngon-tinh' },
        { label: 'Isekai', value: 'isekai' },
        { label: 'Lịch Sử', value: 'lich-su' },
        { label: 'Web Novel', value: 'web-novel' },
        { label: 'Xuyên không', value: 'xuyen-khong' },
        { label: 'Trọng sinh', value: 'trong-sinh' },
        { label: 'Trinh thám', value: 'trinh-tham' },
        { label: 'Dị giới', value: 'di-gioi' },
        { label: 'Huyền ảo', value: 'huyen-ao' },
        { label: 'Sắc Hiệp', value: 'sac-hiep' },
        { label: 'Dị năng', value: 'di-nang' },
        { label: 'Linh dị', value: 'linh-di' },
        { label: 'Đô thị', value: 'do-thi' },
        { label: 'Comedy', value: 'comedy' },
        { label: 'School Life', value: 'school-life' },
        { label: 'Romance', value: 'romance' },
        { label: 'Martial-arts', value: 'martial-arts' },
        { label: 'Light Novel', value: 'light-novel' },
        { label: 'Huyền huyễn', value: 'huyen-huyen' },
        { label: 'Kỳ Huyễn', value: 'ky-huyen' },
        { label: 'Khoa Huyễn', value: 'khoa-huyen' },
        { label: 'Võng Du', value: 'vong-du' },
        { label: 'Đồng Nhân', value: 'dong-nhan' },
      ],
    },
  } satisfies Filters;
}

export default new TruyenConect();