tuikit-atomicx-vue3 0.1.0

package/dist/states/BarrageListState/BarrageListState.js

@@ -0,0 +1,208 @@
+import { ref, shallowRef, watch, onUnmounted, triggerRef } from "vue";
+import { TUIStore, StoreName, TUIChatService } from "@tencentcloud/chat-uikit-engine";
+import { useScroll } from "../../hooks/useScroll.js";
+import { useRoomEngine } from "../../hooks/useRoomEngine.js";
+import TUIRoomEngine, { TUIRoomEvents } from "@tencentcloud/tuiroom-engine-js";
+import { useLiveState } from "../LiveState/index.js";
+import { LiveStatus } from "../../types/live.js";
+const roomEngine = useRoomEngine();
+const { localLiveStatus } = useLiveState();
+const messageGroupTipRef = ref(void 0);
+const messageListRef = ref(void 0);
+const hasMoreMessageRef = ref(void 0);
+const currentConversationIDRef = ref(void 0);
+const highlightMessageIDListRef = ref([]);
+const recalledMessageIDSetRef = shallowRef(/* @__PURE__ */ new Set());
+const messageListCursor = ref(0);
+const messageUpdateQueue = ref([]);
+const isProcessingQueue = ref(false);
+const messageGroupTipQueue = ref([]);
+const isProcessingMessageGroupTipQueue = ref(false);
+const MAX_MESSAGE_COUNT = 1e3;
+const MESSAGE_GROUP_TIP_AUTO_CLEAR_DELAY = 2e3;
+const MESSAGE_QUEUE_PROCESS_DELAY = 1e3;
+const BATCH_SIZE = 20;
+const MESSAGE_GROUP_TIP_QUEUE_MAX_LENGTH = 10;
+let enterRoomListener = null;
+let leaveRoomListener = null;
+const clearEventListeners = () => {
+  if (roomEngine.instance && enterRoomListener) {
+    roomEngine.instance.off(TUIRoomEvents.onRemoteUserEnterRoom, enterRoomListener);
+    enterRoomListener = null;
+  }
+  if (roomEngine.instance && leaveRoomListener) {
+    roomEngine.instance.off(TUIRoomEvents.onRemoteUserLeaveRoom, leaveRoomListener);
+    leaveRoomListener = null;
+  }
+};
+const truncateMessageList = (messages) => {
+  if (messages.length <= MAX_MESSAGE_COUNT) {
+    return messages;
+  }
+  const excessCount = messages.length - MAX_MESSAGE_COUNT;
+  const cleanedMessages = messages.slice(excessCount);
+  return cleanedMessages;
+};
+const processMessageQueue = async () => {
+  if (isProcessingQueue.value || messageUpdateQueue.value.length === 0) {
+    return;
+  }
+  isProcessingQueue.value = true;
+  try {
+    let currentBatch = [];
+    let lastUpdateTime = Date.now();
+    while (messageUpdateQueue.value.length > 0) {
+      const messages = messageUpdateQueue.value.splice(0, 1)[0];
+      currentBatch.push(...messages);
+      const newMessageList = [...messageListRef.value || [], ...currentBatch];
+      messageListRef.value = truncateMessageList(newMessageList);
+      currentBatch = [];
+      lastUpdateTime = Date.now();
+      if (messageUpdateQueue.value.length > 0) {
+        await new Promise((resolve) => setTimeout(resolve, MESSAGE_QUEUE_PROCESS_DELAY));
+      }
+    }
+  } finally {
+    isProcessingQueue.value = false;
+  }
+};
+const processedMessageListUpdate = (list) => {
+  const newList = list.slice(messageListCursor.value);
+  messageListCursor.value = list.length;
+  if (newList.length === 0) {
+    return;
+  }
+  for (let i = 0; i < newList.length; i += BATCH_SIZE) {
+    messageUpdateQueue.value.push(newList.slice(i, i + BATCH_SIZE));
+  }
+  processMessageQueue();
+};
+const processMessageGroupTipQueue = async () => {
+  if (isProcessingMessageGroupTipQueue.value || messageGroupTipQueue.value.length === 0) {
+    return;
+  }
+  isProcessingMessageGroupTipQueue.value = true;
+  try {
+    while (messageGroupTipQueue.value.length > 0) {
+      const tip = messageGroupTipQueue.value.splice(0, 1)[0];
+      messageGroupTipRef.value = tip;
+      await new Promise((resolve) => setTimeout(resolve, MESSAGE_GROUP_TIP_AUTO_CLEAR_DELAY));
+      messageGroupTipRef.value = void 0;
+    }
+  } catch (error) {
+    console.error("[BarrageListState] processMessageGroupTipQueue error", error);
+  } finally {
+    isProcessingMessageGroupTipQueue.value = false;
+  }
+};
+const processMessageGroupTipUpdate = (tip) => {
+  messageGroupTipQueue.value.push(tip);
+  if (messageGroupTipQueue.value.length > MESSAGE_GROUP_TIP_QUEUE_MAX_LENGTH) {
+    messageGroupTipQueue.value = messageGroupTipQueue.value.slice(-2);
+  }
+  processMessageGroupTipQueue();
+};
+const initWatchers = () => {
+  clearEventListeners();
+  TUIRoomEngine.once("ready", () => {
+    var _a, _b;
+    enterRoomListener = ({ userInfo }) => {
+      processMessageGroupTipUpdate({
+        avatarUrl: userInfo.avatarUrl,
+        nameCard: userInfo.nameCard,
+        roomCustomInfo: userInfo.roomCustomInfo,
+        userId: userInfo.userId,
+        userName: userInfo.userName,
+        userRole: userInfo.userRole,
+        displayAction: "enter"
+      });
+    };
+    leaveRoomListener = ({ userInfo }) => {
+      processMessageGroupTipUpdate({
+        avatarUrl: userInfo.avatarUrl,
+        nameCard: userInfo.nameCard,
+        roomCustomInfo: userInfo.roomCustomInfo,
+        userId: userInfo.userId,
+        userName: userInfo.userName,
+        userRole: userInfo.userRole,
+        displayAction: "leave"
+      });
+    };
+    if (enterRoomListener) {
+      (_a = roomEngine.instance) == null ? void 0 : _a.on(TUIRoomEvents.onRemoteUserEnterRoom, enterRoomListener);
+    }
+    if (leaveRoomListener) {
+      (_b = roomEngine.instance) == null ? void 0 : _b.on(TUIRoomEvents.onRemoteUserLeaveRoom, leaveRoomListener);
+    }
+  });
+  TUIStore.watch(StoreName.CHAT, {
+    messageList: (list) => {
+      if (!currentConversationIDRef.value) {
+        return;
+      }
+      const unDeletedList = list.filter((message) => {
+        if (message.isRevoked) {
+          recalledMessageIDSetRef.value.add(message.ID);
+        }
+        return !message.isDeleted;
+      });
+      triggerRef(recalledMessageIDSetRef);
+      processedMessageListUpdate(unDeletedList);
+    },
+    isCompleted: (value) => {
+      hasMoreMessageRef.value = !value;
+    }
+  });
+  TUIStore.watch(StoreName.CONV, {
+    currentConversationID: (conversationID) => {
+      if (!conversationID) {
+        messageListRef.value = void 0;
+        hasMoreMessageRef.value = void 0;
+        currentConversationIDRef.value = void 0;
+      } else {
+        currentConversationIDRef.value = conversationID;
+        messageListRef.value = void 0;
+        hasMoreMessageRef.value = void 0;
+      }
+    }
+  });
+};
+const resetState = () => {
+  messageListRef.value = void 0;
+  hasMoreMessageRef.value = void 0;
+  currentConversationIDRef.value = void 0;
+  messageListCursor.value = 0;
+  messageUpdateQueue.value = [];
+  isProcessingQueue.value = false;
+  messageGroupTipRef.value = void 0;
+  highlightMessageIDListRef.value = [];
+  recalledMessageIDSetRef.value.clear();
+  messageGroupTipQueue.value = [];
+  triggerRef(recalledMessageIDSetRef);
+};
+watch(localLiveStatus, (newVal, oldVal) => {
+  if (newVal !== LiveStatus.Live && oldVal === LiveStatus.Live) {
+    resetState();
+  }
+});
+onUnmounted(() => {
+  clearEventListeners();
+});
+initWatchers();
+function useBarrageListState() {
+  const { scrollToBottom, scrollToMessage } = useScroll();
+  return {
+    messageList: messageListRef,
+    messageGroupTip: messageGroupTipRef,
+    hasMoreMessage: hasMoreMessageRef,
+    highlightMessageIDList: highlightMessageIDListRef,
+    recalledMessageIDSet: recalledMessageIDSetRef,
+    currentConversationID: currentConversationIDRef,
+    loadMoreMessage: TUIChatService.getMessageList,
+    scrollToBottom,
+    scrollToMessage
+  };
+}
+export {
+  useBarrageListState
+};

