tuikit-atomicx-vue3 0.1.0

package/dist/states/DeviceState.js

@@ -0,0 +1,438 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { ref } from "vue";
+import { DeviceStatus, DeviceError, AudioOutput } from "../types/device.js";
+import { TUIRoomEvents, TUIVideoStreamType } from "../types/types.js";
+import TUIRoomEngine, { TUIChangeReason, TUIVideoQuality, TUIRoomDeviceMangerEvents, TUIMediaDeviceType, TUIMediaDeviceState, TRTCVideoFillMode, TRTCVideoRotation, TRTCVideoMirrorType, TUIAudioRoute } from "@tencentcloud/tuiroom-engine-js";
+import { useRoomEngine, useDeviceManager } from "../hooks/useRoomEngine.js";
+import { useLoginState } from "./LoginState.js";
+const roomEngine = useRoomEngine();
+const deviceManager = useDeviceManager();
+const { loginUserInfo } = useLoginState();
+const microphoneStatus = ref(DeviceStatus.Off);
+const microphoneStatusReason = ref(TUIChangeReason.kChangedBySelf);
+const microphoneList = ref([]);
+const currentMicrophone = ref(null);
+const microphoneLastError = ref(DeviceError.NoError);
+const isMicrophoneTesting = ref(false);
+const audioVolume = ref(0);
+const captureVolume = ref(100);
+const outputVolume = ref(100);
+const testAudioVolume = ref(0);
+const cameraStatus = ref(DeviceStatus.Off);
+const cameraStatusReason = ref(TUIChangeReason.kChangedBySelf);
+const cameraList = ref([]);
+const currentCamera = ref(null);
+const cameraLastError = ref(DeviceError.NoError);
+const isCameraTesting = ref(false);
+const isCameraTestLoading = ref(false);
+const isFrontCamera = ref(true);
+const isLocalMirror = ref(true);
+const localVideoQuality = ref(TUIVideoQuality.kVideoQuality_720p);
+TUIRoomEngine.once("ready", () => {
+  var _a;
+  (_a = roomEngine.instance) == null ? void 0 : _a.updateVideoQuality({ quality: TUIVideoQuality.kVideoQuality_720p });
+});
+const speakerList = ref([]);
+const currentSpeaker = ref(null);
+const currentAudioOutput = ref(AudioOutput.Speaker);
+const isSpeakerTesting = ref(false);
+const screenStatus = ref(DeviceStatus.Off);
+const screenStatusReason = ref(void 0);
+const openLocalMicrophone = async () => {
+  var _a;
+  try {
+    await ((_a = roomEngine.instance) == null ? void 0 : _a.openLocalMicrophone());
+    microphoneStatus.value = DeviceStatus.On;
+  } catch (error) {
+    if (error.code === 0 && error.message === "you have already mute the audio") {
+      return;
+    }
+    throw error;
+  }
+};
+const closeLocalMicrophone = async () => {
+  var _a;
+  await ((_a = roomEngine.instance) == null ? void 0 : _a.closeLocalMicrophone());
+  microphoneStatus.value = DeviceStatus.Off;
+};
+const muteLocalAudio = async () => {
+  var _a;
+  await ((_a = roomEngine.instance) == null ? void 0 : _a.muteLocalAudio());
+};
+const unmuteLocalAudio = async () => {
+  var _a;
+  await ((_a = roomEngine.instance) == null ? void 0 : _a.unmuteLocalAudio());
+};
+const getMicrophoneList = async () => {
+  var _a, _b;
+  try {
+    microphoneList.value = await ((_a = deviceManager.instance) == null ? void 0 : _a.getDevicesList({
+      type: TUIMediaDeviceType.kMediaDeviceTypeAudioInput
+    })) || [];
+    currentMicrophone.value = await ((_b = deviceManager.instance) == null ? void 0 : _b.getCurrentDevice({
+      type: TUIMediaDeviceType.kMediaDeviceTypeAudioInput
+    })) || null;
+  } catch (error) {
+    console.error("Failed to get microphone list:", error);
+    microphoneLastError.value = DeviceError.NoSystemPermission;
+    throw error;
+  }
+};
+const setCurrentMicrophone = async (options) => {
+  var _a;
+  await ((_a = deviceManager.instance) == null ? void 0 : _a.setCurrentDevice({
+    type: TUIMediaDeviceType.kMediaDeviceTypeAudioInput,
+    deviceId: options.deviceId
+  }));
+  const device = microphoneList.value.find((item) => item.deviceId === options.deviceId);
+  if (device) {
+    currentMicrophone.value = device;
+  }
+};
+const startMicrophoneTest = async (options) => {
+  var _a, _b;
+  await ((_a = roomEngine.instance) == null ? void 0 : _a.startMicDeviceTest({ interval: options.interval || 200 }));
+  isMicrophoneTesting.value = true;
+  (_b = deviceManager.instance) == null ? void 0 : _b.on(TUIRoomDeviceMangerEvents.onTestMicVolume, onTestMicVolume);
+};
+const setCaptureVolume = async (volume) => {
+  var _a;
+  const trtcCloud = (_a = roomEngine.instance) == null ? void 0 : _a.getTRTCCloud();
+  await (trtcCloud == null ? void 0 : trtcCloud.setAudioCaptureVolume(volume));
+  captureVolume.value = volume;
+};
+const setOutputVolume = async (volume) => {
+  var _a;
+  const trtcCloud = (_a = roomEngine.instance) == null ? void 0 : _a.getTRTCCloud();
+  await (trtcCloud == null ? void 0 : trtcCloud.setAudioPlayoutVolume(volume));
+  outputVolume.value = volume;
+};
+const onTestMicVolume = (options) => {
+  testAudioVolume.value = options.volume;
+};
+const stopMicrophoneTest = async () => {
+  var _a, _b;
+  await ((_a = roomEngine.instance) == null ? void 0 : _a.stopMicDeviceTest());
+  isMicrophoneTesting.value = false;
+  (_b = deviceManager.instance) == null ? void 0 : _b.off(TUIRoomDeviceMangerEvents.onTestMicVolume, onTestMicVolume);
+};
+class Speaker {
+  constructor() {
+    __publicField(this, "speakerTestPlayer", null);
+  }
+  async startSpeakerDeviceTest(options) {
+    var _a, _b, _c;
+    const isElectron = /electron/i.test(window.navigator.userAgent);
+    if (isElectron) {
+      (_a = deviceManager.instance) == null ? void 0 : _a.startSpeakerDeviceTest(options);
+      return;
+    }
+    this.speakerTestPlayer = document == null ? void 0 : document.createElement("audio");
+    if (this.speakerTestPlayer && typeof this.speakerTestPlayer.loop !== "undefined") {
+      this.speakerTestPlayer.loop = true;
+    }
+    await ((_c = this.speakerTestPlayer) == null ? void 0 : _c.setSinkId(((_b = currentSpeaker.value) == null ? void 0 : _b.deviceId) || ""));
+    this.speakerTestPlayer.src = options.filePath;
+    this.speakerTestPlayer.play();
+    isSpeakerTesting.value = true;
+  }
+  async stopSpeakerDeviceTest() {
+    var _a;
+    const isElectron = /electron/i.test(window.navigator.userAgent);
+    if (isElectron) {
+      (_a = deviceManager.instance) == null ? void 0 : _a.stopSpeakerDeviceTest();
+      return;
+    }
+    if (this.speakerTestPlayer) {
+      this.speakerTestPlayer.pause();
+      this.speakerTestPlayer.currentTime = 0;
+    }
+    isSpeakerTesting.value = false;
+  }
+}
+const speakerInstance = new Speaker();
+const getSpeakerList = async () => {
+  var _a, _b;
+  try {
+    speakerList.value = await ((_a = deviceManager.instance) == null ? void 0 : _a.getDevicesList({
+      type: TUIMediaDeviceType.kMediaDeviceTypeAudioOutput
+    })) || [];
+    currentSpeaker.value = await ((_b = deviceManager.instance) == null ? void 0 : _b.getCurrentDevice({
+      type: TUIMediaDeviceType.kMediaDeviceTypeAudioOutput
+    })) || null;
+  } catch (error) {
+    console.error("Failed to get speaker list:", error);
+    throw error;
+  }
+};
+const setCurrentSpeaker = async (options) => {
+  var _a;
+  await ((_a = deviceManager.instance) == null ? void 0 : _a.setCurrentDevice({
+    type: TUIMediaDeviceType.kMediaDeviceTypeAudioOutput,
+    deviceId: options.deviceId
+  }));
+  const device = speakerList.value.find((item) => item.deviceId === options.deviceId);
+  if (device) {
+    currentSpeaker.value = device;
+  }
+};
+const setAudioOutput = async (output) => {
+  var _a;
+  await ((_a = deviceManager.instance) == null ? void 0 : _a.setAudioRoute({
+    route: output === AudioOutput.Speaker ? TUIAudioRoute.kAudioRouteSpeakerphone : TUIAudioRoute.kAudioRouteEarpiece
+  }));
+  currentAudioOutput.value = output;
+};
+const startSpeakerTest = async (options) => {
+  await speakerInstance.startSpeakerDeviceTest({ filePath: options.filePath });
+};
+const stopSpeakerTest = async () => {
+  await speakerInstance.stopSpeakerDeviceTest();
+};
+const openLocalCamera = async () => {
+  var _a, _b;
+  const isMobile = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
+  if (isMobile) {
+    await ((_a = roomEngine.instance) == null ? void 0 : _a.openLocalCamera({
+      isFrontCamera: isFrontCamera.value
+    }));
+  } else {
+    await ((_b = roomEngine.instance) == null ? void 0 : _b.openLocalCamera());
+  }
+  cameraStatus.value = DeviceStatus.On;
+};
+const closeLocalCamera = async () => {
+  var _a;
+  await ((_a = roomEngine.instance) == null ? void 0 : _a.closeLocalCamera());
+  cameraStatus.value = DeviceStatus.Off;
+};
+const getCameraList = async () => {
+  var _a, _b;
+  try {
+    cameraList.value = await ((_a = deviceManager.instance) == null ? void 0 : _a.getDevicesList({
+      type: TUIMediaDeviceType.kMediaDeviceTypeVideoCamera
+    })) || [];
+    currentCamera.value = await ((_b = deviceManager.instance) == null ? void 0 : _b.getCurrentDevice({
+      type: TUIMediaDeviceType.kMediaDeviceTypeVideoCamera
+    })) || null;
+  } catch (error) {
+    console.error("Failed to get camera list:", error);
+    cameraLastError.value = DeviceError.NoSystemPermission;
+    throw error;
+  }
+};
+const setCurrentCamera = async (options) => {
+  var _a;
+  await ((_a = deviceManager.instance) == null ? void 0 : _a.setCurrentDevice({
+    type: TUIMediaDeviceType.kMediaDeviceTypeVideoCamera,
+    deviceId: options.deviceId
+  }));
+  const device = cameraList.value.find((item) => item.deviceId === options.deviceId);
+  if (device) {
+    currentCamera.value = device;
+  }
+};
+const switchCamera = async (options) => {
+  var _a;
+  await ((_a = deviceManager.instance) == null ? void 0 : _a.switchCamera(options));
+  isFrontCamera.value = options.isFrontCamera;
+};
+const switchMirror = async (options) => {
+  var _a;
+  const trtcCloud = (_a = roomEngine.instance) == null ? void 0 : _a.getTRTCCloud();
+  trtcCloud == null ? void 0 : trtcCloud.setLocalRenderParams({
+    mirrorType: options.mirror ? TRTCVideoMirrorType.TRTCVideoMirrorType_Enable : TRTCVideoMirrorType.TRTCVideoMirrorType_Disable,
+    rotation: TRTCVideoRotation.TRTCVideoRotation0,
+    fillMode: TRTCVideoFillMode.TRTCVideoFillMode_Fill
+  });
+  isLocalMirror.value = options.mirror;
+};
+const updateVideoQuality = async (options) => {
+  var _a;
+  await ((_a = roomEngine.instance) == null ? void 0 : _a.updateVideoQuality(options));
+  localVideoQuality.value = options.quality;
+};
+const startCameraDeviceTest = async (options) => {
+  var _a;
+  isCameraTestLoading.value = true;
+  try {
+    await ((_a = deviceManager.instance) == null ? void 0 : _a.startCameraDeviceTest(options));
+    isCameraTestLoading.value = false;
+    isCameraTesting.value = true;
+  } catch (error) {
+    isCameraTestLoading.value = false;
+    throw error;
+  }
+};
+const startScreenShare = async (options) => {
+  var _a;
+  await ((_a = roomEngine.instance) == null ? void 0 : _a.startScreenSharing({ screenAudio: options == null ? void 0 : options.screenAudio, view: options == null ? void 0 : options.view }));
+};
+const stopScreenShare = async () => {
+  var _a;
+  await ((_a = roomEngine.instance) == null ? void 0 : _a.stopScreenSharing());
+};
+const stopCameraDeviceTest = async () => {
+  var _a;
+  isCameraTestLoading.value = false;
+  await ((_a = deviceManager.instance) == null ? void 0 : _a.stopCameraDeviceTest());
+  isCameraTesting.value = false;
+};
+function screenCaptureStopped() {
+  screenStatus.value = DeviceStatus.Off;
+  screenStatusReason.value = TUIChangeReason.kChangedBySelf;
+}
+async function onDeviceChanged(eventInfo) {
+  var _a, _b, _c, _d, _e, _f;
+  const { deviceId, type, state } = eventInfo;
+  if (!deviceManager.instance) {
+    return;
+  }
+  ({
+    [TUIMediaDeviceType.kMediaDeviceTypeAudioInput]: "mic",
+    [TUIMediaDeviceType.kMediaDeviceTypeAudioOutput]: "speaker",
+    [TUIMediaDeviceType.kMediaDeviceTypeVideoCamera]: "camera",
+    [TUIMediaDeviceType.kMediaDeviceTypeUnknown]: "unknown"
+  });
+  ({
+    [TUIMediaDeviceState.kMediaDeviceStateAdd]: "add",
+    [TUIMediaDeviceState.kMediaDeviceStateRemove]: "remove",
+    [TUIMediaDeviceState.kMediaDeviceStateActive]: "active"
+  });
+  if (type === TUIMediaDeviceType.kMediaDeviceTypeAudioInput) {
+    microphoneList.value = await ((_a = deviceManager.instance) == null ? void 0 : _a.getDevicesList({
+      type
+    })) || [];
+    if (state === TUIMediaDeviceState.kMediaDeviceStateActive) {
+      currentMicrophone.value = ((_b = deviceManager.instance) == null ? void 0 : _b.getCurrentDevice({
+        type: TUIMediaDeviceType.kMediaDeviceTypeAudioInput
+      })) || null;
+    }
+  }
+  if (type === TUIMediaDeviceType.kMediaDeviceTypeAudioOutput) {
+    speakerList.value = await ((_c = deviceManager.instance) == null ? void 0 : _c.getDevicesList({
+      type
+    })) || [];
+    if (state === TUIMediaDeviceState.kMediaDeviceStateActive) {
+      currentSpeaker.value = ((_d = deviceManager.instance) == null ? void 0 : _d.getCurrentDevice({
+        type: TUIMediaDeviceType.kMediaDeviceTypeAudioOutput
+      })) || null;
+    }
+  }
+  if (type === TUIMediaDeviceType.kMediaDeviceTypeVideoCamera) {
+    cameraList.value = await ((_e = deviceManager.instance) == null ? void 0 : _e.getDevicesList({ type })) || [];
+    if (state === TUIMediaDeviceState.kMediaDeviceStateActive) {
+      currentCamera.value = ((_f = deviceManager.instance) == null ? void 0 : _f.getCurrentDevice({
+        type: TUIMediaDeviceType.kMediaDeviceTypeVideoCamera
+      })) || null;
+    }
+  }
+}
+function onUserVoiceVolumeChanged(eventInfo) {
+  const { userVolumeList } = eventInfo;
+  const localVolume = userVolumeList.find((item) => {
+    var _a;
+    return item.userId === ((_a = loginUserInfo.value) == null ? void 0 : _a.userId);
+  });
+  audioVolume.value = (localVolume == null ? void 0 : localVolume.volume) || 0;
+}
+function onUserAudioStateChanged(eventInfo) {
+  var _a;
+  const { userId, hasAudio, reason } = eventInfo;
+  if (userId === ((_a = loginUserInfo.value) == null ? void 0 : _a.userId)) {
+    microphoneStatus.value = hasAudio ? DeviceStatus.On : DeviceStatus.Off;
+    microphoneStatusReason.value = reason;
+  }
+}
+function onUserVideoStateChanged(eventInfo) {
+  var _a;
+  const { userId, streamType, hasVideo, reason } = eventInfo;
+  if (userId === ((_a = loginUserInfo.value) == null ? void 0 : _a.userId)) {
+    if (streamType === TUIVideoStreamType.kCameraStream) {
+      cameraStatus.value = hasVideo ? DeviceStatus.On : DeviceStatus.Off;
+      cameraStatusReason.value = reason;
+    } else if (streamType === TUIVideoStreamType.kScreenStream) {
+      screenStatus.value = hasVideo ? DeviceStatus.On : DeviceStatus.Off;
+      screenStatusReason.value = reason;
+    }
+  }
+}
+TUIRoomEngine.once("ready", () => {
+  var _a, _b, _c, _d, _e, _f;
+  (_a = deviceManager.instance) == null ? void 0 : _a.on(TUIRoomDeviceMangerEvents.onDeviceChanged, onDeviceChanged);
+  const trtcCloud = (_b = roomEngine.instance) == null ? void 0 : _b.getTRTCCloud();
+  trtcCloud == null ? void 0 : trtcCloud.enableAudioVolumeEvaluation(200);
+  (_c = roomEngine.instance) == null ? void 0 : _c.on(TUIRoomEvents.onUserVoiceVolumeChanged, onUserVoiceVolumeChanged);
+  (_d = roomEngine.instance) == null ? void 0 : _d.on(TUIRoomEvents.onUserScreenCaptureStopped, screenCaptureStopped);
+  (_e = roomEngine.instance) == null ? void 0 : _e.on(TUIRoomEvents.onUserAudioStateChanged, onUserAudioStateChanged);
+  (_f = roomEngine.instance) == null ? void 0 : _f.on(TUIRoomEvents.onUserVideoStateChanged, onUserVideoStateChanged);
+});
+function useDeviceState() {
+  return {
+    // 麦克风数据
+    microphoneStatus,
+    microphoneList,
+    currentMicrophone,
+    microphoneLastError,
+    isMicrophoneTesting,
+    audioVolume,
+    captureVolume,
+    outputVolume,
+    testAudioVolume,
+    // 摄像头数据
+    cameraStatus,
+    cameraList,
+    currentCamera,
+    cameraLastError,
+    isCameraTesting,
+    isCameraTestLoading,
+    isFrontCamera,
+    isLocalMirror,
+    localVideoQuality,
+    // 扬声器数据
+    speakerList,
+    currentSpeaker,
+    currentAudioOutput,
+    isSpeakerTesting,
+    // 屏幕分享数据
+    screenStatus,
+    screenStatusReason,
+    // 麦克风操作
+    openLocalMicrophone,
+    closeLocalMicrophone,
+    muteLocalAudio,
+    unmuteLocalAudio,
+    getMicrophoneList,
+    setCurrentMicrophone,
+    startMicrophoneTest,
+    stopMicrophoneTest,
+    setCaptureVolume,
+    // 扬声器操作
+    getSpeakerList,
+    setCurrentSpeaker,
+    setAudioOutput,
+    startSpeakerTest,
+    stopSpeakerTest,
+    setOutputVolume,
+    // 摄像头操作
+    openLocalCamera,
+    closeLocalCamera,
+    getCameraList,
+    setCurrentCamera,
+    switchCamera,
+    switchMirror,
+    updateVideoQuality,
+    startCameraDeviceTest,
+    stopCameraDeviceTest,
+    // 屏幕分享
+    startScreenShare,
+    stopScreenShare
+  };
+}
+export {
+  useDeviceState as default,
+  onDeviceChanged,
+  useDeviceState
+};

