rsshub 1.0.0-master.f9ec483 → 1.0.0-master.fa1dcc5

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

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