lnreader-plugins/plugins/russian/ranoberf.ts

import { Plugin } from "@typings/plugin";
import { FilterInputs } from "@libs/filterInputs";
import { defaultCover } from "@libs/defaultCover";
import { fetchApi, fetchFile } from "@libs/fetch";
import { NovelStatus } from "@libs/novelStatus";
import { load as parseHTML } from "cheerio";
import dayjs from "dayjs";

class RNRF implements Plugin.PluginBase {
  id = "RNRF";
  name = "РанобэРФ";
  site = "https://ранобэ.рф";
  version = "1.0.0";
  icon = "src/ru/ranoberf/icon.png";
  userAgent = "";
  cookieString = "";

  async popularNovels(
    pageNo: number,
    { showLatestNovels, filters }: Plugin.PopularNovelsOptions,
  ): Promise<Plugin.NovelItem[]> {
    let url = this.site + "/books?order=";
    url += showLatestNovels
      ? "lastPublishedChapter"
      : filters?.sort || "popular";
    url += "&page=" + pageNo;

    const result = await fetchApi(url);
    const body = await result.text();

    const loadedCheerio = parseHTML(body);
    const jsonRaw = loadedCheerio("#__NEXT_DATA__").html();
    const json: response = JSON.parse(jsonRaw || "{}");

    const novels: Plugin.NovelItem[] = [];
    json.props.pageProps?.totalData?.items?.forEach((novel) =>
      novels.push({
        name: novel.title,
        cover: novel?.verticalImage?.url
          ? this.site + novel.verticalImage.url
          : defaultCover,
        url: this.site + "/" + novel.slug,
      }),
    );

    return novels;
  }

  async parseNovelAndChapters(novelUrl: string): Promise<Plugin.SourceNovel> {
    const result = await fetchApi(novelUrl);
    const body = await result.text();

    const loadedCheerio = parseHTML(body);
    const jsonRaw = loadedCheerio("#__NEXT_DATA__").html();
    const book = (JSON.parse(jsonRaw || "{}") as response).props.pageProps.book;

    const novel: Plugin.SourceNovel = {
      url: novelUrl,
      name: book?.title,
      cover: book?.verticalImage?.url
        ? this.site + book.verticalImage.url
        : defaultCover,
      summary: book?.description,
      author: book?.author || "",
      genres: book?.genres.map((item) => item.title).join(", "),
      status: book?.additionalInfo.includes("Активен")
        ? NovelStatus.Ongoing
        : NovelStatus.Completed,
    };

    const chapters: Plugin.ChapterItem[] = [];

    book?.chapters?.forEach((chapter) => {
      if (!chapter?.isDonate || chapter?.isUserPaid) {
        chapters.push({
          name: chapter.title,
          releaseTime: dayjs(chapter.publishedAt).format("LLL"),
          url: this.site + chapter.url,
        });
      }
    });

    novel.chapters = chapters.reverse();
    return novel;
  }

  async parseChapter(chapterUrl: string): Promise<string> {
    const result = await fetchApi(chapterUrl);
    const body = await result.text();

    let loadedCheerio = parseHTML(body);
    const jsonRaw = loadedCheerio("#__NEXT_DATA__").html();
    const json: response = JSON.parse(jsonRaw || "{}");

    loadedCheerio = parseHTML(
      json.props.pageProps?.chapter?.content?.text || "",
    );

    const baseUrl = this.site;
    loadedCheerio("img").each(function () {
      if (!loadedCheerio(this).attr("src")?.startsWith("http")) {
        const src = loadedCheerio(this).attr("src");
        loadedCheerio(this).attr("src", baseUrl + src);
      }
    });

    const chapterText = loadedCheerio.html();
    return chapterText;
  }

  async searchNovels(
    searchTerm: string,
    //pageNo: number | undefined = 1,
  ): Promise<Plugin.NovelItem[]> {
    const url = `${this.site}/v3/books?filter[or][0][title][like]=${searchTerm}&filter[or][1][titleEn][like]=${searchTerm}&filter[or][2][fullTitle][like]=${searchTerm}&filter[status][]=active&filter[status][]=abandoned&filter[status][]=completed&expand=verticalImage`;
    const result = await fetchApi(url);
    const body = (await result.json()) as { items: Item[] };
    const novels: Plugin.NovelItem[] = [];

    body.items.forEach((novel) =>
      novels.push({
        name: novel.title,
        cover: novel?.verticalImage?.url
          ? this.site + novel.verticalImage.url
          : defaultCover,
        url: this.site + "/" + novel.slug,
      }),
    );

    return novels;
  }
  fetchImage = fetchFile;

  filters = [
    {
      key: "sort",
      label: "Сортировка",
      values: [
        { label: "Рейтинг", value: "popular" },
        { label: "Дате добавления", value: "new" },
        { label: "Дате обновления", value: "lastPublishedChapter" },
        { label: "Законченные", value: "completed" },
      ],
      inputType: FilterInputs.Picker,
    },
  ];
}
export default new RNRF();

