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

package/lib/routes/pixiv/novel-api/content/types.ts

@@ -0,0 +1,254 @@
+export interface NovelContent {
+    id: string;
+    title: string;
+    description: string;
+    content: string;
+
+    userId: string;
+    userName: string | null;
+
+    bookmarkCount: number;
+    viewCount: number;
+    likeCount: number;
+
+    createDate: Date;
+    updateDate: Date | null;
+
+    tags: string[];
+
+    coverUrl: string;
+    images: Record<string, string>;
+
+    seriesId: string | null;
+    seriesTitle: string | null;
+}
+
+export interface SFWNovelDetail {
+    error: boolean;
+    message: string;
+    body: {
+        bookmarkCount: number;
+        commentCount: number;
+        markerCount: number;
+        createDate: string;
+        uploadDate: string;
+        description: string;
+        id: string;
+        title: string;
+        likeCount: number;
+        pageCount: number;
+        userId: string;
+        userName: string;
+        viewCount: number;
+        isOriginal: boolean;
+        isBungei: boolean;
+        xRestrict: number;
+        restrict: number;
+        content: string;
+        coverUrl: string;
+        suggestedSettings: {
+            viewMode: number;
+            themeBackground: number;
+            themeSize: null;
+            themeSpacing: null;
+        };
+        isBookmarkable: boolean;
+        bookmarkData: null;
+        likeData: boolean;
+        pollData: null;
+        marker: null;
+        tags: {
+            authorId: string;
+            isLocked: boolean;
+            tags: Array<{
+                tag: string;
+                locked: boolean;
+                deletable: boolean;
+                userId: string;
+                userName: string;
+            }>;
+            writable: boolean;
+        };
+        seriesNavData: {
+            seriesType: string;
+            seriesId: number;
+            title: string;
+            isConcluded: boolean;
+            isReplaceable: boolean;
+            isWatched: boolean;
+            isNotifying: boolean;
+            order: number;
+            next: {
+                title: string;
+                order: number;
+                id: string;
+                available: boolean;
+            } | null;
+            prev: null;
+        } | null;
+        descriptionBoothId: null;
+        descriptionYoutubeId: null;
+        comicPromotion: null;
+        fanboxPromotion: null;
+        contestBanners: any[];
+        contestData: null;
+        request: null;
+        imageResponseOutData: any[];
+        imageResponseData: any[];
+        imageResponseCount: number;
+        userNovels: {
+            [key: string]: {
+                id: string;
+                title: string;
+                genre: string;
+                xRestrict: number;
+                restrict: number;
+                url: string;
+                tags: string[];
+                userId: string;
+                userName: string;
+                profileImageUrl: string;
+                textCount: number;
+                wordCount: number;
+                readingTime: number;
+                useWordCount: boolean;
+                description: string;
+                isBookmarkable: boolean;
+                bookmarkData: null;
+                bookmarkCount: number | null;
+                isOriginal: boolean;
+                marker: null;
+                titleCaptionTranslation: {
+                    workTitle: null;
+                    workCaption: null;
+                };
+                createDate: string;
+                updateDate: string;
+                isMasked: boolean;
+                aiType: number;
+                seriesId?: string;
+                seriesTitle?: string;
+                isUnlisted: boolean;
+            } | null;
+        };
+        hasGlossary: boolean;
+        zoneConfig: {
+            [key: string]: {
+                url: string;
+            };
+        };
+        extraData: {
+            meta: {
+                title: string;
+                description: string;
+                canonical: string;
+                descriptionHeader: string;
+                ogp: {
+                    description: string;
+                    image: string;
+                    title: string;
+                    type: string;
+                };
+                twitter: {
+                    description: string;
+                    image: string;
+                    title: string;
+                    card: string;
+                };
+            };
+        };
+        titleCaptionTranslation: {
+            workTitle: null;
+            workCaption: null;
+        };
+        isUnlisted: boolean;
+        language: string;
+        textEmbeddedImages: {
+            [key: string]: {
+                novelImageId: string;
+                sl: string;
+                urls: {
+                    '240mw': string;
+                    '480mw': string;
+                    '1200x1200': string;
+                    '128x128': string;
+                    original: string;
+                };
+            };
+        };
+        commentOff: number;
+        characterCount: number;
+        wordCount: number;
+        useWordCount: boolean;
+        readingTime: number;
+        genre: string;
+        aiType: number;
+        noLoginData: {
+            breadcrumbs: {
+                successor: any[];
+                current: {
+                    ja: string;
+                };
+            };
+            zengoWorkData: {
+                nextWork: {
+                    id: string;
+                    title: string;
+                } | null;
+                prevWork: {
+                    id: string;
+                    title: string;
+                } | null;
+            };
+        };
+    };
+}
+
+export interface NSFWNovelDetail {
+    id: string;
+    title: string;
+    seriesId: string | null;
+    seriesTitle: string | null;
+    seriesIsWatched: boolean | null;
+    userId: string;
+    coverUrl: string;
+    tags: string[];
+    caption: string;
+    cdate: string;
+    rating: {
+        like: number;
+        bookmark: number;
+        view: number;
+    };
+    text: string;
+    marker: null;
+    illusts: string[];
+    images: {
+        [key: string]: {
+            novelImageId: string;
+            sl: string;
+            urls: {
+                '240mw': string;
+                '480mw': string;
+                '1200x1200': string;
+                '128x128': string;
+                original: string;
+            };
+        };
+    };
+    seriesNavigation: {
+        nextNovel: null;
+        prevNovel: {
+            id: number;
+            viewable: boolean;
+            contentOrder: string;
+            title: string;
+            coverUrl: string;
+            viewableMessage: null;
+        } | null;
+    } | null;
+    glossaryItems: string[];
+    replaceableItemIds: string[];
+    aiType: number;
+    isOriginal: boolean;
+}

