yz-yuki-plugin 2.0.1 → 2.0.2-1

package/lib/models/bilibili/bilibili.query.js

@@ -6,16 +6,21 @@ import axios from 'axios';
 import lodash from 'lodash';
 
 class BiliQuery {
+    /**
+     * 序列化动态数据
+     * @param data - 动态数据对象
+     * @returns 序列化后的动态数据对象
+     */
     static async formatDynamicData(data) {
         const BiliDrawDynamicLinkUrl = "https://m.bilibili.com/dynamic/";
         let desc, pics = [], majorType;
         let formatData = { data: {} };
         const author = data?.modules?.module_author || {};
-        formatData.data.face = author.face;
-        formatData.data.name = author.name;
-        formatData.data.pendant = author?.pendant?.image || data?.pendant?.image;
-        formatData.data.created = moment().format("YYYY年MM月DD日 HH:mm:ss");
-        formatData.data.type = data.type;
+        formatData.data.face = author.face; // 作者头像
+        formatData.data.name = author.name; // 作者名字
+        formatData.data.pendant = author?.pendant?.image || data?.pendant?.image; // 作者挂件
+        formatData.data.created = moment().format("YYYY年MM月DD日 HH:mm:ss"); // 创建时间
+        formatData.data.type = data.type; // 动态类型
         switch (data.type) {
             case "DYNAMIC_TYPE_AV":
                 desc = data?.modules?.module_dynamic?.major?.archive || {};
@@ -85,10 +90,13 @@ class BiliQuery {
                         const readInfo = await this.getFullArticleContent(this.formatUrl(desc?.jump_url));
                         formatData.data.content = this.praseFullArticleContent(readInfo?.content);
                         formatData.data.pics = [];
-                        if ((formatData.data.content) === null) {
+                        if (!(formatData.data.content)) {
                             formatData.data.content = this.parseRichTextNodes(desc?.summary?.rich_text_nodes || desc?.summary?.text) || "";
                             formatData.data.pics = pics;
                         }
+                        else {
+                            formatData.data.pics = [];
+                        }
                     }
                     else {
                         formatData.data.content = this.parseRichTextNodes(desc?.summary?.rich_text_nodes || desc?.summary?.text) || "";
@@ -146,12 +154,18 @@ class BiliQuery {
         }
         return {
             ...formatData,
-            uid: data?.id_str,
+            uid: data?.id_str, // 用户ID
         };
     }
     ;
+    /**
+     * 动态内容富文本节点解析
+     * @param nodes - 动态内容富文本节点
+     * @returns 解析后的动态内容富文本
+     */
     static parseRichTextNodes = (nodes) => {
         if (typeof nodes === 'string') {
+            // 将\t 替换为&nbsp;实现空格，\n 替换为 <br> 以实现换行
             nodes = nodes.replace(/\t/g, '&nbsp;');
             return nodes.replace(/\n/g, '<br>');
         }
@@ -159,23 +173,30 @@ class BiliQuery {
             return nodes.map((node) => {
                 switch (node.type) {
                     case 'RICH_TEXT_NODE_TYPE_TOPIC':
+                        // 确保链接以 https:// 开头
                         let jumpUrl = node?.jump_url;
                         if (jumpUrl && !jumpUrl.startsWith('http://') && !jumpUrl.startsWith('https://')) {
                             jumpUrl = `https://${jumpUrl}`;
                         }
                         return `<span class="bili-rich-text-module topic" href="${jumpUrl}">${node?.text}</span>`;
                     case 'RICH_TEXT_NODE_TYPE_TEXT':
+                        // 正文将 \n 替换为 <br> 以实现换行
                         return node.text.replace(/\n/g, '<br>');
                     case 'RICH_TEXT_NODE_TYPE_AT':
+                        // 处理 @ 类型，使用官方的HTML标签写法
                         return `<span data-module="desc" data-type="at" data-oid="${node?.rid}" class="bili-rich-text-module at">${node?.text}</span>`;
                     case 'RICH_TEXT_NODE_TYPE_LOTTERY':
+                        // 处理互动抽奖类型，使用官方的HTML标签写法
                         return `<span data-module="desc" data-type="lottery" data-oid="${node?.rid}" class="bili-rich-text-module lottery">${node?.text}</span>`;
                     case 'RICH_TEXT_NODE_TYPE_WEB':
+                        // 处理 RICH_TEXT_NODE_TYPE_WEB 类型，直接拼接 text 属性
                         return node.text;
                     case 'RICH_TEXT_NODE_TYPE_EMOJI':
+                        // 处理表情类型，使用 img 标签显示表情
                         const emoji = node.emoji;
                         return `<img src="${emoji?.icon_url}" alt="${emoji?.text}" title="${emoji?.text}" style="vertical-align: middle; width: ${emoji?.size}em; height: ${emoji?.size}em;">`;
                     case 'RICH_TEXT_NODE_TYPE_GOODS':
+                        // 处理商品推广类型，使用官方的HTML标签写法
                         const goods_url = node?.jump_url;
                         return `<span data-module="desc" data-type="goods" data-url="${goods_url}" data-oid="${node?.rid}" class="bili-rich-text-module goods ${node?.icon_name}">&ZeroWidthSpace;${node?.text}</span>`;
                     default:
@@ -184,9 +205,14 @@ class BiliQuery {
             }).join('');
         }
         else {
+            // 未知类型，直接返回
             return nodes;
         }
     };
+    /**获取完整B站文章内容
+  * @param postId - 文章ID
+  * @returns {Json}完整的B站文章内容json数据
+  */
     static async getFullArticleContent(postUrl) {
         const Cookie = await readSyncCookie();
         try {
@@ -207,24 +233,37 @@ class BiliQuery {
             return null;
         }
     }
+    /**解析完整文章内容 */
     static praseFullArticleContent(content) {
         content = String(content).replace(/\n/g, '<br>');
+        // 使用正则表达式匹配 <img> 标签的 data-src 属性
         const imgTagRegex = /<img[^>]*data-src="([^"]*)"[^>]*>/g;
+        // 替换 data-src 为 src，并将 // 开头的链接改为 https:// 开头
         content = content.replace(imgTagRegex, (match, p1) => {
             const newSrc = this.formatUrl(p1);
             return match.replace('data-src', 'src').replace(p1, newSrc);
         });
         return content;
     }
+    // 处理斜杠开头的链接
     static formatUrl(url) {
         return 0 == url.indexOf('//') ? `https:${url}` : url;
     }
+    /**
+     * 生成动态消息文字内容
+     * @param upName - UP主名称
+     * @param formatData - 动态数据
+     * @param isForward - 是否为转发动态
+     * @param setData - 设置数据
+     * @returns 生成的动态消息文字内容
+     */
     static async formatTextDynamicData(upName, data, isForward, setData) {
         const BiliDrawDynamicLinkUrl = "https://m.bilibili.com/dynamic/";
         let desc, msg, pics, author, majorType, content, dynamicTitle;
         let title = `B站【${upName}】动态推送：\n`;
         switch (data.type) {
             case "DYNAMIC_TYPE_AV":
+                // 处理视频动态
                 desc = data?.modules?.module_dynamic?.major?.archive;
                 author = data?.modules?.module_author;
                 if (!desc && !author)
@@ -241,6 +280,7 @@ class BiliQuery {
                 ];
                 return msg;
             case "DYNAMIC_TYPE_WORD":
+                // 处理文字动态
                 author = data?.modules?.module_author;
                 majorType = data?.modules?.module_dynamic?.major?.type;
                 if (majorType === "MAJOR_TYPE_OPUS") {
@@ -267,6 +307,7 @@ class BiliQuery {
                 ];
                 return msg;
             case "DYNAMIC_TYPE_DRAW":
+                // 处理图文动态
                 author = data?.modules?.module_author;
                 majorType = data?.modules?.module_dynamic?.major?.type;
                 if (majorType === "MAJOR_TYPE_OPUS") {
@@ -309,6 +350,7 @@ class BiliQuery {
                 ];
                 return msg;
             case "DYNAMIC_TYPE_ARTICLE":
+                // 处理文章动态
                 author = data?.modules?.module_author;
                 majorType = data?.modules?.module_dynamic?.major?.type;
                 if (majorType === "MAJOR_TYPE_OPUS") {
@@ -349,6 +391,7 @@ class BiliQuery {
                 ];
                 return msg;
             case "DYNAMIC_TYPE_FORWARD":
+                // 处理转发动态
                 author = data?.modules?.module_author;
                 desc = data?.modules?.module_dynamic?.desc || {};
                 content = desc?.text;
@@ -376,6 +419,7 @@ class BiliQuery {
                 ];
                 return msg;
             case "DYNAMIC_TYPE_LIVE_RCMD":
+                // 处理直播动态
                 desc = data?.modules?.module_dynamic?.major?.live_rcmd?.content;
                 if (!desc)
                     return;
@@ -393,14 +437,17 @@ class BiliQuery {
                 ];
                 return msg;
             default:
+                // 处理未定义的动态类型
                 (Bot.logger ?? logger)?.mark(`未处理的B站推送【${upName}】：${data.type}`);
                 return "continue";
         }
     }
+    // 限制文字模式下动态内容的字数和行数
     static dynamicContentLimit(content, setData) {
         const lines = content.split("\n");
         const lengthLimit = setData.pushContentLenLimit || 100;
         const lineLimit = setData.pushContentLineLimit || 5;
+        // 限制行数
         if (lines.length > lineLimit) {
             lines.length = lineLimit;
         }
@@ -421,7 +468,9 @@ class BiliQuery {
         }
         return lines.join("\n");
     }
+    /**根据关键字更新 up 的动态类型 */
     static typeHandle(up, msg, type) {
+        // 定义一个对象映射，将关键字映射到对应的类型
         const typeMap = {
             "直播": "DYNAMIC_TYPE_LIVE_RCMD",
             "转发": "DYNAMIC_TYPE_FORWARD",
@@ -429,33 +478,42 @@ class BiliQuery {
             "图文": ["DYNAMIC_TYPE_DRAW", "DYNAMIC_TYPE_WORD"],
             "视频": "DYNAMIC_TYPE_AV"
         };
+        // 初始化新的类型集合，如果 up.type 存在则使用它，否则使用空数组
         let newType = new Set(up.type || []);
+        // 定义一个处理类型的函数，根据传入的 action 参数决定是添加还是删除类型
         const handleType = (action) => {
-            let isHandled = false;
+            let isHandled = false; // 标记是否有类型被处理
+            // 遍历 typeMap 对象，根据 msg 中的关键字进行类型操作
             for (const [key, value] of Object.entries(typeMap)) {
                 if (msg.indexOf(key) !== -1) {
                     if (Array.isArray(value)) {
+                        // 如果 value 是数组，则对数组中的每个元素进行操作
                         value.forEach(v => action === "add" ? newType.add(v) : newType.delete(v));
                     }
                     else {
+                        // 否则直接对单个值进行操作
                         action === "add" ? newType.add(value) : newType.delete(value);
                     }
-                    isHandled = true;
+                    isHandled = true; // 标记有类型被处理
                 }
             }
-            return isHandled;
+            return isHandled; // 返回是否有类型被处理
         };
+        // 根据 type 参数决定是添加还是删除类型
         if (type === "add") {
-            handleType("add");
+            handleType("add"); // 调用 handleType 函数进行类型添加
         }
         else if (type === "del") {
             if (!newType.size) {
+                // 如果 newType 为空，则初始化它为所有可能的类型
                 newType = new Set(Object.values(typeMap).flat());
             }
+            // 调用 handleType 函数进行类型删除，如果没有类型被删除则清空 newType
             if (!handleType("delete")) {
                 newType.clear();
             }
         }
+        // 将 newType 转换为数组并返回
         return Array.from(newType);
     }
 }

package/lib/models/bilibili/bilibili.task.d.ts

@@ -9,11 +9,52 @@ export declare class BiliTask {
     constructor(e?: EventType);
     hendleEventDynamicData(uid: string | number, count?: number): Promise<any>;
     runTask(): Promise<void>;
+    /**
+     * 处理Bilibili数据，获取动态列表并构建 uid 映射
+     * @param biliPushData Bilibili推送数据
+     * @param uidMap uid 映射
+     * @param dynamicList 动态列表
+     * @param lastLiveStatus 最后直播状态
+     */
     processBiliData(biliPushData: any, uidMap: Map<any, Map<string, any>>, dynamicList: any, lastLiveStatus: any): Promise<void>;
+    /**
+     * 推送动态消息
+     * @param uidMap uid 映射
+     * @param dynamicList 动态列表
+     * @param now 当前时间戳
+     * @param interval 推送间隔时间
+     * @param biliConfigData Bilibili配置数据
+     */
     pushDynamicMessages(uidMap: Map<any, Map<string, any>>, dynamicList: any, now: number, interval: number, biliConfigData: any): Promise<void>;
     sendDynamic(chatId: string | number, bot_id: string | number, upName: string, pushDynamicData: any, biliConfigData: any, chatType: string): Promise<string>;
+    /**
+     * 构建渲染数据
+     * @param extentData 扩展数据
+     * @param urlQrcodeData URL 二维码数据
+     * @param boxGrid 是否启用九宫格样式
+     * @returns 渲染数据
+     */
     buildRenderData(extentData: any, urlQrcodeData: string, boxGrid: boolean): MainProps;
+    /**
+     * 渲染动态卡片
+     * @param uid 用户 ID
+     * @param renderData 渲染数据
+     * @param ScreenshotOptionsData 截图选项数据
+     * @returns 图片数据
+     */
     renderDynamicCard(uid: string, renderData: MainProps, ScreenshotOptionsData: ScreenshotOptions): Promise<Buffer[] | null>;
+    /**
+     * 发送消息
+     * @param chatId 聊天 ID
+     * @param bot_id 机器人 ID
+     * @param chatType 聊天类型
+     * @param message 消息内容
+     */
     sendMessage(chatId: string | number, bot_id: string | number, chatType: string, message: any): Promise<void>;
+    /**
+     * 随机延时
+     * @param min 最小延时时间
+     * @param max 最大延时时间
+     */
     randomDelay(min: number, max: number): Promise<void>;
 }

package/lib/models/bilibili/bilibili.task.js

@@ -26,7 +26,7 @@ class BiliTask {
         else if (resjson.code === -352) {
             await postGateway(cookie);
             if (count < 3) {
-                await new Promise((resolve) => setTimeout(resolve, Math.floor(Math.random() * (10500 - 2000 + 1) + 2000)));
+                await new Promise((resolve) => setTimeout(resolve, Math.floor(Math.random() * (10500 - 2000 + 1) + 2000))); // 随机延时2-10.5秒
                 await this.hendleEventDynamicData(uid, count + 1);
                 logger.error(`获取 ${uid} 动态，Gateway count：${String(count)}`);
             }
@@ -44,18 +44,25 @@ class BiliTask {
         let biliPushData = await Config.getUserConfig("bilibili", "push");
         let interval = biliConfigData.interval || 7200;
         let lastLiveStatus = JSON.parse(await Redis.get("yuki:bililive:lastlivestatus")) || {};
-        const uidMap = new Map();
-        const dynamicList = {};
+        const uidMap = new Map(); // 存放group 和 private 对应所属 uid 与推送信息的映射
+        const dynamicList = {}; // 存放获取的所有动态，键为 uid，值为动态数组
         await this.processBiliData(biliPushData, uidMap, dynamicList, lastLiveStatus);
-        let now = Date.now() / 1000;
+        let now = Date.now() / 1000; // 时间戳（秒）
         await this.pushDynamicMessages(uidMap, dynamicList, now, interval, biliConfigData);
     }
+    /**
+     * 处理Bilibili数据，获取动态列表并构建 uid 映射
+     * @param biliPushData Bilibili推送数据
+     * @param uidMap uid 映射
+     * @param dynamicList 动态列表
+     * @param lastLiveStatus 最后直播状态
+     */
     async processBiliData(biliPushData, uidMap, dynamicList, lastLiveStatus) {
-        for (let chatType in biliPushData) {
+        for (let chatType in biliPushData) { // 遍历 group 和 private
             if (!uidMap.has(chatType)) {
                 uidMap.set(chatType, new Map());
             }
-            const chatTypeMap = uidMap.get(chatType);
+            const chatTypeMap = uidMap.get(chatType); // 建立当前 chatType (group 或 private) 的 uid 映射
             for (let chatId in biliPushData[chatType]) {
                 const subUpsOfChat = biliPushData[chatType][chatId] || [];
                 for (let subInfoOfup of subUpsOfChat) {
@@ -85,17 +92,25 @@ class BiliTask {
                     const bot_id = subInfoOfup.bot_id || [];
                     const { name, type } = subInfoOfup;
                     chatTypeMap.set(subInfoOfup.uid, { chatIds, bot_id, upName: name, type });
-                    await new Promise((resolve) => setTimeout(resolve, Math.floor(Math.random() * (8000 - 2000 + 1) + 2000)));
+                    await new Promise((resolve) => setTimeout(resolve, Math.floor(Math.random() * (8000 - 2000 + 1) + 2000))); // 随机延时2-8秒
                 }
             }
         }
     }
+    /**
+     * 推送动态消息
+     * @param uidMap uid 映射
+     * @param dynamicList 动态列表
+     * @param now 当前时间戳
+     * @param interval 推送间隔时间
+     * @param biliConfigData Bilibili配置数据
+     */
     async pushDynamicMessages(uidMap, dynamicList, now, interval, biliConfigData) {
         for (let [chatType, chatTypeMap] of uidMap) {
             for (let [key, value] of chatTypeMap) {
                 const tempDynamicList = dynamicList[key] || [];
                 const willPushDynamicList = [];
-                const printedList = new Set();
+                const printedList = new Set(); // 已打印的动态列表
                 for (let dynamicItem of tempDynamicList) {
                     let author = dynamicItem?.modules?.module_author || {};
                     if (!printedList.has(author?.mid)) {
@@ -103,31 +118,33 @@ class BiliTask {
                         printedList.add(author?.mid);
                     }
                     if (!author?.pub_ts)
-                        continue;
+                        continue; // 如果动态没有发布时间，跳过当前循环
                     if (Number(now - author.pub_ts) > interval) {
                         logger.debug(`超过间隔，跳过  [ ${author?.name} : ${author?.mid} ] ${author?.pub_time} 的动态`);
                         continue;
-                    }
+                    } // 如果超过推送时间间隔，跳过当前循环
                     if (dynamicItem.type === "DYNAMIC_TYPE_FORWARD" && !biliConfigData.pushTransmit)
-                        continue;
+                        continue; // 如果关闭了转发动态的推送，跳过当前循环
                     willPushDynamicList.push(dynamicItem);
                 }
                 printedList.clear();
-                const pushMapInfo = value || {};
+                const pushMapInfo = value || {}; // 获取当前 uid 对应的推送信息
                 const { chatIds, bot_id, upName, type } = pushMapInfo;
+                // 遍历待推送的动态数组，发送动态消息
                 for (let pushDynamicData of willPushDynamicList) {
                     if (chatIds && chatIds.length) {
                         for (let chatId of chatIds) {
                             if (type && type.length && !type.includes(pushDynamicData.type))
-                                continue;
-                            await this.sendDynamic(chatId, bot_id, upName, pushDynamicData, biliConfigData, chatType);
-                            await new Promise((resolve) => setTimeout(resolve, Math.floor(Math.random() * (6500 - 2000 + 1) + 2000)));
+                                continue; // 如果禁用了某类型的动态推送，跳过当前循环
+                            await this.sendDynamic(chatId, bot_id, upName, pushDynamicData, biliConfigData, chatType); // 发送动态消息
+                            await new Promise((resolve) => setTimeout(resolve, Math.floor(Math.random() * (6500 - 2000 + 1) + 2000))); // 随机延时2-6.5秒
                         }
                     }
                 }
             }
         }
     }
+    /*发送动态*/
     async sendDynamic(chatId, bot_id, upName, pushDynamicData, biliConfigData, chatType) {
         const id_str = pushDynamicData.id_str;
         let sended, markKey;
@@ -140,18 +157,18 @@ class BiliTask {
             sended = await Redis.get(`${markKey}${chatId}:${id_str}`);
         }
         if (sended)
-            return;
+            return; // 如果已经发送过，则直接返回
         if (!!biliConfigData.pushMsgMode) {
-            const { data, uid } = await BiliQuery.formatDynamicData(pushDynamicData);
+            const { data, uid } = await BiliQuery.formatDynamicData(pushDynamicData); // 处理动态数据
             const extentData = { ...data };
             const eval2 = eval;
-            let banWords = eval2(`/${biliConfigData.banWords.join("|")}/g`);
+            let banWords = eval2(`/${biliConfigData.banWords.join("|")}/g`); // 构建屏蔽关键字正则表达式
             if (new RegExp(banWords).test(`${extentData?.title}${extentData?.content}`)) {
-                return "return";
+                return "return"; // 如果动态包含屏蔽关键字，则直接返回
             }
-            let boxGrid = !!biliConfigData.boxGrid === false ? false : true;
-            let isSplit = !!biliConfigData.isSplit === false ? false : true;
-            let style = isSplit ? '' : '.unfold { height: 7500px; }';
+            let boxGrid = !!biliConfigData.boxGrid === false ? false : true; // 是否启用九宫格样式，默认为 true
+            let isSplit = !!biliConfigData.isSplit === false ? false : true; // 是否启用分片截图，默认为 true
+            let style = isSplit ? '' : '.unfold { height: 7500px; }'; // 不启用分片截图模式的样式
             const urlQrcodeData = await QRCode.toDataURL(extentData?.url);
             let renderData = this.buildRenderData(extentData, urlQrcodeData, boxGrid);
             const ScreenshotOptionsData = {
@@ -168,31 +185,38 @@ class BiliTask {
             let imgs = await this.renderDynamicCard(uid, renderData, ScreenshotOptionsData);
             if (!imgs)
                 return;
-            Redis.set(`${markKey}${chatId}:${id_str}`, "1", { EX: 3600 * 10 });
+            Redis.set(`${markKey}${chatId}:${id_str}`, "1", { EX: 3600 * 10 }); // 设置已发送标记
             (logger ?? Bot.logger)?.mark("优纪插件：B站动态执行推送");
             for (let i = 0; i < imgs.length; i++) {
                 const image = imgs[i];
                 await this.sendMessage(chatId, bot_id, chatType, Segment.image(image));
-                await new Promise((resolve) => setTimeout(resolve, Math.floor(Math.random() * (6500 - 2000 + 1) + 2000)));
+                await new Promise((resolve) => setTimeout(resolve, Math.floor(Math.random() * (6500 - 2000 + 1) + 2000))); // 随机延时2-6.5秒
             }
-            await new Promise((resolve) => setTimeout(resolve, 1000));
+            await new Promise((resolve) => setTimeout(resolve, 1000)); // 休眠1秒
         }
         else {
-            const dynamicMsg = await BiliQuery.formatTextDynamicData(upName, pushDynamicData, false, biliConfigData);
-            Redis.set(`${markKey}${chatId}:${id_str}`, "1", { EX: 3600 * 10 });
+            const dynamicMsg = await BiliQuery.formatTextDynamicData(upName, pushDynamicData, false, biliConfigData); // 构建图文动态消息
+            Redis.set(`${markKey}${chatId}:${id_str}`, "1", { EX: 3600 * 10 }); // 设置已发送标记
             if (dynamicMsg == "continue") {
-                return "return";
+                return "return"; // 如果动态消息构建失败，则直接返回
             }
             if (biliConfigData.banWords.length > 0) {
-                const banWords = new RegExp(biliConfigData.banWords.join("|"), "g");
+                const banWords = new RegExp(biliConfigData.banWords.join("|"), "g"); // 构建屏蔽关键字正则表达式
                 if (banWords.test(dynamicMsg.join(""))) {
-                    return "return";
+                    return "return"; // 如果动态消息包含屏蔽关键字，则直接返回
                 }
             }
             await this.sendMessage(chatId, bot_id, chatType, dynamicMsg);
             await new Promise((resolve) => setTimeout(resolve, 1000));
         }
     }
+    /**
+     * 构建渲染数据
+     * @param extentData 扩展数据
+     * @param urlQrcodeData URL 二维码数据
+     * @param boxGrid 是否启用九宫格样式
+     * @returns 渲染数据
+     */
     buildRenderData(extentData, urlQrcodeData, boxGrid) {
         if (extentData.orig && (extentData.orig).length !== 0) {
             return {
@@ -246,18 +270,32 @@ class BiliTask {
             };
         }
     }
+    /**
+     * 渲染动态卡片
+     * @param uid 用户 ID
+     * @param renderData 渲染数据
+     * @param ScreenshotOptionsData 截图选项数据
+     * @returns 图片数据
+     */
     async renderDynamicCard(uid, renderData, ScreenshotOptionsData) {
-        const dynamicMsg = await Image.renderPage(uid, "MainPage", renderData, ScreenshotOptionsData);
+        const dynamicMsg = await Image.renderPage(uid, "MainPage", renderData, ScreenshotOptionsData); // 渲染动态卡片
         if (dynamicMsg !== false) {
-            return dynamicMsg.img;
+            return dynamicMsg.img; // 缓存图片数据
         }
         else {
             return null;
         }
     }
+    /**
+     * 发送消息
+     * @param chatId 聊天 ID
+     * @param bot_id 机器人 ID
+     * @param chatType 聊天类型
+     * @param message 消息内容
+     */
     async sendMessage(chatId, bot_id, chatType, message) {
         if (chatType === "group") {
-            await (Bot[bot_id] ?? Bot)?.pickGroup(String(chatId)).sendMsg(message)
+            await (Bot[bot_id] ?? Bot)?.pickGroup(String(chatId)).sendMsg(message) // 发送群聊
                 .catch((error) => {
                 (logger ?? Bot.logger)?.error(`群组[${chatId}]推送失败：${JSON.stringify(error)}`);
             });
@@ -266,9 +304,14 @@ class BiliTask {
             await (Bot[bot_id] ?? Bot)?.pickFriend(String(chatId)).sendMsg(message)
                 .catch((error) => {
                 (logger ?? Bot.logger)?.error(`用户[${chatId}]推送失败：${JSON.stringify(error)}`);
-            });
+            }); // 发送好友私聊
         }
     }
+    /**
+     * 随机延时
+     * @param min 最小延时时间
+     * @param max 最大延时时间
+     */
     async randomDelay(min, max) {
         await new Promise((resolve) => setTimeout(resolve, Math.floor(Math.random() * (max - min + 1) + min)));
     }

package/lib/models/bilibili/bilibili.wbi.d.ts

@@ -1,3 +1,9 @@
+/**
+ * https://github.com/SocialSisterYi/bilibili-API-collect/blob/master/docs/misc/sign/wbi.md#javascript
+ * 对实际请求参数进行 wbi 签名, 生成 wbi 签名
+ * @param {object} params 除了 wbi 签名外的全部请求参数，例如 api get请求的查询参数 { uid: 12345678, jsonp: jsonp}
+ * @param {object} headers 必需要 referer 和 UA 两个请求头
+ */
 export declare function getWbiSign(params: any, headers: any, cookie: string): Promise<{
     query: string;
     w_rid: string;

package/lib/models/bilibili/bilibili.wbi.js

@@ -6,33 +6,40 @@ const mixinKeyEncTab = [
     61, 26, 17, 0, 1, 60, 51, 30, 4, 22, 25, 54, 21, 56, 59, 6, 63, 57, 62, 11,
     36, 20, 34, 44, 52
 ];
+// 对 imgKey 和 subKey 进行字符顺序打乱编码
 const getMixinKey = (orig) => mixinKeyEncTab
     .map((n) => orig[n])
     .join("")
     .slice(0, 32);
+// 为请求参数进行 wbi 签名
 function encWbi(params, img_key, sub_key) {
     const mixin_key = getMixinKey(img_key + sub_key), curr_time = Math.round(Date.now() / 1000), chr_filter = /[!'()*]/g;
-    Object.assign(params, { wts: curr_time });
+    Object.assign(params, { wts: curr_time }); // 添加 wts 字段
+    // 按照 key 重排参数
     const query = Object.keys(params)
         .sort()
         .map((key) => {
+        // 过滤 value 中的 "!'()*" 字符
         const value = params[key].toString().replace(chr_filter, "");
         return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
     })
         .join("&");
-    const wbi_sign = md5(query + mixin_key);
+    const wbi_sign = md5(query + mixin_key); // 计算 w_rid
+    //return query + "&w_rid=" + wbi_sign;
     return {
         query: query,
         w_rid: wbi_sign,
         time_stamp: curr_time
     };
 }
+// 获取最新的 img_key 和 sub_key
 async function getWbiKeys(headers, cookie) {
     const res = await fetch('https://api.bilibili.com/x/web-interface/nav', {
         headers: {
+            // SESSDATA 字段
             Cookie: cookie,
             'User-Agent': headers['User-Agent'],
-            Referer: 'https://www.bilibili.com/'
+            Referer: 'https://www.bilibili.com/' //对于直接浏览器调用可能不适用
         }
     });
     const { data: { wbi_img: { img_url, sub_url }, }, } = (await res.json());
@@ -41,6 +48,12 @@ async function getWbiKeys(headers, cookie) {
         sub_key: sub_url.slice(sub_url.lastIndexOf('/') + 1, sub_url.lastIndexOf('.'))
     };
 }
+/**
+ * https://github.com/SocialSisterYi/bilibili-API-collect/blob/master/docs/misc/sign/wbi.md#javascript
+ * 对实际请求参数进行 wbi 签名, 生成 wbi 签名
+ * @param {object} params 除了 wbi 签名外的全部请求参数，例如 api get请求的查询参数 { uid: 12345678, jsonp: jsonp}
+ * @param {object} headers 必需要 referer 和 UA 两个请求头
+ */
 async function getWbiSign(params, headers, cookie) {
     const { img_key, sub_key } = await getWbiKeys(headers, cookie);
     return encWbi(params, img_key, sub_key);

package/lib/models/version/version.d.ts

@@ -3,5 +3,15 @@ export default class VersionData {
     cache: any;
     versionPath: string;
     constructor();
+    /**
+     * CHANGELOG.md内容支持示例：
+     * # 1.0.0
+     * * 新增功能3
+     * * 新增功能4
+     *
+     * # 0.1.0
+     * * 新增功能1
+     * * 新增功能2
+     */
     getChangelogContent(): Promise<any>;
 }

package/lib/models/version/version.js

@@ -11,6 +11,16 @@ class VersionData {
         this.cache = {};
         this.versionPath = path.resolve(_paths.pluginPath, 'CHANGELOG.md');
     }
+    /**
+     * CHANGELOG.md内容支持示例：
+     * # 1.0.0
+     * * 新增功能3
+     * * 新增功能4
+     *
+     * # 0.1.0
+     * * 新增功能1
+     * * 新增功能2
+     */
     async getChangelogContent() {
         let key = this.model;
         if (this.cache[key])
@@ -42,6 +52,7 @@ class VersionData {
                 data: currentData
             });
         }
+        // 对版本进行排序并截取最新的10个版本
         result.sort((a, b) => {
             let aParts = a.version.split('.').map(Number);
             let bParts = b.version.split('.').map(Number);
@@ -54,7 +65,7 @@ class VersionData {
             }
             return 0;
         });
-        this.cache[key] = result.slice(0, 5);
+        this.cache[key] = result.slice(0, 10);
         return this.cache[key];
     }
 }