rsshub 1.0.0-master.f9ec483 → 1.0.0-master.fa04a11

package/lib/routes/syosetu/index.ts

@@ -0,0 +1,85 @@
+import { Route, Data, DataItem } from '@/types';
+import { fetchNovelInfo, fetchChapterContent } from './utils';
+import { Context } from 'hono';
+import { NovelType } from 'narou';
+
+export const route: Route = {
+    path: '/:ncode',
+    categories: ['reading'],
+    example: '/syosetu/n9292ii',
+    parameters: {
+        ncode: 'Novel code, can be found in URL',
+    },
+    features: {
+        requireConfig: false,
+        requirePuppeteer: false,
+        antiCrawler: false,
+        supportBT: false,
+        supportPodcast: false,
+        supportScihub: false,
+    },
+    name: 'Novel Updates',
+    maintainers: ['eternasuno', 'SnowAgar25'],
+    handler,
+    radar: [
+        {
+            title: 'Novel Updates',
+            source: ['ncode.syosetu.com/:ncode', 'ncode.syosetu.com/:ncode/:chapter'],
+            target: '/:ncode',
+        },
+        {
+            title: 'Novel Updates',
+            source: ['novel18.syosetu.com/:ncode', 'novel18.syosetu.com/:ncode/:chapter'],
+            target: '/:ncode',
+        },
+    ],
+};
+
+async function handler(ctx: Context): Promise<Data> {
+    const { ncode } = ctx.req.param();
+    const limit = Math.min(Number(ctx.req.query('limit') ?? 5), 20);
+
+    const { baseUrl, novel } = await fetchNovelInfo(ncode);
+    novel.story = novel.story.replaceAll('\n', '<br>') || '';
+
+    // Tanpen = Short
+    if (novel.noveltype === NovelType.Tanpen) {
+        const chapterUrl = `${baseUrl}/${ncode}`;
+        const item = await fetchChapterContent(chapterUrl);
+
+        // Shorts are updated rather than having new chapters
+        // Use novelupdated_at as pubDate since RSS 2.0 doesn't have updated field
+        item.pubDate = novel.novelupdated_at;
+
+        return {
+            title: novel.title,
+            description: novel.story,
+            link: chapterUrl,
+            item: [item] as DataItem[],
+            language: 'ja',
+        };
+    }
+
+    // Rensai = Series
+    // if (novel.noveltype === NovelType.Rensai)
+    const totalChapters = novel.general_all_no ?? 1;
+    const startChapter = Math.max(totalChapters - limit + 1, 1);
+
+    const items = await Promise.all(
+        Array.from({ length: Math.min(limit, totalChapters) }, async (_, index) => {
+            const chapterNumber = startChapter + index;
+            const chapterUrl = `${baseUrl}/${ncode}/${chapterNumber}`;
+
+            const item = await fetchChapterContent(chapterUrl, chapterNumber);
+            return item;
+        }).reverse()
+    );
+
+    return {
+        title: novel.title,
+        description: novel.story,
+        link: `${baseUrl}/${ncode}`,
+        item: items as DataItem[],
+        language: 'ja',
+    };
+}

package/lib/routes/syosetu/namespace.ts

@@ -1,7 +1,7 @@
 import type { Namespace } from '@/types';
 
 export const namespace: Namespace = {
-    name: 'syosetu',
-    url: 'ncode.syosetu.com',
+    name: 'Syosetu',
+    url: 'syosetu.com',
     lang: 'ja',
 };

package/lib/routes/syosetu/ranking-isekai.ts

