more page items for parseLastAddedSection + getSection() restyle

Author: Catta1997

src/generic/main.ts

@@ -6,7 +6,6 @@ import {
     type Chapter,
     type ChapterDetails,
     type ChapterProviding,
-    type ChapterUpdatesCarouselItem,
     type DiscoverSection,
     type DiscoverSectionItem,
     type DiscoverSectionProviding,
@@ -299,72 +298,49 @@ export abstract class MangaWorldGeneric
                 items: [],
                 metadata: metadata,
             };
-        const chapterUpdate: ChapterUpdatesCarouselItem[] = [];
-        for (const item of json) {
-            switch (item.kind) {
-                case "trending":
-                    if (id == "popular_section")
-                        section = this.parser.parseTrendingChapters(
-                            metadata,
-                            this,
-                            item.data.mostViewedChapters,
-                        );
+        const parsers: Record<
+            string,
+            () => Promise<{
+                items: DiscoverSectionItem[];
+                metadata: MangaMetadata;
+            }>
+        > = {
+            updated_section: () =>
+                this.parser.parseChapterUpdateSection(metadata, this),
+            most_read_section: () =>
+                this.parser.parseMostReadSection(metadata, this),
+            new_manga_section: () =>
+                this.parser.parseLastAddedSection(metadata, this, false),
+            new_fav_type_section: () =>
+                this.parser.parseLastAddedSection(metadata, this, true),
+            genre_section: () => this.parser.parseGenreSection(this, metadata),
+            type_section: () => this.parser.parseTypeSection(this, metadata),
+        };
+        if (id === "popular_section" || id === "mese_section") {
+            for (const item of json) {
+                if (id === "popular_section" && item.kind === "trending") {
+                    section = this.parser.parseTrendingChapters(
+                        metadata,
+                        this,
+                        item.data.mostViewedChapters,
+                    );
                     break;
-                case "global":
-                    if (id == "mese_section")
-                        section = this.parser.parseMonthTrending(
-                            metadata,
-                            this,
-                            item.data.globalData.topMangas,
-                        );
-                    break;
-                case "manga":
-                    if (id == "updated_section") {
-                        const updated_section =
-                            await this.parser.parseLastAddedSection(
-                                metadata,
-                                this,
-                                item.data,
-                            );
-                        if (updated_section)
-                            chapterUpdate.push(updated_section);
-                    }
+                }
+
+                if (id === "mese_section" && item.kind === "global") {
+                    section = this.parser.parseMonthTrending(
+                        metadata,
+                        this,
+                        item.data.globalData.topMangas,
+                    );
                     break;
+                }
             }
         }
-        if (chapterUpdate.length > 0) {
-            section = { items: chapterUpdate, metadata: metadata };
-        }
-        if (section.items.length > 1) {
-            return section;
-        }
-        switch (id) {
-            case "most_read_section": {
-                return this.parser.parseMostReadSection(metadata, this);
-            }
-            case "new_manga_section": {
-                return this.parser.parseLastMangaAddedSection(
-                    metadata,
-                    this,
-                    false,
-                );
-            }
-            case "new_fav_type_section": {
-                return this.parser.parseLastMangaAddedSection(
-                    metadata,
-                    this,
-                    true,
-                );
-            }
-            case "genre_section": {
-                return this.parser.parseGenreSection(this, metadata);
-            }
-            case "type_section": {
-                return this.parser.parseTypeSection(this, metadata);
-            }
-            default:
-                return { items: [], metadata: metadata };
-        }
+        if (section.items.length > 1) return section;
+        const sectionParser = parsers[id];
+        if (sectionParser) return await sectionParser();
+        return section;
     }
 
     async getDiscoverSectionItems(

src/generic/models.ts

@@ -56,6 +56,7 @@ export interface Manga {
     statusT: string;
     tramaT: string;
     createdAt: string;
+    updatedAt: string;
 }
 
 export interface MangaChapterList {

src/generic/parsers.ts

@@ -9,12 +9,18 @@ import {
     type SourceManga,
     type TagSection,
 } from "@paperback/types";
-import { filter, jsonParser, MangaWorldGeneric, tags, types } from "./main";
+import {
+    cache,
+    filter,
+    jsonParser,
+    MangaWorldGeneric,
+    tags,
+    types,
+} from "./main";
 import type {
     Manga,
     MangaChapterList,
     MangaMetadata,
-    MangaPageData,
     TrendingManga,
     WindowEntry,
 } from "./models";
@@ -348,7 +354,7 @@ export class Parsers {
      * Parsing most read
      * @param {MangaMetadata} metadata - metadata
      * @param source
-     * @return {{ items: DiscoverSectionItem[], metadata: Metadata }}
+     * @return {{ items: DiscoverSectionItem[], metadata: MangaMetadata }}
      */
     async parseMostReadSection(
         metadata: MangaMetadata,
@@ -362,7 +368,7 @@ export class Parsers {
         return { items: latest, metadata: { page: page } };
     }
 
-    async parseLastMangaAddedSection(
+    async parseLastAddedSection(
         metadata: MangaMetadata,
         source: MangaWorldGeneric,
         favTags: boolean,
@@ -412,31 +418,50 @@ export class Parsers {
      * Parse new chapters
      * @param {MangaMetadata} metadata - manga metadata
      * @param source
-     * @param manga
-     * @return {{
-     *        items: DiscoverSectionItem[],
-     *        metadata: MangaMetadata | undefined
-     *    }}
+     * @return {Promise<{ items: DiscoverSectionItem[]; metadata: MangaMetadata }> }
      */
 
-    async parseLastAddedSection(
+    async parseChapterUpdateSection(
         metadata: MangaMetadata,
         source: MangaWorldGeneric,
-        manga: MangaPageData,
-    ): Promise<ChapterUpdatesCarouselItem | undefined> {
-        return {
-            chapterId: "items.manga",
-            metadata: metadata,
-            type: "chapterUpdatesCarouselItem",
-            publishDate: new Date(manga.manga.createdAt),
-            contentRating:
-                source.defaultContentRating === ContentRating.ADULT
-                    ? ContentRating.ADULT
-                    : source.defaultContentRating,
-            imageUrl: manga.manga.imageT ?? manga.manga.image,
-            mangaId: manga.manga.linkId + "/" + manga.manga.slug,
-            title: manga.manga.title ?? "",
-            subtitle: manga.chapters[0]?.name ?? "",
-        };
+    ): Promise<{ items: DiscoverSectionItem[]; metadata: MangaMetadata }> {
+        const page = metadata?.page ?? 1;
+        let html = "";
+        const updates: ChapterUpdatesCarouselItem[] = [];
+        if (page == 1) {
+            html = Application.arrayBufferToUTF8String(
+                await cache.getPageCache("home", source.base_url),
+            );
+        } else {
+            const data = (
+                await Application.scheduleRequest({
+                    url: `${source.base_url}/?page=${page}`,
+                    method: "GET",
+                })
+            )[1];
+            html = Application.arrayBufferToUTF8String(data);
+        }
+        const windowEntry = jsonParser.getWindowEntry(html);
+        for (const { kind, data } of windowEntry) {
+            if (kind !== "manga") continue;
+            const { manga, chapters } = data;
+            const firstChapter = chapters?.[0];
+            if (firstChapter) {
+                updates.push({
+                    chapterId: firstChapter.id ?? "",
+                    type: "chapterUpdatesCarouselItem",
+                    publishDate: new Date(firstChapter.createdAt),
+                    contentRating:
+                        source.defaultContentRating === ContentRating.ADULT
+                            ? ContentRating.ADULT
+                            : source.defaultContentRating,
+                    imageUrl: manga.imageT ?? manga.image,
+                    mangaId: `${manga.linkId}/${manga.slug}`,
+                    title: manga.title ?? "",
+                    subtitle: firstChapter.name ?? "",
+                });
+            }
+        }
+        return { items: updates, metadata: { page: page + 1 } };
     }
 }