@tencentcloud/roomkit-electron-vue3 2.3.3

package/es/stores/room.mjs

@@ -0,0 +1,651 @@
+import { defineStore } from "pinia";
+import { TUIRole, TUIVideoStreamType, TUIVideoQuality, TUISeatMode, TUIMediaDeviceType } from "@tencentcloud/tuiroom-engine-electron";
+import { useBasicStore } from "./basic.mjs";
+import { set, del } from "../utils/vue.mjs";
+import useGetRoomEngine from "../hooks/useRoomEngine.mjs";
+import { isMobile } from "../utils/environment.mjs";
+const roomEngine = useGetRoomEngine();
+const useRoomStore = defineStore("room", {
+  state: () => ({
+    localUser: {
+      userId: "",
+      userName: "",
+      avatarUrl: "",
+      hasAudioStream: false,
+      hasVideoStream: false,
+      hasScreenStream: false,
+      userRole: TUIRole.kGeneralUser,
+      onSeat: false,
+      cameraStreamInfo: {
+        userId: "",
+        userName: "",
+        avatarUrl: "",
+        hasAudioStream: false,
+        hasVideoStream: false,
+        streamType: TUIVideoStreamType.kCameraStream,
+        isVisible: true
+      },
+      screenStreamInfo: {
+        userId: "",
+        userName: "",
+        avatarUrl: "",
+        hasScreenStream: false,
+        streamType: TUIVideoStreamType.kScreenStream,
+        isVisible: true
+      }
+    },
+    remoteUserObj: {},
+    userVolumeObj: {},
+    isDefaultOpenCamera: false,
+    isDefaultOpenMicrophone: false,
+    canControlSelfAudio: true,
+    canControlSelfVideo: true,
+    localVideoQuality: isMobile ? TUIVideoQuality.kVideoQuality_360p : TUIVideoQuality.kVideoQuality_720p,
+    currentCameraId: "",
+    currentMicrophoneId: "",
+    currentSpeakerId: "",
+    cameraList: [],
+    microphoneList: [],
+    speakerList: [],
+    masterUserId: "",
+    isMicrophoneDisableForAllUser: false,
+    isCameraDisableForAllUser: false,
+    isMessageDisableForAllUser: false,
+    isSeatEnabled: false,
+    seatMode: TUISeatMode.kFreeToTake,
+    maxMembersCount: 5,
+    // Includes local streams and screen shares, above which subsequent streams are played
+    hasVideoStreamObject: {},
+    // Visual area user flow list
+    currentStreamIdListInVisibleView: [],
+    hasOtherScreenShare: false,
+    isOnStateTabActive: true
+  }),
+  getters: {
+    isMaster(state) {
+      return state.localUser.userId === state.masterUserId;
+    },
+    isAdmin(state) {
+      return state.localUser.userRole === TUIRole.kAdministrator;
+    },
+    isGeneralUser(state) {
+      return state.localUser.userRole === TUIRole.kGeneralUser;
+    },
+    // Whether the current user is on the stage
+    isAnchor(state) {
+      if (this.isFreeSpeakMode) {
+        return true;
+      }
+      if (this.isSpeakAfterTakingSeatMode) {
+        return state.localUser.onSeat;
+      }
+    },
+    // Whether the current user is under the stage
+    isAudience(state) {
+      if (this.isFreeSpeakMode) {
+        return false;
+      }
+      if (this.isSpeakAfterTakingSeatMode) {
+        return !state.localUser.onSeat;
+      }
+    },
+    isSpeakAfterTakingSeatMode() {
+      return this.isSeatEnabled && this.seatMode === TUISeatMode.kApplyToTake;
+    },
+    isFreeSpeakMode() {
+      return !this.isSeatEnabled;
+    },
+    isLocalAudioIconDisable() {
+      const micForbidden = this.isGeneralUser && !this.canControlSelfAudio;
+      return micForbidden || this.isAudience;
+    },
+    isLocalVideoIconDisable() {
+      const cameraForbidden = this.isGeneralUser && !this.canControlSelfVideo;
+      return cameraForbidden || this.isAudience;
+    },
+    localStream: (state) => {
+      const { userId, userName, avatarUrl, hasAudioStream, hasVideoStream } = state.localUser;
+      Object.assign(
+        state.localUser.cameraStreamInfo,
+        { userId, userName, avatarUrl, hasAudioStream, hasVideoStream }
+      );
+      return state.localUser.cameraStreamInfo;
+    },
+    localScreenStream: (state) => {
+      const { userId, userName, avatarUrl, hasScreenStream } = state.localUser;
+      Object.assign(
+        state.localUser.screenStreamInfo,
+        { userId, userName, avatarUrl, hasScreenStream }
+      );
+      return state.localUser.screenStreamInfo;
+    },
+    remoteStreamObj: (state) => {
+      const obj = {};
+      [...Object.values(state.remoteUserObj)].forEach((userInfo) => {
+        const {
+          userId,
+          avatarUrl,
+          userName,
+          onSeat,
+          hasAudioStream,
+          hasVideoStream,
+          hasScreenStream,
+          isVideoVisible,
+          isScreenVisible
+        } = userInfo;
+        if (onSeat) {
+          obj[`${userId}_${TUIVideoStreamType.kCameraStream}`] = Object.assign(userInfo.cameraStreamInfo, { userId, avatarUrl, userName, hasAudioStream, hasVideoStream, streamType: TUIVideoStreamType.kCameraStream, isVisible: isVideoVisible });
+        }
+        if (hasScreenStream) {
+          obj[`${userId}_${TUIVideoStreamType.kScreenStream}`] = Object.assign(userInfo.screenStreamInfo, { userId, avatarUrl, userName, hasScreenStream, streamType: TUIVideoStreamType.kScreenStream, isVisible: isScreenVisible });
+        }
+      });
+      return obj;
+    },
+    remoteStreamList() {
+      return [...Object.values(this.remoteStreamObj)];
+    },
+    streamList() {
+      const list = [this.localStream, ...Object.values(this.remoteStreamObj)];
+      if (this.localUser.hasScreenStream) {
+        list.unshift(this.localScreenStream);
+      }
+      return list;
+    },
+    streamNumber() {
+      return this.streamList.length;
+    },
+    remoteUserList: (state) => [...Object.values(state.remoteUserObj)],
+    remoteAnchorList: (state) => [...Object.values(state.remoteUserObj)].filter((item) => item.onSeat),
+    userList: (state) => [state.localUser, ...Object.values(state.remoteUserObj)],
+    userNumber() {
+      return this.userList.length;
+    },
+    anchorUserList: (state) => [state.localUser, ...Object.values(state.remoteUserObj)].filter((item) => item.onSeat),
+    applyToAnchorList: (state) => [...Object.values(state.remoteUserObj)].filter((item) => item.isUserApplyingToAnchor).sort((item1, item2) => ((item1 == null ? void 0 : item1.applyToAnchorTimestamp) || 0) - ((item2 == null ? void 0 : item2.applyToAnchorTimestamp) || 0)) || [],
+    defaultStreamType() {
+      return Object.keys(this.hasVideoStreamObject).length > this.maxMembersCount ? TUIVideoStreamType.kCameraStreamLow : TUIVideoStreamType.kCameraStream;
+    }
+  },
+  actions: {
+    setLocalUser(obj) {
+      Object.assign(this.localUser, obj);
+    },
+    updateLocalStream(obj) {
+      Object.assign(this.localStream, obj);
+    },
+    getUserName(userId) {
+      var _a;
+      if (userId === this.localUser.userId) {
+        return this.localUser.userName || userId;
+      }
+      return ((_a = this.remoteUserObj[userId]) == null ? void 0 : _a.userName) || userId;
+    },
+    getUserRole(userId) {
+      var _a;
+      if (userId === this.localUser.userId) {
+        return this.localUser.userRole;
+      }
+      return (_a = this.remoteUserObj[userId]) == null ? void 0 : _a.userRole;
+    },
+    getNewUserInfo(userId) {
+      const newUserInfo = {
+        userId,
+        userName: "",
+        avatarUrl: "",
+        hasAudioStream: false,
+        hasVideoStream: false,
+        hasScreenStream: false,
+        isVideoVisible: false,
+        isScreenVisible: false,
+        userRole: TUIRole.kGeneralUser,
+        onSeat: !this.isSpeakAfterTakingSeatMode,
+        isChatMutedByMasterOrAdmin: false,
+        isUserApplyingToAnchor: false,
+        isInvitingUserToAnchor: false,
+        cameraStreamInfo: {
+          userId,
+          userName: "",
+          avatarUrl: "",
+          hasAudioStream: false,
+          hasVideoStream: false,
+          streamType: TUIVideoStreamType.kCameraStream,
+          isVisible: false
+        },
+        screenStreamInfo: {
+          userId,
+          userName: "",
+          avatarUrl: "",
+          hasScreenStream: false,
+          streamType: TUIVideoStreamType.kScreenStream,
+          isVisible: false
+        }
+      };
+      return newUserInfo;
+    },
+    updateUserList(userList) {
+      userList.forEach((user) => {
+        if (user.userId === this.localUser.userId) {
+          Object.assign(this.localUser, user);
+          return;
+        }
+        if (this.remoteUserObj[user.userId]) {
+          Object.assign(this.remoteUserObj[user.userId], user);
+        } else {
+          const newUserInfo = Object.assign(this.getNewUserInfo(user.userId), user);
+          set(this.remoteUserObj, user.userId, newUserInfo);
+        }
+      });
+    },
+    // Remote user enters the room (IM event)
+    addRemoteUser(userInfo) {
+      const { userId } = userInfo;
+      const basicStore = useBasicStore();
+      if (!userId || userId === basicStore.userId) {
+        return;
+      }
+      if (this.remoteUserObj[userId]) {
+        Object.assign(this.remoteUserObj[userId], userInfo);
+      } else {
+        const newUserInfo = Object.assign(this.getNewUserInfo(userId), userInfo);
+        set(this.remoteUserObj, userId, newUserInfo);
+      }
+    },
+    updateRemoteUser(userId, newUserInfo) {
+      const remoteUser = this.remoteUserObj[userId];
+      if (!remoteUser) {
+        return;
+      }
+      const { nick, avatar } = newUserInfo;
+      Object.assign(remoteUser, { userName: nick, avatarUrl: avatar });
+    },
+    setSeatList(seatList) {
+      seatList.forEach((seat) => {
+        const { userId } = seat;
+        if (!userId)
+          return;
+        if (userId === this.localUser.userId) {
+          Object.assign(this.localUser, { onSeat: true });
+        } else {
+          const user = this.remoteUserObj[userId];
+          if (user) {
+            Object.assign(user, { onSeat: true });
+          } else {
+            const newUserInfo = Object.assign(this.getNewUserInfo(userId), { onSeat: true });
+            set(this.remoteUserObj, userId, newUserInfo);
+          }
+        }
+      });
+    },
+    // Updating changes to seatList
+    // The onSeatListChanged, onUserVideoAvailable, onUserAudioAvailable events are notified as soon as the room is entered, so they are updated to the userMap first.
+    // Wait for getUserList to get the full list of users before updating it.
+    updateOnSeatList(seatedList, leftList) {
+      seatedList.forEach((seat) => {
+        const { userId } = seat;
+        if (userId === this.localUser.userId) {
+          Object.assign(this.localUser, { onSeat: true });
+        } else {
+          const user = this.remoteUserObj[userId];
+          if (user) {
+            Object.assign(user, { onSeat: true });
+          } else {
+            const newUserInfo = Object.assign(this.getNewUserInfo(userId), { onSeat: true });
+            set(this.remoteUserObj, userId, newUserInfo);
+          }
+        }
+      });
+      leftList.forEach((seat) => {
+        if (seat.userId === this.localUser.userId) {
+          Object.assign(this.localUser, { onSeat: false });
+          const basicStore = useBasicStore();
+          basicStore.setIsOpenMic(false);
+        } else {
+          const user = this.remoteUserObj[seat.userId];
+          user && Object.assign(user, { onSeat: false });
+        }
+      });
+    },
+    updateUserVideoState(userId, streamType, hasVideo) {
+      const basicStore = useBasicStore();
+      let user = userId === basicStore.userId ? this.localUser : this.remoteUserObj[userId];
+      if (!user && hasVideo) {
+        user = this.getNewUserInfo(userId);
+        set(this.remoteUserObj, userId, user);
+      }
+      if (user) {
+        this.updatehasVideoStreamObject(user, hasVideo, userId === basicStore.userId);
+        if (streamType === TUIVideoStreamType.kCameraStream || streamType === TUIVideoStreamType.kCameraStreamLow) {
+          user.hasVideoStream = hasVideo;
+        } else if (streamType === TUIVideoStreamType.kScreenStream) {
+          user.hasScreenStream = hasVideo;
+        }
+      }
+    },
+    updatehasVideoStreamObject(userInfo, hasVideo, isSelf) {
+      if (isSelf)
+        return;
+      const { userId, cameraStreamInfo, screenStreamInfo, hasVideoStream } = userInfo;
+      const streamId = `${userId}_${hasVideoStream ? cameraStreamInfo.streamType : screenStreamInfo.streamType}`;
+      if (hasVideo) {
+        set(this.hasVideoStreamObject, streamId, userInfo);
+      } else {
+        del(this.hasVideoStreamObject, streamId);
+      }
+    },
+    updateUserAudioState(userId, hasAudio) {
+      const basicStore = useBasicStore();
+      let user = userId === basicStore.userId ? this.localUser : this.remoteUserObj[userId];
+      if (!user && hasAudio) {
+        user = this.getNewUserInfo(userId);
+        set(this.remoteUserObj, userId, user);
+      }
+      if (user) {
+        user.hasAudioStream = hasAudio;
+      }
+    },
+    removeRemoteUser(userId) {
+      const basicStore = useBasicStore();
+      if (!userId || userId === basicStore.userId) {
+        return;
+      }
+      del(this.remoteUserObj, userId);
+    },
+    updateUserStreamVisible(streamIdList) {
+      streamIdList.forEach((item) => {
+        const userId = item.slice(0, item.length - 2);
+        const streamType = Number(item.slice(-1));
+        if (userId === this.localUser.userId) {
+          return;
+        }
+        const user = this.remoteUserObj[userId];
+        if (!user) {
+          return;
+        }
+        if (streamType === TUIVideoStreamType.kCameraStream || streamType === TUIVideoStreamType.kCameraStreamLow) {
+          user.isVideoVisible = true;
+        } else if (streamType === TUIVideoStreamType.kScreenStream) {
+          user.isScreenVisible = true;
+        }
+      });
+      this.currentStreamIdListInVisibleView.forEach((item) => {
+        const userId = item.slice(0, item.length - 2);
+        const streamType = Number(item.slice(-1));
+        if (streamIdList.indexOf(item) < 0) {
+          const user = this.remoteUserObj[userId];
+          if (!user) {
+            return;
+          }
+          if (streamType === TUIVideoStreamType.kCameraStream || streamType === TUIVideoStreamType.kCameraStreamLow) {
+            user.isVideoVisible = false;
+          } else if (streamType === TUIVideoStreamType.kScreenStream) {
+            user.isScreenVisible = false;
+          }
+        }
+      });
+      this.currentStreamIdListInVisibleView = streamIdList;
+    },
+    setAudioVolume(audioVolumeArray) {
+      const basicStore = useBasicStore();
+      audioVolumeArray.forEach((audioVolumeItem) => {
+        let { userId } = audioVolumeItem;
+        const { volume } = audioVolumeItem;
+        if (userId === "") {
+          userId = basicStore.userId;
+        }
+        set(this.userVolumeObj, userId, volume);
+      });
+    },
+    setCurrentDeviceId(type, deviceId) {
+      switch (type) {
+        case TUIMediaDeviceType.kMediaDeviceTypeVideoCamera:
+          this.setCurrentCameraId(deviceId);
+          break;
+        case TUIMediaDeviceType.kMediaDeviceTypeAudioInput:
+          this.setCurrentMicrophoneId(deviceId);
+          break;
+        case TUIMediaDeviceType.kMediaDeviceTypeAudioOutput:
+          this.setCurrentSpeakerId(deviceId);
+          break;
+      }
+    },
+    setCurrentCameraId(deviceId) {
+      this.currentCameraId = deviceId;
+    },
+    setCurrentMicrophoneId(deviceId) {
+      this.currentMicrophoneId = deviceId;
+    },
+    setCurrentSpeakerId(deviceId) {
+      this.currentSpeakerId = deviceId;
+    },
+    setRoomInfo(roomInfo) {
+      const {
+        roomOwner,
+        isMicrophoneDisableForAllUser,
+        isCameraDisableForAllUser,
+        isMessageDisableForAllUser,
+        isSeatEnabled,
+        seatMode
+      } = roomInfo;
+      if (this.localUser.userId === roomOwner) {
+        this.localUser.userRole = TUIRole.kRoomOwner;
+      }
+      this.masterUserId = roomOwner;
+      this.isMicrophoneDisableForAllUser = isMicrophoneDisableForAllUser;
+      this.isCameraDisableForAllUser = isCameraDisableForAllUser;
+      this.isMessageDisableForAllUser = isMessageDisableForAllUser;
+      this.isSeatEnabled = isSeatEnabled;
+      this.seatMode = seatMode;
+      this.canControlSelfAudio = !this.isMicrophoneDisableForAllUser;
+      this.canControlSelfVideo = !this.isCameraDisableForAllUser;
+    },
+    setDisableMicrophoneForAllUserByAdmin(isDisable) {
+      this.isMicrophoneDisableForAllUser = isDisable;
+    },
+    setDisableCameraForAllUserByAdmin(isDisable) {
+      this.isCameraDisableForAllUser = isDisable;
+    },
+    setDisableMessageAllUserByAdmin(isDisable) {
+      this.isMessageDisableForAllUser = isDisable;
+    },
+    setMasterUserId(userId) {
+      this.masterUserId = userId;
+    },
+    setRoomParam(roomParam) {
+      var _a, _b, _c;
+      if (!roomParam) {
+        return;
+      }
+      const { isOpenCamera, isOpenMicrophone, defaultCameraId, defaultMicrophoneId, defaultSpeakerId } = roomParam;
+      if (defaultCameraId) {
+        this.setCurrentCameraId(defaultCameraId);
+        (_a = roomEngine.instance) == null ? void 0 : _a.setCurrentCameraDevice({ deviceId: defaultCameraId });
+      }
+      if (defaultMicrophoneId) {
+        this.setCurrentMicrophoneId(defaultMicrophoneId);
+        (_b = roomEngine.instance) == null ? void 0 : _b.setCurrentMicDevice({ deviceId: defaultMicrophoneId });
+      }
+      if (defaultSpeakerId) {
+        this.setCurrentSpeakerId(defaultSpeakerId);
+        (_c = roomEngine.instance) == null ? void 0 : _c.setCurrentSpeakerDevice({ deviceId: defaultSpeakerId });
+      }
+      if (this.isMaster || !this.isMicrophoneDisableForAllUser && this.isFreeSpeakMode) {
+        typeof isOpenMicrophone === "boolean" && (this.isDefaultOpenMicrophone = isOpenMicrophone);
+      }
+      if (this.isMaster || !this.isCameraDisableForAllUser && this.isFreeSpeakMode) {
+        typeof isOpenCamera === "boolean" && (this.isDefaultOpenCamera = isOpenCamera);
+      }
+    },
+    setCanControlSelfAudio(capability) {
+      this.canControlSelfAudio = capability;
+    },
+    setCanControlSelfVideo(capability) {
+      this.canControlSelfVideo = capability;
+    },
+    updateVideoQuality(quality) {
+      this.localVideoQuality = quality;
+    },
+    setDeviceList(type, deviceList) {
+      switch (type) {
+        case TUIMediaDeviceType.kMediaDeviceTypeVideoCamera:
+          this.setCameraList(deviceList);
+          break;
+        case TUIMediaDeviceType.kMediaDeviceTypeAudioInput:
+          this.setMicrophoneList(deviceList);
+          break;
+        case TUIMediaDeviceType.kMediaDeviceTypeAudioOutput:
+          this.setSpeakerList(deviceList);
+          break;
+      }
+    },
+    setCameraList(deviceList) {
+      this.cameraList = deviceList;
+      if (!this.currentCameraId && deviceList.length > 0) {
+        this.setCurrentCameraId(deviceList[0].deviceId);
+      }
+    },
+    setMicrophoneList(deviceList) {
+      this.microphoneList = deviceList;
+      if (!this.currentMicrophoneId && deviceList.length > 0) {
+        this.setCurrentMicrophoneId(deviceList[0].deviceId);
+      }
+    },
+    setSpeakerList(deviceList) {
+      this.speakerList = deviceList;
+      if (!this.currentSpeakerId && deviceList.length > 0) {
+        this.setCurrentSpeakerId(deviceList[0].deviceId);
+      }
+    },
+    // Set everyone's mute status when banning/cancelling the ban
+    setMicrophoneDisableState(isDisable) {
+      this.isMicrophoneDisableForAllUser = isDisable;
+    },
+    // Set everyone's video banned status when banning/cancelling a ban
+    setCameraDisableState(isDisable) {
+      this.isCameraDisableForAllUser = isDisable;
+    },
+    // Moderator individually modifies the mute status of a user's outgoing text messages
+    setMuteUserChat(userId, muted) {
+      const remoteUserInfo = this.remoteUserObj[userId];
+      if (remoteUserInfo) {
+        remoteUserInfo.isChatMutedByMasterOrAdmin = muted;
+      }
+    },
+    setRemoteUserRole(userId, role) {
+      const remoteUserInfo = this.remoteUserObj[userId];
+      if (remoteUserInfo) {
+        remoteUserInfo.userRole = role;
+      }
+    },
+    setRequestUserOpenMic(options) {
+      const { userId, isRequesting, requestId } = options;
+      const remoteUserInfo = this.remoteUserObj[userId];
+      if (remoteUserInfo) {
+        remoteUserInfo.isRequestingUserOpenMic = isRequesting;
+        remoteUserInfo.requestUserOpenMicRequestId = isRequesting ? requestId : "";
+      }
+    },
+    setRequestUserOpenCamera(options) {
+      const { userId, isRequesting, requestId } = options;
+      const remoteUserInfo = this.remoteUserObj[userId];
+      if (remoteUserInfo) {
+        remoteUserInfo.isRequestingUserOpenCamera = isRequesting;
+        remoteUserInfo.requestUserOpenCameraRequestId = isRequesting ? requestId : "";
+      }
+    },
+    addApplyToAnchorUser(options) {
+      const { userId, requestId, timestamp } = options;
+      const remoteUserInfo = this.remoteUserObj[userId];
+      if (remoteUserInfo) {
+        remoteUserInfo.isUserApplyingToAnchor = true;
+        remoteUserInfo.applyToAnchorRequestId = requestId;
+        remoteUserInfo.applyToAnchorTimestamp = timestamp;
+      }
+    },
+    removeApplyToAnchorUser(requestId) {
+      const applyToAnchorItem = Object.values(this.remoteUserObj).find((item) => item.isUserApplyingToAnchor && item.applyToAnchorRequestId === requestId);
+      if (applyToAnchorItem) {
+        applyToAnchorItem.isUserApplyingToAnchor = false;
+        applyToAnchorItem.applyToAnchorRequestId = "";
+        applyToAnchorItem.applyToAnchorTimestamp = 0;
+      }
+    },
+    addInviteToAnchorUser(options) {
+      const { userId, requestId } = options;
+      const remoteUserInfo = this.remoteUserObj[userId];
+      if (remoteUserInfo) {
+        remoteUserInfo.isInvitingUserToAnchor = true;
+        remoteUserInfo.inviteToAnchorRequestId = requestId;
+      }
+    },
+    removeInviteToAnchorUser(userId) {
+      const remoteUserInfo = this.remoteUserObj[userId];
+      if (remoteUserInfo) {
+        remoteUserInfo.isInvitingUserToAnchor = false;
+        remoteUserInfo.inviteToAnchorRequestId = "";
+      }
+    },
+    setHasOtherScreenShare(hasScreenShare) {
+      this.hasOtherScreenShare = hasScreenShare;
+    },
+    setOnStageTabStatus(isOnStateTabActive) {
+      this.isOnStateTabActive = isOnStateTabActive;
+    },
+    reset() {
+      const basicStore = useBasicStore();
+      basicStore.setIsOpenMic(false);
+      this.localUser = {
+        userId: "",
+        userName: "",
+        avatarUrl: "",
+        hasAudioStream: false,
+        hasVideoStream: false,
+        hasScreenStream: false,
+        userRole: TUIRole.kGeneralUser,
+        onSeat: false,
+        cameraStreamInfo: {
+          userId: "",
+          userName: "",
+          avatarUrl: "",
+          hasAudioStream: false,
+          hasVideoStream: false,
+          streamType: TUIVideoStreamType.kCameraStream,
+          isVisible: true
+        },
+        screenStreamInfo: {
+          userId: "",
+          userName: "",
+          avatarUrl: "",
+          hasScreenStream: false,
+          streamType: TUIVideoStreamType.kScreenStream,
+          isVisible: true
+        }
+      };
+      this.remoteUserObj = {};
+      this.userVolumeObj = {};
+      this.isDefaultOpenCamera = false;
+      this.isDefaultOpenMicrophone = false;
+      this.canControlSelfAudio = true;
+      this.canControlSelfVideo = true;
+      this.localVideoQuality = TUIVideoQuality.kVideoQuality_720p;
+      this.currentCameraId = "";
+      this.currentMicrophoneId = "";
+      this.currentSpeakerId = "";
+      this.cameraList = [];
+      this.microphoneList = [];
+      this.speakerList = [];
+      this.masterUserId = "";
+      this.isMicrophoneDisableForAllUser = false;
+      this.isCameraDisableForAllUser = false;
+      this.isMessageDisableForAllUser = false;
+      this.isSeatEnabled = false;
+      this.seatMode = TUISeatMode.kFreeToTake;
+      this.hasVideoStreamObject = {};
+      this.hasOtherScreenShare = false;
+      this.isOnStateTabActive = true;
+    }
+  }
+});
+export {
+  useRoomStore
+};