@@ -0,0 +1,93 @@
+import { Data, DataItem } from '@/types';
+import { NarouNovelFetch, SearchBuilder, SearchParams, BigGenre } from 'narou';
+import { art } from '@/utils/render';
+import path from 'node:path';
+import { getCurrentPath } from '@/utils/helpers';
+import InvalidParameterError from '@/errors/types/invalid-parameter';
+import { Join } from 'narou/util/type';
+import { RankingPeriod, NovelType, periodToJapanese, novelTypeToJapanese, periodToOrder, periodToPointField, IsekaiCategory, isekaiCategoryToJapanese } from './types/ranking';
+
+const __dirname = getCurrentPath(import.meta.url);
+
+export function parseIsekaiRankingType(type: string): { period: RankingPeriod; category: IsekaiCategory; novelType: NovelType } {
+    const [periodStr, categoryStr, novelTypeStr = NovelType.TOTAL] = type.split('_');
+
+    const period = periodStr as RankingPeriod;
+    const category = categoryStr as IsekaiCategory;
+    const novelType = novelTypeStr as NovelType;
+
+    const isValid = [Object.values(RankingPeriod).includes(period), Object.values(IsekaiCategory).includes(category), Object.values(NovelType).includes(novelType)].every(Boolean);
+
+    if (!isValid) {
+        throw new InvalidParameterError(`Invalid isekai ranking type: ${type}`);
+    }
+
+    return { period, category, novelType };
+}
+
+function getIsekaiSearchParams(period, category, novelType, limit): SearchParams {
+    const searchParams: SearchParams = {
+        order: periodToOrder[period],
+        gzip: 5,
+        // Request 20% more items to compensate for potential duplicates between tensei/tenni
+        lim: Math.ceil((limit / 2) * 1.2),
+    };
+
+    if (novelType !== NovelType.TOTAL) {
+        searchParams.type = novelType;
+    }
+
+    switch (category) {
+        case IsekaiCategory.RENAI:
+            searchParams.biggenre = BigGenre.Renai;
+            break;
+        case IsekaiCategory.FANTASY:
+            searchParams.biggenre = BigGenre.Fantasy;
+            break;
+        case IsekaiCategory.OTHER:
+            searchParams.biggenre = `${BigGenre.Bungei}-${BigGenre.Sf}-${BigGenre.Sonota}` as Join<BigGenre>;
+            break;
+        default:
+            throw new InvalidParameterError(`Invalid Isekai category: ${category}`);
+    }
+
+    return searchParams;
+}
+
+export async function handleIsekaiRanking(type: string, limit: number): Promise<Data> {
+    const { period, category, novelType } = parseIsekaiRankingType(type);
+    const rankingUrl = `https://yomou.syosetu.com/rank/isekailist/type/${type}`;
+    const rankingTitle = `[${periodToJapanese[period]}] 異世界転生/転移${isekaiCategoryToJapanese[category]}ランキング - ${novelTypeToJapanese[novelType]} BEST${limit}`;
+
+    const searchParams = getIsekaiSearchParams(period, category, novelType, limit);
+    const api = new NarouNovelFetch();
+
+    const [tenseiResult, tenniResult] = await Promise.all([new SearchBuilder({ ...searchParams, istensei: 1 }, api).execute(), new SearchBuilder({ ...searchParams, istenni: 1 }, api).execute()]);
+
+    const combinedNovels = [...tenseiResult.values, ...tenniResult.values];
+    const uniqueNovels = [...new Map(combinedNovels.map((novel) => [novel.ncode, novel])).values()];
+
+    const pointField = periodToPointField[period];
+    if (!pointField) {
+        throw new InvalidParameterError(`Invalid period: ${period}`);
+    }
+
+    const items = uniqueNovels
+        .sort((a, b) => (b[pointField] || 0) - (a[pointField] || 0))
+        .map((novel, index) => ({
+            title: `#${index + 1} ${novel.title}`,
+            link: `https://ncode.syosetu.com/${String(novel.ncode).toLowerCase()}`,
+            description: art(path.join(__dirname, 'templates', 'description.art'), {
+                novel,
+            }),
+            author: novel.writer,
+            category: novel.keyword.split(/[\s/\uFF0F]/).filter(Boolean),
+        }));
+
+    return {
+        title: `小説家になろう - ${rankingTitle}`,
+        link: rankingUrl,
+        item: items.slice(0, limit) as DataItem[],
+        language: 'ja',
+    };
+}