package/dist/states/BarrageListState/index.d.ts

@@ -0,0 +1 @@
+export * from './BarrageListState';

package/dist/states/BarrageListState/index.js

@@ -0,0 +1,4 @@
+import { useBarrageListState } from "./BarrageListState.js";
+export {
+  useBarrageListState
+};

package/dist/states/CoGuestState.d.ts

@@ -0,0 +1,106 @@
+import { TUIMediaDevice, TUIRequestCallback } from '@tencentcloud/tuiroom-engine-js';
+import { CoGuestStatus, AudienceInfo, CoGuestRequestInfo, SeatUserInfo } from '../types';
+
+export declare function useCoGuestState(): {
+    localCoGuestStatus: import('vue').ComputedRef<CoGuestStatus>;
+    userListInCoGuest: import('vue').ComputedRef<SeatUserInfo[]>;
+    receivedCoGuestUserList: import('vue').ComputedRef<AudienceInfo[]>;
+    availableCoGuestUserList: import('vue').ComputedRef<AudienceInfo[]>;
+    sentCoGuestUserList: import('vue').ComputedRef<AudienceInfo[]>;
+    latestReceivedCoGuestRequest: import('vue').Ref<{
+        timestamp: number;
+        requestId: string;
+        userId: string;
+        userName: string;
+        nameCard: string;
+        avatarUrl: string;
+    } | null, CoGuestRequestInfo | {
+        timestamp: number;
+        requestId: string;
+        userId: string;
+        userName: string;
+        nameCard: string;
+        avatarUrl: string;
+    } | null>;
+    latestCancelledCoGuestRequest: import('vue').Ref<{
+        timestamp: number;
+        requestId: string;
+        userId: string;
+        userName: string;
+        nameCard: string;
+        avatarUrl: string;
+    } | null, CoGuestRequestInfo | {
+        timestamp: number;
+        requestId: string;
+        userId: string;
+        userName: string;
+        nameCard: string;
+        avatarUrl: string;
+    } | null>;
+    latestAcceptedCoGuestRequest: import('vue').Ref<{
+        timestamp: number;
+        requestId: string;
+        userId: string;
+        userName: string;
+        nameCard: string;
+        avatarUrl: string;
+    } | null, CoGuestRequestInfo | {
+        timestamp: number;
+        requestId: string;
+        userId: string;
+        userName: string;
+        nameCard: string;
+        avatarUrl: string;
+    } | null>;
+    latestRejectedCoGuestRequest: import('vue').Ref<{
+        timestamp: number;
+        requestId: string;
+        userId: string;
+        userName: string;
+        nameCard: string;
+        avatarUrl: string;
+    } | null, CoGuestRequestInfo | {
+        timestamp: number;
+        requestId: string;
+        userId: string;
+        userName: string;
+        nameCard: string;
+        avatarUrl: string;
+    } | null>;
+    sendCoGuestRequest: (options: {
+        seatIndex?: number;
+        timeout?: number;
+        userId?: string;
+        requestCallback?: (callbackInfo: TUIRequestCallback) => void;
+    }) => Promise<void>;
+    cancelCoGuestRequest: (options: {
+        userId?: string;
+    }) => Promise<void>;
+    acceptCoGuestRequest: (options: {
+        userId?: string;
+    }) => Promise<void>;
+    rejectCoGuestRequest: (options: {
+        userId?: string;
+    }) => Promise<void>;
+    disconnect: (userId?: string) => Promise<void>;
+    sendOpenDeviceRequest: (options: {
+        type: TUIMediaDevice;
+        timeout?: number;
+        userId: string;
+        requestCallback?: (callbackInfo: TUIRequestCallback) => void;
+    }) => Promise<void>;
+    cancelOpenDeviceRequest: (options: {
+        type: TUIMediaDevice;
+        userId: string;
+    }) => Promise<void>;
+    acceptOpenDeviceRequest: (options: {
+        type: TUIMediaDevice;
+    }) => Promise<void>;
+    rejectOpenDeviceRequest: (options: {
+        type: TUIMediaDevice;
+    }) => Promise<void>;
+    closeRemoteDevice: (options: {
+        type: TUIMediaDevice;
+        userId: string;
+    }) => Promise<void>;
+};