package/lib/routes/pixiv/novel-api/content/utils.ts

@@ -0,0 +1,133 @@
+import { load } from 'cheerio';
+import getIllustDetail from '../../api/get-illust-detail';
+import pixivUtils from '../../utils';
+
+export function convertPixivProtocolExtended(caption: string): string {
+    const protocolMap = new Map([
+        [/pixiv:\/\/novels\/(\d+)/g, 'https://www.pixiv.net/novel/show.php?id=$1'],
+        [/pixiv:\/\/illusts\/(\d+)/g, 'https://www.pixiv.net/artworks/$1'],
+        [/pixiv:\/\/users\/(\d+)/g, 'https://www.pixiv.net/users/$1'],
+        [/pixiv:\/\/novel\/series\/(\d+)/g, 'https://www.pixiv.net/novel/series/$1'],
+    ]);
+
+    let convertedText = caption;
+    for (const [pattern, replacement] of protocolMap) {
+        convertedText = convertedText.replace(pattern, replacement);
+    }
+    return convertedText;
+}
+
+// docs: https://www.pixiv.help/hc/ja/articles/235584168-小説作品の本文内に使える特殊タグとは
+export async function parseNovelContent(content: string, images: Record<string, string>, token?: string): Promise<string> {
+    try {
+        // 如果有 token，處理 pixiv 圖片引用
+        // If token exists, process pixiv image references
+        if (token) {
+            const imageMatches = [...content.matchAll(/\[pixivimage:(\d+)(?:-(\d+))?\]/g)];
+            const imageIdToUrl = new Map<string, string>();
+
+            // 批量獲取圖片資訊
+            // Batch fetch image information
+            await Promise.all(
+                imageMatches.map(async ([, illustId, pageNum]) => {
+                    if (!illustId) {
+                        return;
+                    }
+
+                    try {
+                        const illust = (await getIllustDetail(illustId, token)).data.illust;
+                        const pixivimages = pixivUtils.getImgs(illust).map((img) => img.match(/src="([^"]+)"/)?.[1] || '');
+
+                        const imageUrl = pixivimages[Number(pageNum) || 0];
+                        if (imageUrl) {
+                            imageIdToUrl.set(pageNum ? `${illustId}-${pageNum}` : illustId, imageUrl);
+                        }
+                    } catch (error) {
+                        // 記錄錯誤但不中斷處理
+                        // Log error but don't interrupt processing
+                        logger.warn(`Failed to fetch illust detail for ID ${illustId}: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                })
+            );
+
+            // 替換 pixiv 圖片引用為 img 標籤
+            // Replace pixiv image references with img tags
+            content = content.replaceAll(/\[pixivimage:(\d+)(?:-(\d+))?\]/g, (match, illustId, pageNum) => {
+                const key = pageNum ? `${illustId}-${pageNum}` : illustId;
+                const imageUrl = imageIdToUrl.get(key);
+                return imageUrl ? `<img src="${imageUrl}" alt="pixiv illustration ${illustId}${pageNum ? ` page ${pageNum}` : ''}">` : match;
+            });
+        } else {
+            /*
+             * 處理 get-novels-sfw 的情況
+             * 當沒有 PIXIV_REFRESHTOKEN 時，將 [pixivimage:(\d+)] 格式轉換為 artwork 連結
+             * 因無法獲取 Pixiv 作品詳情，改為提供直接連結到原始作品頁面
+             *
+             * Handle get-novels-sfw case
+             * When PIXIV_REFRESHTOKEN is not available, convert [pixivimage:(\d+)] format to artwork link
+             * Provide direct link to original artwork page since artwork details cannot be retrieved
+             */
+            content = content.replaceAll(/\[pixivimage:(\d+)(?:-(\d+))?\]/g, (_, illustId) => `<a href="https://www.pixiv.net/artworks/${illustId}" target="_blank" rel="noopener noreferrer">Pixiv Artwork #${illustId}</a>`);
+        }
+
+        // 處理作者上傳的圖片
+        // Process author uploaded images
+        content = content.replaceAll(/\[uploadedimage:(\d+)\]/g, (match, imageId) => {
+            if (images[imageId]) {
+                return `<img src="${pixivUtils.getProxiedImageUrl(images[imageId])}" alt="novel illustration ${imageId}">`;
+            }
+            return match;
+        });
+
+        // 基本格式處理
+        // Basic formatting
+        content = content
+            // 換行轉換為 HTML 換行
+            // Convert newlines to HTML breaks
+            .replaceAll('\n', '<br>')
+            // 連續換行轉換為段落
+            // Convert consecutive breaks to paragraphs
+            .replaceAll(/(<br>){2,}/g, '</p><p>')
+            // ruby 標籤（為日文漢字標註讀音）
+            // ruby tags (for Japanese kanji readings)
+            .replaceAll(/\[\[rb:(.*?)>(.*?)\]\]/g, '<ruby>$1<rt>$2</rt></ruby>')
+            // 外部連結
+            // external links
+            .replaceAll(/\[\[jumpuri:(.*?)>(.*?)\]\]/g, '<a href="$2" target="_blank" rel="noopener noreferrer">$1</a>')
+            // 頁面跳轉，但由於 [newpage] 使用 hr 分隔，沒有頁數，沒必要跳轉，所以只顯示文字
+            // Page jumps, but since [newpage] uses hr separators, without the page numbers, jumping isn't needed, so just display text
+            .replaceAll(/\[jump:(\d+)\]/g, 'Jump to page $1')
+            // 章節標題
+            // chapter titles
+            .replaceAll(/\[chapter:(.*?)\]/g, '<h2>$1</h2>')
+            // 分頁符
+            // page breaks
+            .replaceAll('[newpage]', '<hr>');
+
+        // 使用 cheerio 進行 HTML 清理和優化
+        // Use cheerio for HTML cleanup and optimization
+        const $content = load(`<article><p>${content}</p></article>`);
+
+        // 處理嵌套段落：移除多餘的嵌套
+        // Handle nested paragraphs: remove unnecessary nesting
+        $content('p p').each((_, elem) => {
+            const $elem = $content(elem);
+            $elem.replaceWith($elem.html() || '');
+        });
+
+        // 處理段落中的標題：確保正確的 HTML 結構
+        // Handle headings in paragraphs: ensure correct HTML structure
+        $content('p h2').each((_, elem) => {
+            const $elem = $content(elem);
+            const $parent = $elem.parent('p');
+            const html = $elem.prop('outerHTML');
+            if ($parent.length && html) {
+                $parent.replaceWith(`</p>${html}<p>`);
+            }
+        });
+
+        return $content.html() || '';
+    } catch (error) {
+        throw new Error(`Error parsing novel content: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/lib/routes/pixiv/novel-api/series/nsfw.ts

@@ -0,0 +1,84 @@
+import got from '../../pixiv-got';
+import { maskHeader } from '../../constants';
+import { getNSFWNovelContent } from '../content/nsfw';
+import pixivUtils from '../../utils';
+import { AppNovelSeries, SeriesDetail, SeriesFeed } from './types';
+import ConfigNotFoundError from '@/errors/types/config-not-found';
+import { getToken } from '../../token';
+import { config } from '@/config';
+import cache from '@/utils/cache';
+import queryString from 'query-string';
+
+const baseUrl = 'https://www.pixiv.net';
+
+async function getNovelSeries(seriesId: string, offset: number, token: string): Promise<AppNovelSeries> {
+    const rsp = await got('https://app-api.pixiv.net/v2/novel/series', {
+        headers: {
+            ...maskHeader,
+            Authorization: 'Bearer ' + token,
+        },
+        searchParams: queryString.stringify({
+            series_id: seriesId,
+            last_order: offset,
+        }),
+    });
+    return rsp.data as AppNovelSeries;
+}
+
+export async function getNSFWSeriesNovels(seriesId: string, limit: number = 10): Promise<SeriesFeed> {
+    if (limit > 30) {
+        limit = 30;
+    }
+
+    if (!config.pixiv || !config.pixiv.refreshToken) {
+        throw new ConfigNotFoundError('This user is an R18 creator, PIXIV_REFRESHTOKEN is required.\npixiv RSS is disabled due to the lack of relevant config.\n該用戶爲 R18 創作者，需要 PIXIV_REFRESHTOKEN。');
+    }
+
+    const token = await getToken(cache.tryGet);
+    if (!token) {
+        throw new ConfigNotFoundError('pixiv not login');
+    }
+
+    const seriesResponse = await got(`${baseUrl}/ajax/novel/series/${seriesId}`, {
+        headers: {
+            ...maskHeader,
+            Authorization: 'Bearer ' + token,
+        },
+    });
+    const seriesData = seriesResponse.data as SeriesDetail;
+
+    let offset = seriesData.body.total - limit;
+    if (offset < 0) {
+        offset = 0;
+    }
+    const appSeriesData = await getNovelSeries(seriesId, offset, token);
+
+    const items = await Promise.all(
+        appSeriesData.novels.map(async (novel) => {
+            const novelContent = await getNSFWNovelContent(novel.id, token);
+            return {
+                title: novel.title,
+                description: `
+                    <img src="${pixivUtils.getProxiedImageUrl(novelContent.coverUrl)}" />
+                    <div>
+                    <p>${novelContent.description}</p>
+                    <hr>
+                    ${novelContent.content}
+                    </div>
+                `,
+                link: `${baseUrl}/novel/show.php?id=${novel.id}`,
+                pubDate: novel.create_date,
+                author: novel.user.name,
+                category: novelContent.tags,
+            };
+        })
+    );
+
+    return {
+        title: appSeriesData.novel_series_detail.title,
+        description: appSeriesData.novel_series_detail.caption,
+        link: `${baseUrl}/novel/series/${seriesId}`,
+        image: pixivUtils.getProxiedImageUrl(seriesData.body.cover.urls.original),
+        item: items,
+    };
+}

package/lib/routes/pixiv/novel-api/series/sfw.ts

@@ -0,0 +1,70 @@
+import got from '@/utils/got';
+import { load } from 'cheerio';
+import { getSFWNovelContent } from '../content/sfw';
+import pixivUtils from '../../utils';
+import { SeriesContentResponse, SeriesFeed } from './types';
+
+const baseUrl = 'https://www.pixiv.net';
+
+export async function getSFWSeriesNovels(seriesId: string, limit: number = 10): Promise<SeriesFeed> {
+    const seriesPage = await got(`${baseUrl}/novel/series/${seriesId}`);
+    const $ = load(seriesPage.data);
+
+    const title = $('meta[property="og:title"]').attr('content') || '';
+    const description = $('meta[property="og:description"]').attr('content') || '';
+    const image = $('meta[property="og:image"]').attr('content') || '';
+
+    const response = await got(`${baseUrl}/ajax/novel/series/${seriesId}/content_titles`, {
+        headers: {
+            referer: `${baseUrl}/novel/series/${seriesId}`,
+        },
+    });
+
+    const data = response.data as SeriesContentResponse;
+
+    if (data.error) {
+        throw new Error(data.message || 'Failed to get series data');
+    }
+
+    const chapters = data.body.slice(-Math.abs(limit));
+    const chapterStartNum = Math.max(data.body.length - limit + 1, 1);
+
+    const items = await Promise.all(
+        chapters
+            .map(async (chapter, index) => {
+                if (!chapter.available) {
+                    return {
+                        title: `#${chapterStartNum + index} ${chapter.title}`,
+                        description: `PIXIV_REFRESHTOKEN is required to view the full content.<br>需要 PIXIV_REFRESHTOKEN 才能查看完整內文。`,
+                        link: `${baseUrl}/novel/show.php?id=${chapter.id}`,
+                    };
+                }
+
+                const novelContent = await getSFWNovelContent(chapter.id);
+                return {
+                    title: `#${chapterStartNum + index} ${novelContent.title}`,
+                    description: `
+                    <img src="${pixivUtils.getProxiedImageUrl(novelContent.coverUrl)}" />
+                    <div>
+                    <p>${novelContent.description}</p>
+                    <hr>
+                    ${novelContent.content}
+                    </div>
+                `,
+                    link: `${baseUrl}/novel/show.php?id=${novelContent.id}`,
+                    pubDate: novelContent.createDate,
+                    author: novelContent.userName || `User ID: ${novelContent.userId}`,
+                    category: novelContent.tags,
+                };
+            })
+            .reverse()
+    );
+
+    return {
+        title,
+        description,
+        image: pixivUtils.getProxiedImageUrl(image),
+        link: `${baseUrl}/novel/series/${seriesId}`,
+        item: items,
+    };
+}

package/lib/routes/pixiv/novel-api/series/types.ts

@@ -0,0 +1,94 @@
+export interface SeriesChapter {
+    id: string;
+    title: string;
+    available: boolean;
+}
+
+export interface SeriesContentResponse {
+    error: boolean;
+    message: string;
+    body: SeriesChapter[];
+}
+
+export interface SeriesDetail {
+    error: boolean;
+    message: string;
+    body: {
+        id: string;
+        userId: string;
+        userName: string;
+        title: string;
+        caption: string;
+        description?: string;
+        tags: string[];
+        publishedContentCount: number;
+        createDate: string;
+        updateDate: string;
+        firstNovelId: string;
+        latestNovelId: string;
+        xRestrict: number;
+        isOriginal: boolean;
+        total: number;
+        cover: {
+            urls: {
+                original: string;
+                small?: string;
+                regular?: string;
+                original_square?: string;
+            };
+        };
+        extraData: {
+            meta: {
+                title: string;
+                description: string;
+                canonical: string;
+                ogp: {
+                    description: string;
+                    image: string;
+                    title: string;
+                    type: string;
+                };
+            };
+        };
+    };
+}
+
+export interface SeriesFeed {
+    title: string;
+    description: string;
+    image: string;
+    link: string;
+    item: Array<{
+        title: string;
+        description: string;
+        link: string;
+        pubDate?: Date;
+        author?: string;
+        category?: string[];
+    }>;
+}
+
+export interface AppUser {
+    id: number;
+    name: string;
+}
+
+export interface AppNovelSeriesDetail {
+    id: string;
+    title: string;
+    caption: string;
+    content_count: number;
+    is_concluded: boolean;
+    is_original: boolean;
+    user: AppUser;
+}
+
+export interface AppNovelSeries {
+    novel_series_detail: AppNovelSeriesDetail;
+    novels: {
+        id: string;
+        title: string;
+        create_date: Date;
+        user: AppUser;
+    }[];
+}