rsshub 1.0.0-master.f9003f9 → 1.0.0-master.f917bdc

package/lib/routes/psyche/type.ts

@@ -0,0 +1,53 @@
+import { Route } from '@/types';
+import { load } from 'cheerio';
+import { getData } from './utils';
+import ofetch from '@/utils/ofetch';
+
+export const route: Route = {
+    path: '/type/:type',
+    categories: ['new-media'],
+    example: '/psyche/type/ideas',
+    parameters: { type: 'Type' },
+    features: {
+        requireConfig: false,
+        requirePuppeteer: false,
+        antiCrawler: false,
+        supportBT: false,
+        supportPodcast: false,
+        supportScihub: false,
+    },
+    radar: [
+        {
+            source: ['psyche.co/:type'],
+        },
+    ],
+    name: 'Types',
+    maintainers: ['emdoe'],
+    handler,
+    description: `Supported types: Ideas, Guides, and Films.`,
+};
+
+async function handler(ctx) {
+    const type = ctx.req.param('type');
+    const capitalizedType = type.charAt(0).toUpperCase() + type.slice(1);
+
+    const url = `https://psyche.co/${type}`;
+    const response = await ofetch(url);
+    const $ = load(response);
+
+    const data = JSON.parse($('script#__NEXT_DATA__').text());
+    const prefix = `https://psyche.co/_next/data/${data.buildId}`;
+    const list = data.props.pageProps.articles.map((item) => ({
+        title: item.title,
+        link: `${url}/${item.slug}`,
+        json: `${prefix}/${type}/${item.slug}.json`,
+    }));
+
+    const items = await getData(list);
+
+    return {
+        title: `Psyche | ${capitalizedType}`,
+        link: url,
+        item: items,
+    };
+}

package/lib/routes/psyche/utils.ts

@@ -0,0 +1,107 @@
+import { getCurrentPath } from '@/utils/helpers';
+const __dirname = getCurrentPath(import.meta.url);
+
+import cache from '@/utils/cache';
+import ofetch from '@/utils/ofetch';
+import { load } from 'cheerio';
+import { art } from '@/utils/render';
+import path from 'node:path';
+
+const getImageById = async (id) => {
+    const response = await ofetch('https://api.aeonmedia.co/graphql', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            query: 'query getImageById($id: ID!) { image(id: $id) { id url alt caption width height } }',
+            variables: { id, site: 'Aeon' },
+            operationName: 'getImageById',
+        }),
+    });
+
+    return response.data.image.url;
+};
+
+function format(article) {
+    const type = article.type.toLowerCase();
+
+    let block = '';
+    let banner = '';
+    let authorsBio = '';
+
+    switch (type) {
+        case 'film':
+            block = art(path.join(__dirname, 'templates/video.art'), { article });
+
+            break;
+
+        case 'guide': {
+            banner = article.imageSquare?.url;
+            authorsBio = article.authors.map((author) => author.bio).join(' ');
+
+            const sectionNames = ['Need To Know', 'What To Do', 'Key Points', 'Learn More', 'Links & Books'];
+            const sections = Object.keys(article).filter((key) => key.startsWith('section') && key !== 'section');
+            const content = sections
+                .map((section) => {
+                    const capture = load(article[section]);
+                    capture('p.pullquote').remove();
+                    const sectionName = sectionNames.shift();
+                    return `<h2>${sectionName}</h2>` + capture.html();
+                })
+                .join('');
+
+            block = art(path.join(__dirname, 'templates/essay.art'), { banner, authorsBio, content });
+
+            break;
+        }
+        case 'idea': {
+            banner = article.imageLandscape?.url;
+            authorsBio = article.authors.map((author) => author.bio).join(' ');
+
+            const capture = load(article.body);
+            capture('p.pullquote').remove();
+            block = art(path.join(__dirname, 'templates/essay.art'), { banner, authorsBio, content: capture.html() });
+
+            break;
+        }
+        default:
+            break;
+    }
+    return block;
+}
+
+const getData = async (list) => {
+    const items = await Promise.all(
+        list.map((item) =>
+            cache.tryGet(item.link, async () => {
+                const data = await ofetch(item.json);
+                const article = data.pageProps.article;
+                item.pubDate = new Date(article.publishedAt).toUTCString();
+                const content = format(article);
+                const capture = load(content);
+                await Promise.all(
+                    capture('dl > dt')
+                        .toArray()
+                        .map(async (item) => {
+                            const id = capture(item).text();
+                            const image = await getImageById(id);
+                            capture(item).replaceWith(`<img src="${image}" alt="${id}">`);
+                        })
+                );
+
+                let authors = '';
+                authors = article.type === 'film' ? article.creditsShort : article.authors.map((author) => author.name).join(', ');
+
+                item.description = capture.html();
+                item.author = authors;
+
+                return item;
+            })
+        )
+    );
+
+    return items;
+};
+
+export { getData };

package/lib/routes/pubscholar/explore.ts

