rsshub 1.0.0-master.f71451d → 1.0.0-master.f72af1b

package/lib/routes/questn/community.ts

@@ -0,0 +1,76 @@
+import { Route } from '@/types';
+import { parseDate } from '@/utils/parse-date';
+import ofetch from '@/utils/ofetch';
+
+export const route: Route = {
+    path: '/community/:communityUrl',
+    name: 'Community Events',
+    url: 'app.questn.com',
+    maintainers: ['cxheng315'],
+    example: '/questn/community/gmnetwork',
+    parameters: {
+        community_url: 'Community URL',
+    },
+    categories: ['other'],
+    features: {
+        requireConfig: false,
+        requirePuppeteer: false,
+        antiCrawler: false,
+        supportBT: false,
+        supportPodcast: false,
+        supportScihub: false,
+    },
+    radar: [
+        {
+            source: ['app.questn.com/:communityUrl'],
+            target: '/community/:communityUrl',
+        },
+    ],
+    handler,
+};
+
+async function handler(ctx) {
+    const url = 'https://api.questn.com/consumer/explore/entity_list/';
+
+    const params = {
+        count: ctx.req.query('limit') || '20',
+        page: '1',
+        community_url: ctx.req.param('communityUrl') || 'questn', // default to questn
+    };
+
+    const response = await ofetch(`${url}?${new URLSearchParams(params)}`, {
+        method: 'GET',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+    });
+
+    const data = await response.result.data;
+
+    const items = data.map((item) => ({
+        title: item.title,
+        link: `https://app.questn.com/quest/${item.id}`,
+        author: item.community_info ? item.community_info.name : '',
+        guid: item.id,
+        pubDate: parseDate(item.start_time * 1000),
+        itunes_duration: item.end_time > 0 ? item.end_time - item.start_time : 0,
+    }));
+
+    return {
+        title: `QuestN Community - ${data[0].community_info ? data[0].community_info.name : ''} Events`,
+        link: `https://app.questn.com/${ctx.req.param('community_url')}`,
+        description: data[0].community_info ? data[0].community_info.introduction : '',
+        image: data[0].community_info ? data[0].community_info.logo : '',
+        logo: data[0].community_info ? data[0].community_info.logo : '',
+        item:
+            items && items.length > 0
+                ? items
+                : [
+                      {
+                          title: 'No events found',
+                          link: `https://app.questn.com/${ctx.req.param('community_url')}`,
+                          description: 'No events found',
+                      },
+                  ],
+    };
+}

package/lib/routes/questn/events.ts