package/dist/states/CoGuestState.js

@@ -0,0 +1,329 @@
+import { ref, computed, watch } from "vue";
+import TUIRoomEngine, { TUIRoomEvents, TUIRequestAction, TUIMediaDevice } from "@tencentcloud/tuiroom-engine-js";
+import { useRoomEngine } from "../hooks/useRoomEngine.js";
+import { LiveStatus } from "../types/live.js";
+import { CoGuestStatus } from "../types/coGuest.js";
+import { useLiveAudienceState } from "./LiveAudienceState.js";
+import { useLiveState } from "./LiveState/index.js";
+import { useLoginState } from "./LoginState.js";
+import { useSeatStore } from "./SeatStore.js";
+const roomEngine = useRoomEngine();
+const { loginUserInfo } = useLoginState();
+const { audienceList } = useLiveAudienceState();
+const { localLiveStatus } = useLiveState();
+const {
+  sentDeviceRequestMap,
+  receivedDeviceRequestMap,
+  seatList,
+  liveOwnerUserId,
+  localUserId,
+  userInfoMap,
+  getUserInfo
+} = useSeatStore();
+const localUserInfo = ref(null);
+const sendCoRequestMap = ref(/* @__PURE__ */ new Map());
+const receivedCoRequestMap = ref(/* @__PURE__ */ new Map());
+const localCoGuestStatus = computed(() => {
+  var _a;
+  const isInCoGuest = seatList.value.some((seat) => {
+    var _a2, _b;
+    return ((_a2 = seat.userInfo) == null ? void 0 : _a2.userId) === ((_b = loginUserInfo.value) == null ? void 0 : _b.userId);
+  });
+  const isInSentCoGuest = sendCoRequestMap.value.has(((_a = loginUserInfo.value) == null ? void 0 : _a.userId) || "");
+  const isInReceivedCoGuest = receivedCoRequestMap.value.has(liveOwnerUserId.value);
+  if (isInCoGuest) {
+    return CoGuestStatus.Connected;
+  }
+  if (isInSentCoGuest) {
+    return CoGuestStatus.UserApplying;
+  }
+  if (isInReceivedCoGuest) {
+    return CoGuestStatus.AdminInviting;
+  }
+  return CoGuestStatus.Disconnected;
+});
+const receivedCoGuestUserList = computed(() => Array.from(receivedCoRequestMap.value.keys()).map((userId) => {
+  const userInfo = userInfoMap.value.get(userId);
+  if (!userInfo) {
+    console.error("[CoGuestState receivedCoGuestUserList] userInfo not found", userId);
+  }
+  return userInfo;
+}));
+const sentCoGuestUserList = computed(() => Array.from(sendCoRequestMap.value.keys()).filter((requestKey) => !requestKey.startsWith("owner-")).map((userId) => {
+  const userInfo = userInfoMap.value.get(userId);
+  if (!userInfo) {
+    console.error("[CoGuestState sentCoGuestUserList] userInfo not found", userId);
+  }
+  return userInfo;
+}));
+const userListInCoGuest = computed(() => seatList.value.filter((seat) => !!seat.userInfo).map((seat) => seat.userInfo));
+const availableCoGuestUserList = computed(() => audienceList.value.filter((audience) => {
+  var _a;
+  const isLocalUser = audience.userId === ((_a = loginUserInfo.value) == null ? void 0 : _a.userId);
+  const isInSeat = seatList.value.some((seat) => {
+    var _a2;
+    return ((_a2 = seat.userInfo) == null ? void 0 : _a2.userId) === audience.userId;
+  });
+  const isInActiveRequest = sendCoRequestMap.value.has(audience.userId);
+  const isInPassiveRequest = receivedCoRequestMap.value.has(audience.userId);
+  return !isLocalUser && !isInSeat && !isInActiveRequest && !isInPassiveRequest;
+}));
+const latestReceivedCoGuestRequest = ref(null);
+const latestCancelledCoGuestRequest = ref(null);
+const latestAcceptedCoGuestRequest = ref(null);
+const latestRejectedCoGuestRequest = ref(null);
+const sendCoGuestRequest = async (options) => {
+  var _a, _b;
+  const { seatIndex = -1, timeout = 30, userId = "", requestCallback } = options;
+  if (!userId) {
+    const request2 = await ((_a = roomEngine.instance) == null ? void 0 : _a.takeSeat({
+      seatIndex,
+      timeout,
+      requestCallback: (callbackInfo) => {
+        sendCoRequestMap.value.delete(localUserId.value);
+        requestCallback == null ? void 0 : requestCallback(callbackInfo);
+      }
+    }));
+    if (request2) {
+      sendCoRequestMap.value.set(localUserId.value, request2);
+    }
+    return;
+  }
+  const request = await ((_b = roomEngine.instance) == null ? void 0 : _b.takeUserOnSeatByAdmin({
+    seatIndex,
+    timeout,
+    userId,
+    requestCallback: (callbackInfo) => {
+      sendCoRequestMap.value.delete(userId);
+      requestCallback == null ? void 0 : requestCallback(callbackInfo);
+    }
+  }));
+  if (request) {
+    const userInfo = await getUserInfo(userId);
+    sendCoRequestMap.value.set(userId, request);
+    userInfoMap.value.set(userId, userInfo);
+  }
+};
+const cancelCoGuestRequest = async (options) => {
+  var _a, _b;
+  const { userId = ((_a = loginUserInfo.value) == null ? void 0 : _a.userId) || "" } = options;
+  const request = sendCoRequestMap.value.get(userId);
+  if (request) {
+    await ((_b = roomEngine.instance) == null ? void 0 : _b.cancelRequest({
+      requestId: request.requestId
+    }));
+    sendCoRequestMap.value.delete(userId);
+  }
+};
+const acceptCoGuestRequest = async (options) => {
+  var _a;
+  const { userId = liveOwnerUserId.value } = options;
+  const request = receivedCoRequestMap.value.get(userId);
+  if (request) {
+    await ((_a = roomEngine.instance) == null ? void 0 : _a.responseRemoteRequest({
+      requestId: request.requestId,
+      agree: true
+    }));
+    receivedCoRequestMap.value.delete(userId);
+  }
+};
+const rejectCoGuestRequest = async (options) => {
+  var _a;
+  const { userId = liveOwnerUserId.value } = options;
+  const request = receivedCoRequestMap.value.get(userId);
+  if (request) {
+    await ((_a = roomEngine.instance) == null ? void 0 : _a.responseRemoteRequest({
+      requestId: request.requestId,
+      agree: false
+    }));
+    receivedCoRequestMap.value.delete(userId);
+  }
+};
+const disconnect = async (userId) => {
+  var _a, _b, _c, _d;
+  if (!userId) {
+    return (_a = roomEngine.instance) == null ? void 0 : _a.leaveSeat();
+  }
+  const seatIndex = ((_c = (_b = seatList.value) == null ? void 0 : _b.find((seat) => {
+    var _a2;
+    return ((_a2 = seat.userInfo) == null ? void 0 : _a2.userId) === userId;
+  })) == null ? void 0 : _c.index) || -1;
+  if (seatIndex === -1) {
+    console.error("[CoGuestState disconnect] seatIndex not found", userId);
+    return;
+  }
+  return (_d = roomEngine.instance) == null ? void 0 : _d.kickUserOffSeatByAdmin({
+    userId,
+    seatIndex
+  });
+};
+const sendOpenDeviceRequest = async (options) => {
+  var _a;
+  const { type, timeout = 30, userId, requestCallback } = options;
+  const request = await ((_a = roomEngine.instance) == null ? void 0 : _a.openRemoteDeviceByAdmin({
+    device: type,
+    timeout,
+    userId,
+    requestCallback: (callbackInfo) => {
+      sentDeviceRequestMap.value.delete(`${userId}-${type}`);
+      requestCallback == null ? void 0 : requestCallback(callbackInfo);
+    }
+  }));
+  if (request) {
+    sentDeviceRequestMap.value.set(`${userId}-${type}`, request);
+  }
+};
+const cancelOpenDeviceRequest = async (options) => {
+  var _a;
+  const { type, userId } = options;
+  const request = sentDeviceRequestMap.value.get(`${userId}-${type}`);
+  if (request) {
+    await ((_a = roomEngine.instance) == null ? void 0 : _a.cancelRequest({
+      requestId: request.requestId
+    }));
+    sentDeviceRequestMap.value.delete(`${userId}-${type}`);
+  }
+};
+const acceptOpenDeviceRequest = async (options) => {
+  var _a;
+  const { type } = options;
+  const request = receivedDeviceRequestMap.value.get(`${liveOwnerUserId.value}-${type}`);
+  if (request) {
+    await ((_a = roomEngine.instance) == null ? void 0 : _a.responseRemoteRequest({
+      requestId: request.requestId,
+      agree: true
+    }));
+    receivedDeviceRequestMap.value.delete(`${liveOwnerUserId.value}-${type}`);
+  }
+};
+const rejectOpenDeviceRequest = async (options) => {
+  var _a;
+  const { type } = options;
+  const request = receivedDeviceRequestMap.value.get(`${liveOwnerUserId.value}-${type}`);
+  if (request) {
+    await ((_a = roomEngine.instance) == null ? void 0 : _a.responseRemoteRequest({
+      requestId: request.requestId,
+      agree: false
+    }));
+    receivedDeviceRequestMap.value.delete(`${liveOwnerUserId.value}-${type}`);
+  }
+};
+const closeRemoteDevice = async (options) => {
+  var _a, _b;
+  const { type, userId } = options;
+  const seat = (_a = seatList.value) == null ? void 0 : _a.find((seat2) => {
+    var _a2;
+    return ((_a2 = seat2.userInfo) == null ? void 0 : _a2.userId) === userId;
+  });
+  if (!seat) {
+    return;
+  }
+  await ((_b = roomEngine.instance) == null ? void 0 : _b.lockSeatByAdmin({
+    seatIndex: seat.index,
+    lockParams: {
+      lockSeat: seat.isLocked,
+      lockVideo: type === TUIMediaDevice.kCamera || seat.isVideoLocked,
+      lockAudio: type === TUIMediaDevice.kMicrophone || seat.isAudioLocked
+    }
+  }));
+};
+const onRequestReceived = async ({ request }) => {
+  const { userId, requestAction } = request;
+  userInfoMap.value.set(userId, await getUserInfo(userId));
+  switch (requestAction) {
+    case TUIRequestAction.kRequestToTakeSeat:
+      receivedCoRequestMap.value.set(userId, request);
+      break;
+    case TUIRequestAction.kRequestRemoteUserOnSeat:
+      receivedCoRequestMap.value.set(liveOwnerUserId.value, request);
+      break;
+  }
+};
+const onRequestProcessed = ({
+  userId,
+  request
+}) => {
+  const { requestAction } = request;
+  switch (requestAction) {
+    case TUIRequestAction.kRequestToTakeSeat:
+      receivedCoRequestMap.value.delete(userId);
+      break;
+    case TUIRequestAction.kRequestRemoteUserOnSeat:
+      receivedCoRequestMap.value.delete(liveOwnerUserId.value);
+      break;
+  }
+};
+const onRequestCancelled = ({
+  userId,
+  request
+}) => {
+  const { requestAction } = request;
+  switch (requestAction) {
+    case TUIRequestAction.kRequestToTakeSeat:
+      receivedCoRequestMap.value.delete(userId);
+      break;
+    case TUIRequestAction.kRequestRemoteUserOnSeat:
+      receivedCoRequestMap.value.delete(liveOwnerUserId.value);
+      break;
+  }
+};
+const roomEvents = [
+  { event: TUIRoomEvents.onRequestReceived, handler: onRequestReceived },
+  { event: TUIRoomEvents.onRequestProcessed, handler: onRequestProcessed },
+  { event: TUIRoomEvents.onRequestCancelled, handler: onRequestCancelled }
+];
+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 (newStatus) => {
+    var _a;
+    if (newStatus === LiveStatus.Live) {
+      if ((_a = loginUserInfo.value) == null ? void 0 : _a.userId) {
+        localUserInfo.value = await getUserInfo(loginUserInfo.value.userId);
+        userInfoMap.value.set(loginUserInfo.value.userId, localUserInfo.value);
+      }
+    } else {
+      sendCoRequestMap.value.clear();
+      receivedCoRequestMap.value.clear();
+      userInfoMap.value.clear();
+      localUserInfo.value = null;
+    }
+  },
+  { immediate: true }
+);
+function useCoGuestState() {
+  return {
+    // state
+    localCoGuestStatus,
+    userListInCoGuest,
+    receivedCoGuestUserList,
+    availableCoGuestUserList,
+    sentCoGuestUserList,
+    latestReceivedCoGuestRequest,
+    latestCancelledCoGuestRequest,
+    latestAcceptedCoGuestRequest,
+    latestRejectedCoGuestRequest,
+    // action
+    sendCoGuestRequest,
+    cancelCoGuestRequest,
+    acceptCoGuestRequest,
+    rejectCoGuestRequest,
+    disconnect,
+    sendOpenDeviceRequest,
+    cancelOpenDeviceRequest,
+    acceptOpenDeviceRequest,
+    rejectOpenDeviceRequest,
+    closeRemoteDevice
+  };
+}
+export {
+  useCoGuestState
+};

