rsshub 1.0.0-master.fc1b99f → 1.0.0-master.fc2cf18

package/lib/routes/fanbox/index.ts

@@ -0,0 +1,62 @@
+import InvalidParameterError from '@/errors/types/invalid-parameter';
+import type { Data, Route } from '@/types';
+import { isValidHost } from '@/utils/valid-host';
+import type { Context } from 'hono';
+import { getHeaders, parseItem } from './utils';
+import type { PostListResponse, UserInfoResponse } from './types';
+import ofetch from '@/utils/ofetch';
+
+export const route: Route = {
+    path: '/:creator',
+    categories: ['social-media'],
+    example: '/fanbox/official',
+    parameters: { creator: 'fanbox user name' },
+    maintainers: ['KarasuShin'],
+    name: 'Creator',
+    handler,
+    features: {
+        requireConfig: [
+            {
+                name: 'FANBOX_SESSION_ID',
+                description: 'Required for private posts. Can be found in browser DevTools -> Application -> Cookies -> https://www.fanbox.cc -> FANBOXSESSID',
+                optional: true,
+            },
+        ],
+    },
+};
+
+async function handler(ctx: Context): Promise<Data> {
+    const creator = ctx.req.param('creator');
+    if (!isValidHost(creator)) {
+        throw new InvalidParameterError('Invalid user name');
+    }
+
+    let title = `Fanbox - ${creator}`;
+
+    let description: string | undefined;
+
+    let image: string | undefined;
+
+    try {
+        const userApi = `https://api.fanbox.cc/creator.get?creatorId=${creator}`;
+        const userInfoResponse = (await ofetch(userApi, {
+            headers: getHeaders(),
+        })) as UserInfoResponse;
+        title = `Fanbox - ${userInfoResponse.body.user.name}`;
+        description = userInfoResponse.body.description;
+        image = userInfoResponse.body.user.iconUrl;
+    } catch {
+        // ignore
+    }
+
+    const postListResponse = (await ofetch(`https://api.fanbox.cc/post.listCreator?creatorId=${creator}&limit=20`, { headers: getHeaders() })) as PostListResponse;
+    const items = await Promise.all(postListResponse.body.items.map((i) => parseItem(i)));
+
+    return {
+        title,
+        link: `https://${creator}.fanbox.cc`,
+        description,
+        image,
+        item: items,
+    };
+}

package/lib/routes/fanbox/namespace.ts

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

package/lib/routes/fanbox/templates/fanbox-post.art

@@ -0,0 +1,7 @@
+<a href={{postUrl}}>
+    <h1>{{title}}</h1>
+    <span style="margin-right:1.6em">{{user.name}}</span>
+    <br />
+    <br />
+    <span>{{excerpt}}</span>
+</a>

package/lib/routes/fanbox/types.ts