@@ -0,0 +1,101 @@
+import { Route } from '@/types';
+import { parseDate } from '@/utils/parse-date';
+import ofetch from '@/utils/ofetch';
+
+import { parseFilterStr } from './util';
+
+export const route: Route = {
+    path: '/events/:filter?',
+    name: 'Events',
+    url: 'app.questn.com',
+    maintainers: ['cxheng315'],
+    example: '/questn/events',
+    parameters: {
+        filter: 'Filter string',
+    },
+    description: `
+:::tip
+
+Filter parameters:
+- category: 100: trending, 200: newest, 300: top
+- status_filter: 0: all, 100: available, 400: missed
+- community_filter: 0: all community, 100: verified, 200: followed
+- rewards_filter: 0: all rewards, 100: nft, 200: token, 400: whitelist
+- chain_filter: 0: all chains, 1: ethereum, 56: bsc, 137: polygon, 42161: arb, 10: op, 324: zksync, 43114: avax
+- search: 'Search keyword',
+- count: 'Number of events to fetch',
+- page: 'Page number',
+:::`,
+    categories: ['other'],
+    features: {
+        requireConfig: false,
+        requirePuppeteer: false,
+        antiCrawler: false,
+        supportBT: false,
+        supportPodcast: false,
+        supportScihub: false,
+    },
+    radar: [
+        {
+            source: ['app.questn.com/explore'],
+            target: '/events/:category?/:status_filter?/:community_filter?/:reward_filter?/:chain_filter?/:search?/:count?/:page?',
+        },
+    ],
+    handler,
+};
+
+async function handler(ctx) {
+    const url = 'https://api.questn.com/consumer/explore/list/';
+
+    const parsedFilter: { category?: string; status_filter?: string; community_filter?: string; reward_filter?: string; chain_filter?: string; search?: string; count?: string; page?: string } = parseFilterStr(
+        ctx.req.param('filter')
+    );
+
+    const params = {
+        category: parsedFilter.category || '200',
+        status_filter: parsedFilter.status_filter || '100',
+        community_filter: parsedFilter.community_filter || '0',
+        rewards_filter: parsedFilter.reward_filter || '0',
+        chain_filter: parsedFilter.chain_filter || '0',
+        search: parsedFilter.search || '',
+        count: parsedFilter.count || ctx.req.query('limit') || '20',
+        page: parsedFilter.page || '1',
+    };
+
+    const response = await ofetch(`${url}?${new URLSearchParams(params)}`, {
+        method: 'GET',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+    });
+
+    const data = await response.result.data;
+
+    const items = data.map((item) => ({
+        title: item.title,
+        link: `https://app.questn.com/quest/${item.id}`,
+        author: item.community_info ? item.community_info.name : '',
+        guid: item.id,
+        pubDate: parseDate(item.start_time * 1000),
+        itunes_duration: item.end_time > 0 ? item.end_time - item.start_time : 0,
+    }));
+
+    return {
+        title: 'QuestN Events',
+        link: 'https://app.questn.com/explore',
+        description: 'A Quest Protocol Dedicated to DePIN and AI Training',
+        image: 'https://app.questn.com/static/svgs/logo-white.svg',
+        logo: 'https://app.questn.com/static/svgs/logo-white.svg',
+        author: 'QuestN',
+        item:
+            items && items.length > 0
+                ? items
+                : [
+                      {
+                          title: 'No events found',
+                          description: 'No events found',
+                          link: 'https://app.questn.com/explore',
+                      },
+                  ],
+    };
+}

package/lib/routes/questn/namespace.ts

@@ -0,0 +1,6 @@
+import type { Namespace } from '@/types';
+
+export const namespace: Namespace = {
+    name: 'QuestN',
+    url: 'app.questn.com',
+};

package/lib/routes/questn/util.ts

@@ -0,0 +1,16 @@
+const parseFilterStr = (filterStr) => {
+    const filters = {};
+    if (!filterStr) {
+        return filters;
+    }
+    const filterPairs = filterStr.split('&'); // Split by '&'
+
+    for (const pair of filterPairs) {
+        const [key, value] = pair.split('='); // Split by '='
+        filters[key] = value;
+    }
+
+    return filters;
+};
+
+export { parseFilterStr };

package/lib/routes/radio-canada/latest.ts

@@ -63,7 +63,7 @@ async function handler(ctx) {
                     .match(/window\._rcState_ = (.*);/)[1];
                 const rcStateJson = JSON.parse(rcState);
                 const news = Object.values(rcStateJson.pagesV2.pages)[0];
-                item.description = news.data.newsStory.body.html.replaceAll('\\n', '<br>');
+                item.description = news.data.newsStory.body.html.replaceAll(String.raw`\n`, '<br>');
 
                 return item;
             })

package/lib/routes/raycast/changelog.ts