package/dist/states/CoHostState.d.ts

@@ -0,0 +1,22 @@
+import { SeatUserInfo } from '../types';
+import { TUILiveConnectionUser } from '@tencentcloud/tuiroom-engine-js';
+import { CoHostStatus } from '../types/coHost';
+
+export declare function useCoHostState(): {
+    localCoHostStatus: import('vue').ComputedRef<CoHostStatus>;
+    userListInCoHost: import('vue').ComputedRef<SeatUserInfo[]>;
+    receivedCoHostRequestList: import('vue').ComputedRef<TUILiveConnectionUser[]>;
+    sendCoHostUserList: import('vue').ComputedRef<SeatUserInfo[]>;
+    availableCoHostUserList: import('vue').ComputedRef<SeatUserInfo[]>;
+    sendCoHostRequest: (options: {
+        userList: Array<SeatUserInfo>;
+        timeout: number;
+        extensionInfo: string;
+    }) => Promise<void>;
+    cancelCoHostRequest: (options: {
+        userList: Array<SeatUserInfo>;
+    }) => Promise<void>;
+    acceptCoHostRequest: (user: TUILiveConnectionUser) => Promise<void>;
+    rejectCoHostRequest: (user: TUILiveConnectionUser) => Promise<void>;
+    exitCoHost: () => Promise<void | undefined>;
+};