package/dist/states/LiveAudienceState.d.ts

@@ -0,0 +1,20 @@
+import { AudienceInfo } from '../types';
+
+export declare function useLiveAudienceState(): {
+    audienceList: import('vue').ComputedRef<AudienceInfo[]>;
+    audienceCount: import('vue').ComputedRef<number>;
+    fetchAudienceList: () => Promise<AudienceInfo[]>;
+    setAdministrator: ({ userId }: {
+        userId: string;
+    }) => Promise<void | undefined>;
+    revokeAdministrator: ({ userId }: {
+        userId: string;
+    }) => Promise<void | undefined>;
+    kickUserOutOfRoom: ({ userId }: {
+        userId: string;
+    }) => Promise<void | undefined>;
+    disableSendMessage: ({ userId, isDisable }: {
+        userId: string;
+        isDisable: boolean;
+    }) => Promise<void | undefined>;
+};

package/dist/states/LiveAudienceState.js

@@ -0,0 +1,156 @@
+import { ref, computed, watch } from "vue";
+import TUIRoomEngine, { TUIRole } from "@tencentcloud/tuiroom-engine-js";
+import { useRoomEngine } from "../hooks/useRoomEngine.js";
+import { TUIRoomEvents } from "../types/types.js";
+import { LiveStatus } from "../types/live.js";
+import { useLiveState } from "./LiveState/index.js";
+const roomEngine = useRoomEngine();
+const { localLiveStatus, currentLive } = useLiveState();
+const MAX_AUDIENCE_COUNT = 200;
+const audienceMap = ref(/* @__PURE__ */ new Map());
+const roomUserCount = ref(0);
+const clearState = () => {
+  audienceMap.value.clear();
+};
+const audienceList = computed(
+  () => Array.from(audienceMap.value.values()).filter((user) => {
+    var _a;
+    return user.userId !== ((_a = currentLive.value) == null ? void 0 : _a.liveOwner.userId);
+  })
+);
+const audienceCount = computed(() => roomUserCount.value > MAX_AUDIENCE_COUNT ? roomUserCount.value : audienceList.value.length);
+const fetchAudienceList = async () => {
+  var _a;
+  const { nextSequence, userInfoList } = await ((_a = roomEngine.instance) == null ? void 0 : _a.getUserList({ nextSequence: 0 })) || {
+    nextSequence: 0,
+    userInfoList: []
+  };
+  audienceMap.value.clear();
+  userInfoList.filter((user) => {
+    var _a2;
+    return user.userId !== ((_a2 = currentLive.value) == null ? void 0 : _a2.liveOwner.userId);
+  }).reverse().forEach((user) => {
+    audienceMap.value.set(user.userId, {
+      userId: user.userId,
+      userName: user.userName,
+      avatarUrl: user.avatarUrl,
+      customInfo: user.roomCustomInfo,
+      userRole: user.userRole,
+      isMessageDisabled: user.isMessageDisabled
+    });
+  });
+  return audienceList.value;
+};
+const setAdministrator = async ({ userId }) => {
+  var _a;
+  return (_a = roomEngine.instance) == null ? void 0 : _a.changeUserRole({
+    userId,
+    userRole: TUIRole.kAdministrator
+  });
+};
+const revokeAdministrator = async ({ userId }) => {
+  var _a;
+  return (_a = roomEngine.instance) == null ? void 0 : _a.changeUserRole({
+    userId,
+    userRole: TUIRole.kGeneralUser
+  });
+};
+const kickUserOutOfRoom = async ({ userId }) => {
+  var _a;
+  return (_a = roomEngine.instance) == null ? void 0 : _a.kickRemoteUserOutOfRoom({ userId });
+};
+const disableSendMessage = async ({ userId, isDisable }) => {
+  var _a;
+  return (_a = roomEngine.instance) == null ? void 0 : _a.disableSendingMessageByAdmin({
+    userId,
+    isDisable
+  });
+};
+const onRemoteUserEnterRoom = async ({ userInfo }) => {
+  if (audienceList.value.length >= MAX_AUDIENCE_COUNT) {
+    return;
+  }
+  audienceMap.value.set(userInfo.userId, {
+    userId: userInfo.userId,
+    userName: userInfo.userName,
+    avatarUrl: userInfo.avatarUrl,
+    customInfo: userInfo.roomCustomInfo,
+    userRole: userInfo.userRole,
+    isMessageDisabled: userInfo.isMessageDisabled
+  });
+};
+const onRemoteUserLeaveRoom = async ({ userInfo }) => {
+  audienceMap.value.delete(userInfo.userId);
+};
+const onUserInfoChanged = async ({ userInfo }) => {
+  const audienceInfo = audienceMap.value.get(userInfo.userId);
+  if (!audienceInfo) {
+    return;
+  }
+  audienceMap.value.set(userInfo.userId, {
+    ...audienceInfo,
+    userId: userInfo.userId,
+    userName: userInfo.userName,
+    avatarUrl: userInfo.avatarUrl,
+    customInfo: userInfo.roomCustomInfo,
+    userRole: userInfo.userRole,
+    isMessageDisabled: userInfo.isMessageDisabled
+  });
+};
+const onSendMessageForUserDisableChanged = ({ userId, isDisable }) => {
+  const audienceInfo = audienceMap.value.get(userId);
+  if (!audienceInfo) {
+    console.error(`audienceInfo not found for userId: ${userId}`);
+    return;
+  }
+  audienceMap.value.set(userId, {
+    ...audienceInfo,
+    isMessageDisabled: isDisable
+  });
+};
+const onRoomUserCountChanged = async ({ userCount }) => {
+  roomUserCount.value = userCount;
+};
+const onKickedOutOfRoom = async () => {
+  clearState();
+};
+const roomEvents = [
+  { event: TUIRoomEvents.onRemoteUserEnterRoom, handler: onRemoteUserEnterRoom },
+  { event: TUIRoomEvents.onRemoteUserLeaveRoom, handler: onRemoteUserLeaveRoom },
+  { event: TUIRoomEvents.onUserInfoChanged, handler: onUserInfoChanged },
+  { event: TUIRoomEvents.onKickedOutOfRoom, handler: onKickedOutOfRoom },
+  { event: TUIRoomEvents.onSendMessageForUserDisableChanged, handler: onSendMessageForUserDisableChanged },
+  { event: TUIRoomEvents.onRoomUserCountChanged, handler: onRoomUserCountChanged }
+];
+const bindEvent = () => {
+  roomEvents.forEach(({ event, handler }) => {
+    var _a;
+    (_a = roomEngine.instance) == null ? void 0 : _a.on(event, handler);
+  });
+};
+TUIRoomEngine.once("ready", () => {
+  bindEvent();
+});
+watch(localLiveStatus, async () => {
+  if (localLiveStatus.value === LiveStatus.Live) {
+    await fetchAudienceList();
+  } else {
+    clearState();
+  }
+});
+function useLiveAudienceState() {
+  return {
+    // state
+    audienceList,
+    audienceCount,
+    // action
+    fetchAudienceList,
+    setAdministrator,
+    revokeAdministrator,
+    kickUserOutOfRoom,
+    disableSendMessage
+  };
+}
+export {
+  useLiveAudienceState
+};

package/dist/states/LiveMonitorState/api/http.d.ts

@@ -0,0 +1,13 @@
+import { Response } from '../types';
+
+declare const fetchLiveList: (baseUrl: string, data: {
+    next: string;
+    count: number;
+}) => Promise<Response>;
+declare const destroyRoom: (baseUrl: string, data: {
+    roomId: string;
+}) => Promise<Response>;
+declare const getRoomInfo: (baseUrl: string, data: {
+    roomId: string;
+}) => Promise<Response>;
+export { fetchLiveList, destroyRoom, getRoomInfo };