package/lib/routes/syosetu/ranking-r18.ts

@@ -0,0 +1,192 @@
+import { Route, Data, DataItem } from '@/types';
+import { art } from '@/utils/render';
+import path from 'node:path';
+import { Context } from 'hono';
+import { SearchBuilderR18, SearchParams, NarouNovelFetch } from 'narou';
+import InvalidParameterError from '@/errors/types/invalid-parameter';
+import { getCurrentPath } from '@/utils/helpers';
+import { RankingPeriod, periodToJapanese, novelTypeToJapanese, periodToOrder, NovelType, SyosetuSub, syosetuSubToJapanese, syosetuSubToNocgenre } from './types/ranking-r18';
+
+const __dirname = getCurrentPath(import.meta.url);
+
+/**
+ * Implementation of "Syosetu" R18 Rankings
+ *
+ * While "Syosetu" only provides ranking API for "Syosetu o yomou" (general audience),
+ * equivalent ranking functionality can be achieved using the point-based sorting in the search API.
+ *
+ * This implementation utilizes the 'order' parameter (e.g., dailypoint, weeklypoint)
+ * of the search API to replicate ranking functionality across all Syosetu subsidiary sites.
+ */
+
+const getParameters = () => {
+    // Generate options for sub parameter
+    const subOptions = Object.entries(SyosetuSub).map(([, value]) => ({
+        value,
+        label: syosetuSubToJapanese[value],
+    }));
+
+    // Generate period options
+    const periodOptions = Object.entries(RankingPeriod).map(([key, value]) => ({
+        value,
+        label: `${periodToJapanese[value]} (${key})`,
+    }));
+
+    // Generate novel type options
+    const novelTypeOptions = Object.entries(NovelType).map(([key, value]) => ({
+        value,
+        label: `${novelTypeToJapanese[value]} (${key})`,
+    }));
+
+    return {
+        sub: {
+            description: 'Target site for R18 rankings',
+            options: subOptions,
+        },
+        type: {
+            description: 'Detailed ranking type (format: period_noveltype)',
+            options: periodOptions.flatMap((period) =>
+                novelTypeOptions.map((type) => ({
+                    value: `${period.value}_${type.value}`,
+                    label: `${period.label} ${type.label}`,
+                }))
+            ),
+        },
+    };
+};
+
+const getBest5RadarItems = () =>
+    Object.entries(SyosetuSub).flatMap(([, domain]) =>
+        Object.values(RankingPeriod).map((period) => ({
+            title: `${syosetuSubToJapanese[domain]} ${periodToJapanese[period]}ランキング BEST5`,
+            source: [`${domain === SyosetuSub.MOONLIGHT_BL ? SyosetuSub.MOONLIGHT : domain}.syosetu.com/rank/${domain === SyosetuSub.MOONLIGHT_BL ? 'bltop' : 'top'}`],
+            target: `/rankingr18/${domain}/${period}_${NovelType.TOTAL}?limit=5`,
+        }))
+    );
+
+export const route: Route = {
+    path: '/rankingr18/:sub/:type',
+    categories: ['reading'],
+    example: '/syosetu/rankingr18/noc/daily_total?limit=50',
+    parameters: getParameters(),
+    features: {
+        requireConfig: false,
+        requirePuppeteer: false,
+        antiCrawler: false,
+        supportBT: false,
+        supportPodcast: false,
+        supportScihub: false,
+    },
+    name: 'R18 Rankings',
+    url: 'syosetu.com/site/group',
+    maintainers: ['SnowAgar25'],
+    handler,
+    description: `
+| Period | Description | 説明 |
+| --- | --- | --- |
+| daily | Daily Ranking | 日間ランキング |
+| weekly | Weekly Ranking | 週間ランキング |
+| monthly | Monthly Ranking | 月間ランキング |
+| quarter | Quarterly Ranking | 四半期ランキング |
+| yearly | Yearly Ranking | 年間ランキング |
+
+| Novel Type | Description | 説明 |
+| --- | --- | --- |
+| total | All Works | 総合 |
+| t | Short Stories | 短編 |
+| r | Ongoing Series | 連載中 |
+| er | Completed Series | 完結済 |
+
+::: tip
+Combine Period and Novel Type with \`_\`.
+For example: \`daily_total\`, \`weekly_r\`, \`monthly_er\`
+:::`,
+    radar: [
+        {
+            source: ['noc.syosetu.com/rank/list/type/:type'],
+            target: '/rankingr18/noc/:type',
+        },
+        {
+            source: ['mid.syosetu.com/rank/list/type/:type'],
+            target: '/rankingr18/mid/:type',
+        },
+        {
+            source: ['mnlt.syosetu.com/rank/list/type/:type'],
+            target: '/rankingr18/mnlt/:type',
+        },
+        {
+            source: ['mnlt.syosetu.com/rank/bllist/type/:type'],
+            target: '/rankingr18/mnlt-bl/:type',
+        },
+        ...getBest5RadarItems(),
+    ],
+};
+
+function parseRankingType(type: string): { period: RankingPeriod; novelType: NovelType } {
+    const [periodStr, novelTypeStr] = type.split('_');
+
+    const period = periodStr as RankingPeriod;
+    const novelType = novelTypeStr as NovelType;
+
+    const isValid = [Object.values(RankingPeriod).includes(period), Object.values(NovelType).includes(novelType)].every(Boolean);
+
+    if (!isValid) {
+        throw new InvalidParameterError(`Invalid ranking type: ${type}`);
+    }
+
+    return {
+        period: periodStr as RankingPeriod,
+        novelType: novelTypeStr as NovelType,
+    };
+}
+
+function getRankingTitle(type: string, limit: number): string {
+    const { period, novelType } = parseRankingType(type);
+    return `${periodToJapanese[period]}${novelTypeToJapanese[novelType]}ランキング BEST${limit}`;
+}
+
+async function handler(ctx: Context): Promise<Data> {
+    const { sub, type } = ctx.req.param();
+    const baseUrl = `https://${sub === SyosetuSub.MOONLIGHT_BL ? SyosetuSub.MOONLIGHT : sub}.syosetu.com`;
+    const rankingUrl = `${baseUrl}/rank/list/type/${type}`;
+    const api = new NarouNovelFetch();
+
+    const limit = Math.min(Number(ctx.req.query('limit') ?? 300), 300);
+    const { period, novelType } = parseRankingType(type);
+
+    const searchParams: SearchParams = {
+        gzip: 5,
+        lim: limit,
+        order: periodToOrder[period],
+    };
+
+    // TOTAL: Skip type filter to get all types combined
+    if (novelType !== NovelType.TOTAL) {
+        searchParams.type = novelType;
+    }
+
+    if (!(sub in syosetuSubToNocgenre)) {
+        throw new InvalidParameterError(`Invalid subsite: ${sub}`);
+    }
+    const nocgenre = syosetuSubToNocgenre[sub];
+
+    const builder = new SearchBuilderR18(searchParams, api).r18Site(nocgenre);
+    const result = await builder.execute();
+
+    const items = result.values.map((novel, index) => ({
+        title: `#${index + 1} ${novel.title}`,
+        link: `https://novel18.syosetu.com/${String(novel.ncode).toLowerCase()}`,
+        description: art(path.join(__dirname, 'templates', 'description.art'), {
+            novel,
+        }),
+        author: novel.writer,
+        category: novel.keyword.split(/[\s/\uFF0F]/).filter(Boolean),
+    }));
+
+    return {
+        title: `小説家になろう (${sub}) - ${getRankingTitle(type, limit)}`,
+        link: rankingUrl,
+        item: items as DataItem[],
+        language: 'ja',
+    };
+}

