rsshub 1.0.0-master.f6c2ebb → 1.0.0-master.f70afef

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',
+    };
+}

package/lib/routes/syosetu/search.ts

@@ -0,0 +1,161 @@
+import { Route, Data } from '@/types';
+import { art } from '@/utils/render';
+import path from 'node:path';
+import { Context } from 'hono';
+import { Genre, GenreNotation, NarouNovelFetch, NovelTypeParam, Order, R18Site, SearchBuilder, SearchBuilderR18, SearchParams } from 'narou';
+import queryString from 'query-string';
+import { Join } from 'narou/util/type';
+import InvalidParameterError from '@/errors/types/invalid-parameter';
+import { SyosetuSub, NarouSearchParams, syosetuSubToJapanese } from './types/search';
+
+import { getCurrentPath } from '@/utils/helpers';
+const __dirname = getCurrentPath(import.meta.url);
+
+export const route: Route = {
+    path: '/search/:sub/:query',
+    categories: ['reading'],
+    example: '/syosetu/search/noc/word=ハーレム&notword=&type=r&mintime=&maxtime=&minlen=30000&maxlen=&min_globalpoint=&max_globalpoint=&minlastup=&maxlastup=&minfirstup=&maxfirstup=&isgl=1&notbl=1&order=new?limit=5',
+    parameters: {
+        sub: {
+            description: 'The target Syosetu subsite.',
+            options: Object.entries(SyosetuSub).map(([, value]) => ({
+                value,
+                label: syosetuSubToJapanese[value],
+            })),
+        },
+        query: 'Search parameters in Syosetu format.',
+    },
+    features: {
+        requireConfig: false,
+        requirePuppeteer: false,
+        antiCrawler: false,
+        supportBT: false,
+        supportPodcast: false,
+        supportScihub: false,
+    },
+    name: 'Search',
+    maintainers: ['SnowAgar25'],
+    handler,
+};
+
+const setIfExists = (value) => value ?? undefined;
+
+/**
+ * This function converts query string generated by Syosetu website into API-compatible format.
+ * It is not intended for users to freely adjust values.
+ *
+ * @see https://deflis.github.io/node-narou/index.html
+ * @see https://dev.syosetu.com/man/api/
+ */
+function mapToSearchParams(query: string, limit: number): SearchParams {
+    const params = queryString.parse(query) as NarouSearchParams;
+
+    const searchParams: SearchParams = {
+        gzip: 5,
+        lim: limit,
+    };
+
+    searchParams.word = setIfExists(params.word);
+    searchParams.notword = setIfExists(params.notword);
+
+    searchParams.title = setIfExists(params.title);
+    searchParams.ex = setIfExists(params.ex);
+    searchParams.keyword = setIfExists(params.keyword);
+    searchParams.wname = setIfExists(params.wname);
+
+    searchParams.sasie = setIfExists(params.sasie);
+    searchParams.iszankoku = setIfExists(params.iszankoku);
+    searchParams.isbl = setIfExists(params.isbl);
+    searchParams.isgl = setIfExists(params.isgl);
+    searchParams.istensei = setIfExists(params.istensei);
+    searchParams.istenni = setIfExists(params.istenni);
+
+    searchParams.stop = setIfExists(params.stop);
+    searchParams.notzankoku = setIfExists(params.notzankoku);
+    searchParams.notbl = setIfExists(params.notbl);
+    searchParams.notgl = setIfExists(params.notgl);
+    searchParams.nottensei = setIfExists(params.nottensei);
+    searchParams.nottenni = setIfExists(params.nottenni);
+
+    searchParams.minlen = setIfExists(params.minlen);
+    searchParams.maxlen = setIfExists(params.maxlen);
+
+    searchParams.type = setIfExists(params.type as NovelTypeParam);
+    searchParams.order = setIfExists(params.order as Order);
+    searchParams.genre = setIfExists(params.genre as Join<Genre> | Genre);
+    searchParams.nocgenre = setIfExists(params.nocgenre as Join<R18Site> | R18Site);
+
+    if (params.mintime || params.maxtime) {
+        searchParams.time = `${params.mintime || ''}-${params.maxtime || ''}`;
+    }
+
+    return searchParams;
+}
+
+const isGeneral = (sub: string): boolean => sub === SyosetuSub.YOMOU;
+
+function createNovelSearchBuilder(sub: string, searchParams: SearchParams) {
+    if (isGeneral(sub)) {
+        return new SearchBuilder(searchParams, new NarouNovelFetch());
+    }
+
+    const r18Params = { ...searchParams };
+
+    switch (sub) {
+        case SyosetuSub.NOCTURNE:
+            r18Params.nocgenre = R18Site.Nocturne;
+            break;
+        case SyosetuSub.MOONLIGHT:
+            // If either 女性向け/BL is chosen, nocgenre will be in query string
+            // If no specific genre selected, include both
+            if (!r18Params.nocgenre) {
+                r18Params.nocgenre = [R18Site.MoonLight, R18Site.MoonLightBL].join('-') as Join<R18Site>;
+            }
+            break;
+        case SyosetuSub.MIDNIGHT:
+            r18Params.nocgenre = R18Site.Midnight;
+            break;
+        default:
+            throw new InvalidParameterError('Invalid Syosetu subsite.\nValid subsites are: yomou, noc, mnlt, mid');
+    }
+
+    return new SearchBuilderR18(r18Params, new NarouNovelFetch());
+}
+
+async function handler(ctx: Context): Promise<Data> {
+    const { sub, query } = ctx.req.param();
+    const searchUrl = `https://${sub}.syosetu.com/search/search/search.php?${query}`;
+
+    const limit = Math.min(Number(ctx.req.query('limit') ?? 40), 40);
+    const searchParams = mapToSearchParams(query, limit);
+    const builder = createNovelSearchBuilder(sub, searchParams);
+    const result = await builder.execute();
+
+    const items = result.values.map((novel) => ({
+        title: novel.title,
+        link: `https://${isGeneral(sub) ? 'ncode' : 'novel18'}.syosetu.com/${String(novel.ncode).toLowerCase()}`,
+        description: art(path.join(__dirname, 'templates', 'description.art'), {
+            novel,
+            genreText: GenreNotation[novel.genre],
+        }),
+        // Skip pubDate - search results prioritize search sequence over timestamps
+        // pubDate: novel.general_lastup,
+        author: novel.writer,
+        // Split by whitespace characters(\s), slash(/), full-width slash(／)
+        category: novel.keyword.split(/[\s/\uFF0F]/).filter(Boolean),
+    }));
+
+    const searchTerms: string[] = [];
+    if (searchParams.word) {
+        searchTerms.push(searchParams.word);
+    }
+    if (searchParams.notword) {
+        searchTerms.push(`-${searchParams.notword}`);
+    }
+
+    return {
+        title: searchTerms.length > 0 ? `Syosetu Search: ${searchTerms.join(' ')}` : 'Syosetu Search',
+        link: searchUrl,
+        item: items,
+    };
+}