interface response {
  props: Props;
  page: string;
  query: Query;
  buildId: string;
  isFallback: boolean;
  gssp: boolean;
  appGip: boolean;
  dynamicIds?: string[];
}

interface Props {
  pageProps: PageProps;
  isMobile: boolean;
  theme: string;
  __N_SSP: boolean;
}

interface PageProps {
  initialReduxState: InitialReduxState;
  book?: PagePropsBook;
  totalData?: TotalData;
  layoutViewCookies?: string;
  displayBanner?: boolean;
  chapter?: PagePropsChapter;
}

interface PagePropsBook {
  id: number;
  countryId: number;
  creatorId: number;
  lastChapterId: number;
  sourceId: number;
  imgVerticalId: number;
  imgHorizontalId: number;
  imgSquareId: number;
  imageVerticalId: number;
  imageHorizontalId: number;
  title: string;
  titleEn: string;
  fullTitle: string;
  fullTitleEn: string;
  description: string;
  slug: string;
  author: string;
  additionalInfo: string;
  importantInfo: string;
  status: string;
  views: number;
  likes: number;
  dislikes: number;
  intervalSec: number;
  intervalForNextFreeChapterSec: number;
  chapterCost: number;
  chapterPrice: number;
  chapterPriceCollected: number;
  maxSubscriptionChapters: number;
  maxDonateChapters: number;
  isDisplayOnMainPage: boolean;
  withoutSchedule: boolean;
  nextFreeChapterPublishedAt: null;
  createdAt: Date;
  updatedAt: Date;
  userRating: null;
  userBookmark: null;
  country: Country;
  genres: Genre[];
  timer: Timer;
  chapters: ChapterElement[];
  verticalImage: Image;
  horizontalImage: Image;
  squareImage: Image;
}

interface ChapterElement {
  id: number;
  bookId: number;
  title: string;
  url: string;
  numberChapter: string;
  tom: number | null;
  chapterShortNumber: number | null;
  isDonate: boolean;
  isSponsored: boolean;
  isSubscription: boolean;
  isEdited: boolean;
  publishedAt: Date;
  price: number;
  views: number;
  isUserPaid?: boolean;
}

interface Country {
  id: number;
  title: string;
  code: string;
}

interface Genre {
  id: number;
  title: string;
  slug: string;
}

interface Image {
  id: number;
  alt: string;
  path: string;
  name: string;
  url: string;
}

interface Timer {
  value: null;
  for: null;
  message: string;
}

interface PagePropsChapter {
  id: number;
  bookId: number;
  editorId: null;
  translatorId: number;
  parserChapterId: null;
  title: string;
  slug: string;
  status: string;
  tom: null;
  views: number;
  isSponsored: boolean;
  isSubscription: boolean;
  isDonate: boolean;
  isIndexing: boolean;
  publishedAt: Date;
  changeAvailabilityAt: null;
  createdAt: Date;
  updatedAt: Date;
  numberChapter: string;
  price: number;
  content: Content;
  book: ChapterBook;
  userBookmark: null;
  isUserPaid: boolean;
  nextChapter: null;
  previousChapter: PreviousChapter;
  corrections: null;
}

interface ChapterBook {
  id: number;
  title: string;
  titleEn: string;
  url: string;
}

interface Content {
  id: number;
  text: string;
  symbolsCount: number;
}

interface PreviousChapter {
  id: number;
  title: string;
  views: number;
  publishedAt: Date;
  url: string;
  numberChapter: string;
}

interface InitialReduxState {
  data?: Data;
  auth: Auth;
  banners?: Banners;
  corrections?: Corrections;
  readerSettings?: ReaderSettings;
}

interface Auth {
  isAuth: boolean;
  user: null;
}

interface Banners {
  displaySale: boolean;
}

interface Corrections {
  items: null;
  data: null;
}

interface Data {
  bookPage: BookPage | null;
  chapterPage: ChapterPage | null;
}

interface BookPage {
  bookId: number;
  bookmark: null;
}

interface ChapterPage {
  chapterId: number;
  bookId: number;
  bookmark: null;
}

interface ReaderSettings {
  fontSize: number;
  lineHeight: number;
  textIndent: number;
  sidebarHide: number;
  textAlign: string;
}

interface TotalData {
  items: Item[];
  _links: Links;
  pagesData: PagesData;
}

interface Links {
  self: First;
  first: First;
  last: First;
  next: First;
}

interface First {
  href: string;
}

interface Item {
  id: number;
  title: string;
  description: string;
  slug: string;
  url: string;
  status: string;
  dislikes: number;
  likes: number;
  userRating: null;
  lastChapter: ChapterElement;
  verticalImage: Image;
  horizontalImage: Image;
  squareImage: Image;
}

interface PagesData {
  totalCount: number;
  pageCount: number;
  currentPage: number;
  perPage: number;
}

interface Query {
  book?: string;
  chapter?: string;
}