koishi-plugin-bilibili-notify 3.0.0-alpha.17 → 3.0.0-alpha.19

package/lib/comRegister.d.ts

@@ -21,6 +21,7 @@ declare class ComRegister {
     constructor(ctx: Context, config: ComRegister.Config);
     init(config: ComRegister.Config): Promise<void>;
     getBot(pf: string): Bot<Context, any>;
+    test_wordCloud(): Promise<void>;
     sendPrivateMsg(content: string): Promise<void>;
     sendPrivateMsgAndRebootService(): Promise<void>;
     sendPrivateMsgAndStopService(): Promise<void>;

package/lib/comRegister.js

@@ -4,13 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const jsx_runtime_1 = require("@satorijs/element/jsx-runtime");
+// Koishi核心依赖
 const koishi_1 = require("koishi");
-// 导入qrcode
+// 外部依赖：qrcode
 const qrcode_1 = __importDefault(require("qrcode"));
+// Types
 const type_1 = require("./type");
-// 弹幕词云
-// TODO:WorlCloud
-// import { Segment } from "segmentit";
 class ComRegister {
     // 必须服务
     static inject = ["ba", "gi", "database", "bl", "sm"];
@@ -284,8 +283,33 @@ class ComRegister {
         this.checkIfDynamicDetectIsNeeded();
         // 在控制台中显示订阅对象
         this.updateSubNotifier();
-        /* // Test
-        const testTarget: Target = [
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    getBot(pf) {
+        return this.ctx.bots.find((bot) => bot.platform === pf);
+    }
+    // TODO:WordCloud
+    async test_wordCloud() {
+        /* const currentLiveDanmakuArr = []
+        // 定义获取弹幕权重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;
+        }; */
+        // Test
+        const testTarget = [
             {
                 channelIdArr: [
                     {
@@ -299,13 +323,6 @@ class ComRegister {
                 platform: "qqguild",
             },
         ];
-
-        const buffer = await this.ctx.gi.generateWordCloudImg();
-        this.sendMsg(testTarget, h.image(buffer, "image/png")); */
-    }
-    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-    getBot(pf) {
-        return this.ctx.bots.find((bot) => bot.platform === pf);
     }
     async sendPrivateMsg(content) {
         if (this.config.master.enable) {
@@ -911,323 +928,6 @@ class ComRegister {
         }
         return content.data;
     }
-    /* async liveDetectWithAPI() {
-        // 定义变量：第一次订阅
-        let liveDetectSetup = true;
-        // 定义变量：timer计时器
-        let timer = 0;
-        // 相当于锁的作用，防止上一个循环没处理完
-        let flag = true;
-        // 定义订阅对象Record 0未开播 1正在直播 2轮播中
-        const liveRecord: Record<
-            number,
-            {
-                liveStatus: number;
-                liveTime: string;
-                target: Target;
-            }
-        > = {};
-
-        // 定义函数: 发送请求获取直播状态
-        const useLiveStatus = async (roomId: string) => {
-            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-            let content: any;
-            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;
@@ -1267,7 +967,7 @@ class ComRegister {
             // 设置开播时间
             liveTime = liveRoomInfo.live_time;
             // 获取watched
-            const watched = watchedNum?.toString() || '暂未获取到';
+            const watched = watchedNum || "暂未获取到";
             // 设置直播中消息
             const liveMsg = this.config.customLive
                 ? this.config.customLive
@@ -1324,7 +1024,7 @@ class ComRegister {
             },
             onWatchedChange: ({ body }) => {
                 // 保存观看人数到变量
-                watchedNum = body.num;
+                watchedNum = body.text_small;
             },
             onGuardBuy: ({ body }) => {
                 // 定义消息
@@ -1348,7 +1048,9 @@ class ComRegister {
                 // 设置开播时间
                 liveTime = liveRoomInfo.live_time;
                 // 获取当前粉丝数
-                const follower = masterInfo.liveOpenFollowerNum.toString();
+                const follower = masterInfo.liveOpenFollowerNum >= 10_000
+                    ? `${(masterInfo.liveOpenFollowerNum / 10000).toFixed(1)}万`
+                    : masterInfo.liveOpenFollowerNum.toString();
                 // 定义开播通知语
                 const liveStartMsg = this.config.customLiveStart
                     ? this.config.customLiveStart
@@ -1381,7 +1083,21 @@ class ComRegister {
                 // 更改直播时长
                 liveRoomInfo.live_time = liveTime;
                 // 获取粉丝数变化
-                const followerChange = masterInfo.liveFollowerChange.toString();
+                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
@@ -1414,7 +1130,7 @@ class ComRegister {
             // 设置开播时间
             liveTime = liveRoomInfo.live_time;
             // 获取当前累计观看人数
-            const watched = watchedNum?.toString() || '暂未获取到';
+            const watched = watchedNum || "暂未获取到";
             // 定义直播中通知消息
             const liveMsg = this.config.customLive
                 ? this.config.customLive
@@ -1631,26 +1347,10 @@ class ComRegister {
                     // 发送提示
                     this.logger.warn(`UID:${sub.uid} 用户没有开通直播间，无法订阅直播！`);
                 }
-                // 直播类型模式匹配
-                const liveDetectModeSelector = {
-                    API: async () => {
-                        // 判断是否已开启直播检测
-                        if (!this.liveDispose) {
-                            // 未开启直播检测
-                            // 开启直播检测并保存销毁函数
-                            // this.liveDispose = await this.liveDetectWithAPI();
-                            this.logger.warn("API模式暂时不可用");
-                        }
-                    },
-                    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

@@ -24,7 +24,6 @@ declare class GenerateImg extends Service {
         link: string;
         buffer?: undefined;
     }>;
-    generateWordCloudImg(): Promise<Buffer<ArrayBufferLike>>;
     getLiveStatus(time: string, liveStatus: number): Promise<[string, string, boolean]>;
     getTimeDifference(dateString: string): Promise<string>;
     unixTimestampToString(timestamp: number): string;

package/lib/generateImg.js

@@ -171,11 +171,11 @@ class GenerateImg extends koishi_1.Service {
             ? /* html */ `
                                         <span>
                                         ${liveStatus === 1
-                ? `当前粉丝数为${followerDisplay}`
+                ? `当前粉丝数：${followerDisplay}`
                 : liveStatus === 2
-                    ? `本场直播累计观看人数：${followerDisplay}`
+                    ? `累计观看人数：${followerDisplay}`
                     : liveStatus === 3
-                        ? `本场直播粉丝数变化：${followerDisplay}`
+                        ? `粉丝数变化：${followerDisplay}`
                         : ""}
                                         </span>`
             : ""}
@@ -1429,35 +1429,6 @@ class GenerateImg extends koishi_1.Service {
             }
         }
     }
-    async generateWordCloudImg() {
-        const page = await this.ctx.puppeteer.page();
-        // 创建HTML内容
-        const htmlContent = /* html */ `
-            <!DOCTYPE html>
-            <html>
-                <head>
-                <script src="https://cdn.jsdelivr.net/npm/echarts@5.4.0/dist/echarts.min.js"></script>
-                </head>
-                <body>
-                <div id="chart" style="width:800px;height:600px;"></div>
-                <script>
-                    const chart = echarts.init(document.getElementById('chart'));
-                    chart.setOption({
-                    title: { text: 'Node.js ECharts示例' },
-                    tooltip: {},
-                    xAxis: { data: ['A', 'B', 'C', 'D', 'E'] },
-                    yAxis: {},
-                    series: [{ name: '数据', type: 'bar', data: [5, 20, 36, 10, 15] }]
-                    });
-                </script>
-                </body>
-            </html>
-        `;
-        // 加载HTML并截图
-        await page.setContent(htmlContent);
-        const buffer = await page.screenshot({ path: "output.png" });
-        return buffer;
-    }
     async getLiveStatus(time, liveStatus) {
         let titleStatus;
         let liveTime;

package/lib/index.js

@@ -237,7 +237,7 @@ function apply(ctx, config) {
     });
     ctx.notifier.create({
         type: "warning",
-        content: "请使用Auth插件创建超级管理员账号，没有权限将无法使用该插件提供的指令。",
+        content: "请使用Auth插件创建超级管理员账号，没有权限将无法使用该插件提供的指令",
     });
     // load database
     ctx.plugin(Database);
@@ -302,18 +302,18 @@ exports.Config = koishi_1.Schema.object({
         .description("设置请求头User-Agen，请求出现-352时可以尝试修改，UA获取方法可参考：https://blog.csdn.net/qq_44503987/article/details/104929111"),
     subTitle: koishi_1.Schema.object({}).description("订阅配置"),
     sub: koishi_1.Schema.array(koishi_1.Schema.object({
-        uid: koishi_1.Schema.string().description("订阅用户UID"),
-        dynamic: koishi_1.Schema.boolean().description("是否订阅用户动态"),
-        live: koishi_1.Schema.boolean().description("是否订阅用户直播"),
+        uid: koishi_1.Schema.string().required().description("订阅用户UID"),
+        dynamic: koishi_1.Schema.boolean().required().description("是否订阅用户动态"),
+        live: koishi_1.Schema.boolean().required().description("是否订阅用户直播"),
         target: koishi_1.Schema.array(koishi_1.Schema.object({
             channelIdArr: koishi_1.Schema.array(koishi_1.Schema.object({
-                channelId: koishi_1.Schema.string().description("频道/群组号"),
-                dynamic: koishi_1.Schema.boolean().description("该频道/群组是否推送动态信息"),
-                live: koishi_1.Schema.boolean().description("该频道/群组是否推送直播通知"),
-                liveGuardBuy: koishi_1.Schema.boolean().description("该频道/群组是否推送上舰消息"),
-                atAll: koishi_1.Schema.boolean().description("推送开播通知时是否艾特全体成员"),
-            })).description("需推送的频道/群组详细设置"),
-            platform: koishi_1.Schema.string().description("推送平台"),
+                channelId: koishi_1.Schema.string().required().description("频道/群组号"),
+                dynamic: koishi_1.Schema.boolean().required().description("该频道/群组是否推送动态信息"),
+                live: koishi_1.Schema.boolean().required().description("该频道/群组是否推送直播通知"),
+                liveGuardBuy: koishi_1.Schema.boolean().required().description("该频道/群组是否推送上舰消息"),
+                atAll: koishi_1.Schema.boolean().required().description("推送开播通知时是否艾特全体成员"),
+            })).required().description("需推送的频道/群组详细设置"),
+            platform: koishi_1.Schema.string().required().description("推送平台"),
         })).description("订阅用户需要发送的平台和频道/群组信息(一个平台下可以推送多个频道/群组)"),
     }))
         .role("table")
@@ -338,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("直播检测模式")
@@ -356,10 +356,10 @@ exports.Config = koishi_1.Schema.object({
         .default("-name开播啦，当前粉丝数为-follower -link")
         .description("自定义开播提示语，-name代表UP昵称，-follower代表当前粉丝数，-link代表直播间链接（如果使用的是QQ官方机器人，请不要使用）。例如-name开播啦，会发送为xxxUP开播啦"),
     customLive: koishi_1.Schema.string()
-        .default("-name正在直播，目前已播-time，直播间累计看过人数为-watched，-link")
+        .default("-name正在直播，目前已播-time。累计看过人数：-watched，-link")
         .description("自定义直播中提示语，-name代表UP昵称，-time代表开播时长，-watched代表累计看过人数，-link代表直播间链接（如果使用的是QQ官方机器人，请不要使用）。例如-name正在直播，会发送为xxxUP正在直播xxx"),
     customLiveEnd: koishi_1.Schema.string()
-        .default("-name下播啦，本次直播了-time，粉丝数的变化-follower_change")
+        .default("-name下播啦，本次直播了-time。粉丝数变化-follower_change")
         .description("自定义下播提示语，-name代表UP昵称，-follower_change代表本场直播粉丝数变，-time代表开播时长。例如-name下播啦，本次直播了-time，会发送为xxxUP下播啦，直播时长为xx小时xx分钟xx秒"),
     followerDisplay: koishi_1.Schema.boolean()
         .default(true)

package/package.json

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

package/readme.md

@@ -197,6 +197,8 @@
 - 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模式已被废弃； 优化：更多提示语数据显示优化
+- ver 3.0.0-alpha.19 修复：开播提示语粉丝数单位错误； 优化：订阅配置中所有配置项改为必填项
 
 ## 交流群
 
@@ -204,7 +206,9 @@
 
 ## 感谢
 
-感谢 [koishijs](https://github.com/koishijs/koishi) 官方提供的插件开发框架, 以及技术指导
+[koishijs](https://github.com/koishijs/koishi) 感谢官方提供的插件开发框架, 以及技术指导
+[blive-message-listener](https://github.com/ddiu8081/blive-message-listener) 感谢 `ddiu8081` 提供简单方便的B站直播监听依赖
+[bilibili-API-collect](https://github.com/SocialSisterYi/bilibili-API-collect) 感谢 `SocialSisterYi` 提供B站API参考
 
 ## License