@@ -0,0 +1,239 @@
+export interface UserInfoResponse {
+    body: {
+        user: {
+            userId: string;
+            name: string;
+            iconUrl: string;
+        };
+        creatorId: string;
+        description: string;
+        hasAdultContent: boolean;
+        coverImageUrl: string;
+        profileLinks: string[];
+        profileItems: {
+            id: string;
+            type: string;
+            serviceProvider: string;
+            videoId: string;
+        }[];
+        isFollowed: boolean;
+        isSupported: boolean;
+        isStopped: boolean;
+        isAcceptingRequest: boolean;
+        hasBoothShop: boolean;
+    };
+}
+
+export interface PostListResponse {
+    body: {
+        items: PostItem[];
+        nextUrl: string | null;
+    };
+}
+
+export interface PostDetailResponse {
+    body: PostDetail;
+}
+
+export interface PostItem {
+    commentCount: number;
+    cover: {
+        type: string;
+        url: string;
+    };
+    creatorId: string;
+    excerpt: string;
+    feeRequired: number;
+    hasAdultContent: boolean;
+    id: string;
+    isLiked: boolean;
+    isRestricted: boolean;
+    likeCount: number;
+    publishedDatetime: string;
+    tags: string[];
+    title: string;
+    updatedDatetime: string;
+    user: {
+        iconUrl: string;
+        name: string;
+        userId: string;
+    };
+}
+
+interface BasicPost {
+    commentCount: number;
+    commentList: {
+        items: {
+            body: string;
+            createdDatetime: string;
+            id: string;
+            isLiked: boolean;
+            isOwn: boolean;
+            likeCount: number;
+            parentCommentId: string;
+            replies: {
+                body: string;
+                createdDatetime: string;
+                id: string;
+                isLiked: boolean;
+                isOwn: boolean;
+                likeCount: number;
+                parentCommentId: string;
+                rootCommentId: string;
+            }[];
+            rootCommentId: string;
+            user: {
+                iconUrl: string;
+                name: string;
+                userId: string;
+            };
+        }[];
+        nextUrl: string | null;
+    };
+    coverImageUrl: string | null;
+    creatorId: string;
+    excerpt: string;
+    feeRequired: number;
+    hasAdultContent: boolean;
+    id: string;
+    imageForShare: string;
+    isLiked: boolean;
+    isRestricted: boolean;
+    likeCount: number;
+    nextPost: {
+        id: string;
+        title: string;
+        publishedDatetime: string;
+    };
+    publishedDatetime: string;
+    tags: string[];
+    title: string;
+    updatedDatetime: string;
+}
+
+export interface ArticlePost extends BasicPost {
+    type: 'article';
+    body: {
+        blocks: Block[];
+        embedMap: {
+            [key: string]: unknown;
+        };
+        fileMap: {
+            [key: string]: {
+                id: string;
+                extension: string;
+                name: string;
+                size: number;
+                url: string;
+            };
+        };
+        imageMap: {
+            [key: string]: {
+                id: string;
+                originalUrl: string;
+                thumbnailUrl: string;
+                width: number;
+                height: number;
+                extension: string;
+            };
+        };
+        urlEmbedMap: {
+            [key: string]:
+                | {
+                      type: 'html';
+                      html: string;
+                      id: string;
+                  }
+                | {
+                      type: 'fanbox.post';
+                      id: string;
+                      postInfo: PostItem;
+                  };
+        };
+    };
+}
+
+export interface FilePost extends BasicPost {
+    type: 'file';
+    body: {
+        files: {
+            extension: string;
+            id: string;
+            name: string;
+            size: number;
+            url: string;
+        }[];
+        text: string;
+    };
+}
+
+export interface VideoPost extends BasicPost {
+    type: 'video';
+    body: {
+        text: string;
+        video: {
+            serviceProvider: 'youtube' | 'vimeo' | 'soundcloud';
+            videoId: 'string';
+        };
+    };
+}
+
+export interface ImagePost extends BasicPost {
+    type: 'image';
+    body: {
+        images: {
+            id: string;
+            originalUrl: string;
+            thumbnailUrl: string;
+            width: number;
+            height: number;
+            extension: string;
+        }[];
+        text: string;
+    };
+}
+
+export interface TextPost extends BasicPost {
+    type: 'text';
+    body: {
+        text: string;
+    };
+}
+
+export interface PostDetailResponse {
+    body: PostDetail;
+}
+
+interface TextBlock {
+    type: 'p';
+    text: string;
+    styles?: {
+        length: number;
+        offset: number;
+        type: 'bold';
+    }[];
+}
+
+interface HeaderBlock {
+    type: 'header';
+    text: string;
+}
+
+interface ImageBlock {
+    type: 'image';
+    imageId: string;
+}
+
+interface FileBlock {
+    type: 'file';
+    fileId: string;
+}
+
+interface EmbedBlock {
+    type: 'url_embed';
+    urlEmbedId: string;
+}
+
+type PostDetail = ArticlePost | FilePost | ImagePost | VideoPost | TextPost;
+
+type Block = TextBlock | HeaderBlock | ImageBlock | FileBlock | EmbedBlock;

package/lib/routes/fanbox/utils.ts

