yz-yuki-plugin 2.0.2 → 2.0.3-1

package/lib/models/weibo/weibo.api.js

@@ -1,8 +1,10 @@
 class WeiboApi {
     static WEIBO_API = {
         weiboGetIndex: 'https://m.weibo.cn/api/container/getIndex',
+        //通过关键词${upKeyword}搜索博主 parama = { q: 'Keyword'},
         weiboAjaxSearch: 'https://weibo.com/ajax/side/search',
     };
+    /**统一设置header */
     static WEIBO_HEADERS = {
         'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9',
         'Accept-language': 'zh-CN,zh;q=0.9',

package/lib/models/weibo/weibo.get.web.data.d.ts

@@ -2,7 +2,10 @@ import { EventType } from 'yunzai';
 export declare class WeiboGetWebData {
     e?: EventType;
     constructor(e?: EventType);
+    /**通过uid获取博主信息 */
     getBloggerInfo(target: any): Promise<import("axios").AxiosResponse<any, any>>;
+    /**通过关键词搜索微博大v */
     searchBloggerInfo(keyword: string): Promise<import("axios").AxiosResponse<any, any>>;
+    /**获取主页动态资源相关数组 */
     getBloggerDynamicList(target: any): Promise<any>;
 }

package/lib/models/weibo/weibo.get.web.data.js

@@ -7,6 +7,7 @@ class WeiboGetWebData {
     e;
     constructor(e) {
     }
+    /**通过uid获取博主信息 */
     async getBloggerInfo(target) {
         const param = { containerid: '100505' + target };
         const url = new URL(WeiboApi.WEIBO_API.weiboGetIndex);
@@ -17,6 +18,7 @@ class WeiboGetWebData {
         });
         return resp;
     }
+    /**通过关键词搜索微博大v */
     async searchBloggerInfo(keyword) {
         const url = WeiboApi.WEIBO_API.weiboAjaxSearch;
         const params = {
@@ -29,6 +31,7 @@ class WeiboGetWebData {
         });
         return resp;
     }
+    /**获取主页动态资源相关数组 */
     async getBloggerDynamicList(target) {
         const params = { containerid: '107603' + target };
         const url = new URL(WeiboApi.WEIBO_API.weiboGetIndex);

package/lib/models/weibo/weibo.query.d.ts

@@ -1,18 +1,38 @@
 export declare class WeiboQuery {
+    /**获取文章id */
     static getDynamicId(post: any): any;
+    /**获取指定动态类型的原始数据 */
     static filterCardTypeCustom(raw_post: any): boolean;
+    /**转换微博动态创建时间：（created_at）转换为 UNIX 时间戳（以毫秒为单位） */
     static getDynamicCreatetDate(raw_post: any): number;
+    /**分类动态，返回标识 */
     static MakeCategory(raw_post: any): "DYNAMIC_TYPE_AV" | "DYNAMIC_TYPE_DRAW" | "DYNAMIC_TYPE_ARTICLE" | "DYNAMIC_TYPE_FORWARD";
+    /**筛选正文 */
     static filterText(raw_text: string): string;
+    /** 获取并生成微博动态渲染数据 */
     static formatDynamicData(raw_post: any): Promise<{
         uid: any;
         data: {
             [key: string]: any;
         };
     }>;
+    /**
+   * 动态内容富文本节点解析
+   * @param nodes - 动态内容富文本节点
+   * @returns 解析后的动态内容富文本
+   */
     static parseRichTextNodes: (nodes: any[] | string | any) => any;
+    /**
+     * 生成动态消息文字内容
+     * @param upName - UP主名称
+     * @param formatData - 动态数据
+     * @param isForward - 是否为转发动态
+     * @param setData - 设置数据
+     * @returns 生成的动态消息文字内容
+     */
     static formatTextDynamicData(upName: string, raw_post: any, isForward?: boolean, setData?: any): Promise<false | any[] | "continue">;
     static dynamicContentLimit(content: string, setData: any): string;
     static formatUrl(url: string): string;
+    /**推送类型设置 */
     static typeHandle(up: any, msg: string, type: string): unknown[];
 }

package/lib/models/weibo/weibo.query.js

@@ -5,16 +5,20 @@ import { Bot, Segment } from 'yunzai';
 import { JSDOM } from 'jsdom';
 
 class WeiboQuery {
+    /**获取文章id */
     static getDynamicId(post) {
         return post?.mblog?.mid || post?.mblog?.id;
     }
+    /**获取指定动态类型的原始数据 */
     static filterCardTypeCustom(raw_post) {
         return raw_post.card_type === 9;
     }
+    /**转换微博动态创建时间：（created_at）转换为 UNIX 时间戳（以毫秒为单位） */
     static getDynamicCreatetDate(raw_post) {
         const created_time = Date.parse(raw_post?.mblog?.created_at || raw_post?.created_at);
         return created_time;
     }
+    /**分类动态，返回标识 */
     static MakeCategory(raw_post) {
         if (raw_post?.mblog?.retweeted_status) {
             return "DYNAMIC_TYPE_FORWARD";
@@ -29,12 +33,15 @@ class WeiboQuery {
             return "DYNAMIC_TYPE_ARTICLE";
         }
     }
+    /**筛选正文 */
     static filterText(raw_text) {
         const text = raw_text.replace(/<br \/>/g, '\n');
         const dom = new JSDOM(text);
         return dom.window.document.body.textContent || '';
     }
+    /** 获取并生成微博动态渲染数据 */
     static async formatDynamicData(raw_post) {
+        /* 初始数据进一步处理 **************** */
         let info = raw_post?.mblog || raw_post;
         let retweeted = info && info?.retweeted_status ? true : false;
         let pic_num = retweeted ? info?.retweeted_status?.pic_num : info?.pic_num;
@@ -53,14 +60,22 @@ class WeiboQuery {
                 logger?.error(`优纪插件：微博 detail message error(https://m.weibo.cn/detail/${info?.mid})`);
             }
         }
+        /**头像链接 */
         const face_url = info?.user?.profile_image_url;
+        /**昵称 */
         const nick_name = info?.user?.screen_name;
+        /**动态发布时间 */
         let created_time = this.getDynamicCreatetDate(raw_post);
+        /**动态详情链接 */
         let detail_url = `https://weibo.com/${info?.user?.id}/${info?.bid}`;
+        /* 构造动态渲染数据 *************************** */
         let pics = [];
         let formatData = { data: {} };
+        /**头像 */
         formatData.data.face = face_url;
+        /**昵称 */
         formatData.data.name = nick_name;
+        /**头像框 */
         formatData.data.pendant = '';
         formatData.data.created = moment().format("YYYY年MM月DD日 HH:mm:ss");
         formatData.data.type = type;
@@ -110,33 +125,60 @@ class WeiboQuery {
         };
     }
     ;
+    /**
+   * 动态内容富文本节点解析
+   * @param nodes - 动态内容富文本节点
+   * @returns 解析后的动态内容富文本
+   */
     static parseRichTextNodes = (nodes) => {
         if (typeof nodes === 'string') {
+            // 将 \n 替换为 <br> 以实现换行
             let parsedContent = nodes.replace(/\n/g, '<br>');
+            // 使用正则表达式查找所有的 <a> 标签
             parsedContent = parsedContent.replace(/<a/g, () => {
+                // 生成一个随机的 key 值
                 const randomKey = Math.random().toString(36).substring(7);
                 return `<a key="${randomKey}"`;
             });
             parsedContent = parsedContent.replace(/class="url-icon"/g, () => {
+                // 生成一个随机的 key 值
                 const randomKey = Math.random().toString(36).substring(7);
                 return `class="url-icon ${randomKey}"`;
             });
+            // 使用正则表达式查找所有的 <img> 标签
             parsedContent = parsedContent.replace(/<img/g, () => {
+                // 生成一个随机的 key 值
                 const randomKey = Math.random().toString(36).substring(7);
                 return `<img key="${randomKey}"`;
             });
             return parsedContent;
         }
         else {
+            // 未知类型，直接返回
             return nodes;
         }
     };
+    /**
+     * 生成动态消息文字内容
+     * @param upName - UP主名称
+     * @param formatData - 动态数据
+     * @param isForward - 是否为转发动态
+     * @param setData - 设置数据
+     * @returns 生成的动态消息文字内容
+     */
     static async formatTextDynamicData(upName, raw_post, isForward, setData) {
-        let msg = [], raw_pics_list, pic_urls, pics;
+        let msg = [], 
+        /**全部图片资源链接*/
+        raw_pics_list, 
+        /**图片高清资源链接*/
+        pic_urls, 
+        /**图片*/
+        pics;
         let info = raw_post?.mblog || raw_post;
-        let retweeted = info && info.retweeted_status ? true : false;
+        let retweeted = info && info.retweeted_status ? true : false; //是否为转发动态
         let pic_num = retweeted ? info?.retweeted_status?.pic_num : info?.pic_num;
         let type = this.MakeCategory(raw_post);
+        /**获取动态全文 */
         if (info?.isLongText || pic_num > 9) {
             const res = await fetch(`https://m.weibo.cn/detail/${info.mid}`, { headers: WeiboApi.WEIBO_HEADERS });
             try {
@@ -151,6 +193,7 @@ class WeiboQuery {
                 (logger ?? Bot.logger)?.mark(`优纪插件：获取微博动态全文出错：https://m.weibo.cn/detail/${info?.mid}`);
             }
         }
+        /**动态发布时间 */
         let created_time = this.getDynamicCreatetDate(raw_post);
         let detail_url = `https://weibo.com/${info?.user?.id}/${info?.bid}`;
         let title = `微博【${upName}】动态推送：\n`;
@@ -254,10 +297,12 @@ class WeiboQuery {
                 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;
         }
@@ -278,10 +323,13 @@ class WeiboQuery {
         }
         return lines.join("\n");
     }
+    // 处理斜杠开头的url
     static formatUrl(url) {
         return 0 == url.indexOf('//') ? `https:${url}` : url;
     }
+    /**推送类型设置 */
     static typeHandle(up, msg, type) {
+        // 定义一个对象映射，将关键字映射到对应的类型
         const typeMap = {
             "直播": "DYNAMIC_TYPE_LIVE_RCMD",
             "转发": "DYNAMIC_TYPE_FORWARD",
@@ -289,33 +337,42 @@ class WeiboQuery {
             "图文": ["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/weibo/weibo.task.d.ts

@@ -8,11 +8,60 @@ export declare class WeiboTask {
     e?: EventType;
     constructor(e?: any);
     runTask(): Promise<void>;
+    /**
+     * 处理微博数据，获取动态列表并构建 uid 映射
+     * @param weiboPushData 微博推送数据
+     * @param uidMap uid 映射
+     * @param dynamicList 动态列表
+     */
     processWeiboData(weiboPushData: any, uidMap: Map<any, Map<string, any>>, dynamicList: any): Promise<void>;
+    /**
+     * 推送动态消息
+     * @param uidMap uid 映射
+     * @param dynamicList 动态列表
+     * @param now 当前时间戳
+     * @param interval 推送间隔时间
+     * @param weiboConfigData 微博配置数据
+     */
     pushDynamicMessages(uidMap: Map<any, Map<string, any>>, dynamicList: any, now: number, interval: number, weiboConfigData: any): Promise<void>;
+    /**
+     * 发送动态消息
+     * @param chatId 聊天 ID
+     * @param bot_id 机器人 ID
+     * @param upName 用户名
+     * @param pushDynamicData 推送动态数据
+     * @param weiboConfigData 微博配置数据
+     * @param chatType 聊天类型
+     */
     sendDynamic(chatId: string | number, bot_id: string | number, upName: string, pushDynamicData: any, weiboConfigData: 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 | number, 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/weibo/weibo.task.js

@@ -18,23 +18,29 @@ class WeiboTask {
     async runTask() {
         let weiboConfigData = await Config.getUserConfig("weibo", "config");
         let weiboPushData = await Config.getUserConfig("weibo", "push");
-        let interval = weiboConfigData.interval || 7200;
-        const uidMap = new Map();
-        const dynamicList = {};
+        let interval = weiboConfigData.interval || 7200; // 推送间隔时间，单位为秒，默认2小时
+        const uidMap = new Map(); // 存放group 和 private 对应所属 uid 与推送信息的映射
+        const dynamicList = {}; // 存放获取的所有动态，键为 uid，值为动态数组
         await this.processWeiboData(weiboPushData, uidMap, dynamicList);
-        let now = Date.now() / 1000;
+        let now = Date.now() / 1000; // 当前时间戳（秒）
         await this.pushDynamicMessages(uidMap, dynamicList, now, interval, weiboConfigData);
     }
+    /**
+     * 处理微博数据，获取动态列表并构建 uid 映射
+     * @param weiboPushData 微博推送数据
+     * @param uidMap uid 映射
+     * @param dynamicList 动态列表
+     */
     async processWeiboData(weiboPushData, uidMap, dynamicList) {
-        for (let chatType in weiboPushData) {
+        for (let chatType in weiboPushData) { // 遍历 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 weiboPushData[chatType]) {
                 const subUpsOfChat = weiboPushData[chatType][chatId] || [];
                 for (let subInfoOfup of subUpsOfChat) {
-                    const resp = await new WeiboGetWebData().getBloggerDynamicList(subInfoOfup.uid);
+                    const resp = await new WeiboGetWebData().getBloggerDynamicList(subInfoOfup.uid); // 获取指定 uid 的动态列表
                     if (resp) {
                         const dynamicData = resp || [];
                         dynamicList[subInfoOfup.uid] = dynamicData;
@@ -43,17 +49,25 @@ class WeiboTask {
                     const bot_id = subInfoOfup.bot_id || [];
                     const { name, type } = subInfoOfup;
                     chatTypeMap.set(subInfoOfup.uid, { chatIds, bot_id, upName: name, type });
-                    await this.randomDelay(1000, 4000);
+                    await this.randomDelay(1000, 4000); // 随机延时1-4秒
                 }
             }
         }
     }
+    /**
+     * 推送动态消息
+     * @param uidMap uid 映射
+     * @param dynamicList 动态列表
+     * @param now 当前时间戳
+     * @param interval 推送间隔时间
+     * @param weiboConfigData 微博配置数据
+     */
     async pushDynamicMessages(uidMap, dynamicList, now, interval, weiboConfigData) {
         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 raw_post = dynamicItem || {};
                     let user = raw_post?.mblog?.user || {};
@@ -66,29 +80,39 @@ class WeiboTask {
                     if (Number(now - (WeiboQuery.getDynamicCreatetDate(raw_post) / 1000)) > interval) {
                         logger.debug(`超过间隔，跳过   [ ${user?.screen_name} : ${user?.id} ] ${raw_post?.mblog?.created_at} 的动态`);
                         continue;
-                    }
+                    } // 如果超过推送时间间隔，跳过当前循环
                     if (dynamicItem.type === "DYNAMIC_TYPE_FORWARD" && !weiboConfigData.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, weiboConfigData, chatType);
-                            await this.randomDelay(2000, 10500);
+                                continue; // 如果禁用了某类型的动态推送，跳过当前循环
+                            await this.sendDynamic(chatId, bot_id, upName, pushDynamicData, weiboConfigData, chatType); // 发送动态消息
+                            await this.randomDelay(2000, 10500); // 随机延时2-10.5秒
                         }
                     }
                 }
             }
         }
     }
+    /**
+     * 发送动态消息
+     * @param chatId 聊天 ID
+     * @param bot_id 机器人 ID
+     * @param upName 用户名
+     * @param pushDynamicData 推送动态数据
+     * @param weiboConfigData 微博配置数据
+     * @param chatType 聊天类型
+     */
     async sendDynamic(chatId, bot_id, upName, pushDynamicData, weiboConfigData, chatType) {
-        const id_str = WeiboQuery.getDynamicId(pushDynamicData);
+        const id_str = WeiboQuery.getDynamicId(pushDynamicData); // 获取动态 ID
         let sended, markKey;
         if (chatType === "group") {
             markKey = this.groupKey;
@@ -99,17 +123,17 @@ class WeiboTask {
             sended = await Redis.get(`${markKey}${chatId}:${id_str}`);
         }
         if (sended)
-            return;
+            return; // 如果已经发送过，则直接返回
         if (!!weiboConfigData.pushMsgMode) {
-            const { data, uid } = await WeiboQuery.formatDynamicData(pushDynamicData);
+            const { data, uid } = await WeiboQuery.formatDynamicData(pushDynamicData); // 处理动态数据
             const eval2 = eval;
-            let banWords = eval2(`/${weiboConfigData.banWords.join("|")}/g`);
+            let banWords = eval2(`/${weiboConfigData.banWords.join("|")}/g`); // 构建屏蔽关键字正则表达式
             if (new RegExp(banWords).test(`${data?.title}${data?.content}`)) {
-                return "return";
+                return "return"; // 如果动态包含屏蔽关键字，则直接返回
             }
-            let boxGrid = !!weiboConfigData.boxGrid === false ? false : true;
-            let isSplit = !!weiboConfigData.isSplit === false ? false : true;
-            let style = isSplit ? '' : '.unfold { height: 7500px; }';
+            let boxGrid = !!weiboConfigData.boxGrid === false ? false : true; // 是否启用九宫格样式，默认为 true
+            let isSplit = !!weiboConfigData.isSplit === false ? false : true; // 是否启用分片截图，默认为 true
+            let style = isSplit ? '' : '.unfold { height: 7500px; }'; // 不启用分片截图模式的样式
             const extentData = { ...data };
             const urlQrcodeData = await QRCode.toDataURL(extentData?.url);
             let renderData = this.buildRenderData(extentData, urlQrcodeData, boxGrid);
@@ -127,31 +151,38 @@ class WeiboTask {
             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 this.randomDelay(2000, 6500);
+                await this.randomDelay(2000, 6500); // 随机延时2-6.5秒
             }
             await this.randomDelay(1000, 2000);
         }
         else {
-            const dynamicMsg = await WeiboQuery.formatTextDynamicData(upName, pushDynamicData, false, weiboConfigData);
-            Redis.set(`${markKey}${chatId}:${id_str}`, "1", { EX: 3600 * 10 });
+            const dynamicMsg = await WeiboQuery.formatTextDynamicData(upName, pushDynamicData, false, weiboConfigData); //构建文字动态消息
+            Redis.set(`${markKey}${chatId}:${id_str}`, "1", { EX: 3600 * 10 }); // 设置已发送标记
             if (dynamicMsg == "continue" || dynamicMsg == false) {
-                return "return";
+                return "return"; // 如果动态消息构建失败或内部资源获取失败，则直接返回
             }
             if (weiboConfigData.banWords.length > 0) {
-                const banWords = new RegExp(weiboConfigData.banWords.join("|"), "g");
+                const banWords = new RegExp(weiboConfigData.banWords.join("|"), "g"); // 构建屏蔽关键字正则表达式
                 if (banWords.test(dynamicMsg.join(""))) {
-                    return "return";
+                    return "return"; // 如果动态消息包含屏蔽关键字，则直接返回
                 }
             }
             await this.sendMessage(chatId, bot_id, chatType, dynamicMsg);
             await this.randomDelay(1000, 2000);
         }
     }
+    /**
+     * 构建渲染数据
+     * @param extentData 扩展数据
+     * @param urlQrcodeData URL 二维码数据
+     * @param boxGrid 是否启用九宫格样式
+     * @returns 渲染数据
+     */
     buildRenderData(extentData, urlQrcodeData, boxGrid) {
         if (extentData.orig && (extentData.orig).length !== 0) {
             return {
@@ -205,18 +236,32 @@ class WeiboTask {
             };
         }
     }
+    /**
+     * 渲染动态卡片
+     * @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)}`);
             });
@@ -225,9 +270,14 @@ class WeiboTask {
             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/utils/config.d.ts

@@ -1,20 +1,70 @@
 import chokidar from "chokidar";
+/**
+ * Config 类用于管理配置文件的读取和监听
+ */
 declare class Config {
-    readonly versionPath: string;
+    readonly packageJsonPath: string;
     readonly defaultConfigPath: string;
     readonly userConfigPath: string;
     defaultConfig: Record<string, any>;
     userConfig: Record<string, any>;
     watcher: Record<string, chokidar.FSWatcher>;
     constructor();
+    /** 操作并创建配置文件到指定目录 */
     initConfigFiles(): void;
+    /**
+     * 通用获取配置文件数据方法
+     * @param typeDir 配置文件目录类型对应路径 defaultConfig: defaultConfig 或 config: yunzai/data/yuki-plugin/config
+     * @param appDir 配置app目录
+     * @param functionName 配置文件名称，不包含.yaml后缀
+     * @returns {object} 配置数据
+     */
     getConfigData(typeDir: string, appDir: string, functionName: string): any;
+    /**
+     * 获取配置文件路径
+     * @param typeDir 配置文件目录类型对应路径 defaultConfig: defaultConfig 或 config: yunzai/data/yuki-plugin/config
+     * @param appDir 配置app目录
+     * @param functionName 配置文件名称，不包含.yaml后缀
+     * @returns {string} 配置文件路径
+     */
     getConfigFilePath(typeDir: string, appDir: string, functionName: string): string;
+    /**
+     * 监听配置文件的变化
+     * @param configFilePath 文件路径
+     * @param typeDir 配置文件目录类型对应路径 defaultConfig: defaultConfig 或 config: yunzai/data/yuki-plugin/config
+     * @param appDir 配置app目录
+     * @param functionName 配置文件名称，不包含.yaml后缀
+     */
     watch(configFilePath: string, typeDir: string, appDir: string, functionName: string): void;
+    /**
+     * 获取默认配置
+     * @param appDir 配置app目录
+     * @param functionName 配置文件名称，不包含.yaml后缀
+     */
     getDefaultConfig(appDir: string, functionName: string): any;
+    /**
+     * 获取用户配置
+     * @param appDir 配置app目录
+     * @param functionName 配置文件名称，不包含.yaml后缀
+     */
     getUserConfig(appDir: string, functionName: string): any;
+    /**
+     * 保存配置文件
+     * @param typeDir 插件为起始的配置文件目录
+     * @param appDir 配置app目录
+     * @param functionName 配置文件名称，不包含.yaml后缀
+     * @param data 配置数据
+     */
     saveConfig(typeDir: string, appDir: string, functionName: string, data: any): void;
+    /**
+     * 更新并保存配置项
+     * @param appDir 配置app目录
+     * @param functionName 配置文件名称，不包含.yaml后缀
+     * @param key 配置项的键
+     * @param value 配置项的值
+     */
     updateConfigItem(appDir: string, functionName: string, key: string, value: any): void;
+    /** 读取package.json文件，获取最新版本号*/
     getLatestVersion(): string | null;
 }
 declare const _default: Config;