package/lib/routes/syosetu/ranking.ts

@@ -0,0 +1,285 @@
+import { Route, Data, DataItem } from '@/types';
+import { art } from '@/utils/render';
+import path from 'node:path';
+import { Context } from 'hono';
+import { Genre, SearchBuilder, SearchParams, NarouNovelFetch, GenreNotation } from 'narou';
+import InvalidParameterError from '@/errors/types/invalid-parameter';
+import { getCurrentPath } from '@/utils/helpers';
+import { handleIsekaiRanking } from './ranking-isekai';
+import { RankingPeriod, periodToJapanese, novelTypeToJapanese, periodToOrder, RankingType, NovelType, isekaiCategoryToJapanese, IsekaiCategory } from './types/ranking';
+
+const __dirname = getCurrentPath(import.meta.url);
+
+const getParameters = () => {
+    // Generate ranking type options
+    const rankingTypeOptions = [
+        { value: RankingType.LIST, label: '総合ランキング (General Ranking)' },
+        { value: RankingType.GENRE, label: 'ジャンル別ランキング (Genre Ranking)' },
+        { value: RankingType.ISEKAI, label: '異世界転生/転移ランキング (Isekai Ranking)' },
+    ];
+
+    // Generate period options
+    const periodOptions = Object.entries(RankingPeriod).map(([key, value]) => ({
+        value,
+        label: `${periodToJapanese[value]} (${key})`,
+    }));
+
+    // Generate novel type options
+    const novelTypeOptions = Object.entries(NovelType).map(([key, value]) => ({
+        value,
+        label: `${novelTypeToJapanese[value]} (${key})`,
+    }));
+
+    // Generate genre options
+    const genreOptions = Object.entries(Genre)
+        .filter(([, value]) => typeof value === 'number') // Filter out reverse mappings
+        .map(([key, value]) => ({
+            value: value.toString(),
+            label: key,
+        }));
+
+    // Generate isekai category options
+    const isekaiOptions = Object.entries(IsekaiCategory).map(([key, value]) => ({
+        value,
+        label: `${isekaiCategoryToJapanese[value]} (${key})`,
+    }));
+
+    return {
+        listType: {
+            description: 'Ranking type',
+            options: rankingTypeOptions,
+        },
+        type: {
+            description: 'Detailed ranking type, can be found in Syosetu ranking URLs',
+            options: [
+                // General ranking options
+                ...periodOptions.flatMap((period) =>
+                    novelTypeOptions.map((novelType) => ({
+                        value: `${period.value}_${novelType.value}`,
+                        label: `${RankingType.LIST} - [${periodToJapanese[period.value]}] 総合ランキング - ${novelTypeToJapanese[novelType.value]}`,
+                    }))
+                ),
+                // Genre ranking options
+                ...periodOptions.flatMap((period) =>
+                    genreOptions.flatMap((genre) =>
+                        novelTypeOptions.map((novelType) => ({
+                            value: `${period.value}_${genre.value}_${novelType.value}`,
+                            label: `${RankingType.GENRE} - [${periodToJapanese[period.value]}] ${GenreNotation[genre.value]}ランキング - ${novelTypeToJapanese[novelType.value]}`,
+                        }))
+                    )
+                ),
+                // Isekai ranking options
+                ...periodOptions.flatMap((period) =>
+                    isekaiOptions.flatMap((category) =>
+                        novelTypeOptions.map((novelType) => ({
+                            value: `${period.value}_${category.value}_${novelType.value}`,
+                            label: `${RankingType.ISEKAI} - [${periodToJapanese[period.value]}] 異世界転生/転移${isekaiCategoryToJapanese[category.value]}ランキング - ${novelTypeToJapanese[novelType.value]}`,
+                        }))
+                    )
+                ),
+            ],
+        },
+    };
+};
+
+const getBest5RadarItems = () => {
+    // List
+    const periodRankings = Object.values(RankingPeriod).map((period) => ({
+        title: `${periodToJapanese[period]}ランキング BEST5`,
+        source: ['yomou.syosetu.com/rank/top/'],
+        target: `/ranking/list/${period}_total?limit=5`,
+    }));
+
+    // Genre
+    const genreRankings = Object.entries(Genre)
+        .filter(([, value]) => typeof value === 'number' && value !== Genre.SonotaReplay && value !== Genre.NonGenre)
+        .map(([, value]) => ({
+            title: `[${periodToJapanese.daily}] ${GenreNotation[value]}ランキング BEST5`,
+            source: ['yomou.syosetu.com/rank/top/'],
+            target: `/ranking/genre/daily_${value}_total?limit=5`,
+        }));
+
+    // Isekai
+    const isekaiRankings = Object.values(IsekaiCategory).map((category) => ({
+        title: `[${periodToJapanese.daily}] 異世界転生/転移${isekaiCategoryToJapanese[category]}ランキング BEST5`,
+        source: ['yomou.syosetu.com/rank/top/'],
+        target: `/ranking/isekai/daily_${category}_total?limit=5`,
+    }));
+
+    return [...periodRankings, ...genreRankings, ...isekaiRankings];
+};
+
+export const route: Route = {
+    path: '/ranking/:listType/:type',
+    categories: ['reading'],
+    example: '/syosetu/ranking/list/daily_total?limit=50',
+    parameters: getParameters(),
+    features: {
+        requireConfig: false,
+        requirePuppeteer: false,
+        antiCrawler: false,
+        supportBT: false,
+        supportPodcast: false,
+        supportScihub: false,
+    },
+    name: 'Rankings',
+    url: 'yomou.syosetu.com/rank/top',
+    maintainers: ['SnowAgar25'],
+    handler,
+    description: `
+| Keyword | Description | 説明 |
+| --- | --- | --- |
+| list | Overall Ranking | 総合ランキング |
+| genre | Genre Ranking | ジャンル別ランキング |
+| isekai | Isekai/Reincarnation/Transfer Ranking | 異世界転生/転移ランキング |
+
+| Period | Description |
+| --- | --- |
+| daily | Daily Ranking |
+| weekly | Weekly Ranking |
+| monthly | Monthly Ranking |
+| quarter | Quarterly Ranking |
+| yearly | Yearly Ranking |
+
+
+| Type | Description |
+| --- | --- |
+| total | All Works |
+| t | Short Stories |
+| r | Ongoing Series |
+| er | Completed Series |
+
+::: warning
+Please note that novel type options may vary depending on the ranking category.
+
+ランキングの種類によって、小説タイプが異なる場合がございますのでご注意ください。
+:::
+
+::: danger 注意事項
+The "注目度ランキング" (Attention Ranking) is not supported as syosetu does not provide a public API for this feature and the results cannot be replicated through the search API.
+
+「注目度ランキング」については、API が非公開で検索 API でも同様の結果を得ることができないため、本 Route ではサポートしておりません。
+:::
+
+::: tip 異世界転生/転移ランキングについて (Isekai)
+When multiple works have the same points, their order may differ from syosetu's ranking as syosetu randomizes the order for works with identical points.
+
+集計の結果、同じポイントの作品が複数存在する場合、Syosetu ではランダムで順位が決定されるため、本 Route の順位と異なる場合があります。
+:::
+`,
+    radar: [
+        {
+            source: ['yomou.syosetu.com/rank/list/type/:type'],
+            target: '/ranking/list/:type',
+        },
+        {
+            source: ['yomou.syosetu.com/rank/genrelist/type/:type'],
+            target: '/ranking/genre/:type',
+        },
+        {
+            source: ['yomou.syosetu.com/rank/isekailist/type/:type'],
+            target: '/ranking/isekai/:type',
+        },
+        ...getBest5RadarItems(),
+    ],
+};
+
+function parseGeneralRankingType(type: string): { period: RankingPeriod; novelType: NovelType } {
+    const [periodStr, novelTypeStr] = type.split('_');
+
+    const period = periodStr as RankingPeriod;
+    const novelType = novelTypeStr as NovelType;
+
+    const isValid = [Object.values(RankingPeriod).includes(period), Object.values(NovelType).includes(novelType)].every(Boolean);
+
+    if (!isValid) {
+        throw new InvalidParameterError(`Invalid general ranking type: ${type}`);
+    }
+
+    return { period, novelType };
+}
+
+function parseGenreRankingType(type: string): { period: RankingPeriod; genre: number; novelType: NovelType } {
+    const [periodStr, genreStr, novelTypeStr = NovelType.TOTAL] = type.split('_');
+
+    const period = periodStr as RankingPeriod;
+    const genre = Number(genreStr) as Genre;
+    const novelType = novelTypeStr as NovelType;
+
+    const isValid = [Object.values(RankingPeriod).includes(period), Object.values(Genre).includes(genre), Object.values(NovelType).includes(novelType), genre !== Genre.SonotaReplay, genre !== Genre.NonGenre].every(Boolean);
+
+    if (!isValid) {
+        throw new InvalidParameterError(`Invalid genre ranking type: ${type}`);
+    }
+
+    return { period, genre, novelType };
+}
+
+async function handler(ctx: Context): Promise<Data> {
+    const { listType, type } = ctx.req.param();
+    const rankingType = listType as RankingType;
+    const limit = Math.min(Number(ctx.req.query('limit') ?? 300), 300);
+
+    const api = new NarouNovelFetch();
+    const searchParams: SearchParams = {
+        gzip: 5,
+        lim: limit,
+    };
+
+    let rankingUrl: string;
+    let rankingTitle: string;
+
+    // Build search parameters and titles based on ranking type
+    switch (rankingType) {
+        case RankingType.LIST: {
+            const { period, novelType } = parseGeneralRankingType(type);
+            rankingUrl = `https://yomou.syosetu.com/rank/list/type/${type}`;
+            rankingTitle = `[${periodToJapanese[period]}] 総合ランキング - ${novelTypeToJapanese[novelType]} BEST${limit}`;
+
+            searchParams.order = periodToOrder[period];
+            if (novelType !== NovelType.TOTAL) {
+                searchParams.type = novelType;
+            }
+            break;
+        }
+
+        case RankingType.GENRE: {
+            const { period, genre, novelType } = parseGenreRankingType(type);
+            rankingUrl = `https://yomou.syosetu.com/rank/genrelist/type/${type}`;
+            rankingTitle = `[${periodToJapanese[period]}] ${GenreNotation[genre]}ランキング - ${novelTypeToJapanese[novelType]} BEST${limit}`;
+
+            searchParams.order = periodToOrder[period];
+            searchParams.genre = genre as Genre;
+            if (novelType !== NovelType.TOTAL) {
+                searchParams.type = novelType;
+            }
+            break;
+        }
+
+        case RankingType.ISEKAI:
+            return handleIsekaiRanking(type, limit);
+
+        default:
+            throw new InvalidParameterError(`Invalid ranking type: ${type}`);
+    }
+
+    const builder = new SearchBuilder(searchParams, api);
+    const result = await builder.execute();
+
+    const items = result.values.map((novel, index) => ({
+        title: `#${index + 1} ${novel.title}`,
+        link: `https://ncode.syosetu.com/${String(novel.ncode).toLowerCase()}`,
+        description: art(path.join(__dirname, 'templates', 'description.art'), {
+            novel,
+        }),
+        author: novel.writer,
+        category: novel.keyword.split(/[\s/\uFF0F]/).filter(Boolean),
+    }));
+
+    return {
+        title: `小説家になろう - ${rankingTitle}`,
+        link: rankingUrl,
+        item: items as DataItem[],
+        language: 'ja',
+    };
+}