@@ -0,0 +1,62 @@
+import { Route } from '@/types';
+import ofetch from '@/utils/ofetch';
+import { parseDate } from '@/utils/parse-date';
+import { baseUrl, uuidv4, getArticleLink, getSignedHeaders } from './utils';
+import md5 from '@/utils/md5';
+import { Resource } from './types';
+import sanitizeHtml from 'sanitize-html';
+
+export const route: Route = {
+    path: '/explore/:category?/:keyword?',
+    name: 'Explore',
+    maintainers: ['TonyRL'],
+    example: '/pubscholar/explore',
+    parameters: {
+        category: 'Category, see the table below, `articles` by default',
+        keyword: 'Search Keyword',
+    },
+    handler,
+    description: `| Articles / 论文 | Patents / 专利 | Reports / 领域快报 | Information / 动态快讯 | Datasets / 科学数据 | Books / 图书 |
+| --------------- | -------------- | ------------------ | ---------------------- | ------------------- | ------------ |
+| articles        | patents        | bulletins          | reports                | sciencedata         | books        |`,
+};
+
+async function handler(ctx) {
+    const { category = 'articles', keyword } = ctx.req.param();
+    const uuid = uuidv4();
+
+    const response = await ofetch<Resource>(`${baseUrl}/hky/open/resources/api/v1/${category}`, {
+        method: 'POST',
+        headers: {
+            ...getSignedHeaders(),
+            Cookie: `XSRF-TOKEN=${uuid}`,
+            'X-XSRF-TOKEN': uuid,
+        },
+        body: {
+            page: 1,
+            size: 10,
+            order_field: 'date',
+            order_direction: 'desc',
+            user_id: md5(Date.now().toString()),
+            lang: 'zh',
+            query: keyword,
+            strategy: null,
+            orderField: 'default',
+        },
+    });
+
+    const list = response.content.map((item) => ({
+        title: (item.is_free || item.links.some((l) => l.is_open_access) ? '「Open Access」' : '') + sanitizeHtml(item.title, { allowedTags: [], allowedAttributes: {} }),
+        description: item.abstracts + `<br>${item.links.map((link) => `<a href="${link.url}">${link.is_open_access ? '「Open Access」' : ''}${link.name}</a>`).join('<br>')}`,
+        author: item.author.join('; '),
+        pubDate: parseDate(item.date),
+        category: item.keywords.map((keyword) => sanitizeHtml(keyword, { allowedTags: [], allowedAttributes: {} })),
+        link: `${baseUrl}/${category}/${getArticleLink(item.id)}`,
+    }));
+
+    return {
+        title: 'PubScholar 公益学术平台',
+        link: `${baseUrl}/explore`,
+        item: list,
+    };
+}

package/lib/routes/pubscholar/namespace.ts

@@ -0,0 +1,7 @@
+import type { Namespace } from '@/types';
+
+export const namespace: Namespace = {
+    name: 'PubScholar 公益学术平台',
+    url: 'pubscholar.cn',
+    categories: ['journal'],
+};

package/lib/routes/pubscholar/types.ts

@@ -0,0 +1,41 @@
+interface Link {
+    is_open_access: boolean;
+    name: string;
+    url: string;
+}
+
+interface Content {
+    date: string;
+    attachments: any[];
+    keywords: string[];
+    year: number;
+    source: string;
+    title: string;
+    type: string;
+    abstracts_abbreviation: string;
+    major: string;
+    school: any[];
+    first_page: string;
+    local_links: any[];
+    links: Link[];
+    id: string;
+    graduation_institution: any[];
+    cn_type: string;
+    article_type: string;
+    issue: string;
+    abstracts: string;
+    author: string[];
+    last_page: string;
+    degree: string;
+    tutor: any[];
+    semantic_entities: object;
+    volume: string;
+    source_list: string[];
+    is_free: boolean;
+}
+
+export interface Resource {
+    total: number;
+    is_last: boolean;
+    content: Content[];
+}

package/lib/routes/pubscholar/utils.ts

@@ -0,0 +1,44 @@
+import crypto from 'node:crypto';
+import CryptoJS from 'crypto-js';
+
+const salt = '6m6pingbinwaktg227gngifoocrfbo95';
+const key = CryptoJS.enc.Utf8.parse('eRtYuIoPaSdFgHqW');
+const iv = CryptoJS.enc.Utf8.parse('Nmc09JkLzX8765Vb');
+
+export const baseUrl = 'https://pubscholar.cn';
+export const sha1 = (str: string) => crypto.createHash('sha1').update(str).digest('hex');
+export const uuidv4 = () => crypto.randomUUID();
+
+const generateNonce = (length: number): string => {
+    if (!length) {
+        return null;
+    }
+
+    let nonce = '';
+    while (nonce.length < length) {
+        const randomString = Math.random().toString(36).slice(2).toUpperCase();
+        nonce += randomString;
+    }
+
+    return nonce.slice(0, length);
+};
+
+export const getSignedHeaders = () => {
+    const nonce = generateNonce(6);
+    const timestamp = Date.now().toString();
+    const signature = sha1([salt, timestamp, nonce].sort().join(''));
+    return {
+        nonce,
+        timestamp,
+        signature,
+    };
+};
+
+export const getArticleLink = (id: string) => {
+    const ciphertext = CryptoJS.AES.encrypt(CryptoJS.enc.Utf8.parse(id), key, {
+        iv,
+        mode: CryptoJS.mode.CBC,
+        padding: CryptoJS.pad.Pkcs7,
+    }).ciphertext.toString();
+    return ciphertext;
+};