package/lib/routes/syosetu/templates/description.art

@@ -0,0 +1,73 @@
+{{  if novel.story }}
+<p>{{@ novel.story.replaceAll('\n', '<br>') }}</p>
+{{ /if }}
+
+<h2>作品情報</h2>
+<table>
+    <tr>
+        <td>状態</td>
+        <td>
+            {{ if novel.novel_type === 2 }}
+                短編
+            {{ else }}
+                {{ if novel.end === 0 }}
+                    完結済
+                {{ else }}
+                    連載中
+                {{ /if }}
+                （全{{ novel.general_all_no }}エピソード）
+            {{ /if }}
+        </td>
+    </tr>
+    {{ if genreText }}
+    <tr>
+        <td>ジャンル</td>
+        <td>{{ genreText }}</td>
+    </tr>
+    {{ /if }}
+    <tr>
+        <td>キーワード</td>
+        <td>{{ novel.keyword.replaceAll(' ', '、') }}</td>
+    </tr>
+    <tr>
+        <td>最終掲載</td>
+        <td>{{ novel.general_lastup }}</td>
+    </tr>
+    <tr>
+        <td>Nコード</td>
+        <td>{{ novel.ncode }}</td>
+    </tr>
+    <tr>
+        <td>読了時間</td>
+        <td>約{{ novel.time }}分（{{ novel.length }}文字）</td>
+    </tr>
+</table>
+<br>
+<table>
+    {{ if novel.weekly_unique }}
+    <tr>
+        <td>週別ユニークユーザ</td>
+        <td>{{ novel.weekly_unique < 100 ? '100未満' : novel.weekly_unique }}</td>
+    </tr>
+    {{ /if }}
+    <tr>
+        <td>総合ポイント</td>
+        <td>{{ novel.global_point }} pt</td>
+    </tr>
+    <tr>
+        <td>評価人数</td>
+        <td>{{ novel.all_hyoka_cnt }} 人</td>
+    </tr>
+    <tr>
+        <td>評価ポイント</td>
+        <td>{{ novel.all_point }} pt</td>
+    </tr>
+    <tr>
+        <td>ブックマーク</td>
+        <td>{{ novel.fav_novel_cnt }} 件</td>
+    </tr>
+</table>
+
+{{ if novel.sasie_cnt > 0 }}
+<p>挿絵数：{{ novel.sasie_cnt }}枚</p>
+{{ /if }}

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

