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

package/lib/routes/osu/beatmaps/latest-ranked.ts

@@ -0,0 +1,313 @@
+import { Data, DataItem, Route } from '@/types';
+import path from 'node:path';
+import got from '@/utils/got';
+import { load } from 'cheerio';
+import { parseDate } from '@/utils/parse-date';
+import cache from '@/utils/cache';
+import { config } from '@/config';
+import { art } from '@/utils/render';
+import { getCurrentPath } from '@/utils/helpers';
+const __dirname = getCurrentPath(import.meta.url);
+
+const actualParametersDescTable = `
+| Name              | Default  | Description                                                                                                                                                                                                                                          |
+| ----------------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| \`includeMode\`     | All mode | Could be \`osu\`, \`mania\`, \`fruits\` or \`taiko\`. Specify included game mode of beatmaps. Including this paramseter multiple times to specify multiple game modes, e.g.: \`includeMode=osu&includeMode=mania\`. Subscribe to all game modes if not specified |
+| \`difficultyLimit\` | None     | Lower/upper limit of star rating of the beatmaps in the beatmapset item, e.g.:\`difficultyLimit=U6\`. Checkout tips in descriptions for detailed explaination and examples.                                                                            |
+| \`modeInTitle\`     | \`true\`   | \`true\` or \`false\` Add mode info into feed title.
+`;
+
+const descriptionDoc: string = `
+Subscribe to the new beatmaps on https://osu.ppy.sh/beatmapsets.
+
+#### Parameter Description
+
+Parameters allows you to:
+
+- Filter game mode
+- Limit beatmap difficulty
+- Show/hide game mode in feed title
+
+Below is a table of all allowed parameters passed to \`routeParams\`
+
+${actualParametersDescTable}
+
+This actual parameters should be passed as \`routeParams\` in URL Query String format without \`?\`, e.g.:
+
+    /osu/latest-ranked/modeInTitle=true&includeMode=osu
+
+:::tip
+You could make use of \`difficultyLimit\` paramters to create a "high difficulty/low difficulty only" only feed.
+
+For example, if you only wants to play low star rating beatmap like 1 or 2 star, you could subscribe to:
+
+    /osu/latest-ranked/difficultyLimit=U2
+
+This will filter out all beatmapsets that do not provide at least one beatmap with star rating<=\`2.00\`.
+
+Similarly, you could use lower bound to filter out beatmapsets which don't have at least one beatmap
+with star rating higher than a certain threshold.
+
+    /osu/latest-ranked/difficultyLimit=L6
+
+Now all beatmapsets that don't provided at least one beatmap with star rating higher than \`6.00\` will be filtered.
+:::
+`;
+
+export const route: Route = {
+    path: '/latest-ranked/:routeParams?',
+    categories: ['game'],
+    example: '/osu/latest-ranked/includeMode=osu&difficultyLimit=L3&difficultyLimit=U7',
+    features: {
+        requireConfig: false,
+        requirePuppeteer: false,
+        antiCrawler: false,
+        supportBT: false,
+        supportPodcast: false,
+        supportScihub: false,
+        supportRadar: true,
+    },
+    parameters: {
+        routeParams: {
+            description: 'Used to pass route parameters in Query String format. Check out route description for more info.',
+            default: 'null',
+        },
+    },
+    name: 'Latest Ranked Beatmap',
+    description: descriptionDoc,
+    maintainers: ['nfnfgo'],
+    radar: [
+        {
+            source: ['osu.ppy.sh/beatmapsets'],
+        },
+    ],
+    handler,
+};
+
+interface Beatmap {
+    beatmapset_id: number;
+    difficulty_rating: number;
+    id: number;
+    mode: string;
+    status: string;
+    total_length: number;
+    user_id: number;
+    version: string;
+    accuracy: number;
+    ar: number;
+    bpm: number;
+    convert: boolean;
+    count_circles: number;
+    count_sliders: number;
+    count_spinners: number;
+    cs: number;
+    deleted_at: string | null;
+    drain: number;
+    hit_length: number;
+    is_scoreable: boolean;
+    last_updated: string;
+    mode_int: number;
+    passcount: number;
+    playcount: number;
+    ranked: number;
+    url: string;
+    checksum: string;
+    max_combo: number;
+}
+
+interface NominationsSummary {
+    current: number;
+    eligible_main_rulesets: string[];
+    required_meta: {
+        main_ruleset: number;
+        non_main_ruleset: number;
+    };
+}
+
+interface Covers {
+    cover: string;
+    'cover@2x': string;
+    card: string;
+    'card@2x': string;
+    list: string;
+    'list@2x': string;
+    slimcover: string;
+    'slimcover@2x': string;
+}
+
+interface Availability {
+    download_disabled: boolean;
+    more_information: string | null;
+}
+
+interface BeatmapsetInfo {
+    artist: string;
+    artist_unicode: string;
+    covers: Covers;
+    creator: string;
+    favourite_count: number;
+    hype: null | string;
+    id: number;
+    nsfw: boolean;
+    offset: number;
+    play_count: number;
+    preview_url: string;
+    source: string;
+    spotlight: boolean;
+    status: string;
+    title: string;
+    title_unicode: string;
+    track_id: number;
+    user_id: number;
+    video: boolean;
+    bpm: number;
+    can_be_hyped: boolean;
+    deleted_at: string | null;
+    discussion_enabled: boolean;
+    discussion_locked: boolean;
+    is_scoreable: boolean;
+    last_updated: string;
+    legacy_thread_url: string;
+    nominations_summary: NominationsSummary;
+    ranked: number;
+    ranked_date: string;
+    storyboard: boolean;
+    submitted_date: string;
+    tags: string;
+    availability: Availability;
+    beatmaps: Beatmap[];
+    pack_tags: string[];
+}
+
+async function handler(ctx): Promise<Data> {
+    // Parse & retrive searchParams
+    const pathParams = ctx.req.param('routeParams');
+    // Here user actually pass the query using path param, like: `/osu/latest-ranked/includeMode=osu`
+    // We first retrieve path param part: `includeMode=osu`, then concat it with host to construct a "fake" URL:
+    // `https://osu.ppy.sh?includeMode=osu`
+    // Then we use URL.searchParams to parse and retrieve params from this "fake" URL.
+    const searchParams = new URL(`https://osu.ppy.sh?${pathParams}`).searchParams; // use URL to parse params
+    const includeModes = searchParams.getAll('includeMode');
+    const difficultyLimits = searchParams.getAll('difficultyLimit');
+    const modeInTitle = searchParams.get('modeInTitle') ?? 'true'; // show mode name in title, default to true.
+
+    // fetch beatmap JSON info from website within cache
+    let beatmapsetList = (await cache.tryGet(
+        'https://osu.ppy.sh/beatmapsets:JSON',
+        async () => {
+            const link = 'https://osu.ppy.sh/beatmapsets';
+
+            const response = await got.get(link);
+            const $ = load(response.data);
+
+            const beatmapInfo = JSON.parse($('#json-beatmaps').text() ?? '{"beatmapsets": undefined}');
+
+            const beatmapList: BeatmapsetInfo[] = beatmapInfo.beatmapsets;
+
+            // Failed to fetch, raise error
+            if (beatmapList === undefined) {
+                throw new Error('Failed to retrieve JSON beatmap info from osu! website');
+            }
+
+            return beatmapList;
+        },
+        config.cache.routeExpire,
+        false
+    )) as BeatmapsetInfo[];
+
+    // Sort beatmap by difficultyRate.desc
+    // This step is necessary even if difficultyLimit not enabled, since we want the beatmap
+    // in RSS description sorted when displayed
+    for (const item of beatmapsetList) {
+        item.beatmaps.sort((a, b) => a.difficulty_rating - b.difficulty_rating);
+    }
+
+    // filter beatmapset types
+    // Note:
+    // One Osu beatmapset could actually contains several beatmaps with different game mode.
+    // Here for simplicity we just use the mode of first beatmap in this set for filtering criteria.
+    if (includeModes?.length && includeModes?.length > 0) {
+        beatmapsetList = beatmapsetList.filter((bm) => includeModes.includes(bm.beatmaps[0].mode));
+    }
+
+    let upperLimit = 99; // Osu! will never have maps with 99+ star rating right?
+    let lowerLimit = 0;
+    if (difficultyLimits && difficultyLimits.length > 0 && difficultyLimits.length < 2) {
+        for (const dfLimit of difficultyLimits) {
+            if (dfLimit.startsWith('U')) {
+                upperLimit = Number.parseFloat(dfLimit.substring(1));
+            } else if (dfLimit.startsWith('L')) {
+                lowerLimit = Number.parseFloat(dfLimit.substring(1));
+            }
+        }
+
+        const difficultyRateFilterFunc = (item: BeatmapsetInfo): boolean => {
+            if (item.beatmaps.at(0)!.difficulty_rating > upperLimit) {
+                return false;
+            }
+            if (item.beatmaps.at(-1)!.difficulty_rating < lowerLimit) {
+                return false;
+            }
+            return true;
+        };
+
+        beatmapsetList = beatmapsetList.filter((item) => difficultyRateFilterFunc(item));
+    }
+
+    // Returns a user-readble string that shows details about route parameter config
+    function getReadableFeedConfig(): string {
+        if (!pathParams) {
+            return '';
+        }
+
+        let readableConf = 'Feed Configurations:\n';
+        readableConf += `Game Mode: ${includeModes.length > 0 ? JSON.stringify(includeModes) : 'All modes'}\n`;
+        readableConf += `Star Rating Limit: Lower=${lowerLimit}, Upper=${upperLimit}`;
+        return readableConf;
+    }
+
+    // Construct beatmap feed items
+    const rssItems: DataItem[] = beatmapsetList.map((beatmapset) => {
+        // Format publication date using parseDate utility
+        // Here it make sense to consider the ranked date as the pubDate of this item since this is ranked map RSS
+        const pubDate = parseDate(beatmapset.ranked_date);
+
+        // Select the best resolution cover (2x if available)
+        const coverImage = beatmapset.covers['cover@2x'] || beatmapset.covers.cover;
+        const bannerImage = beatmapset.covers['card@2x'] || beatmapset.covers.card;
+
+        // Readable beatmap total length
+        const readableTotalLength = `${Math.floor(beatmapset.beatmaps[0].total_length / 60)
+            .toString()
+            .padStart(2, '0')}:${(beatmapset.beatmaps[0].total_length % 60).toString().padStart(2, '0')}`;
+
+        const modeLiteralToDisplayNameMap = {
+            osu: 'Osu!',
+            fruits: 'Osu!Catch',
+            taiko: 'Osu!Taiko',
+            mania: 'Osu!Mania',
+        };
+
+        // Create a description with beatmap details and a table of difficulties
+        const description = art(path.join(__dirname, 'templates/beatmapset.art'), { ...beatmapset, readableTotalLength, modeLiteralToDisplayNameMap });
+
+        return {
+            title: `${modeInTitle === 'true' ? `[${modeLiteralToDisplayNameMap[beatmapset.beatmaps[0].mode]}] ` : ``}${beatmapset.title_unicode ?? beatmapset.title}`,
+            description,
+            pubDate,
+            link: `https://osu.ppy.sh/beatmapsets/${beatmapset.id}`,
+            category: ['osu!', 'game'],
+            author: [{ name: beatmapset.creator }],
+            image: coverImage,
+            banner: bannerImage,
+            updated: beatmapset.last_updated,
+        };
+    });
+
+    return {
+        title: 'Osu! Latest Ranked Map',
+        link: 'https://osu.ppy.sh/beatmapsets',
+        description: `Newly ranked beatmaps at https://osu.ppy.sh/beatmapsets.\n${getReadableFeedConfig()}`,
+        item: rssItems,
+    };
+}