@@ -0,0 +1,188 @@
+import { config } from '@/config';
+import type { DataItem } from '@/types';
+import ofetch from '@/utils/ofetch';
+import type { ArticlePost, FilePost, ImagePost, PostDetailResponse, PostItem, TextPost, VideoPost } from './types';
+import { parseDate } from '@/utils/parse-date';
+import cache from '@/utils/cache';
+import { art } from '@/utils/render';
+import path from 'node:path';
+import { getCurrentPath } from '@/utils/helpers';
+
+const __dirname = getCurrentPath(import.meta.url);
+
+export function getHeaders() {
+    const sessionid = config.fanbox.session;
+    const cookie = sessionid ? `FANBOXSESSID=${sessionid}` : '';
+    return {
+        origin: 'https://fanbox.cc',
+        cookie,
+    };
+}
+
+function embedUrlMap(urlEmbed: ArticlePost['body']['urlEmbedMap'][string]) {
+    switch (urlEmbed.type) {
+        case 'html':
+            return urlEmbed.html;
+        case 'fanbox.post':
+            return art(path.join(__dirname, 'templates/fanbox-post.art'), {
+                postUrl: `https://${urlEmbed.postInfo.creatorId}.fanbox.cc/posts/${urlEmbed.postInfo.id}`,
+                title: urlEmbed.postInfo.title,
+                user: urlEmbed.postInfo.user,
+                excerpt: urlEmbed.postInfo.excerpt,
+            });
+        default:
+            return '';
+    }
+}
+
+function passageConv(p) {
+    const seg = [...p.text];
+    if (p.styles) {
+        p.styles.map((s) => {
+            switch (s.type) {
+                case 'bold':
+                    seg[s.offset] = `<b>` + seg[s.offset];
+                    seg[s.offset + s.length - 1] += `</b>`;
+                    break;
+                default:
+            }
+            return s;
+        });
+    }
+    if (p.links) {
+        p.links.map((l) => {
+            seg[l.offset] = `<a href="${l.url}">` + seg[l.offset];
+            seg[l.offset + l.length - 1] += `</a>`;
+            return l;
+        });
+    }
+    const ret = seg.join('');
+    return ret;
+}
+
+function parseText(body: TextPost['body']) {
+    return body.text || '';
+}
+
+function parseImage(body: ImagePost['body']) {
+    let ret = body.text || '';
+    for (const i of body.images) {
+        ret += `<hr><img src="${i.originalUrl}">`;
+    }
+    return ret;
+}
+
+function parseFile(body: FilePost['body']) {
+    let ret = body.text || '';
+    for (const f of body.files) {
+        ret += `<br><a href="${f.url}" download="${f.name}.${f.extension}">${f.name}.${f.extension}</a>`;
+    }
+    return ret;
+}
+
+async function parseVideo(body: VideoPost['body']) {
+    let ret = '';
+    switch (body.video.serviceProvider) {
+        case 'soundcloud':
+            ret += await getSoundCloudEmbedUrl(body.video.videoId);
+            break;
+        case 'youtube':
+            ret += `<iframe src="https://www.youtube-nocookie.com/embed/${body.video.videoId}" frameborder="0"></iframe>`;
+            break;
+        case 'vimeo':
+            ret += `<iframe src="https://player.vimeo.com/video/${body.video.videoId}" frameborder="0"></iframe>`;
+            break;
+        default:
+    }
+    ret += `<br>${body.text}`;
+    return ret;
+}
+
+async function parseArtile(body: ArticlePost['body']) {
+    let ret: Array<string> = [];
+    for (let x = 0; x < body.blocks.length; ++x) {
+        const b = body.blocks[x];
+        ret.push('<p>');
+
+        switch (b.type) {
+            case 'p':
+                ret.push(passageConv(b));
+                break;
+            case 'header':
+                ret.push(`<h2>${b.text}</h2>`);
+                break;
+            case 'image': {
+                const i = body.imageMap[b.imageId];
+                ret.push(`<img src="${i.originalUrl}">`);
+                break;
+            }
+            case 'file': {
+                const file = body.fileMap[b.fileId];
+                ret.push(`<a href="${file.url}" download="${file.name}.${file.extension}">${file.name}.${file.extension}</a>`);
+                break;
+            }
+            case 'url_embed':
+                ret.push(embedUrlMap(body.urlEmbedMap[b.urlEmbedId]));
+                break;
+            default:
+        }
+    }
+    ret = await Promise.all(ret);
+    return ret.join('');
+}
+
+async function parseDetail(i: PostDetailResponse['body']) {
+    let ret = '';
+    if (i.feeRequired !== 0) {
+        ret += `Fee Required: <b>${i.feeRequired} JPY/month</b><hr>`;
+    }
+    if (i.coverImageUrl) {
+        ret += `<img src="${i.coverImageUrl}"><hr>`;
+    }
+
+    if (!i.body) {
+        ret += i.excerpt;
+        return ret;
+    }
+
+    switch (i.type) {
+        case 'text':
+            ret += parseText(i.body);
+            break;
+        case 'file':
+            ret += parseFile(i.body);
+            break;
+        case 'image':
+            ret += parseImage(i.body);
+            break;
+        case 'video':
+            ret += await parseVideo(i.body);
+            break;
+        case 'article':
+            ret += await parseArtile(i.body);
+            break;
+        default:
+            ret += '<b>Unsupported content (RSSHub)</b>';
+    }
+    return ret;
+}
+
+export function parseItem(item: PostItem) {
+    return cache.tryGet(`fanbox-${item.id}-${item.updatedDatetime}`, async () => {
+        const postDetail = (await ofetch(`https://api.fanbox.cc/post.info?postId=${item.id}`, { headers: getHeaders() })) as PostDetailResponse;
+        return {
+            title: item.title || `No title`,
+            description: await parseDetail(postDetail.body),
+            pubDate: parseDate(item.updatedDatetime),
+            link: `https://${item.creatorId}.fanbox.cc/posts/${item.id}`,
+            category: item.tags,
+        };
+    }) as Promise<DataItem>;
+}
+
+async function getSoundCloudEmbedUrl(videoId: string) {
+    const videoUrl = `https://soundcloud.com/${videoId}`;
+    const apiUrl = `https://soundcloud.com/oembed?url=${encodeURIComponent(videoUrl)}&format=json&maxheight=400&format=json`;
+    const resp = await ofetch(apiUrl);
+    return resp.html;
+}

