lnreader-plugins/plugins/vietnamese/LNHako.ts

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

class HakoPlugin implements Plugin.PluginBase {
  id = 'ln.hako';
  name = 'Hako';
  icon = 'src/vi/hakolightnovel/icon.png';
  site = 'https://ln.hako.vn';
  version = '1.0.1';
  parseNovels(loadedCheerio: CheerioAPI) {
    const novels: Plugin.NovelItem[] = [];
    loadedCheerio('#mainpart .row .thumb-item-flow').each((index, ele) => {
      let url = loadedCheerio(ele)
        .find('div.thumb_attr.series-title > a')
        .attr('href');

      if (url) {
        const name = loadedCheerio(ele).find('.series-title').text().trim();
        let cover = loadedCheerio(ele).find('.img-in-ratio').attr('data-bg');

        if (cover && !isUrlAbsolute(cover)) {
          cover = this.site + cover;
        }

        const novel = { name, path: url.replace(this.site, ''), cover };

        novels.push(novel);
      }
    });
    return novels;
  }
  async popularNovels(
    pageNo: number,
    {
      showLatestNovels,
      filters,
    }: Plugin.PopularNovelsOptions<typeof this.filters>,
  ): Promise<Plugin.NovelItem[]> {
    let link = this.site + '/danh-sach';
    if (filters.alphabet.value) {
      link += '/' + filters.alphabet.value;
    }
    const params = new URLSearchParams();
    for (const novelType of filters.type.value) {
      params.append(novelType, '1');
    }
    for (const status of filters.status.value) {
      params.append(status, '1');
    }
    params.append('sapxep', filters.sort.value);
    link += '?' + params.toString() + '&page=' + pageNo;
    const result = await fetch(link);
    const body = await result.text();
    const loadedCheerio = parseHTML(body);
    return this.parseNovels(loadedCheerio);
  }
  async parseNovel(novelPath: string): Promise<Plugin.SourceNovel> {
    const novel: Plugin.SourceNovel = {
      path: novelPath,
      name: 'Không có tiêu đề',
    };
    const result = await fetch(this.site + novelPath);
    const body = await result.text();

    let loadedCheerio = parseHTML(body);

    novel.name = loadedCheerio('.series-name').text().trim();

    const background =
      loadedCheerio('.series-cover > .a6-ratio > div').attr('style') || '';
    const novelCover = background.substring(
      background.indexOf('http'),
      background.length - 2,
    );

    novel.cover = novelCover
      ? isUrlAbsolute(novelCover)
        ? novelCover
        : this.site + novelCover
      : '';

    novel.summary = loadedCheerio('.summary-content').text().trim();

    novel.genres = loadedCheerio('.series-information > div:nth-child(1)')
      .text()
      .trim()
      .split(/\n[\s\n]*/)
      .join(',');

    novel.author = loadedCheerio(
      '.series-information > div:nth-child(2) > .info-value',
    )
      .text()
      .trim();
    novel.artist = loadedCheerio(
      '.series-information > div:nth-child(3) > .info-value',
    )
      .text()
      .trim();

    novel.status = loadedCheerio(
      '.series-information > div:nth-child(4) > .info-value',
    )
      .text()
      .trim();

    switch (novel.status) {
      case 'Đang tiến hành':
        novel.status = NovelStatus.Ongoing;
        break;
      case 'Tạm ngưng':
        novel.status = NovelStatus.OnHiatus;
        break;
      case 'Completed':
        novel.status = NovelStatus.Completed;
        break;
      default:
        novel.status = NovelStatus.Unknown;
    }

    novel.chapters = [];
    loadedCheerio('.volume-list').each((idx, ele) => {
      const customPage = loadedCheerio(ele).find('.sect-title').text().trim();
      let num = 0,
        part = 1;
      loadedCheerio(ele)
        .find('.list-chapters > li')
        .each((idx, chapterEle) => {
          const path = loadedCheerio(chapterEle).find('a').attr('href');
          const chapterName = loadedCheerio(chapterEle)
            .find('.chapter-name')
            .text()
            .trim();
          let chapterNumber = Number(chapterName.match(/Chương\s*(\d+)/i)?.[1]);
          if (chapterNumber) {
            num = chapterNumber;
            part = 1;
          } else {
            chapterNumber = num + part / 10;
            part++;
          }
          const chapterTime = loadedCheerio(chapterEle)
            .find('.chapter-time')
            .text()
            .split('/')
            .map(x => Number(x));
          if (path) {
            novel.chapters?.push({
              page: customPage,
              path,
              name: chapterName,
              releaseTime: new Date(
                chapterTime[2],
                chapterTime[1],
                chapterTime[0],
              ).toISOString(),
              chapterNumber: chapterNumber,
            });
          }
        });
    });
    return novel;
  }
  async parseChapter(chapterPath: string): Promise<string> {
    const result = await fetch(this.site + chapterPath);
    const body = await result.text();

    const loadedCheerio = parseHTML(body);

    const chapterText = loadedCheerio('#chapter-content').html() || '';

    return chapterText;
  }
  async searchNovels(
    searchTerm: string,
    pageNo: number,
  ): Promise<Plugin.NovelItem[]> {
    const url =
      this.site + '/tim-kiem?keywords=' + searchTerm + '&page=' + pageNo;
    const result = await fetch(url);
    const body = await result.text();
    const loadedCheerio = parseHTML(body);
    return this.parseNovels(loadedCheerio);
  }
  async fetchImage(url: string): Promise<string | undefined> {
    const headers = {
      Referer: 'https://ln.hako.vn',
    };
    return await fetchFile(url, { headers: headers });
  }
  filters = {
    alphabet: {
      type: FilterTypes.Picker,
      value: '',
      label: 'Chữ cái',
      options: [
        { label: 'Tất cả', value: '' },
        { label: 'Khác', value: 'khac' },
        { label: 'A', value: 'a' },
        { label: 'B', value: 'b' },
        { label: 'C', value: 'c' },
        { label: 'D', value: 'd' },
        { label: 'E', value: 'e' },
        { label: 'F', value: 'f' },
        { label: 'G', value: 'g' },
        { label: 'H', value: 'h' },
        { label: 'I', value: 'i' },
        { label: 'J', value: 'j' },
        { label: 'K', value: 'k' },
        { label: 'L', value: 'l' },
        { label: 'M', value: 'm' },
        { label: 'N', value: 'n' },
        { label: 'O', value: 'o' },
        { label: 'P', value: 'p' },
        { label: 'Q', value: 'q' },
        { label: 'R', value: 'r' },
        { label: 'S', value: 's' },
        { label: 'T', value: 't' },
        { label: 'U', value: 'u' },
        { label: 'V', value: 'v' },
        { label: 'W', value: 'w' },
        { label: 'X', value: 'x' },
        { label: 'Y', value: 'y' },
        { label: 'Z', value: 'z' },
      ],
    },
    type: {
      type: FilterTypes.CheckboxGroup,
      label: 'Phân loại',
      value: [],
      options: [
        { label: 'Truyện dịch', value: 'truyendich' },
        { label: 'Truyện sáng tác', value: 'sangtac' },
        { label: 'Convert', value: 'convert' },
      ],
    },
    status: {
      type: FilterTypes.CheckboxGroup,
      label: 'Tình trạng',
      value: [],
      options: [
        { label: 'Đang tiến hành', value: 'dangtienhanh' },
        { label: 'Tạm ngưng', value: 'tamngung' },
        { label: 'Đã hoàn thành', value: 'hoanthanh' },
      ],
    },
    sort: {
      type: FilterTypes.Picker,
      label: 'Sắp xếp',
      value: 'top',
      options: [
        { label: 'A-Z', value: 'tentruyen' },
        { label: 'Z-A', value: 'tentruyenza' },
        { label: 'Mới cập nhật', value: 'capnhat' },
        { label: 'Truyện mới', value: 'truyenmoi' },
        { label: 'Theo dõi', value: 'theodoi' },
        { label: 'Top toàn thời gian', value: 'top' },
        { label: 'Top tháng', value: 'topthang' },
        { label: 'Số từ', value: 'sotu' },
      ],
    },
  } satisfies Filters;
}

export default new HakoPlugin();