package/lib/routes/pwc/sustainability.ts

@@ -1,22 +1,45 @@
 import { Route } from '@/types';
-import { load } from 'cheerio';
-import logger from '@/utils/logger';
 import { parseDate } from '@/utils/parse-date';
-import puppeteer from '@/utils/puppeteer';
+import ofetch from '@/utils/ofetch';
+
+interface PlayerOptions {
+    link: string;
+    image: string;
+    flashplayer: string;
+    width: string;
+    height: string;
+    aspectratio: string;
+    title: string;
+    description: string;
+    autostart: boolean;
+}
+
+interface Element {
+    index: number;
+    href: string;
+    relativeHref: string;
+    text: string;
+    thumbnailText: string;
+    title: string;
+    image: string;
+    tags: string[];
+    filterTags: string;
+    publishDate: string;
+    playerOptions: PlayerOptions;
+    damSize: string;
+    template: string;
+    itemUrl: string;
+    itemWidth: string;
+    itemHeight: string;
+    isPage: boolean;
+    isVideo: boolean;
+    itemVideoTranscriptLink: string;
+}
 
 export const route: Route = {
     path: '/strategyand/sustainability',
     categories: ['other'],
     example: '/pwc/strategyand/sustainability',
-    parameters: {},
-    features: {
-        requireConfig: false,
-        requirePuppeteer: true,
-        antiCrawler: false,
-        supportBT: false,
-        supportPodcast: false,
-        supportScihub: false,
-    },
     radar: [
         {
             source: ['strategyand.pwc.com/at/en/functions/sustainability-strategy/publications.html', 'strategyand.pwc.com/'],
@@ -33,47 +56,28 @@ async function handler() {
     const feedLang = 'en';
     const feedDescription = 'Sustainability Publications from PwC Strategy&';
 
-    const browser = await puppeteer();
-    const page = await browser.newPage();
-    logger.http(`Requesting ${baseUrl}`);
-    await page.setRequestInterception(true);
-    page.on('request', (request) => {
-        request.resourceType() === 'document' || request.resourceType() === 'script' ? request.continue() : request.abort();
-    });
-    await page.goto(baseUrl, {
-        waitUntil: 'domcontentloaded',
-    });
-    const response = await page.content();
-    page.close();
-
-    const $ = load(response);
-
-    const list = $('div#wrapper article')
-        .toArray()
-        .map((item) => {
-            item = $(item);
-            const a = item.find('a').first();
-            const div = item.find('div.collection__item-content').first();
-
-            const link = a.attr('href');
-            const title = div.find('h4').find('span').text();
-            const pubDate = parseDate(div.find('time').attr('datetime'), 'DD/MM/YY');
-            const description = div.find('p.paragraph').text();
-
-            return {
-                title,
-                link,
-                pubDate,
-                description,
-            };
-        });
+    const response = await ofetch(
+        'https://www.strategyand.pwc.com/content/pwc/03/en/functions/sustainability-strategy/publications/jcr:content/root/container/content-free-container/section_545483788/collection_v2.filter-dynamic.html',
+        {
+            query: {
+                currentPagePath: '/content/pwc/03/en/functions/sustainability-strategy/publications',
+                list: { menu_0: [] },
+                defaultImagePath: '/content/dam/pwc/network/strategyand-collection-fallback-images',
+            },
+        }
+    );
+    const elements = JSON.parse(response.elements) as Element[];
 
-    const items = list;
+    const items = elements.map((item) => ({
+        title: item.title,
+        link: item.href,
+        pubDate: parseDate(item.publishDate, 'DD/MM/YY'),
+        description: item.text,
+        category: item.tags,
+    }));
 
     // TODO: Add full text support
 
-    browser.close();
-
     return {
         title: 'PwC Strategy& - Sustainability Publications',
         link: baseUrl,

package/lib/routes/qidian/chapter.ts

@@ -1,11 +1,12 @@
-import { Route } from '@/types';
+import { Route, ViewType } from '@/types';
 import got from '@/utils/got';
 import { load } from 'cheerio';
 import { parseDate } from '@/utils/parse-date';
 
 export const route: Route = {
     path: '/chapter/:id',
-    categories: ['reading'],
+    categories: ['reading', 'popular'],
+    view: ViewType.Notifications,
     example: '/qidian/chapter/1010400217',
     parameters: { id: '小说 id, 可在对应小说页 URL 中找到' },
     features: {
@@ -21,7 +22,7 @@ export const route: Route = {
             source: ['book.qidian.com/info/:id'],
         },
     ],
-    name: '章节',
+    name: '作品章节',
     maintainers: ['fuzy112'],
     handler,
 };

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