koishi-plugin-bilibili-notify 3.0.0-alpha.16 → 3.0.0-alpha.18

package/lib/comRegister.d.ts

@@ -1,34 +1,7 @@
 import { type Bot, type Context, type FlatPick, type Logger, Schema } from "koishi";
 import type { Notifier } from "@koishijs/plugin-notifier";
 import type { LoginBili } from "./database";
-declare enum LiveType {
-    NotLiveBroadcast = 0,
-    StartBroadcasting = 1,
-    LiveBroadcast = 2,
-    StopBroadcast = 3
-}
-type ChannelIdArr = Array<{
-    channelId: string;
-    dynamic: boolean;
-    live: boolean;
-    liveGuardBuy: boolean;
-    atAll: boolean;
-}>;
-type TargetItem = {
-    channelIdArr: ChannelIdArr;
-    platform: string;
-};
-type Target = Array<TargetItem>;
-type SubItem = {
-    id: number;
-    uid: string;
-    roomId: string;
-    target: Target;
-    platform: string;
-    live: boolean;
-    dynamic: boolean;
-};
-type SubManager = Array<SubItem>;
+import { LiveType, type MasterInfo, type SubManager, type Target } from "./type";
 declare class ComRegister {
     static inject: string[];
     qqRelatedBotList: Array<string>;
@@ -59,14 +32,9 @@ declare class ComRegister {
         userface: string;
         target: Target;
         data: any;
-    }, liveType: LiveType, liveNotifyMsg?: string): Promise<void>;
-    useMasterInfo(uid: string): Promise<{
-        username: string;
-        userface: string;
-        roomId: number;
-    }>;
+    }, liveType: LiveType, followerDisplay: string, liveNotifyMsg?: string): Promise<void>;
+    useMasterInfo(uid: string, masterInfo: MasterInfo, liveType: LiveType): Promise<MasterInfo>;
     useLiveRoomInfo(roomId: string): Promise<any>;
-    liveDetectWithAPI(): Promise<() => Promise<void>>;
     liveDetectWithListener(roomId: string, target: Target): Promise<void>;
     subShow(): string;
     updateSubNotifier(): void;

package/lib/comRegister.js

@@ -7,16 +7,10 @@ const jsx_runtime_1 = require("@satorijs/element/jsx-runtime");
 const koishi_1 = require("koishi");
 // 导入qrcode
 const qrcode_1 = __importDefault(require("qrcode"));
+const type_1 = require("./type");
 // 弹幕词云
 // TODO:WorlCloud
 // import { Segment } from "segmentit";
-var LiveType;
-(function (LiveType) {
-    LiveType[LiveType["NotLiveBroadcast"] = 0] = "NotLiveBroadcast";
-    LiveType[LiveType["StartBroadcasting"] = 1] = "StartBroadcasting";
-    LiveType[LiveType["LiveBroadcast"] = 2] = "LiveBroadcast";
-    LiveType[LiveType["StopBroadcast"] = 3] = "StopBroadcast";
-})(LiveType || (LiveType = {}));
 class ComRegister {
     // 必须服务
     static inject = ["ba", "gi", "database", "bl", "sm"];
@@ -206,53 +200,6 @@ class ComRegister {
             const subTable = this.subShow();
             return subTable;
         });
-        biliCom
-            .subcommand(".status <roomId:string>", "查询主播当前直播状态", {
-            hidden: true,
-        })
-            .usage("查询主播当前直播状态")
-            .example("bili status 732")
-            .action(async ({ session }, roomId) => {
-            this.logger.info("调用bili.status指令");
-            if (!roomId)
-                return session.send("请输入房间号!");
-            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-            let content;
-            try {
-                content = await ctx.ba.getLiveRoomInfo(roomId);
-            }
-            catch (e) {
-                return `bili status指令 getLiveRoomInfo() 发生了错误，错误为：${e.message}`;
-            }
-            const { data } = content;
-            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-            let userData;
-            try {
-                const { data: userInfo } = await ctx.ba.getMasterInfo(data.uid);
-                userData = userInfo;
-            }
-            catch (e) {
-                return `bili status指令 getMasterInfo() 发生了错误，错误为：${e.message}`;
-            }
-            // B站出问题了
-            if (content.code !== 0) {
-                if (content.msg === "未找到该房间") {
-                    session.send("未找到该房间");
-                }
-                else {
-                    session.send(`未知错误，错误信息为：${content.message}`);
-                }
-                return;
-            }
-            const { pic, buffer } = await ctx.gi.generateLiveImg(data, userData.info.uname, userData.info.face, data.live_status !== 1
-                ? LiveType.NotLiveBroadcast
-                : LiveType.LiveBroadcast);
-            // pic 存在，使用的是render模式
-            if (pic)
-                return pic;
-            // pic不存在，说明使用的是page模式
-            await session.send(koishi_1.h.image(buffer, "image/png"));
-        });
         biliCom
             .subcommand(".private", "向主人账号发送一条测试消息", { hidden: true })
             .usage("向主人账号发送一条测试消息")
@@ -860,7 +807,7 @@ class ComRegister {
         };
     }
     // 定义发送直播通知卡片方法