package/lib/routes/fanqienovel/namespace.ts

@@ -0,0 +1,7 @@
+import type { Namespace } from '@/types';
+
+export const namespace: Namespace = {
+    name: '番茄小说',
+    url: 'fanqienovel.com',
+    categories: ['reading'],
+};

package/lib/routes/fanqienovel/page.ts

@@ -0,0 +1,100 @@
+import type { Data, Route } from '@/types';
+import type { Context } from 'hono';
+import ofetch from '@/utils/ofetch';
+import * as cheerio from 'cheerio';
+import { parseDate } from '@/utils/parse-date';
+
+interface Chapter {
+    itemId: string;
+    needPay: number;
+    title: string;
+    isChapterLock: boolean;
+    isPaidPublication: boolean;
+    isPaidStory: boolean;
+    volume_name: string;
+    firstPassTime: string;
+}
+
+interface Page {
+    hasFetch: boolean;
+    author: string;
+    authorId: string;
+    bookId: string;
+    mediaId: string;
+    bookName: string;
+    status: number;
+    category: string;
+    categoryV2: string;
+    abstract: string;
+    thumbUri: string;
+    creationStatus: number;
+    wordNumber: number;
+    readCount: number;
+    description: string;
+    avatarUri: string;
+    creatorId: string;
+    lastPublishTime: string;
+    lastChapterItemId: string;
+    lastChapterTitle: string;
+    volumeNameList: string[];
+    chapterListWithVolume: Chapter[][];
+    chapterTotal: number;
+    followStatus: number;
+    itemIds: string[];
+    hasFetchDirectory: boolean;
+    chapterList: any[];
+    serverRendered: boolean;
+    genre: string;
+    platform: string;
+    type: string;
+    originalAuthors: string;
+    completeCategory: string;
+}
+
+export const route: Route = {
+    path: '/page/:bookId',
+    example: '/fanqienovel/page/6621052928482348040',
+    parameters: { bookId: '小说 ID，可在 URL 中找到' },
+    maintainers: ['TonyRL'],
+    name: '小说更新',
+    handler,
+    radar: [
+        {
+            source: ['fanqienovel.com/page/:bookId'],
+        },
+    ],
+};
+
+async function handler(ctx: Context): Promise<Data> {
+    const { bookId } = ctx.req.param();
+    const link = `https://fanqienovel.com/page/${bookId}`;
+
+    const response = await ofetch(link);
+    const $ = cheerio.load(response);
+
+    const initialState = JSON.parse(
+        $('script:contains("window.__INITIAL_STATE__")')
+            .text()
+            .match(/window\.__INITIAL_STATE__\s*=\s*(.*);/)?.[1] ?? '{}'
+    );
+
+    const page = initialState.page as Page;
+    const items = page.chapterListWithVolume.flatMap((volume) =>
+        volume.map((chapter) => ({
+            title: chapter.title,
+            link: `https://fanqienovel.com/reader/${chapter.itemId}`,
+            description: chapter.volume_name,
+            pubDate: parseDate(chapter.firstPassTime, 'X'),
+            author: page.author,
+        }))
+    );
+
+    return {
+        title: `${page.bookName} - ${page.author}`,
+        description: page.abstract,
+        link,
+        language: 'zh-CN',
+        image: page.thumbUri,
+        item: items,
+    };
+}