package/lib/routes/osu/beatmaps/templates/beatmapset.art

@@ -0,0 +1,37 @@
+<img src="{{ covers['cover@2x'] || covers.cover }}" alt="{{ title }}" style="max-width: 100%; height: auto;" />
+
+<h3>Song Info</h3>
+<ul>
+    <li><strong>English Title:</strong> {{ title }}</li>
+    <li><strong>Artist:</strong> {{ artist_unicode }} ({{ artist }})</li>
+    <li><strong>Length:</strong> {{ readableTotalLength }}</li>
+    <li><strong>BPM:</strong> {{ bpm }}</li>
+</ul>
+
+<h3>Beatmapset Info</h3>
+<ul>
+    <li><strong>Mode:</strong> {{ modeLiteralToDisplayNameMap[beatmaps[0].mode] }}</li>
+    <li><strong>Creator:</strong> {{ creator }}</li>
+</ul>
+
+<h3>Difficulties</h3>
+<table border="1">
+    <thead>
+        <tr>
+            <th>Version</th>
+            <th>Rating</th>
+            <th>AR</th>
+            <th>Drain</th>
+        </tr>
+    </thead>
+    <tbody>
+        {{ each beatmaps as beatmap }}
+        <tr>
+            <td><a href="{{ beatmap.url }}" target="_blank">{{ beatmap.version }}</a></td>
+            <td>{{ beatmap.difficulty_rating.toFixed(2) }}</td>
+            <td>{{ beatmap.ar.toFixed(1) }}</td>
+            <td>{{ beatmap.drain }}</td>
+        </tr>
+        {{ /each }}
+    </tbody>
+</table>