-    async sendLiveNotifyCard(info, liveType, liveNotifyMsg) {
+    async sendLiveNotifyCard(info, liveType, followerDisplay, liveNotifyMsg) {
         // 定义变量
         let pic;
         let buffer;
@@ -869,7 +816,7 @@ class ComRegister {
         for (let i = 0; i < attempts; i++) {
             try {
                 // 获取直播通知卡片
-                const { pic: picv, buffer: bufferv } = await this.ctx.gi.generateLiveImg(info.data, info.username, info.userface, liveType);
+                const { pic: picv, buffer: bufferv } = await this.ctx.gi.generateLiveImg(info.data, info.username, info.userface, followerDisplay, liveType);
                 // 赋值
                 pic = picv;
                 buffer = bufferv;
@@ -889,7 +836,7 @@ class ComRegister {
         // pic 存在，使用的是render模式
         if (pic) {
             // 只有在开播时才艾特全体成员
-            if (liveType === LiveType.StartBroadcasting) {
+            if (liveType === type_1.LiveType.StartBroadcasting) {
                 return await this.sendMsg(info.target, pic + (liveNotifyMsg ?? ""), true);
             }
             // 正常不需要艾特全体成员
@@ -898,19 +845,47 @@ class ComRegister {
         // pic不存在，说明使用的是page模式
         const msg = ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, "image/png"), liveNotifyMsg || ""] }));
         // 只有在开播时才艾特全体成员
-        if (liveType === LiveType.StartBroadcasting) {
+        if (liveType === type_1.LiveType.StartBroadcasting) {
             return await this.sendMsg(info.target, msg, true);
         }
         // 正常不需要艾特全体成员
         return await this.sendMsg(info.target, msg);
     }
     // 定义获取主播信息方法
-    async useMasterInfo(uid) {
+    async useMasterInfo(uid, masterInfo, liveType) {
+        // 获取主播信息
         const { data } = await this.ctx.ba.getMasterInfo(uid);
+        // 定义粉丝数变量
+        let liveOpenFollowerNum;
+        let liveEndFollowerNum;
+        let liveFollowerChange;
+        // 判断直播状态
+        if (liveType === type_1.LiveType.StartBroadcasting ||
+            liveType === type_1.LiveType.FirstLiveBroadcast) {
+            // 第一次启动或刚开播
+            // 将当前粉丝数赋值给liveOpenFollowerNum、liveEndFollowerNum
+            liveOpenFollowerNum = data.follower_num;
+            liveEndFollowerNum = data.follower_num;
+            // 将粉丝数变化赋值为0
+            liveFollowerChange = 0;
+        }
+        if (liveType === type_1.LiveType.StopBroadcast ||
+            liveType === type_1.LiveType.LiveBroadcast) {
+            // 将上一次的liveOpenFollowerNum赋值给本次的liveOpenFollowerNum
+            liveOpenFollowerNum = masterInfo.liveOpenFollowerNum;
+            // 将当前粉丝数赋值给liveEndFollowerNum
+            liveEndFollowerNum = data.follower_num;
+            // 计算粉丝数变化量
+            liveFollowerChange = liveEndFollowerNum - masterInfo.liveOpenFollowerNum;
+        }
+        // 返回值
         return {
             username: data.info.uname,
             userface: data.info.face,
             roomId: data.room_id,
+            liveOpenFollowerNum,
+            liveEndFollowerNum,
+            liveFollowerChange,
         };
     }
     async useLiveRoomInfo(roomId) {
@@ -936,241 +911,24 @@ class ComRegister {
         }
         return content.data;
     }
-    async liveDetectWithAPI() {
-        // 定义变量：第一次订阅
-        let liveDetectSetup = true;
-        // 定义变量：timer计时器
-        let timer = 0;
-        // 相当于锁的作用，防止上一个循环没处理完
-        let flag = true;
-        // 定义订阅对象Record 0未开播 1正在直播 2轮播中
-        const liveRecord = {};
-        // 定义函数: 发送请求获取直播状态
-        const useLiveStatus = async (roomId) => {
-            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-            let content;
-            const attempts = 3;
-            for (let i = 0; i < attempts; i++) {
-                try {
-                    // 发送请求获取room信息
-                    content = await this.ctx.ba.getLiveRoomInfo(roomId);
-                    // 成功则跳出循环
-                    break;
-                }
-                catch (e) {
-                    this.logger.error(`liveDetect getLiveRoomInfo 发生了错误，错误为：${e.message}`);
-                    if (i === attempts - 1) {
-                        // 已尝试三次
-                        // 发送私聊消息并重启服务
-                        return await this.sendPrivateMsgAndStopService();
-                    }
-                }
-            }
-            // 返回data
-            return content.data;
-        };
-        return async () => {
-            // 如果flag为false则说明前面的代码还未执行完，则直接返回
-            if (!flag)
-                return;
-            // 将标志位置为false
-            flag = false;
-            try {
-                // 获取正在直播对象
-                const liveUsers = await this.ctx.ba.getTheUserWhoIsLiveStreaming();
-                // 判断是否是初始化直播监测
-                if (liveDetectSetup) {
-                    // 将第一次订阅置为false
-                    liveDetectSetup = false;
-                    // 初始化subRecord
-                    for (const sub of this.subManager) {
-                        // 判断是否订阅直播
-                        if (sub.live) {
-                            // 将该订阅添加到subRecord中
-                            liveRecord[sub.uid] = {
-                                liveStatus: 0,
-                                liveTime: "",
-                                target: sub.target,
-                            };
-                        }
-                    }
-                    // 先判断是否有UP主正在直播
-                    if (liveUsers.count > 0) {
-                        // 遍历liveUsers
-                        for (const item of liveUsers.items) {
-                            // 判断是否有订阅对象正在直播
-                            if (liveRecord[item.mid]) {
-                                // 获取当前用户直播间信息
-                                const data = await useLiveStatus(item.room_id.toString());
-                                // 设置开播时间
-                                liveRecord[item.mid].liveTime = data.live_time;
-                                // 改变开播状态
-                                liveRecord[item.mid].liveStatus = 1;
-                                // 设置直播中消息
-                                const liveMsg = this.config.customLive
-                                    ? this.config.customLive
-                                        .replace("-name", item.uname)
-                                        .replace("-time", await this.ctx.gi.getTimeDifference(liveRecord[item.mid].liveTime))
-                                        .replace("-link", `https://live.bilibili.com/${data.short_id === 0 ? data.room_id : data.short_id}`)
-                                    : null;
-                                // 发送直播通知卡片
-                                if (this.config.restartPush)
-                                    this.sendLiveNotifyCard({
-                                        username: item.uname,
-                                        userface: item.face,
-                                        target: liveRecord[item.mid].target,
-                                        data,
-                                    }, LiveType.LiveBroadcast, liveMsg);
-                            }
-                        }
-                    }
-                    // 没有正在直播的订阅对象，直接返回
-                    return;
-                }
-                // 获取当前订阅直播的数量
-                const currentLiveSubs = this.subManager.filter((sub) => sub.live);
-                // 获取当前liveRecord里的订阅数量
-                const currentLiveRecordKeys = Object.keys(liveRecord);
-                // 判断是否能匹配双方数量
-                if (currentLiveRecordKeys.length < currentLiveSubs.length) {
-                    // 遍历currentLiveSubs
-                    for (const sub of currentLiveSubs) {
-                        // 判断liveRecord中缺少了哪些订阅
-                        if (!liveRecord[sub.uid]) {
-                            // 获取当前用户直播间信息
-                            const data = await useLiveStatus(sub.roomId.toString());
-                            switch (data.live_status) {
-                                case 0:
-                                case 2: {
-                                    // 未开播
-                                    // 添加到liveRecord中
-                                    liveRecord[sub.uid] = {
-                                        liveStatus: 0,
-                                        liveTime: "",
-                                        target: sub.target,
-                                    };
-                                    // break
-                                    break;
-                                }
-                                case 1: {
-                                    //正在直播
-                                    // 添加到liveRecord中
-                                    liveRecord[sub.uid] = {
-                                        liveStatus: 1,
-                                        liveTime: data.live_time,
-                                        target: sub.target,
-                                    };
-                                }
-                            }
-                        }
-                    }
-                }
-                if (currentLiveRecordKeys.length > currentLiveSubs.length) {
-                    // 创建Set
-                    const setCurrentLiveSubs = new Set(currentLiveSubs.map((sub) => sub.uid));
-                    // 找出 currentLiveRecordKeys中比currentLiveSubs 多的元素
-                    const extraInCurrentLiveSubs = currentLiveRecordKeys.filter((key) => !setCurrentLiveSubs.has(key));
-                    // 遍历 extraInCurrentLiveSubs
-                    for (const subUID of extraInCurrentLiveSubs) {
-                        // 删除记录
-                        delete liveRecord[subUID];
-                    }
-                }
-                // 数量没有差异，则不进行其他操作
-                // 遍历liveUsers
-                for (const item of liveUsers.items) {
-                    // 判断是否有正在直播的订阅对象
-                    if (liveRecord[item.mid]) {
-                        // 有正在直播的订阅对象
-                        // 获取当前用户直播间信息
-                        const data = await useLiveStatus(item.room_id.toString());
-                        // 判断开播状态
-                        switch (liveRecord[item.mid].liveStatus) {
-                            case 0: {
-                                // 之前未开播，现在开播了
-                                // 设置开播时间
-                                liveRecord[item.mid].liveTime = data.live_time;
-                                // 定义开播通知语
-                                const liveStartMsg = this.config.customLiveStart
-                                    ? this.config.customLiveStart
-                                        .replace("-name", item.uname)
-                                        .replace("-time", await this.ctx.gi.getTimeDifference(liveRecord[item.mid].liveTime))
-                                        .replace("-link", `https://live.bilibili.com/${data.short_id === 0 ? data.room_id : data.short_id}`)
-                                    : null;
-                                // 发送直播通知卡片
-                                await this.sendLiveNotifyCard({
-                                    username: item.uname,
-                                    userface: item.face,
-                                    target: liveRecord[item.mid].target,
-                                    data,
-                                }, LiveType.LiveBroadcast, liveStartMsg);
-                                // 改变开播状态
-                                liveRecord[item.mid].liveStatus = 1;
-                                // 结束
-                                break;
-                            }
-                            case 1: {
-                                // 仍在直播
-                                if (this.config.pushTime > 0) {
-                                    timer++;
-                                    // 开始记录时间
-                                    if (timer >= 6 * 60 * this.config.pushTime) {
-                                        // 到时间推送直播消息
-                                        // 到时间重新计时
-                                        timer = 0;
-                                        // 定义直播中通知消息
-                                        const liveMsg = this.config.customLive
-                                            ? this.config.customLive
-                                                .replace("-name", item.uname)
-                                                .replace("-time", await this.ctx.gi.getTimeDifference(liveRecord[item.mid].liveTime))
-                                                .replace("-link", `https://live.bilibili.com/${data.short_id === 0 ? data.room_id : data.short_id}`)
-                                            : null;
-                                        // 发送直播通知卡片
-                                        this.sendLiveNotifyCard({
-                                            username: item.uname,
-                                            userface: item.face,
-                                            target: liveRecord[item.mid].target,
-                                            data,
-                                        }, LiveType.LiveBroadcast, liveMsg);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-                // 找出liveRecord中liveStatus为1但liveUsers中没有的元素
-                const extraInLiveRecord = currentLiveRecordKeys.filter((key) => !liveUsers.items.some((item) => item.mid === Number(key)));
-                // 遍历 extraInLiveRecord
-                for (const subUID of extraInLiveRecord) {
-                    // 下播的主播
-                    // 获取主播信息
-                    const masterInfo = await this.useMasterInfo(subUID);
-                    // 获取直播间消息
-                    const liveRoomInfo = await this.useLiveRoomInfo(masterInfo.roomId.toString());
-                    // 设置开播时间
-                    liveRoomInfo.live_time = liveRecord[subUID].liveTime;
-                    // 定义下播播通知语
-                    const liveEndMsg = this.config.customLiveEnd
-                        ? this.config.customLiveEnd
-                            .replace("-name", masterInfo.username)
-                            .replace("-time", await this.ctx.gi.getTimeDifference(liveRecord[subUID].liveTime))
-                            .replace("-link", `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`)
-                        : null;
-                    // 发送下播通知
-                    this.sendLiveNotifyCard({
-                        username: masterInfo.username,
-                        userface: masterInfo.userface,
-                        target: liveRecord[subUID].target,
-                        data: liveRoomInfo,
-                    }, LiveType.StopBroadcast, liveEndMsg);
-                }
-            }
-            finally {
-                // 执行完方法体不论如何都把flag设置为true
-                flag = true;
+    // TODO:WordCloud
+    /* // 定义获取弹幕权重Record函数
+        const getDanmakuWeightRecord = (): Record<string, number> => {
+            // 创建segmentit
+            const segmentit = useDefault(new Segment());
+            // 创建Record
+            const danmakuWeightRecord: Record<string, number> = {};
+            // 循环遍历currentLiveDanmakuArr
+            for (const danmaku of currentLiveDanmakuArr) {
+                // 遍历结果
+                segmentit.doSegment(danmaku).map((word: { w: string; p: number }) => {
+                    // 定义权重
+                    danmakuWeightRecord[word.w] = (danmakuWeightRecord[word.w] || 0) + 1;
+                });
             }
-        };
-    }
+            // 返回Record
+            return danmakuWeightRecord;
+        }; */
     async liveDetectWithListener(roomId, target) {
         // 定义开播时间
         let liveTime;
@@ -1187,6 +945,7 @@ class ComRegister {
         // biome-ignore lint/suspicious/noExplicitAny: <explanation>
         let liveRoomInfo;
         let masterInfo;
+        let watchedNum;
         // 找到频道/群组对应的
         const liveGuardBuyPushTargetArr = target.map((channel) => {
             // 获取符合条件的target
@@ -1202,17 +961,20 @@ class ComRegister {
         // 定义定时推送函数
         const pushAtTimeFunc = async () => {
             // 判断是否信息是否获取成功
-            if (!(await useMasterAndLiveRoomInfo())) {
+            if (!(await useMasterAndLiveRoomInfo(type_1.LiveType.LiveBroadcast))) {
                 // 未获取成功，直接返回
                 return this.sendPrivateMsg("获取直播间信息失败，推送直播卡片失败！");
             }
             // 设置开播时间
             liveTime = liveRoomInfo.live_time;
+            // 获取watched
+            const watched = watchedNum || "暂未获取到";
             // 设置直播中消息
             const liveMsg = this.config.customLive
                 ? this.config.customLive
                     .replace("-name", masterInfo.username)
                     .replace("-time", await this.ctx.gi.getTimeDifference(liveTime))
+                    .replace("-watched", watched)
                     .replace("-link", `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`)
                 : null;
             // 发送直播通知卡片
@@ -1221,28 +983,10 @@ class ComRegister {
                 userface: masterInfo.userface,
                 target,
                 data: liveRoomInfo,
-            }, LiveType.LiveBroadcast, liveMsg);
+            }, type_1.LiveType.LiveBroadcast, watched, liveMsg);
         };
-        // TODO:WordCloud
-        /* // 定义获取弹幕权重Record函数
-        const getDanmakuWeightRecord = (): Record<string, number> => {
-            // 创建segmentit
-            const segmentit = useDefault(new Segment());
-            // 创建Record
-            const danmakuWeightRecord: Record<string, number> = {};
-            // 循环遍历currentLiveDanmakuArr
-            for (const danmaku of currentLiveDanmakuArr) {
-                // 遍历结果
-                segmentit.doSegment(danmaku).map((word: { w: string; p: number }) => {
-                    // 定义权重
-                    danmakuWeightRecord[word.w] = (danmakuWeightRecord[word.w] || 0) + 1;
-                });
-            }
-            // 返回Record
-            return danmakuWeightRecord;
-        }; */
         // 定义直播间信息获取函数
-        const useMasterAndLiveRoomInfo = async () => {
+        const useMasterAndLiveRoomInfo = async (liveType) => {
             // 定义函数是否执行成功flag
             let flag = true;
             // 获取直播间信息
@@ -1260,7 +1004,7 @@ class ComRegister {
                 return flag;
             }
             // 获取主播信息(需要满足flag为true，liveRoomInfo.uid有值)
-            masterInfo = await this.useMasterInfo(liveRoomInfo.uid).catch(() => {
+            masterInfo = await this.useMasterInfo(liveRoomInfo.uid, masterInfo, liveType).catch(() => {
                 // 设置flag为false
                 flag = false;
                 // 返回空
@@ -1269,11 +1013,6 @@ class ComRegister {
             // 返回信息
             return flag;
         };
-        // 判断是否信息是否获取成功
-        if (!(await useMasterAndLiveRoomInfo())) {
-            // 未获取成功，直接返回
-            return this.sendPrivateMsg("获取直播间信息失败，启动直播间弹幕检测失败！");
-        }
         // 构建消息处理函数
         const handler = {
             onIncomeDanmu: ({ body }) => {
@@ -1284,6 +1023,10 @@ class ComRegister {
                 // 保存消息到数组
                 currentLiveDanmakuArr.push(body.content);
             },
+            onWatchedChange: ({ body }) => {
+                // 保存观看人数到变量
+                watchedNum = body.text_small;
+            },
             onGuardBuy: ({ body }) => {
                 // 定义消息
                 const content = `${body.user.uname}加入了大航海（${body.gift_name}）`;
@@ -1297,7 +1040,7 @@ class ComRegister {
                 // 设置开播状态为true
                 liveStatus = true;
                 // 判断是否信息是否获取成功
-                if (!(await useMasterAndLiveRoomInfo())) {
+                if (!(await useMasterAndLiveRoomInfo(type_1.LiveType.StartBroadcasting))) {
                     // 设置开播状态为false
                     liveStatus = false;
                     // 未获取成功，直接返回
@@ -1305,11 +1048,14 @@ class ComRegister {
                 }
                 // 设置开播时间
                 liveTime = liveRoomInfo.live_time;
+                // 获取当前粉丝数
+                const follower = masterInfo.liveOpenFollowerNum >= 10_000 ? `${masterInfo.liveOpenFollowerNum.toFixed(1)}万` : masterInfo.liveOpenFollowerNum.toString();
                 // 定义开播通知语
                 const liveStartMsg = this.config.customLiveStart
                     ? this.config.customLiveStart
                         .replace("-name", masterInfo.username)
                         .replace("-time", await this.ctx.gi.getTimeDifference(liveTime))
+                        .replace("-follower", follower)
                         .replace("-link", `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`)
                     : null;
                 // 推送开播通知
@@ -1318,7 +1064,7 @@ class ComRegister {
                     userface: masterInfo.userface,
                     target,
                     data: liveRoomInfo,
-                }, LiveType.StartBroadcasting, liveStartMsg);
+                }, type_1.LiveType.StartBroadcasting, follower, liveStartMsg);
                 // 判断定时器是否已开启
                 if (!pushAtTimeTimer) {
                     // 开始直播，开启定时器
@@ -1329,17 +1075,30 @@ class ComRegister {
                 // 将直播状态设置为false
                 liveStatus = false;
                 // 判断是否信息是否获取成功
-                if (!(await useMasterAndLiveRoomInfo())) {
+                if (!(await useMasterAndLiveRoomInfo(type_1.LiveType.StopBroadcast))) {
                     // 未获取成功，直接返回
                     return this.sendPrivateMsg("获取直播间信息失败，推送直播下播卡片失败！");
                 }
                 // 更改直播时长
                 liveRoomInfo.live_time = liveTime;
+                // 获取粉丝数变化
+                const followerChange = (() => {
+                    // 获取直播关注变化值
+                    const liveFollowerChangeNum = masterInfo.liveFollowerChange;
+                    // 判断是否大于0
+                    if (liveFollowerChangeNum > 0) {
+                        // 大于0则加+
+                        return liveFollowerChangeNum >= 10_000 ? `+${liveFollowerChangeNum.toFixed(1)}万` : `+${liveFollowerChangeNum}`;
+                    }
+                    // 小于0
+                    return liveFollowerChangeNum <= -10_000 ? `${liveFollowerChangeNum.toFixed(1)}万` : liveFollowerChangeNum.toString();
+                })();
                 // 定义下播播通知语
                 const liveEndMsg = this.config.customLiveEnd
                     ? this.config.customLiveEnd
                         .replace("-name", masterInfo.username)
                         .replace("-time", await this.ctx.gi.getTimeDifference(liveTime))
+                        .replace("-follower_change", followerChange)
                     : null;
                 // 推送通知卡片
                 await this.sendLiveNotifyCard({
@@ -1347,7 +1106,7 @@ class ComRegister {
                     userface: masterInfo.userface,
                     target,
                     data: liveRoomInfo,
-                }, LiveType.StopBroadcast, liveEndMsg);
+                }, type_1.LiveType.StopBroadcast, followerChange, liveEndMsg);
                 // 关闭定时推送定时器
                 pushAtTimeTimer();
                 // 将推送定时器变量置空
@@ -1356,15 +1115,23 @@ class ComRegister {
         };
         // 启动直播间弹幕监测
         await this.ctx.bl.startLiveRoomListener(roomId, handler);
+        // 第一次启动获取信息并判信息是否获取成功
+        if (!(await useMasterAndLiveRoomInfo(type_1.LiveType.FirstLiveBroadcast))) {
+            // 未获取成功，直接返回
+            return this.sendPrivateMsg("获取直播间信息失败，启动直播间弹幕检测失败！");
+        }
         // 判断直播状态
         if (liveRoomInfo.live_status === 1) {
             // 设置开播时间
             liveTime = liveRoomInfo.live_time;
+            // 获取当前累计观看人数
+            const watched = watchedNum || "暂未获取到";
             // 定义直播中通知消息
             const liveMsg = this.config.customLive
                 ? this.config.customLive
                     .replace("-name", masterInfo.username)
                     .replace("-time", await this.ctx.gi.getTimeDifference(liveTime))
+                    .replace("-watched", watched)
                     .replace("-link", `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`)
                 : null;
             // 发送直播通知卡片
@@ -1374,7 +1141,7 @@ class ComRegister {
                     userface: masterInfo.userface,
                     target,
                     data: liveRoomInfo,
-                }, LiveType.LiveBroadcast, liveMsg);
+                }, type_1.LiveType.LiveBroadcast, watched, liveMsg);
             }
             // 正在直播，开启定时器
             // 判断定时器是否已开启
@@ -1575,25 +1342,10 @@ class ComRegister {
                     // 发送提示
                     this.logger.warn(`UID:${sub.uid} 用户没有开通直播间，无法订阅直播！`);
                 }
-                //
-                const liveDetectModeSelector = {
-                    API: async () => {
-                        // 判断是否已开启直播检测
-                        if (!this.liveDispose) {
-                            // 未开启直播检测
-                            // 开启直播检测并保存销毁函数
-                            this.liveDispose = await this.liveDetectWithAPI();
-                        }
-                    },
-                    WS: async () => {
-                        // 连接到服务器
-                        await this.liveDetectWithListener(data.live_room.roomid, sub.target);
-                    },
-                };
                 // 判断是否订阅直播
                 if (sub.live) {
                     // 启动直播监测
-                    await liveDetectModeSelector[this.config.liveDetectMode]();
+                    await this.liveDetectWithListener(data.live_room.roomid, sub.target);
                 }
             }
             // 在B站中订阅该对象

package/lib/generateImg.d.ts

@@ -8,7 +8,7 @@ declare class GenerateImg extends Service {
     static inject: string[];
     giConfig: GenerateImg.Config;
     constructor(ctx: Context, config: GenerateImg.Config);
-    generateLiveImg(data: any, username: string, userface: string, liveStatus: number): Promise<{
+    generateLiveImg(data: any, username: string, userface: string, followerDisplay: string, liveStatus: number): Promise<{
         buffer: Buffer<ArrayBufferLike>;
         pic?: undefined;
     } | {
@@ -45,6 +45,7 @@ declare namespace GenerateImg {
         enableLargeFont: boolean;
         font: string;
         hideDesc: boolean;
+        followerDisplay: boolean;
     }
     const Config: Schema<Config>;
 }

package/lib/generateImg.js

@@ -9,24 +9,16 @@ const DYNAMIC_TYPE_NONE = "DYNAMIC_TYPE_NONE";
 const DYNAMIC_TYPE_FORWARD = "DYNAMIC_TYPE_FORWARD";
 const DYNAMIC_TYPE_AV = "DYNAMIC_TYPE_AV";
 const DYNAMIC_TYPE_PGC = "DYNAMIC_TYPE_PGC";
-const DYNAMIC_TYPE_COURSES = "DYNAMIC_TYPE_COURSES";
 const DYNAMIC_TYPE_WORD = "DYNAMIC_TYPE_WORD";
 const DYNAMIC_TYPE_DRAW = "DYNAMIC_TYPE_DRAW";
 const DYNAMIC_TYPE_ARTICLE = "DYNAMIC_TYPE_ARTICLE";
 const DYNAMIC_TYPE_MUSIC = "DYNAMIC_TYPE_MUSIC";
 const DYNAMIC_TYPE_COMMON_SQUARE = "DYNAMIC_TYPE_COMMON_SQUARE";
-const DYNAMIC_TYPE_COMMON_VERTICAL = "DYNAMIC_TYPE_COMMON_VERTICAL";
 const DYNAMIC_TYPE_LIVE = "DYNAMIC_TYPE_LIVE";
 const DYNAMIC_TYPE_MEDIALIST = "DYNAMIC_TYPE_MEDIALIST";
 const DYNAMIC_TYPE_COURSES_SEASON = "DYNAMIC_TYPE_COURSES_SEASON";
-const DYNAMIC_TYPE_COURSES_BATCH = "DYNAMIC_TYPE_COURSES_BATCH";
-const DYNAMIC_TYPE_AD = "DYNAMIC_TYPE_AD";
-const DYNAMIC_TYPE_APPLET = "DYNAMIC_TYPE_APPLET";
-const DYNAMIC_TYPE_SUBSCRIPTION = "DYNAMIC_TYPE_SUBSCRIPTION";
 const DYNAMIC_TYPE_LIVE_RCMD = "DYNAMIC_TYPE_LIVE_RCMD";
-const DYNAMIC_TYPE_BANNER = "DYNAMIC_TYPE_BANNER";
 const DYNAMIC_TYPE_UGC_SEASON = "DYNAMIC_TYPE_UGC_SEASON";
-const DYNAMIC_TYPE_SUBSCRIPTION_NEW = "DYNAMIC_TYPE_SUBSCRIPTION_NEW";
 // 内容卡片类型
 const ADDITIONAL_TYPE_RESERVE = "ADDITIONAL_TYPE_RESERVE";
 class GenerateImg extends koishi_1.Service {
@@ -38,12 +30,12 @@ class GenerateImg extends koishi_1.Service {
     }
     async generateLiveImg(
     // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-    data, username, userface, liveStatus /*0未开播 1刚开播 2已开播 3停止直播*/) {
+    data, username, userface, followerDisplay, liveStatus /*0未开播 1刚开播 2已开播 3停止直播*/) {
         const [titleStatus, liveTime, cover] = await this.getLiveStatus(data.live_time, liveStatus);
         // 加载字体
         const fontURL = (0, node_url_1.pathToFileURL)((0, node_path_1.resolve)(__dirname, "font/HYZhengYuan-75W.ttf"));
         // 卡片内容
-        const html = `
+        const html = /* html */ `
             <!DOCTYPE html>
             <html>
             <head>
@@ -175,6 +167,18 @@ class GenerateImg extends koishi_1.Service {
                                 </p>
                                 <p class="card-link">
                                     <span>${liveTime}</span>
+                                    ${this.giConfig.followerDisplay
+            ? /* html */ `
+                                        <span>
+                                        ${liveStatus === 1
+                ? `当前粉丝数：${followerDisplay}`
+                : liveStatus === 2
+                    ? `累计观看人数：${followerDisplay}`
+                    : liveStatus === 3
+                        ? `粉丝数变化：${followerDisplay}`
+                        : ""}
+                                        </span>`
+            : ""}
                                 </p>
                             </div>
                         </div>
@@ -260,7 +264,7 @@ class GenerateImg extends koishi_1.Service {
                 if (module_dynamic.desc) {
                     const richText = module_dynamic.desc.rich_text_nodes.reduce((accumulator, currentValue) => {
                         if (currentValue.emoji) {
-                            return `${accumulator}<img style="width:28px; height:28px;" src="${currentValue.emoji.icon_url}"/>`;
+                            return /* html */ `${accumulator}<img style="width:28px; height:28px;" src="${currentValue.emoji.icon_url}"/>`;
                         }
                         return accumulator + currentValue.text;
                     }, "");
@@ -282,7 +286,7 @@ class GenerateImg extends koishi_1.Service {
                     const text = richText.replace(/\n/g, "<br>");
                     // 拼接字符串
                     if (text) {
-                        main += `
+                        main += /* html */ `
                             <div class="card-details">
                                 ${text}
                             </div>
@@ -297,7 +301,7 @@ class GenerateImg extends koishi_1.Service {
                         const height = module_dynamic.major.draw.items[0].height;
                         console.log(height);
                         if (height > 3000) {
-                            major += `
+                            major += /* html */ `
                                 <div class="single-photo-container">
                                     <img class="single-photo-item" src="${module_dynamic.major.draw.items[0].src}"/>
                                     <div class="single-photo-mask">
@@ -308,7 +312,7 @@ class GenerateImg extends koishi_1.Service {
                             `;
                         }
                         else {
-                            major += `
+                            major += /* html */ `
                                 <div class="single-photo-container">
                                     <img class="single-photo-item" src="${module_dynamic.major.draw.items[0].src}"/>
                                 </div>
@@ -317,15 +321,15 @@ class GenerateImg extends koishi_1.Service {
                     }
                     else if (module_dynamic.major.draw.items.length === 4) {
                         major += module_dynamic.major.draw.items.reduce((acc, cV) => {
-                            return `${acc}<img class="four-photo-item" src="${cV.src}"/>`;
+                            return /* html */ `${acc}<img class="four-photo-item" src="${cV.src}"/>`;
                         }, "");
                     }
                     else {
                         major += module_dynamic.major.draw.items.reduce((acc, cV) => {
-                            return `${acc}<img class="photo-item" src="${cV.src}"/>`;
+                            return /* html */ `${acc}<img class="photo-item" src="${cV.src}"/>`;
                         }, "");
                     }
-                    main += `
+                    main += /* html */ `
                         <div class="card-major">
                             ${major}
                         </div>
@@ -353,7 +357,7 @@ class GenerateImg extends koishi_1.Service {
                         // eslint-disable-next-line @typescript-eslint/no-unused-vars
                         const [forwardMain, _, forwardInfo] = await getDynamicMajor(dynamicMajorData.orig, true);
                         // 拼接main
-                        main += `
+                        main += /* html */ `
                         <div class="card-forward">
                             <div class="forward-userinfo">
                                 <img class="forward-avatar" src="${forwardUserAvatarUrl}" alt="avatar">
@@ -377,14 +381,14 @@ class GenerateImg extends koishi_1.Service {
                                 let button;
                                 // 判断按钮类型
                                 if (reserve.button.uncheck.text === "已结束") {
-                                    button = `
+                                    button = /* html */ `
                                         <button class="reserve-button-end">
                                             <span>${reserve.button.uncheck.text}</span>
                                         </button>
                                     `;
                                 }
                                 else {
-                                    button = `
+                                    button = /* html */ `
                                         <button class="reserve-button-ing">
                                             <svg class="bili-dyn-card-reserve__action__icon" style="width: 16px; height: 16px;"
                                                 xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
@@ -403,7 +407,7 @@ class GenerateImg extends koishi_1.Service {
                                         </button>
                                     `;
                                 }
-                                main += `
+                                main += /* html */ `
                                 <div class="card-reserve">
                                     <div class="reserve-main">
                                         <div class="reserve-title">
@@ -472,7 +476,7 @@ class GenerateImg extends koishi_1.Service {
                             pubTime = `${pubTime} · 投稿了视频`;
                         }
                     }
-                    main += `
+                    main += /* html */ `
                     <div class="card-video">
                         <div class="video-cover">
                             <img src="${archive.cover}"
@@ -1302,7 +1306,7 @@ class GenerateImg extends koishi_1.Service {
             `;
         }
         // 定义卡片内容
-        const html = `
+        const html = /* html */ `
             <!DOCTYPE html>
             <html>
             <head>
@@ -1428,7 +1432,7 @@ class GenerateImg extends koishi_1.Service {
     async generateWordCloudImg() {
         const page = await this.ctx.puppeteer.page();
         // 创建HTML内容
-        const htmlContent = `
+        const htmlContent = /* html */ `
             <!DOCTYPE html>
             <html>
                 <head>
@@ -1549,6 +1553,7 @@ class GenerateImg extends koishi_1.Service {
         enableLargeFont: koishi_1.Schema.boolean(),
         font: koishi_1.Schema.string(),
         hideDesc: koishi_1.Schema.boolean(),
+        followerDisplay: koishi_1.Schema.boolean(),
     });
 })(GenerateImg || (GenerateImg = {}));
 exports.default = GenerateImg;

package/lib/index.d.ts

@@ -51,6 +51,7 @@ export interface Config {
     customLiveStart: string;
     customLive: string;
     customLiveEnd: string;
+    followerDisplay: boolean;
     hideDesc: boolean;
     style: {};
     removeBorder: boolean;

package/lib/index.js

@@ -157,6 +157,7 @@ class ServerManager extends koishi_1.Service {
                 hideDesc: globalConfig.hideDesc,
                 enableLargeFont: globalConfig.enableLargeFont,
                 font: globalConfig.font,
+                followerDisplay: globalConfig.followerDisplay
             });
             // CR = ComRegister
             const cr = this.ctx.plugin(comRegister_1.default, {
@@ -231,11 +232,11 @@ function apply(ctx, config) {
     globalConfig = config;
     // 设置提示
     ctx.notifier.create({
-        type: 'danger',
-        content: "3.0.0-alpha.16 全面从指令订阅转移到配置订阅，以前使用指令的订阅需要全部重新填写到订阅配置中",
+        type: "danger",
+        content: "3.0.0-alpha.16 全面从指令订阅迁移到配置订阅，以前使用指令的订阅需要全部重新填写到订阅配置中",
     });
     ctx.notifier.create({
-        type: 'warning',
+        type: "warning",
         content: "请使用Auth插件创建超级管理员账号，没有权限将无法使用该插件提供的指令。",
     });
     // load database
@@ -337,7 +338,7 @@ exports.Config = koishi_1.Schema.object({
         koishi_1.Schema.const("WS").description("WebSocket模式：连接到对应的直播间，可推送弹幕消息，开播下播响应最快，但对订阅数有限制"),
         koishi_1.Schema.const("API")
             .description("API模式：请求对应直播间API，无法获取弹幕消息，开播下播响应慢，理论可无限订阅")
-            .experimental(),
+            .deprecated(),
     ])
         .role("radio")
         .description("直播检测模式")
@@ -352,12 +353,17 @@ exports.Config = koishi_1.Schema.object({
         .default(1)
         .description("设定间隔多长时间推送一次直播状态，单位为小时，默认为一小时"),
     customLiveStart: koishi_1.Schema.string()
-        .default("-name开播啦 -link")
-        .description("自定义开播提示语，-name代表UP昵称，-link代表直播间链接（如果使用的是QQ官方机器人，请不要使用）。例如-name开播啦，会发送为xxxUP开播啦"),
-    customLive: koishi_1.Schema.string().description("自定义直播中提示语，-name代表UP昵称，-time代表开播时长，-link代表直播间链接（如果使用的是QQ官方机器人，请不要使用）。例如-name正在直播，会发送为xxxUP正在直播xxx"),
+        .default("-name开播啦，当前粉丝数为-follower -link")
+        .description("自定义开播提示语，-name代表UP昵称，-follower代表当前粉丝数，-link代表直播间链接（如果使用的是QQ官方机器人，请不要使用）。例如-name开播啦，会发送为xxxUP开播啦"),
+    customLive: koishi_1.Schema.string()
+        .default("-name正在直播，目前已播-time。累计看过人数：-watched，-link")
+        .description("自定义直播中提示语，-name代表UP昵称，-time代表开播时长，-watched代表累计看过人数，-link代表直播间链接（如果使用的是QQ官方机器人，请不要使用）。例如-name正在直播，会发送为xxxUP正在直播xxx"),
     customLiveEnd: koishi_1.Schema.string()
-        .default("-name下播啦，本次直播了-time")
-        .description("自定义下播提示语，-name代表UP昵称，-time代表开播时长。例如-name下播啦，本次直播了-time，会发送为xxxUP下播啦，直播时长为xx小时xx分钟xx秒"),
+        .default("-name下播啦，本次直播了-time。粉丝数变化-follower_change")
+        .description("自定义下播提示语，-name代表UP昵称，-follower_change代表本场直播粉丝数变，-time代表开播时长。例如-name下播啦，本次直播了-time，会发送为xxxUP下播啦，直播时长为xx小时xx分钟xx秒"),
+    followerDisplay: koishi_1.Schema.boolean()
+        .default(true)
+        .description("粉丝数变化和看过本场直播的人数是否显示在推送卡片中"),
     hideDesc: koishi_1.Schema.boolean()
         .default(false)
         .description("是否隐藏UP主直播间简介，开启后推送的直播卡片将不再展示简介"),

package/lib/type/index.d.ts

@@ -0,0 +1,37 @@
+export declare enum LiveType {
+    NotLiveBroadcast = 0,
+    StartBroadcasting = 1,
+    LiveBroadcast = 2,
+    StopBroadcast = 3,
+    FirstLiveBroadcast = 4
+}
+export type ChannelIdArr = Array<{
+    channelId: string;
+    dynamic: boolean;
+    live: boolean;
+    liveGuardBuy: boolean;
+    atAll: boolean;
+}>;
+export type TargetItem = {
+    channelIdArr: ChannelIdArr;
+    platform: string;
+};
+export type Target = Array<TargetItem>;
+export type SubItem = {
+    id: number;
+    uid: string;
+    roomId: string;
+    target: Target;
+    platform: string;
+    live: boolean;
+    dynamic: boolean;
+};
+export type SubManager = Array<SubItem>;
+export type MasterInfo = {
+    username: string;
+    userface: string;
+    roomId: number;
+    liveOpenFollowerNum: number;
+    liveEndFollowerNum: number;
+    liveFollowerChange: number;
+};

package/lib/type/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveType = void 0;
+var LiveType;
+(function (LiveType) {
+    LiveType[LiveType["NotLiveBroadcast"] = 0] = "NotLiveBroadcast";
+    LiveType[LiveType["StartBroadcasting"] = 1] = "StartBroadcasting";
+    LiveType[LiveType["LiveBroadcast"] = 2] = "LiveBroadcast";
+    LiveType[LiveType["StopBroadcast"] = 3] = "StopBroadcast";
+    LiveType[LiveType["FirstLiveBroadcast"] = 4] = "FirstLiveBroadcast";
+})(LiveType || (exports.LiveType = LiveType = {}));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-bilibili-notify",
   "description": "Koishi bilibili notify plugin",
-  "version": "3.0.0-alpha.16",
+  "version": "3.0.0-alpha.18",
   "contributors": [
     "Akokko <admin@akokko.com>"
   ],

package/readme.md

@@ -196,6 +196,8 @@
 - ver 3.0.0-alpha.14 优化：移除不需要的服务
 - ver 3.0.0-alpha.15 修复：启动插件提示发送群组消息失败、直播推送时间显示为负数(不用再特别设置系统时区为UTC+8)
 - ver 3.0.0-alpha.16 重大更新：订阅不再依赖数据库，从指令订阅全面迁移到配置订阅； 修复：直播时长有误； 优化：`bili show` 指令更改为 `bili list`
+- ver 3.0.0-alpha.17 新增：更多的提示语变量，开播，当前粉丝数。正在直播，累计观看人数。下播，粉丝数变化。选项，新增的提示语变量是否展示到推送卡片中
+- ver 3.0.0-alpha.18 移除：直播检测API模式已被废弃； 优化：更多提示语数据显示优化
 
 ## 交流群