@@ -0,0 +1,54 @@
+import type { Route, DataItem } from '@/types';
+import ofetch from '@/utils/ofetch';
+import cache from '@/utils/cache';
+import { load } from 'cheerio';
+import { parseDate } from '@/utils/parse-date';
+
+const handler: Route['handler'] = async () => {
+    const item = (await cache.tryGet('raycast:changelog', async () => {
+        const data = await ofetch('https://www.raycast.com/changelog');
+
+        const $ = load(data);
+
+        return $('article')
+            .toArray()
+            .map<DataItem>((item) => {
+                const $ = load(item);
+
+                const version = $('span[id]').attr('id');
+                const html = $('div.markdown').html() ?? '';
+                const date = $('span[class^=ChangelogEntry_changelogDate]').text().trim();
+
+                return {
+                    title: `Version ${version}`,
+                    description: html,
+                    link: `https://www.raycast.com/changelog/${version?.replaceAll('.', '-')}`,
+                    pubDate: parseDate(date),
+                };
+            });
+    })) as DataItem[];
+
+    return {
+        title: 'Raycast Changelog',
+        link: 'https://www.raycast.com/changelog',
+        language: 'en-US',
+        item,
+    };
+};
+
+export const route: Route = {
+    path: '/changelog',
+    name: 'Changelog',
+    categories: ['program-update'],
+    example: '/raycast/changelog',
+    features: {
+        requireConfig: false,
+        requirePuppeteer: false,
+        antiCrawler: false,
+        supportBT: false,
+        supportPodcast: false,
+        supportScihub: false,
+    },
+    handler,
+    maintainers: ['equt'],
+};

package/lib/routes/raycast/namespace.ts

@@ -0,0 +1,7 @@
+import type { Namespace } from '@/types';
+
+export const namespace: Namespace = {
+    name: 'Raycast',
+    url: 'raycast.com',
+    categories: ['program-update'],
+};

package/lib/routes/react/blog.ts

@@ -0,0 +1,57 @@
+import type { DataItem, Route } from '@/types';
+import { parseDate } from '@/utils/parse-date';
+import cache from '@/utils/cache';
+import { load } from 'cheerio';
+import ofetch from '@/utils/ofetch';
+
+const handler: Route['handler'] = async () => {
+    const data = await ofetch('https://react.dev/blog');
+
+    const $ = load(data);
+
+    const item = (await Promise.all(
+        $('a[href^="/blog/"]')
+            .toArray()
+            .slice(0, 20)
+            .map((item) => {
+                const link = `https://react.dev${item.attribs.href}`;
+
+                return cache.tryGet(`react:blog:${link}`, async () => {
+                    const data = await ofetch(link);
+
+                    const $ = load(data);
+
+                    return {
+                        title: $('h1').first().text().trim(),
+                        link,
+                        description: $('article div:nth-child(2)').html() ?? '',
+                        pubDate: parseDate($('p.whitespace-pre-wrap').first().text().split(/\s+by/)[0]),
+                    };
+                });
+            })
+    )) as DataItem[];
+
+    return {
+        title: 'React Blog',
+        link: 'https://react.dev/blog',
+        language: 'en-US',
+        item,
+    };
+};
+
+export const route: Route = {
+    path: '/blog',
+    name: 'Blog',
+    categories: ['blog'],
+    maintainers: ['equt'],
+    example: '/react/blog',
+    features: {
+        requireConfig: false,
+        requirePuppeteer: false,
+        antiCrawler: false,
+        supportBT: false,
+        supportPodcast: false,
+        supportScihub: false,
+    },
+    handler,
+};

package/lib/routes/react/namespace.ts

@@ -0,0 +1,6 @@
+import type { Namespace } from '@/types';
+
+export const namespace: Namespace = {
+    name: 'React',
+    url: 'react.dev',
+};

package/lib/routes/readhub/util.ts

@@ -40,7 +40,7 @@ const processItems = async (items, tryGet) =>
 
                     const { data: detailResponse } = await got(item.link);
 