package/es/utils/adapter.d.ts

@@ -0,0 +1,5 @@
+export declare const clipBoard: (data: any) => Promise<{
+    code: number;
+    data?: any;
+    err?: any;
+}>;

package/es/utils/adapter.mjs

@@ -0,0 +1,31 @@
+import { isWeChat } from "./environment.mjs";
+const clipBoard = (data) => new Promise((resolve, reject) => {
+  if (!isWeChat) {
+    try {
+      navigator.clipboard.writeText(`${data}`);
+      resolve({ code: 0, data });
+    } catch (err) {
+      reject({ code: -1, err });
+    }
+    return;
+  }
+  uni.setClipboardData({
+    data,
+    success() {
+      uni.getClipboardData({
+        success(data2) {
+          resolve({ code: 0, data: data2 });
+        },
+        fail(err) {
+          reject({ code: -1, err });
+        }
+      });
+    },
+    fail(err) {
+      reject({ code: -1, err });
+    }
+  });
+});
+export {
+  clipBoard
+};

package/es/utils/aegis/config.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Configuration required isUploadLoaded, aegisId, projectName
+ * isUploadLoaded: Upload loaded event
+ * isUploadDetailEvent: Upload loaded and other events
+ * aegisId: aegis Id
+ * projectName: projectName
+ */
+declare const isUploadLoaded: boolean;
+declare const isUploadDetailEvent: boolean;
+declare const aegisId = "iHWefAYqooXkVQhcyK";
+declare const projectName = "TUIRoomKit-Electron";
+export { isUploadLoaded, isUploadDetailEvent, aegisId, projectName, };