@@ -0,0 +1,60 @@
+import { R18Site } from 'narou';
+
+export enum SyosetuSub {
+    NOCTURNE = 'noc',
+    MOONLIGHT = 'mnlt',
+    MIDNIGHT = 'mid',
+    MOONLIGHT_BL = 'mnlt-bl',
+}
+
+export enum RankingPeriod {
+    DAILY = 'daily',
+    WEEKLY = 'weekly',
+    MONTHLY = 'monthly',
+    QUARTER = 'quarter',
+    YEARLY = 'yearly',
+}
+
+export enum NovelType {
+    TOTAL = 'total',
+    SHORT = 't',
+    ONGOING = 'r',
+    COMPLETE = 'er',
+}
+
+export const syosetuSubToNocgenre = {
+    [SyosetuSub.NOCTURNE]: R18Site.Nocturne,
+    [SyosetuSub.MOONLIGHT]: R18Site.MoonLight,
+    [SyosetuSub.MOONLIGHT_BL]: R18Site.MoonLightBL,
+    [SyosetuSub.MIDNIGHT]: R18Site.Midnight,
+} as const;
+
+export const syosetuSubToJapanese = {
+    [SyosetuSub.NOCTURNE]: 'ノクターン',
+    [SyosetuSub.MOONLIGHT]: 'ムーンライト',
+    [SyosetuSub.MOONLIGHT_BL]: 'ムーンライト BL',
+    [SyosetuSub.MIDNIGHT]: 'ミッドナイト',
+} as const;
+
+export const periodToOrder = {
+    [RankingPeriod.DAILY]: 'dailypoint',
+    [RankingPeriod.WEEKLY]: 'weeklypoint',
+    [RankingPeriod.MONTHLY]: 'monthlypoint',
+    [RankingPeriod.QUARTER]: 'quarterpoint',
+    [RankingPeriod.YEARLY]: 'yearlypoint',
+} as const;
+
+export const periodToJapanese = {
+    [RankingPeriod.DAILY]: '日間',
+    [RankingPeriod.WEEKLY]: '週間',
+    [RankingPeriod.MONTHLY]: '月間',
+    [RankingPeriod.QUARTER]: '四半期',
+    [RankingPeriod.YEARLY]: '年間',
+} as const;
+
+export const novelTypeToJapanese = {
+    [NovelType.TOTAL]: '総合',
+    [NovelType.SHORT]: '短編',
+    [NovelType.ONGOING]: '連載中',
+    [NovelType.COMPLETE]: '完結済',
+} as const;

package/lib/routes/syosetu/types/ranking.ts

@@ -0,0 +1,67 @@
+export enum RankingPeriod {
+    DAILY = 'daily',
+    WEEKLY = 'weekly',
+    MONTHLY = 'monthly',
+    QUARTER = 'quarter',
+    YEARLY = 'yearly',
+    TOTAL = 'total',
+}
+
+export enum NovelType {
+    TOTAL = 'total',
+    SHORT = 't',
+    ONGOING = 'r',
+    COMPLETE = 'er',
+}
+
+export enum RankingType {
+    LIST = 'list',
+    GENRE = 'genre',
+    ISEKAI = 'isekai',
+}
+
+export const periodToOrder = {
+    [RankingPeriod.DAILY]: 'dailypoint',
+    [RankingPeriod.WEEKLY]: 'weeklypoint',
+    [RankingPeriod.MONTHLY]: 'monthlypoint',
+    [RankingPeriod.QUARTER]: 'quarterpoint',
+    [RankingPeriod.YEARLY]: 'yearlypoint',
+    [RankingPeriod.TOTAL]: 'hyoka',
+} as const;
+
+export const periodToPointField = {
+    [RankingPeriod.DAILY]: 'pt',
+    [RankingPeriod.WEEKLY]: 'weekly_point',
+    [RankingPeriod.MONTHLY]: 'monthly_point',
+    [RankingPeriod.QUARTER]: 'quarter_point',
+    [RankingPeriod.YEARLY]: 'yearly_point',
+    [RankingPeriod.TOTAL]: 'global_point',
+} as const;
+
+export const periodToJapanese = {
+    [RankingPeriod.DAILY]: '日間',
+    [RankingPeriod.WEEKLY]: '週間',
+    [RankingPeriod.MONTHLY]: '月間',
+    [RankingPeriod.QUARTER]: '四半期',
+    [RankingPeriod.YEARLY]: '年間',
+    [RankingPeriod.TOTAL]: '累計',
+} as const;
+
+export const novelTypeToJapanese = {
+    [NovelType.TOTAL]: 'すべて',
+    [NovelType.SHORT]: '短編',
+    [NovelType.ONGOING]: '連載中',
+    [NovelType.COMPLETE]: '完結済',
+} as const;
+
+export enum IsekaiCategory {
+    RENAI = '1',
+    FANTASY = '2',
+    OTHER = 'o',
+}
+
+export const isekaiCategoryToJapanese = {
+    [IsekaiCategory.RENAI]: '〔恋愛〕',
+    [IsekaiCategory.FANTASY]: '〔ファンタジー〕',
+    [IsekaiCategory.OTHER]: '〔文芸・SF・その他〕',
+} as const;