package/lib/routes/ouc/jwgl.ts

@@ -26,9 +26,9 @@ export const route: Route = {
     maintainers: ['3401797899'],
     handler,
     url: 'jwgl.ouc.edu.cn/cas/login.action',
-    description: `:::warning
+    description: `::: warning
   由于选课通知仅允许校园网访问，需自行部署。
-  :::`,
+:::`,
 };
 
 async function handler() {

package/lib/routes/p-articles/namespace.ts

@@ -4,7 +4,7 @@ export const namespace: Namespace = {
     name: '虚词',
     url: 'p-articles.com',
     description: `
-:::tip
+::: tip
 p-articles provides some official RSS feeds:
 
 -   section: \`https://p-articles.com/section/:section\`

package/lib/routes/pacilution/latest.ts

@@ -0,0 +1,102 @@
+import { DataItem, Route } from '@/types';
+import cache from '@/utils/cache';
+import got from '@/utils/got';
+import { parseDate } from '@/utils/parse-date';
+import { load } from 'cheerio';
+import iconv from 'iconv-lite';
+
+const BASE_URL = 'http://www.pacilution.com/';
+
+const handler: Route['handler'] = async () => {
+    // Fetch the target page
+    const response = await got({
+        method: 'get',
+        url: BASE_URL,
+        responseType: 'buffer',
+    });
+    const $ = load(iconv.decode(response.data, 'gb2312'));
+
+    // Select all list items containing target information
+    const ITEM_SELECTOR = 'ul[class*="ullbxwnew"] > li';
+    const listItems = $(ITEM_SELECTOR);
+
+    // Map through each list item to extract details
+    const contentLinkList = listItems.toArray().map((element) => {
+        const title = $(element).find('a').text();
+        const relativeHref = $(element).find('a').attr('href') || '';
+        const link = `${BASE_URL}${relativeHref}`;
+
+        return {
+            title,
+            link,
+        };
+    });
+
+    return {
+        title: '普世社会科学研究网最新文章',
+        description: '普世社会科学研究网首页上不同板块的最新文章汇总集合',
+        link: BASE_URL,
+        image: 'http://www.pacilution.com/img/top_banner.jpg',
+        item: (
+            await Promise.all(
+                contentLinkList.map((item) =>
+                    cache.tryGet(item.link, async () => {
+                        try {
+                            const CONTENT_SELECTOR = '#MyContent';
+                            const DATE_SELECTOR = 'td[class*="con_info"] > span';
+                            const response = await got({
+                                method: 'get',
+                                url: item.link,
+                                responseType: 'buffer',
+                            });
+                            const targetPage = load(iconv.decode(response.data, 'gb2312'));
+                            const content = targetPage(CONTENT_SELECTOR).html() || '';
+                            const date = parseDate(targetPage(DATE_SELECTOR).text().trim().replaceAll('日', '')).toISOString();
+                            return {
+                                title: item.title,
+                                pubDate: date,
+                                link: item.link,
+                                description: content,
+                                category: ['journal'],
+                                guid: item.link,
+                                id: item.link,
+                                image: 'http://www.pacilution.com/img/top_banner.jpg',
+                                content,
+                                updated: date,
+                                language: 'zh-cn',
+                            };
+                        } catch {
+                            return null as unknown as DataItem;
+                        }
+                    })
+                )
+            )
+        ).filter((item) => item !== null) as DataItem[],
+        allowEmpty: true,
+        language: 'zh-cn',
+        feedLink: 'https://rsshub.app/pacilution/latest',
+        id: 'https://rsshub.app/pacilution/latest',
+    };
+};
+
+export const route: Route = {
+    path: '/latest',
+    name: '最新文章',
+    maintainers: ['PrinOrange'],
+    handler,
+    categories: ['journal'],
+    features: {
+        requireConfig: false,
+        requirePuppeteer: false,
+        antiCrawler: false,
+        supportBT: false,
+        supportPodcast: false,
+        supportScihub: false,
+    },
+    example: '/pacilution/latest',
+    radar: [
+        {
+            source: ['www.pacilution.com'],
+        },
+    ],
+};

package/lib/routes/pacilution/namespace.ts

@@ -0,0 +1,6 @@
+import type { Namespace } from '@/types';
+
+export const namespace: Namespace = {
+    name: '普世社会科学研究所',
+    url: 'www.pacilution.com',
+};

package/lib/routes/panewslab/author.ts

@@ -6,7 +6,7 @@ import { parseDate } from '@/utils/parse-date';
 
 export const route: Route = {
     path: ['/author/:id', '/column/:id'],
-    categories: ['new-media'],
+    categories: ['new-media', 'popular'],
     example: '/panewslab/author/166',
     parameters: { id: '专栏 id，可在地址栏 URL 中找到' },
     features: {

package/lib/routes/panewslab/news.ts

@@ -4,7 +4,7 @@ import { parseDate } from '@/utils/parse-date';
 
 export const route: Route = {
     path: '/news',
-    categories: ['new-media'],
+    categories: ['new-media', 'popular'],
     example: '/panewslab/news',
     radar: [
         {

package/lib/routes/panewslab/profundity.ts

@@ -21,7 +21,7 @@ const categories = {
 
 export const route: Route = {
     path: '/profundity/:category?',
-    categories: ['new-media'],
+    categories: ['new-media', 'popular'],
     example: '/panewslab/profundity',
     parameters: { category: '分类，见下表，默认为精选' },
     radar: [

package/lib/routes/panewslab/topic.ts

@@ -6,7 +6,7 @@ import { parseDate } from '@/utils/parse-date';
 
 export const route: Route = {
     path: '/topic/:id',
-    categories: ['new-media'],
+    categories: ['new-media', 'popular'],
     example: '/panewslab/topic/1629365774078402',
     parameters: { id: '专题 id，可在地址栏 URL 中找到' },
     features: {

package/lib/routes/papers/index.ts

@@ -17,7 +17,7 @@ export const handler = async (ctx) => {
 
     const rootUrl = 'https://papers.cool';
     const currentUrl = new URL(category, rootUrl).href;
-    const feedUrl = new URL(`${category}/feed`, rootUrl).href;
+    const feedUrl = new URL(`arxiv/${category}/feed`, rootUrl).href;
 
     const site = category.split(/\//)[0];
     const apiKimiUrl = new URL(`${site}/kimi?paper=`, rootUrl).href;
@@ -34,10 +34,12 @@ export const handler = async (ctx) => {
         const kimiUrl = new URL(id, apiKimiUrl).href;
         const pdfUrl = Object.hasOwn(pdfUrlGenerators, site) ? pdfUrlGenerators[site](id) : undefined;
 
+        const authorString = item.author;
         const description = art(path.join(__dirname, 'templates/description.art'), {
             pdfUrl,
             siteUrl: item.link,
             kimiUrl,
+            authorString,
             summary: item.summary,
         });
 
@@ -47,7 +49,7 @@ export const handler = async (ctx) => {
             pubDate: parseDate(item.pubDate ?? ''),
             link: item.link,
             category: item.categories,
-            author: item.creator,
+            author: authorString,
             doi: `${site}${id}`,
             guid,
             id: guid,
@@ -74,16 +76,16 @@ export const handler = async (ctx) => {
 };
 
 export const route: Route = {
-    path: '/:category{.+}?',
+    path: '/arxiv/:category{.+}?',
     name: 'Topic',
     url: 'papers.cool',
-    maintainers: ['nczitzk'],
+    maintainers: ['nczitzk', 'Muyun99'],
     handler,
     example: '/papers/arxiv/cs.AI',
     parameters: { category: 'Category, arXiv Artificial Intelligence (cs.AI) by default' },
-    description: `:::tip
-  If you subscribe to [arXiv Artificial Intelligence (cs.AI)](https://papers.cool/arxiv/cs.AI)，where the URL is \`https://papers.cool/arxiv/cs.AI\`, extract the part \`https://papers.cool/\` to the end, and use it as the parameter to fill in. Therefore, the route will be [\`/papers/arxiv/cs.AI\`](https://rsshub.app/papers/arxiv/cs.AI).
-  :::
+    description: `::: tip
+  If you subscribe to [arXiv Artificial Intelligence (cs.AI)](https://papers.cool/arxiv/cs.AI), where the URL is \`https://papers.cool/arxiv/cs.AI\`, extract the part \`https://papers.cool/\` to the end, and use it as the parameter to fill in. Therefore, the route will be [\`/papers/arxiv/cs.AI\`](https://rsshub.app/papers/arxiv/cs.AI).
+:::
 
   | Category                                              | id          |
   | ----------------------------------------------------- | ----------- |
@@ -91,7 +93,7 @@ export const route: Route = {
   | arXiv Computation and Language (cs.CL)                | arxiv/cs.CL |
   | arXiv Computer Vision and Pattern Recognition (cs.CV) | arxiv/cs.CV |
   | arXiv Machine Learning (cs.LG)                        | arxiv/cs.LG |
-  | arXiv Robotics (cs.RO)                        | arxiv/cs.RO |
+  | arXiv Robotics (cs.RO)                                | arxiv/cs.RO |
   `,
     categories: ['journal'],