@akokko/blive-message-listener
Version:
Bilibili-live danmu listener with type
827 lines (803 loc) • 26.6 kB
JavaScript
//#region rolldown:runtime
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
key = keys[i];
if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
get: ((k) => from[k]).bind(null, key),
enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
});
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
value: mod,
enumerable: true
}) : target, mod));
//#endregion
//#region src/parser/HEARTBEAT.ts
const parser$18 = (data) => {
return { attention: data };
};
const HEARTBEAT = {
parser: parser$18,
eventName: "heartbeat",
handlerName: "onAttentionChange"
};
//#endregion
//#region src/parser/LIVE.ts
const parser$17 = (data) => {
return {
live_platform: data.live_platform,
room_id: data.roomid
};
};
const LIVE = {
parser: parser$17,
eventName: "LIVE",
handlerName: "onLiveStart"
};
//#endregion
//#region src/parser/PREPARING.ts
const parser$16 = (data) => {
return { room_id: parseInt(data.roomid) };
};
const PREPARING = {
parser: parser$16,
eventName: "PREPARING",
handlerName: "onLiveEnd"
};
//#endregion
//#region src/parser/ANCHOR_LOT_AWARD.ts
const parser$15 = (data, roomId) => {
const rawData = data.data;
return {
id: rawData.id,
award: {
image: rawData.award_image,
name: rawData.award_name,
virtual: rawData.award_type === 1
},
winner: rawData.award_users.map((user) => ({
uid: user.uid,
uname: user.uname,
face: user.face,
level: user.level,
num: user.num
}))
};
};
const ANCHOR_LOT_AWARD = {
parser: parser$15,
eventName: "ANCHOR_LOT_AWARD",
handlerName: "onAnchorLotteryEnd"
};
//#endregion
//#region src/parser/ANCHOR_LOT_START.ts
const parser$14 = (data, roomId) => {
const rawData = data.data;
return {
id: rawData.id,
start_time: rawData.current_time,
duration: rawData.max_time,
award: {
image: rawData.award_image,
name: rawData.award_name,
num: rawData.award_num,
virtual: rawData.award_type === 1,
price_text: rawData.award_price_text || ""
},
require: {
danmu: rawData.danmu || "",
gift: rawData.gift_id ? {
id: `${rawData.gift_id}`,
name: rawData.gift_name,
num: rawData.gift_num,
price: rawData.gift_price
} : null,
user: rawData.require_type ? {
type: [
"follow",
"medal",
"guard"
][rawData.require_type - 1],
value: rawData.require_value,
text: rawData.require_text
} : null
}
};
};
const ANCHOR_LOT_START = {
parser: parser$14,
eventName: "ANCHOR_LOT_START",
handlerName: "onAnchorLotteryStart"
};
//#endregion
//#region src/utils/color.ts
const intToColorHex = (int) => {
const hex = int.toString(16);
return `#${hex.padStart(6, "0")}`;
};
//#endregion
//#region src/parser/DANMU_MSG.ts
const parser$13 = (data, roomId) => {
const rawData = data.info;
const content = rawData[1];
const shouldParseInMessageEmoticon = /\[.*?\]/.test(content);
let inMessageEmoticon;
if (shouldParseInMessageEmoticon) {
const messageExtraInfo = JSON.parse(rawData[0][15].extra);
const emoctionDict = {};
if (messageExtraInfo.emots) inMessageEmoticon = Object.keys(messageExtraInfo.emots).reduce((acc, key) => {
const emoticon = messageExtraInfo.emots[key];
acc[key] = {
id: emoticon.emoticon_unique,
emoticon_id: emoticon.emoticon_id,
height: emoticon.height,
width: emoticon.width,
url: emoticon.url,
description: emoticon.descript
};
return acc;
}, emoctionDict);
}
return {
user: {
uid: rawData[2][0],
uname: rawData[2][1],
badge: rawData[3].length ? {
active: rawData[3][7] !== 12632256,
name: rawData[3][1],
level: rawData[3][0],
color: intToColorHex(rawData[3][4]),
gradient: [
intToColorHex(rawData[3][7]),
intToColorHex(rawData[3][8]),
intToColorHex(rawData[3][9])
],
anchor: {
uid: rawData[3][12],
uname: rawData[3][2],
room_id: rawData[3][3],
is_same_room: rawData[3][3] === roomId
}
} : void 0,
identity: {
rank: rawData[4][4],
guard_level: rawData[7],
room_admin: rawData[2][2] === 1
}
},
content,
type: rawData[0][1],
content_color: intToColorHex(rawData[0][3]),
timestamp: rawData[0][4],
lottery: rawData[0][9] !== 0,
emoticon: rawData[0][13]?.emoticon_unique ? {
id: rawData[0][13].emoticon_unique,
height: rawData[0][13].height,
width: rawData[0][13].width,
url: rawData[0][13].url
} : void 0,
in_message_emoticon: inMessageEmoticon
};
};
const DANMU_MSG = {
parser: parser$13,
eventName: "DANMU_MSG",
handlerName: "onIncomeDanmu"
};
//#endregion
//#region src/parser/GUARD_BUY.ts
const parser$12 = (data) => {
const rawData = data.data;
return {
user: {
uid: rawData.uid,
uname: rawData.username
},
gift_id: rawData.gift_id,
gift_name: rawData.gift_name,
guard_level: rawData.guard_level,
price: rawData.price,
start_time: rawData.start_time,
end_time: rawData.end_time
};
};
const GUARD_BUY = {
parser: parser$12,
eventName: "GUARD_BUY",
handlerName: "onGuardBuy"
};
//#endregion
//#region src/parser/INTERACT_WORD_ENTRY_EFFECT.ts
const parserNormal = (data, roomId) => {
const rawData = data.data;
let actionType = "unknown";
if (rawData.msg_type === 1) actionType = "enter";
else if (rawData.msg_type === 2) actionType = "follow";
else if (rawData.msg_type === 3) actionType = "share";
return {
user: {
uid: rawData.uid,
uname: rawData.uname,
face: rawData?.face,
badge: rawData.fans_medal?.target_id ? {
active: !!rawData.fans_medal?.is_lighted,
name: rawData.fans_medal?.medal_name,
level: rawData.fans_medal?.medal_level,
color: intToColorHex(rawData.fans_medal?.medal_color),
gradient: [
intToColorHex(rawData.fans_medal?.medal_color_start),
intToColorHex(rawData.fans_medal?.medal_color_start),
intToColorHex(rawData.fans_medal?.medal_color_end)
],
anchor: {
uid: rawData.fans_medal?.target_id,
uname: "",
room_id: rawData.fans_medal?.anchor_roomid,
is_same_room: rawData.fans_medal?.anchor_roomid === roomId
}
} : void 0,
identity: {
rank: 0,
guard_level: rawData.privilege_type,
room_admin: false
}
},
action: actionType,
timestamp: Math.ceil(rawData.trigger_time / 1e6)
};
};
const parserGuard = (data, roomId) => {
const rawData = data.data;
const uname = /<%(.*)%>/.exec(rawData.copy_writing)?.[1] || "";
return {
user: {
uid: rawData.uid,
uname,
identity: {
rank: 0,
guard_level: rawData.privilege_type,
room_admin: false
}
},
action: "enter",
timestamp: Math.ceil(rawData.trigger_time / 1e6)
};
};
const parserLike = (data, roomId) => {
const rawData = data.data;
return {
user: {
uid: rawData.uid,
uname: rawData.uname,
badge: rawData.fans_medal?.target_id ? {
active: rawData.fans_medal?.is_lighted,
name: rawData.fans_medal?.medal_name,
level: rawData.fans_medal?.medal_level,
color: intToColorHex(rawData.fans_medal?.medal_color),
gradient: [
intToColorHex(rawData.fans_medal?.medal_color_start),
intToColorHex(rawData.fans_medal?.medal_color_start),
intToColorHex(rawData.fans_medal?.medal_color_end)
],
anchor: {
uid: rawData.fans_medal?.target_id,
uname: "",
room_id: rawData.fans_medal?.anchor_roomid,
is_same_room: rawData.fans_medal?.anchor_roomid === roomId
}
} : void 0
},
action: "like",
timestamp: Date.now()
};
};
const parser$11 = (data, roomId) => {
const msgType = data.cmd;
if (msgType === "ENTRY_EFFECT") return parserGuard(data, roomId);
if (msgType === "LIKE_INFO_V3_CLICK") return parserLike(data, roomId);
return parserNormal(data, roomId);
};
const INTERACT_WORD = {
parser: parser$11,
eventName: "INTERACT_WORD",
handlerName: "onUserAction"
};
const ENTRY_EFFECT = {
parser: parser$11,
eventName: "ENTRY_EFFECT",
handlerName: "onUserAction"
};
const LIKE_INFO_V3_CLICK = {
parser: parser$11,
eventName: "LIKE_INFO_V3_CLICK",
handlerName: "onUserAction"
};
//#endregion
//#region src/parser/LIKE_INFO_V3_UPDATE.ts
const parser$10 = (data) => {
const rawData = data.data;
return { count: rawData.click_count };
};
const LIKE_INFO_V3_UPDATE = {
parser: parser$10,
eventName: "LIKE_INFO_V3_UPDATE",
handlerName: "onLikedChange"
};
//#endregion
//#region src/parser/ONLINE_RANK_COUNT.ts
const parser$9 = (data) => {
const rawData = data.data;
return { count: rawData.count };
};
const ONLINE_RANK_COUNT = {
parser: parser$9,
eventName: "ONLINE_RANK_COUNT",
handlerName: "onRankCountChange"
};
//#endregion
//#region src/parser/POPULARITY_RED_POCKET_START.ts
const parser$8 = (data, roomId) => {
const rawData = data.data;
return {
id: rawData.lot_id,
user: {
uid: rawData.sender_uid,
uname: rawData.sender_name,
face: rawData.sender_face
},
start_time: rawData.start_time,
end_time: rawData.end_time,
duration: rawData.last_time,
danmu: rawData.danmu,
awards: rawData.awards,
total_price: rawData.total_price,
wait_num: rawData.wait_num
};
};
const POPULARITY_RED_POCKET_START = {
parser: parser$8,
eventName: "POPULARITY_RED_POCKET_START",
handlerName: "onRedPocketStart"
};
//#endregion
//#region src/parser/POPULARITY_RED_POCKET_WINNER_LIST.ts
const parser$7 = (data, roomId) => {
const rawData = data.data;
return {
id: rawData.lot_id,
total_num: rawData.total_num,
winner: rawData.winner_info.map((item) => ({
uid: item[0],
uname: item[1],
award_id: item[3],
...rawData.awards[item[3]]
})),
awards: rawData.awards
};
};
const POPULARITY_RED_POCKET_WINNER_LIST = {
parser: parser$7,
eventName: "POPULARITY_RED_POCKET_WINNER_LIST",
handlerName: "onRedPocketEnd"
};
//#endregion
//#region src/parser/ROOM_ADMIN.ts
const parser$6 = (data, roomId) => {
const msgType = data.cmd;
const rawData = data;
return {
type: msgType === "room_admin_entrance" ? "set" : "revoke",
uid: rawData.uid
};
};
const room_admin_entrance = {
parser: parser$6,
eventName: "room_admin_entrance",
handlerName: "onRoomAdminSet"
};
const ROOM_ADMIN_REVOKE = {
parser: parser$6,
eventName: "ROOM_ADMIN_REVOKE",
handlerName: "onRoomAdminSet"
};
//#endregion
//#region src/parser/ROOM_CHANGE.ts
const parser$5 = (data) => {
const rawData = data.data;
return {
title: rawData.title,
parent_area_id: rawData.parent_area_id,
parent_area_name: rawData.parent_area_name,
area_id: rawData.area_id,
area_name: rawData.area_name
};
};
const ROOM_CHANGE = {
parser: parser$5,
eventName: "ROOM_CHANGE",
handlerName: "onRoomInfoChange"
};
//#endregion
//#region src/parser/ROOM_SILENT.ts
const parser$4 = (data, roomId) => {
const msgType = data.cmd;
const rawData = data.data;
return {
type: msgType === "ROOM_SILENT_OFF" ? "off" : rawData.type,
level: rawData.level,
second: rawData.second
};
};
const ROOM_SILENT_ON = {
parser: parser$4,
eventName: "ROOM_SILENT_ON",
handlerName: "onRoomSilent"
};
const ROOM_SILENT_OFF = {
parser: parser$4,
eventName: "ROOM_SILENT_OFF",
handlerName: "onRoomSilent"
};
//#endregion
//#region src/parser/SEND_GIFT.ts
const parser$3 = (data) => {
const rawData = data.data;
return {
user: {
uid: rawData.uid,
uname: rawData.uname,
face: rawData.face,
badge: rawData.medal_info?.medal_level ? {
active: rawData.medal_info.is_lighted === 1,
name: rawData.medal_info.medal_name,
level: rawData.medal_info.medal_level,
color: intToColorHex(rawData.medal_info.medal_color),
gradient: [
intToColorHex(rawData.medal_info.medal_color_start),
intToColorHex(rawData.medal_info.medal_color_start),
intToColorHex(rawData.medal_info.medal_color_end)
],
anchor: {
uid: rawData.medal_info.target_id,
uname: rawData.medal_info.anchor_uname,
room_id: rawData.medal_info.anchor_roomid
}
} : void 0,
identity: {
rank: 0,
guard_level: rawData.guard_level,
room_admin: false
}
},
gift_id: rawData.giftId,
gift_name: rawData.giftName,
coin_type: rawData.coin_type,
price: rawData.price,
amount: rawData.num,
send_master: rawData.send_master?.uid ? {
uid: rawData.send_master.uid,
uname: rawData.send_master.uname,
room_id: rawData.send_master.room_id
} : void 0,
combo: rawData.batch_combo_id ? {
batch_id: rawData.batch_combo_id,
combo_num: rawData.super_batch_gift_num,
total_price: rawData.combo_total_coin
} : void 0
};
};
const SEND_GIFT = {
parser: parser$3,
eventName: "SEND_GIFT",
handlerName: "onGift"
};
//#endregion
//#region src/parser/SUPER_CHAT_MESSAGE.ts
const parser$2 = (data, roomId) => {
const rawData = data.data;
const { medal_info, user_info } = data.data;
return {
id: rawData.id,
user: {
uid: rawData.uid,
uname: rawData.user_info.uname,
badge: medal_info ? {
active: medal_info.is_lighted === 1,
name: medal_info.medal_name,
level: medal_info.medal_level,
color: medal_info.medal_color,
anchor: {
uid: medal_info.target_id,
uname: medal_info.anchor_uname,
room_id: medal_info.anchor_roomid,
is_same_room: medal_info.anchor_roomid === roomId
}
} : void 0,
identity: {
rank: 0,
guard_level: user_info.guard_level || 0,
room_admin: user_info.manager === 1
}
},
content: rawData.message,
content_color: rawData.background_price_color,
price: rawData.price,
time: rawData.time
};
};
const SUPER_CHAT_MESSAGE = {
parser: parser$2,
eventName: "SUPER_CHAT_MESSAGE",
handlerName: "onIncomeSuperChat"
};
//#endregion
//#region src/parser/WARNING_CUT_OFF.ts
const parser$1 = (data, roomId) => {
const msgType = data.cmd;
const rawData = data;
return {
type: msgType === "WARNING" ? "warning" : "cut",
msg: rawData.msg
};
};
const WARNING = {
parser: parser$1,
eventName: "WARNING",
handlerName: "onRoomWarn"
};
const CUT_OFF = {
parser: parser$1,
eventName: "CUT_OFF",
handlerName: "onRoomWarn"
};
//#endregion
//#region src/parser/WATCHED_CHANGE.ts
const parser = (data) => {
const rawData = data.data;
return {
num: rawData.num,
text_small: rawData.text_small
};
};
const WATCHED_CHANGE = {
parser,
eventName: "WATCHED_CHANGE",
handlerName: "onWatchedChange"
};
//#endregion
//#region src/utils/message.ts
const normalizeDanmu = (msgType, body, rawBody) => {
const timestamp = Date.now();
const randomText = Math.floor(Math.random() * 1e4).toString();
const id = `${timestamp}:${msgType}:${body.user?.uid}:${randomText}`;
return {
id,
timestamp,
type: msgType,
body,
raw: rawBody
};
};
//#endregion
//#region src/listener/index.ts
const listenAll = (instance, roomId, handler) => {
if (!handler) return;
const rawHandler = handler.raw || {};
const rawHandlerNames = new Set(Object.keys(rawHandler));
const isHandleRaw = rawHandlerNames.size > 0;
if (handler.onOpen) instance.on("open", () => {
handler.onOpen?.();
});
if (handler.onClose) instance.on("close", () => {
handler.onClose?.();
});
if (handler.onStartListen) instance.on("live", () => {
handler.onStartListen?.();
});
if (handler[HEARTBEAT.handlerName] || rawHandlerNames.has(HEARTBEAT.eventName)) {
rawHandlerNames.delete(HEARTBEAT.eventName);
instance.on(HEARTBEAT.eventName, (data) => {
isHandleRaw && rawHandler[HEARTBEAT.eventName]?.(data);
const parsedData = HEARTBEAT.parser(data);
handler[HEARTBEAT.handlerName]?.(normalizeDanmu(HEARTBEAT.eventName, parsedData, data));
});
}
if (handler[LIVE.handlerName] || rawHandlerNames.has(LIVE.eventName)) {
rawHandlerNames.delete(LIVE.eventName);
instance.on(LIVE.eventName, (data) => {
isHandleRaw && rawHandler[LIVE.eventName]?.(data.data);
const parsedData = LIVE.parser(data.data);
handler[LIVE.handlerName]?.(normalizeDanmu(LIVE.eventName, parsedData, data.data));
});
}
if (handler[PREPARING.handlerName] || rawHandlerNames.has(PREPARING.eventName)) {
rawHandlerNames.delete(LIVE.eventName);
instance.on(PREPARING.eventName, (data) => {
isHandleRaw && rawHandler[PREPARING.eventName]?.(data.data);
const parsedData = PREPARING.parser(data.data);
handler[PREPARING.handlerName]?.(normalizeDanmu(PREPARING.eventName, parsedData, data.data));
});
}
if (handler[ANCHOR_LOT_AWARD.handlerName] || rawHandlerNames.has(ANCHOR_LOT_AWARD.eventName)) {
rawHandlerNames.delete(ANCHOR_LOT_AWARD.eventName);
instance.on(ANCHOR_LOT_AWARD.eventName, (data) => {
isHandleRaw && rawHandler[ANCHOR_LOT_AWARD.eventName]?.(data.data);
const parsedData = ANCHOR_LOT_AWARD.parser(data.data, roomId);
handler[ANCHOR_LOT_AWARD.handlerName]?.(normalizeDanmu(ANCHOR_LOT_AWARD.eventName, parsedData, data.data));
});
}
if (handler[ANCHOR_LOT_START.handlerName] || rawHandlerNames.has(ANCHOR_LOT_START.eventName)) {
rawHandlerNames.delete(ANCHOR_LOT_START.eventName);
instance.on(ANCHOR_LOT_START.eventName, (data) => {
isHandleRaw && rawHandler[ANCHOR_LOT_START.eventName]?.(data.data);
const parsedData = ANCHOR_LOT_START.parser(data.data, roomId);
handler[ANCHOR_LOT_START.handlerName]?.(normalizeDanmu(ANCHOR_LOT_START.eventName, parsedData, data.data));
});
}
if (handler[DANMU_MSG.handlerName] || rawHandlerNames.has(DANMU_MSG.eventName)) {
rawHandlerNames.delete(DANMU_MSG.eventName);
instance.on(DANMU_MSG.eventName, (data) => {
isHandleRaw && rawHandler[DANMU_MSG.eventName]?.(data.data);
const parsedData = DANMU_MSG.parser(data.data, roomId);
handler[DANMU_MSG.handlerName]?.(normalizeDanmu(DANMU_MSG.eventName, parsedData, data.data));
});
}
if (handler[GUARD_BUY.handlerName] || rawHandlerNames.has(GUARD_BUY.eventName)) {
rawHandlerNames.delete(GUARD_BUY.eventName);
instance.on(GUARD_BUY.eventName, (data) => {
isHandleRaw && rawHandler[GUARD_BUY.eventName]?.(data.data);
const parsedData = GUARD_BUY.parser(data.data);
handler[GUARD_BUY.handlerName]?.(normalizeDanmu(GUARD_BUY.eventName, parsedData, data.data));
});
}
if (handler[INTERACT_WORD.handlerName] || handler[ENTRY_EFFECT.handlerName] || handler[LIKE_INFO_V3_CLICK.handlerName] || rawHandlerNames.has(INTERACT_WORD.eventName) || rawHandlerNames.has(ENTRY_EFFECT.eventName) || rawHandlerNames.has(LIKE_INFO_V3_CLICK.eventName)) {
rawHandlerNames.delete(INTERACT_WORD.eventName);
rawHandlerNames.delete(ENTRY_EFFECT.eventName);
rawHandlerNames.delete(LIKE_INFO_V3_CLICK.eventName);
instance.on(INTERACT_WORD.eventName, (data) => {
isHandleRaw && rawHandler[INTERACT_WORD.eventName]?.(data.data);
const parsedData = INTERACT_WORD.parser(data.data, roomId);
handler[INTERACT_WORD.handlerName]?.(normalizeDanmu(INTERACT_WORD.eventName, parsedData, data.data));
});
instance.on(ENTRY_EFFECT.eventName, (data) => {
isHandleRaw && rawHandler[ENTRY_EFFECT.eventName]?.(data.data);
const parsedData = ENTRY_EFFECT.parser(data.data, roomId);
handler[ENTRY_EFFECT.handlerName]?.(normalizeDanmu(ENTRY_EFFECT.eventName, parsedData, data.data));
});
instance.on(LIKE_INFO_V3_CLICK.eventName, (data) => {
isHandleRaw && rawHandler[LIKE_INFO_V3_CLICK.eventName]?.(data.data);
const parsedData = LIKE_INFO_V3_CLICK.parser(data.data, roomId);
handler[LIKE_INFO_V3_CLICK.handlerName]?.(normalizeDanmu(LIKE_INFO_V3_CLICK.eventName, parsedData, data.data));
});
}
if (handler[LIKE_INFO_V3_UPDATE.handlerName] || rawHandlerNames.has(LIKE_INFO_V3_UPDATE.eventName)) {
rawHandlerNames.delete(LIKE_INFO_V3_UPDATE.eventName);
instance.on(LIKE_INFO_V3_UPDATE.eventName, (data) => {
isHandleRaw && rawHandler[LIKE_INFO_V3_UPDATE.eventName]?.(data.data);
const parsedData = LIKE_INFO_V3_UPDATE.parser(data.data);
handler[LIKE_INFO_V3_UPDATE.handlerName]?.(normalizeDanmu(LIKE_INFO_V3_UPDATE.eventName, parsedData, data.data));
});
}
if (handler[ONLINE_RANK_COUNT.handlerName] || rawHandlerNames.has(ONLINE_RANK_COUNT.eventName)) {
rawHandlerNames.delete(ONLINE_RANK_COUNT.eventName);
instance.on(ONLINE_RANK_COUNT.eventName, (data) => {
isHandleRaw && rawHandler[ONLINE_RANK_COUNT.eventName]?.(data.data);
const parsedData = ONLINE_RANK_COUNT.parser(data.data);
handler[ONLINE_RANK_COUNT.handlerName]?.(normalizeDanmu(ONLINE_RANK_COUNT.eventName, parsedData, data.data));
});
}
if (handler[POPULARITY_RED_POCKET_START.handlerName] || rawHandlerNames.has(POPULARITY_RED_POCKET_START.eventName)) {
rawHandlerNames.delete(POPULARITY_RED_POCKET_START.eventName);
instance.on(POPULARITY_RED_POCKET_START.eventName, (data) => {
isHandleRaw && rawHandler[POPULARITY_RED_POCKET_START.eventName]?.(data.data);
const parsedData = POPULARITY_RED_POCKET_START.parser(data.data, roomId);
handler[POPULARITY_RED_POCKET_START.handlerName]?.(normalizeDanmu(POPULARITY_RED_POCKET_START.eventName, parsedData, data.data));
});
}
if (handler[POPULARITY_RED_POCKET_WINNER_LIST.handlerName] || rawHandlerNames.has(POPULARITY_RED_POCKET_WINNER_LIST.eventName)) {
rawHandlerNames.delete(POPULARITY_RED_POCKET_WINNER_LIST.eventName);
instance.on(POPULARITY_RED_POCKET_WINNER_LIST.eventName, (data) => {
isHandleRaw && rawHandler[POPULARITY_RED_POCKET_WINNER_LIST.eventName]?.(data.data);
const parsedData = POPULARITY_RED_POCKET_WINNER_LIST.parser(data.data, roomId);
handler[POPULARITY_RED_POCKET_WINNER_LIST.handlerName]?.(normalizeDanmu(POPULARITY_RED_POCKET_WINNER_LIST.eventName, parsedData, data.data));
});
}
if (handler[room_admin_entrance.handlerName] || handler[ROOM_ADMIN_REVOKE.handlerName] || rawHandlerNames.has(room_admin_entrance.eventName) || rawHandlerNames.has(ROOM_SILENT_OFF.eventName)) {
rawHandlerNames.delete(room_admin_entrance.eventName);
rawHandlerNames.delete(ROOM_ADMIN_REVOKE.eventName);
instance.on(room_admin_entrance.eventName, (data) => {
isHandleRaw && rawHandler[room_admin_entrance.eventName]?.(data.data);
const parsedData = room_admin_entrance.parser(data.data, roomId);
handler[room_admin_entrance.handlerName]?.(normalizeDanmu(room_admin_entrance.eventName, parsedData, data.data));
});
instance.on(ROOM_ADMIN_REVOKE.eventName, (data) => {
isHandleRaw && rawHandler[ROOM_ADMIN_REVOKE.eventName]?.(data.data);
const parsedData = ROOM_ADMIN_REVOKE.parser(data.data, roomId);
handler[ROOM_ADMIN_REVOKE.handlerName]?.(normalizeDanmu(ROOM_ADMIN_REVOKE.eventName, parsedData, data.data));
});
}
if (handler[ROOM_CHANGE.handlerName] || rawHandlerNames.has(ROOM_CHANGE.eventName)) {
rawHandlerNames.delete(ROOM_CHANGE.eventName);
instance.on(ROOM_CHANGE.eventName, (data) => {
isHandleRaw && rawHandler[ROOM_CHANGE.eventName]?.(data.data);
const parsedData = ROOM_CHANGE.parser(data.data);
handler[ROOM_CHANGE.handlerName]?.(normalizeDanmu(ROOM_CHANGE.eventName, parsedData, data.data));
});
}
if (handler[ROOM_SILENT_ON.handlerName] || handler[ROOM_SILENT_OFF.handlerName] || rawHandlerNames.has(ROOM_SILENT_ON.eventName) || rawHandlerNames.has(ROOM_SILENT_OFF.eventName)) {
rawHandlerNames.delete(ROOM_SILENT_ON.eventName);
rawHandlerNames.delete(ROOM_SILENT_OFF.eventName);
instance.on(ROOM_SILENT_ON.eventName, (data) => {
isHandleRaw && rawHandler[ROOM_SILENT_ON.eventName]?.(data.data);
const parsedData = ROOM_SILENT_ON.parser(data.data, roomId);
handler[ROOM_SILENT_ON.handlerName]?.(normalizeDanmu(ROOM_SILENT_ON.eventName, parsedData, data.data));
});
instance.on(ROOM_SILENT_OFF.eventName, (data) => {
isHandleRaw && rawHandler[ROOM_SILENT_OFF.eventName]?.(data.data);
const parsedData = ROOM_SILENT_OFF.parser(data.data, roomId);
handler[ROOM_SILENT_OFF.handlerName]?.(normalizeDanmu(ROOM_SILENT_OFF.eventName, parsedData, data.data));
});
}
if (handler[SEND_GIFT.handlerName] || rawHandlerNames.has(SEND_GIFT.eventName)) {
rawHandlerNames.delete(SEND_GIFT.eventName);
instance.on(SEND_GIFT.eventName, (data) => {
isHandleRaw && rawHandler[SEND_GIFT.eventName]?.(data.data);
const parsedData = SEND_GIFT.parser(data.data);
handler[SEND_GIFT.handlerName]?.(normalizeDanmu(SEND_GIFT.eventName, parsedData, data.data));
});
}
if (handler[SUPER_CHAT_MESSAGE.handlerName] || rawHandlerNames.has(SUPER_CHAT_MESSAGE.eventName)) {
rawHandlerNames.delete(SUPER_CHAT_MESSAGE.eventName);
instance.on(SUPER_CHAT_MESSAGE.eventName, (data) => {
isHandleRaw && rawHandler[SUPER_CHAT_MESSAGE.eventName]?.(data.data);
const parsedData = SUPER_CHAT_MESSAGE.parser(data.data, roomId);
handler[SUPER_CHAT_MESSAGE.handlerName]?.(normalizeDanmu(SUPER_CHAT_MESSAGE.eventName, parsedData, data.data));
});
}
if (handler[WARNING.handlerName] || handler[CUT_OFF.handlerName] || rawHandlerNames.has(WARNING.eventName) || rawHandlerNames.has(CUT_OFF.eventName)) {
rawHandlerNames.delete(WARNING.eventName);
rawHandlerNames.delete(CUT_OFF.eventName);
instance.on(WARNING.eventName, (data) => {
isHandleRaw && rawHandler[WARNING.eventName]?.(data.data);
const parsedData = WARNING.parser(data.data, roomId);
handler[WARNING.handlerName]?.(normalizeDanmu(WARNING.eventName, parsedData, data.data));
});
instance.on(CUT_OFF.eventName, (data) => {
isHandleRaw && rawHandler[CUT_OFF.eventName]?.(data.data);
const parsedData = CUT_OFF.parser(data.data, roomId);
handler[CUT_OFF.handlerName]?.(normalizeDanmu(CUT_OFF.eventName, parsedData, data.data));
});
}
if (handler[WATCHED_CHANGE.handlerName] || rawHandlerNames.has(WATCHED_CHANGE.eventName)) {
rawHandlerNames.delete(WATCHED_CHANGE.eventName);
instance.on(WATCHED_CHANGE.eventName, (data) => {
isHandleRaw && rawHandler[WATCHED_CHANGE.eventName]?.(data.data);
const parsedData = WATCHED_CHANGE.parser(data.data);
handler[WATCHED_CHANGE.handlerName]?.(normalizeDanmu(WATCHED_CHANGE.eventName, parsedData, data.data));
});
}
for (const eventName of rawHandlerNames) instance.on(eventName, (data) => {
rawHandler[eventName]?.(data.data);
});
};
//#endregion
Object.defineProperty(exports, '__toESM', {
enumerable: true,
get: function () {
return __toESM;
}
});
Object.defineProperty(exports, 'listenAll', {
enumerable: true,
get: function () {
return listenAll;
}
});