package/lib/routes/fansly/post.ts

@@ -1,5 +1,4 @@
 import { Route } from '@/types';
-import cache from '@/utils/cache';
 import { parseDate } from '@/utils/parse-date';
 import { getAccountByUsername, getTimelineByAccountId, parseDescription, baseUrl } from './utils';
 
@@ -29,7 +28,7 @@ export const route: Route = {
 async function handler(ctx) {
     const username = ctx.req.param('username');
 
-    const account = await getAccountByUsername(username, cache.tryGet);
+    const account = await getAccountByUsername(username);
     const timeline = await getTimelineByAccountId(account.id);
 
     const items = timeline.posts.map((post) => ({

package/lib/routes/fansly/tag.ts

@@ -1,5 +1,4 @@
 import { Route } from '@/types';
-import cache from '@/utils/cache';
 import { parseDate } from '@/utils/parse-date';
 import { getTagId, getTagSuggestion, findAccountById, parseDescription, baseUrl, icon } from './utils';
 
@@ -29,7 +28,7 @@ export const route: Route = {
 async function handler(ctx) {
     const tag = ctx.req.param('tag');
 
-    const tagId = await getTagId(tag, cache.tryGet);
+    const tagId = await getTagId(tag);
     const suggestion = await getTagSuggestion(tagId);
 
     const items = suggestion.aggregationData?.posts.map((post) => {

package/lib/routes/fansly/templates/media.art

@@ -1,5 +1,5 @@
 {{ if poster && src }}
-<video controls preload="none" poster="{{ poster.location }}">
+<video controls preload="metadata" poster="{{ poster.location }}">
     <source src="{{ src.location }}" type="video/mp4">
 </video>
 {{ else if src }}

package/lib/routes/fansly/utils.ts

@@ -2,8 +2,10 @@ import { getCurrentPath } from '@/utils/helpers';
 const __dirname = getCurrentPath(import.meta.url);
 
 import got from '@/utils/got';
-import * as path from 'node:path';
+import path from 'node:path';
 import { art } from '@/utils/render';
+import InvalidParameterError from '@/errors/types/invalid-parameter';
+import cache from '@/utils/cache';
 
 const apiBaseUrl = 'https://apiv3.fansly.com';
 const baseUrl = 'https://fansly.com';
@@ -17,8 +19,8 @@ const findAccountById = (accountId, accounts) => {
     };
 };
 
-const getAccountByUsername = (username, tryGet) =>
-    tryGet(`fansly:account:${username.toLowerCase()}`, async () => {
+const getAccountByUsername = (username) =>
+    cache.tryGet(`fansly:account:${username.toLowerCase()}`, async () => {
         const { data: accountResponse } = await got(`${apiBaseUrl}/api/v1/account`, {
             searchParams: {
                 usernames: username,
@@ -27,7 +29,7 @@ const getAccountByUsername = (username, tryGet) =>
         });
 
         if (!accountResponse.response.length) {
-            throw new Error('This profile or page does not exist.');
+            throw new InvalidParameterError('This profile or page does not exist.');
         }
 
         return accountResponse.response[0];
@@ -47,8 +49,8 @@ const getTimelineByAccountId = async (accountId) => {
     return timeline.response;
 };
 
-const getTagId = (tag, tryGet) =>
-    tryGet(`fansly:tag:${tag.toLowerCase()}`, async () => {
+const getTagId = (tag) =>
+    cache.tryGet(`fansly:tag:${tag.toLowerCase()}`, async () => {
         const { data: tagResponse } = await got(`${apiBaseUrl}/api/v1/contentdiscovery/media/tag`, {
             searchParams: {
                 tag,