-                    const data = JSON.parse(detailResponse.match(/{\\"topic\\":(.*?)}]\\n"]\)<\/script>/)[1].replaceAll('\\"', '"'));
+                    const data = JSON.parse(detailResponse.match(/{\\"topic\\":(.*?)}]\\n"]\)<\/script>/)[1].replaceAll(String.raw`\"`, '"'));
 
                     item.title = data.title;
                     item.link = data.url ?? new URL(`topic/${data.uid}`, rootUrl).href;

package/lib/routes/readwise/list.ts

@@ -0,0 +1,152 @@
+import ConfigNotFoundError from '@/errors/types/config-not-found';
+import ofetch from '@/utils/ofetch';
+import { Route } from '@/types';
+import { config } from '@/config';
+import { parseDate } from '@/utils/parse-date';
+
+export const route: Route = {
+    path: '/list/:routeParams?',
+    categories: ['reading'],
+    example: '/readwise/list/location=new&category=article',
+    parameters: { routeParams: 'Parameter combinations, see the description above.' },
+    features: {
+        requireConfig: [
+            {
+                name: 'READWISE_ACCESS_TOKEN',
+                optional: false,
+                description: 'Visit `https://readwise.io/access_token` to get your access token.',
+            },
+        ],
+        requirePuppeteer: false,
+        antiCrawler: false,
+        supportBT: false,
+        supportPodcast: false,
+        supportScihub: false,
+    },
+    radar: [
+        {
+            source: ['read.readwise.io'],
+            target: '/list',
+        },
+    ],
+    name: 'Reader Document List',
+    maintainers: ['xbot'],
+    handler,
+    description: `Specify options (in the format of query string) in parameter \`routeParams\` to filter documents.
+
+| Parameter                  | Description                                                                            |   Values                                                                                    |  Default                             |
+| -------------------------- | -------------------------------------------------------------------------------------- |   ----------------------------------------------------------------------------------------- |  ----------------------------------- |
+| \`location\`               | The document's location.                                                               |   \`new\`/\`later\`/\`shortlist\`/\`archive\`/\`feed\`                                      |                                      |
+| \`category\`               | The document's category.                                                               |   \`article\`/\`email\`/\`rss\`/\`highlight\`/\`note\`/\`pdf\`/\`epub\`/\`tweet\`/\`video\` |                                      |
+| \`updatedAfter\`           | Fetch only documents updated after this date.                                          |   string (formatted as ISO 8601 date)                                                       ||
+| \`tag\`                    | The document's tag, can be specified once or multiple times.                           |||
+| \`tagStrategy\`            | If multiple tags are specified, should the documents match all of them or any of them. |   \`any\`/\`all\`                                                                           |  \`any\`                             |
+
+Customise parameter values to fetch specific documents, for example:
+
+\`\`\`
+https://rsshub.app/readwise/list/location=new&category=article
+\`\`\`
+
+fetches articles in the Inbox.
+
+\`\`\`
+https://rsshub.app/readwise/list/category=article&tag=shortlist&tag=AI&tagStrategy=all
+\`\`\`
+
+fetches articles tagged both by \`shortlist\` and \`AI\`. `,
+};
+
+const TAG_STRATEGY_ALL = 'all'; // Items with tags matching all the given ones can then be returned.
+const TAG_STRATEGY_ANY = 'any'; // Items with tags matching any of the given ones can be returned.
+
+async function handler(ctx) {
+    if (!config.readwise || !config.readwise.accessToken) {
+        throw new ConfigNotFoundError('Readwise access token is missing');
+    }
+
+    let apiUrl = 'https://readwise.io/api/v3/list/?';
+    let tag, tagStrategy;
+
+    if (ctx.req.param('routeParams')) {
+        const urlSearchParams = new URLSearchParams(ctx.req.param('routeParams'));
+
+        const location = urlSearchParams.get('location');
+        const category = urlSearchParams.get('category');
+        const updatedAfter = urlSearchParams.get('updatedAfter');
+
+        tag = urlSearchParams.get('tag');
+        tagStrategy = urlSearchParams.get('tagStrategy') === TAG_STRATEGY_ANY || urlSearchParams.get('tagStrategy') === TAG_STRATEGY_ALL ? urlSearchParams.get('tagStrategy') : TAG_STRATEGY_ANY;
+
+        if (location) {
+            apiUrl += `location=${location}&`;
+        }
+        if (category) {
+            apiUrl += `category=${category}&`;
+        }
+        if (updatedAfter) {
+            apiUrl += `updatedAfter=${updatedAfter}&`;
+        }
+    }
+
+    const fullData = [];
+
+    async function fetchNextPage(url) {
+        const response = await ofetch(url, {
+            headers: {
+                Authorization: `Token ${config.readwise.accessToken}`,
+            },
+        });
+
+        fullData.push(...response.results);
+
+        if (response.nextPageCursor) {
+            await fetchNextPage(apiUrl + `pageCursor=${response.nextPageCursor}`);
+        }
+    }
+
+    await fetchNextPage(apiUrl);
+
+    const items = fullData
+        .filter((item) => {
+            if (!tag) {
+                return true; // No tag filter applied
+            }
+
+            // Check if item.tags exist and match the criteria based on tagStrategy
+            const itemTags = item.tags;
+
+            if (!itemTags) {
+                return false; // If item has no tags and tag filter is applied, exclude it
+            }
+
+            if (Array.isArray(tag)) {
+                if (tagStrategy === TAG_STRATEGY_ANY) {
+                    // Filter if any of the tags match
+                    return tag.some((t) => Object.values(itemTags).some((tagObj) => tagObj.name === t));
+                } else if (tagStrategy === TAG_STRATEGY_ALL) {
+                    // Filter if all tags match
+                    return tag.every((t) => Object.values(itemTags).some((tagObj) => tagObj.name === t));
+                }
+            } else {
+                const tagName = tag;
+                return Object.values(itemTags).some((tagObj) => tagObj.name === tagName);
+            }
+
+            return false;
+        })
+        .map((item) => ({
+            title: item.title,
+            link: item.source_url,
+            description: item.summary,
+            pubDate: parseDate(item.created_at),
+            author: item.author,
+        }));
+
+    return {
+        allowEmpty: true,
+        title: 'Readwise Reader',
+        link: 'https://read.readwise.io',
+        item: items,
+    };
+}

package/lib/routes/readwise/namespace.ts

@@ -0,0 +1,6 @@
+import type { Namespace } from '@/types';
+
+export const namespace: Namespace = {
+    name: 'Readwise',
+    url: 'readwise.io',
+};

package/lib/routes/rebase/geekdaily.ts

@@ -0,0 +1,35 @@
+import { Route } from '@/types';
+import ofetch from '@/utils/ofetch';
+import { parseDate } from '@/utils/parse-date';
+
+export const route: Route = {
+    path: '/geekdaily',
+    categories: ['new-media'],
+    example: '/rebase/geekdaily',
+    radar: [
+        {
+            source: ['rebase.network/geekdaily'],
+            target: '/geekdaily',
+        },
+    ],
+    name: 'Web3 Geek Daily',
+    maintainers: ['gaoyifan'],
+    handler: async () => {
+        const response = await ofetch('https://db.rebase.network/api/v1/geekdailies?sort=id:desc');
+        const data = response.data;
+
+        const items = data.map((item) => ({
+            title: item.attributes.title,
+            link: item.attributes.url,
+            description: item.attributes.introduce,
+            pubDate: parseDate(item.attributes.time),
+            author: item.attributes.author,
+        }));
+
+        return {
+            title: 'Web3 Geek Daily',
+            link: 'https://rebase.network/geekdaily',
+            item: items,
+        };
+    },
+};

package/lib/routes/rebase/namespace.ts

@@ -0,0 +1,6 @@
+import type { Namespace } from '@/types';
+
+export const namespace: Namespace = {
+    name: 'Rebase Network',
+    url: 'rebase.network',
+};

package/lib/routes/reuters/common.ts

@@ -1,4 +1,4 @@
-import { Route } from '@/types';
+import { Route, ViewType } from '@/types';
 import { getCurrentPath } from '@/utils/helpers';
 const __dirname = getCurrentPath(import.meta.url);
 
@@ -11,9 +11,63 @@ import path from 'node:path';
 
 export const route: Route = {
     path: '/:category/:topic?',
-    categories: ['traditional-media'],
+    categories: ['traditional-media', 'popular'],
+    view: ViewType.Articles,
     example: '/reuters/world/us',
-    parameters: { category: 'find it in the URL, or tables below', topic: 'find it in the URL, or tables below' },
+    parameters: {
+        category: {
+            description: 'find it in the URL, or tables below',
+            options: [
+                { value: 'world', label: 'World' },
+                { value: 'business', label: 'Business' },
+                { value: 'legal', label: 'Legal' },
+                { value: 'markets', label: 'Markets' },
+                { value: 'breakingviews', label: 'Breakingviews' },
+                { value: 'technology', label: 'Technology' },
+                { value: 'graphics', label: 'Graphics' },
+                { value: 'authors', label: 'Authors' },
+            ],
+            default: 'world',
+        },
+        topic: {
+            description: 'find it in the URL, or tables below, leave empty for `All`',
+            options: [
+                // World topics
+                { value: 'africa', label: 'Africa' },
+                { value: 'americas', label: 'Americas' },
+                { value: 'asia-pacific', label: 'Asia Pacific' },
+                { value: 'china', label: 'China' },
+                { value: 'europe', label: 'Europe' },
+                { value: 'india', label: 'India' },
+                { value: 'middle-east', label: 'Middle East' },
+                { value: 'uk', label: 'United Kingdom' },
+                { value: 'us', label: 'United States' },
+                { value: 'the-great-reboot', label: 'The Great Reboot' },
+                { value: 'reuters-next', label: 'Reuters Next' },
+                // Business topics
+                { value: 'aerospace-defense', label: 'Aerospace & Defense' },
+                { value: 'autos-transportation', label: 'Autos & Transportation' },
+                { value: 'energy', label: 'Energy' },
+                { value: 'environment', label: 'Environment' },
+                { value: 'finance', label: 'Finance' },
+                { value: 'healthcare-pharmaceuticals', label: 'Healthcare & Pharmaceuticals' },
+                { value: 'media-telecom', label: 'Media & Telecom' },
+                { value: 'retail-consumer', label: 'Retail & Consumer' },
+                { value: 'sustainable-business', label: 'Sustainable Business' },
+                { value: 'charged', label: 'Charged' },
+                { value: 'future-of-health', label: 'Future of Health' },
+                { value: 'future-of-money', label: 'Future of Money' },
+                { value: 'take-five', label: 'Take Five' },
+                { value: 'reuters-impact', label: 'Reuters Impact' },
+                // Legal topics
+                { value: 'government', label: 'Government' },
+                { value: 'legalindustry', label: 'Legal Industry' },
+                { value: 'litigation', label: 'Litigation' },
+                { value: 'transactional', label: 'Transactional' },
+            ],
+            default: 'us',
+        },
+    },
     features: {
         requireConfig: false,
         requirePuppeteer: false,
@@ -64,13 +118,13 @@ export const route: Route = {
 };
 
 async function handler(ctx) {
-    const MUST_FETCH_BY_TOPICS = new Set(['authors']);
+    const MUST_FETCH_BY_TOPICS = new Set(['authors', 'tags']);
     const CAN_USE_SOPHI = ['world'];
 
     const category = ctx.req.param('category');
     const topic = ctx.req.param('topic') ?? (category === 'authors' ? 'reuters' : '');
     const limit = ctx.req.query('limit') ? Number.parseInt(ctx.req.query('limit')) : 20;
-    const useSophi = ctx.req.query('sophi') === 'true' && 'topic' !== '' && CAN_USE_SOPHI.includes(category);
+    const useSophi = ctx.req.query('sophi') === 'true' && topic !== '' && CAN_USE_SOPHI.includes(category);
 
     const section_id = `/${category}/${topic ? `${topic}/` : ''}`;
     const { title, description, rootUrl, response } = await (async () => {

package/lib/routes/reuters/namespace.ts

@@ -1,7 +1,7 @@
 import type { Namespace } from '@/types';
 
 export const namespace: Namespace = {
-    name: 'Reuters 路透社',
+    name: 'Reuters',
     url: 'reuters.com',
     description: `:::tip
 You can use \`sophi=true\` query parameter to invoke the **experimental** method, which can, if possible, fetch more articles(between 20 and 100) with \`limit\` given. But some articles from the old method might not be available.