@tencentcloud/roomkit-electron-vue3 2.3.3

package/es/hooks/useDeviceManager.mjs

@@ -0,0 +1,118 @@
+import TUIRoomEngine, { TUIRoomDeviceMangerEvents, TUIMediaDeviceType, TUIMediaDeviceState } from "@tencentcloud/tuiroom-engine-electron";
+import useGetRoomEngine from "./useRoomEngine.mjs";
+import { useRoomStore } from "../stores/room.mjs";
+import logger from "../utils/common/logger/index.mjs";
+import { onUnmounted } from "vue";
+import i18n from "../locales/index.mjs";
+import MessageBox from "../components/common/base/MessageBox/index.mjs";
+import { isWeChat, isElectron } from "../utils/environment.mjs";
+const roomEngine = useGetRoomEngine();
+const deviceManager = {
+  instance: null
+};
+TUIRoomEngine.once("ready", () => {
+  var _a;
+  deviceManager.instance = (_a = roomEngine.instance) == null ? void 0 : _a.getMediaDeviceManager();
+});
+function useDeviceManager(options) {
+  const roomStore = useRoomStore();
+  const { t } = i18n.global;
+  async function initMediaDeviceList() {
+    var _a, _b, _c, _d, _e, _f;
+    if (!deviceManager.instance) {
+      return;
+    }
+    const cameraList = await ((_a = deviceManager.instance) == null ? void 0 : _a.getDevicesList({
+      type: TUIMediaDeviceType.kMediaDeviceTypeVideoCamera
+    }));
+    const microphoneList = await ((_b = deviceManager.instance) == null ? void 0 : _b.getDevicesList({
+      type: TUIMediaDeviceType.kMediaDeviceTypeAudioInput
+    }));
+    const speakerList = await ((_c = deviceManager.instance) == null ? void 0 : _c.getDevicesList({
+      type: TUIMediaDeviceType.kMediaDeviceTypeAudioOutput
+    }));
+    if (!isWeChat) {
+      const hasCameraDevice = cameraList && cameraList.length > 0;
+      const hasMicrophoneDevice = microphoneList && microphoneList.length > 0;
+      let alertMessage = "";
+      if (hasCameraDevice && !hasMicrophoneDevice) {
+        alertMessage = "Microphone not detected on current device";
+      } else if (!hasCameraDevice && hasMicrophoneDevice) {
+        alertMessage = "Camera not detected on current device";
+      } else if (!hasCameraDevice && !hasMicrophoneDevice) {
+        alertMessage = "Camera And Microphone not detected on current device";
+      }
+      if (alertMessage) {
+        MessageBox({
+          title: t("Note"),
+          message: t(alertMessage),
+          confirmButtonText: t("Sure")
+        });
+      }
+    }
+    cameraList && roomStore.setCameraList(cameraList);
+    microphoneList && roomStore.setMicrophoneList(microphoneList);
+    speakerList && roomStore.setSpeakerList(speakerList);
+    const cameraInfo = (_d = deviceManager.instance) == null ? void 0 : _d.getCurrentDevice({
+      type: TUIMediaDeviceType.kMediaDeviceTypeVideoCamera
+    });
+    const micInfo = (_e = deviceManager.instance) == null ? void 0 : _e.getCurrentDevice({
+      type: TUIMediaDeviceType.kMediaDeviceTypeAudioInput
+    });
+    const speakerInfo = (_f = deviceManager.instance) == null ? void 0 : _f.getCurrentDevice({
+      type: TUIMediaDeviceType.kMediaDeviceTypeAudioOutput
+    });
+    if (cameraInfo && cameraInfo.deviceId) {
+      roomStore.setCurrentCameraId(cameraInfo.deviceId);
+    }
+    if (micInfo && micInfo.deviceId) {
+      roomStore.setCurrentMicrophoneId(micInfo.deviceId);
+    }
+    if (speakerInfo && speakerInfo.deviceId) {
+      roomStore.setCurrentSpeakerId(speakerInfo.deviceId);
+    }
+  }
+  async function onDeviceChanged(eventInfo) {
+    var _a, _b;
+    if (!deviceManager.instance) {
+      return;
+    }
+    const stateList = ["add", "remove", "active"];
+    const deviceTypeList = ["mic", "speaker", "camera"];
+    const { deviceId, type, state } = eventInfo;
+    logger.log(`onDeviceChanged: deviceId: ${deviceId}, type: ${deviceTypeList[type]}, state: ${stateList[state]}`);
+    const deviceList = await ((_a = deviceManager.instance) == null ? void 0 : _a.getDevicesList({ type }));
+    deviceList && roomStore.setDeviceList(type, deviceList);
+    if (state === TUIMediaDeviceState.kMediaDeviceStateActive) {
+      roomStore.setCurrentDeviceId(type, deviceId);
+    }
+    if (isElectron && state === TUIMediaDeviceState.kMediaDeviceStateRemove && type === TUIMediaDeviceType.kMediaDeviceTypeVideoCamera) {
+      const currentCameraInfo = (_b = deviceManager.instance) == null ? void 0 : _b.getCurrentDevice({
+        type: TUIMediaDeviceType.kMediaDeviceTypeVideoCamera
+      });
+      if (currentCameraInfo && currentCameraInfo.deviceId) {
+        roomStore.setCurrentCameraId(currentCameraInfo.deviceId);
+      }
+    }
+  }
+  TUIRoomEngine.once("ready", () => {
+    var _a;
+    if (options && options.listenForDeviceChange) {
+      initMediaDeviceList();
+      (_a = deviceManager.instance) == null ? void 0 : _a.on(TUIRoomDeviceMangerEvents.onDeviceChanged, onDeviceChanged);
+    }
+  });
+  onUnmounted(() => {
+    var _a;
+    if (options && options.listenForDeviceChange) {
+      (_a = deviceManager.instance) == null ? void 0 : _a.off(TUIRoomDeviceMangerEvents.onDeviceChanged, onDeviceChanged);
+    }
+  });
+  return {
+    deviceManager,
+    initMediaDeviceList
+  };
+}
+export {
+  useDeviceManager as default
+};

package/es/hooks/useMasterApplyControl.d.ts

@@ -0,0 +1,18 @@
+import { UserInfo } from '../stores/room';
+
+export default function (): {
+    t: any;
+    roomStore: any;
+    showApplyUserList: any;
+    hideApplyList: () => void;
+    applyToAnchorUserCount: import('vue').ComputedRef<any>;
+    applyToAnchorList: any;
+    handleUserApply: (applyUserId: string, agree: boolean) => Promise<void>;
+    agreeUserOnStage: (userInfo: UserInfo) => Promise<void>;
+    denyUserOnStage: (userInfo: UserInfo) => Promise<void>;
+    inviteUserOnStage: (userInfo: UserInfo) => Promise<void>;
+    cancelInviteUserOnStage: (userInfo: UserInfo) => void;
+    kickUserOffStage: (userInfo: UserInfo) => void;
+    handleAllUserApply: (isAgreeOrRejectAllUserApply: boolean) => Promise<void>;
+    handleShowNotification: () => void;
+};

package/es/hooks/useMasterApplyControl.mjs

@@ -0,0 +1,261 @@
+import { computed, onBeforeUnmount, watch } from "vue";
+import TUIRoomEngine, { TUIRoomEvents, TUIRequestAction, TUIErrorCode, TUIRequestCallbackType } from "@tencentcloud/tuiroom-engine-electron";
+import useGetRoomEngine from "./useRoomEngine.mjs";
+import renderMsg from "../components/common/base/Message/Message.mjs";
+import { MESSAGE_DURATION } from "../constants/message.mjs";
+import { useRoomStore } from "../stores/room.mjs";
+import { storeToRefs } from "pinia";
+import { useI18n } from "../locales/index.mjs";
+import logger from "../utils/common/logger/index.mjs";
+import { useBasicStore } from "../stores/basic.mjs";
+import Notification from "../components/common/base/Notification/index.mjs";
+import { isMobile } from "../utils/environment.mjs";
+const roomEngine = useGetRoomEngine();
+function useMasterApplyControl() {
+  const roomStore = useRoomStore();
+  const basicStore = useBasicStore();
+  const { applyToAnchorList } = storeToRefs(roomStore);
+  const { showApplyUserList } = storeToRefs(basicStore);
+  const { t } = useI18n();
+  let notification;
+  const applyToAnchorUserIdList = computed(() => applyToAnchorList.value.map((item) => item.userId));
+  const applyToAnchorUserCount = computed(() => applyToAnchorList.value.length);
+  function onRequestReceived(eventInfo) {
+    const { requestAction, requestId, userId, timestamp } = eventInfo.request;
+    if (requestAction === TUIRequestAction.kRequestToTakeSeat) {
+      userId && roomStore.addApplyToAnchorUser({ userId, requestId, timestamp });
+    }
+  }
+  function onRequestCancelled(eventInfo) {
+    const { requestId } = eventInfo;
+    roomStore.removeApplyToAnchorUser(requestId);
+  }
+  function onRequestProcessed(eventInfo) {
+    const { requestId } = eventInfo;
+    roomStore.removeApplyToAnchorUser(requestId);
+  }
+  async function handleUserApply(applyUserId, agree) {
+    var _a;
+    try {
+      const userInfo = roomStore.remoteUserObj[applyUserId];
+      const requestId = userInfo.applyToAnchorRequestId;
+      if (requestId) {
+        await ((_a = roomEngine.instance) == null ? void 0 : _a.responseRemoteRequest({
+          requestId,
+          agree
+        }));
+        roomStore.removeApplyToAnchorUser(requestId);
+      } else {
+        logger.warn("Failed to process the stage application. The data is abnormal. Please try again！", userInfo);
+      }
+    } catch (error) {
+      if (error.code === TUIErrorCode.ERR_ALL_SEAT_OCCUPIED) {
+        renderMsg({ type: "warning", message: t("The current number of people on stage has reached the limit") });
+      } else {
+        logger.error("Failure to process a user request", error);
+      }
+    }
+  }
+  async function agreeUserOnStage(userInfo) {
+    var _a;
+    try {
+      const requestId = userInfo.applyToAnchorRequestId;
+      if (requestId) {
+        await ((_a = roomEngine.instance) == null ? void 0 : _a.responseRemoteRequest({ requestId, agree: true }));
+        roomStore.removeApplyToAnchorUser(requestId);
+      } else {
+        logger.warn("Failed to process the stage application. The data is abnormal. Please try again！", userInfo);
+      }
+    } catch (error) {
+      if (error.code === TUIErrorCode.ERR_ALL_SEAT_OCCUPIED) {
+        renderMsg({ type: "warning", message: t("The current number of people on stage has reached the limit") });
+      } else {
+        logger.error("Failed application for consent to go on stage", error);
+      }
+    }
+  }
+  async function denyUserOnStage(userInfo) {
+    var _a;
+    const requestId = userInfo.applyToAnchorRequestId;
+    if (requestId) {
+      await ((_a = roomEngine.instance) == null ? void 0 : _a.responseRemoteRequest({
+        requestId,
+        agree: false
+      }));
+      roomStore.removeApplyToAnchorUser(requestId);
+    } else {
+      logger.warn("Failed to process the stage application. The data is abnormal. Please try again！", userInfo);
+    }
+  }
+  async function handleAllUserApply(isAgreeOrRejectAllUserApply) {
+    var _a;
+    const applyUserList = applyToAnchorList.value.map((item) => ({
+      userId: item.userId,
+      userName: item.userName,
+      applyToAnchorRequestId: item.applyToAnchorRequestId
+    }));
+    for (const { userId, userName, applyToAnchorRequestId } of applyUserList) {
+      const action = isAgreeOrRejectAllUserApply ? "Agree" : "Reject";
+      const actionFailedMessage = `${action} sb on stage failed, please retry`;
+      try {
+        if (applyToAnchorRequestId) {
+          await ((_a = roomEngine.instance) == null ? void 0 : _a.responseRemoteRequest({
+            requestId: applyToAnchorRequestId,
+            agree: isAgreeOrRejectAllUserApply
+          }));
+          roomStore.removeApplyToAnchorUser(applyToAnchorRequestId);
+        }
+      } catch (error) {
+        logger.error(actionFailedMessage);
+        renderMsg({
+          type: "warning",
+          message: t(`${action} sb on stage failed, please retry`, { name: userName || userId }),
+          duration: MESSAGE_DURATION.NORMAL
+        });
+      }
+    }
+  }
+  TUIRoomEngine.once("ready", () => {
+    var _a, _b, _c;
+    (_a = roomEngine.instance) == null ? void 0 : _a.on(TUIRoomEvents.onRequestReceived, onRequestReceived);
+    (_b = roomEngine.instance) == null ? void 0 : _b.on(TUIRoomEvents.onRequestCancelled, onRequestCancelled);
+    (_c = roomEngine.instance) == null ? void 0 : _c.on(TUIRoomEvents.onRequestProcessed, onRequestProcessed);
+  });
+  onBeforeUnmount(() => {
+    var _a, _b, _c;
+    (_a = roomEngine.instance) == null ? void 0 : _a.off(TUIRoomEvents.onRequestReceived, onRequestReceived);
+    (_b = roomEngine.instance) == null ? void 0 : _b.off(TUIRoomEvents.onRequestCancelled, onRequestCancelled);
+    (_c = roomEngine.instance) == null ? void 0 : _c.off(TUIRoomEvents.onRequestProcessed, onRequestProcessed);
+  });
+  async function inviteUserOnStage(userInfo) {
+    var _a;
+    const { userId } = userInfo;
+    const request = await ((_a = roomEngine.instance) == null ? void 0 : _a.takeUserOnSeatByAdmin({
+      seatIndex: -1,
+      userId,
+      timeout: 60,
+      requestCallback: (callbackInfo) => {
+        const { requestCallbackType, userId: userId2, code } = callbackInfo;
+        const userName = roomStore.getUserName(userId2);
+        roomStore.removeInviteToAnchorUser(userId2);
+        switch (requestCallbackType) {
+          case TUIRequestCallbackType.kRequestAccepted:
+            renderMsg({
+              type: "success",
+              message: `${userName || userId2} ${t("accepted the invitation to the stage")}`,
+              duration: MESSAGE_DURATION.NORMAL
+            });
+            break;
+          case TUIRequestCallbackType.kRequestRejected:
+            renderMsg({
+              type: "warning",
+              message: `${userName || userId2} ${t("declined the invitation to the stage")}`,
+              duration: MESSAGE_DURATION.NORMAL
+            });
+            break;
+          case TUIRequestCallbackType.kRequestTimeout:
+            renderMsg({
+              type: "warning",
+              message: t("The invitation to sb to go on stage has timed out", { name: userName || userId2 }),
+              duration: MESSAGE_DURATION.NORMAL
+            });
+            break;
+          case TUIRequestCallbackType.kRequestError:
+            if (code === TUIErrorCode.ERR_REQUEST_ID_REPEAT) {
+              renderMsg({
+                type: "warning",
+                message: t("This member has already received the same request, please try again later"),
+                duration: MESSAGE_DURATION.NORMAL
+              });
+            }
+            break;
+        }
+      }
+    }));
+    if (request && request.requestId) {
+      roomStore.addInviteToAnchorUser({ userId, requestId: request.requestId });
+    }
+  }
+  function cancelInviteUserOnStage(userInfo) {
+    var _a;
+    const { userId, inviteToAnchorRequestId } = userInfo;
+    roomStore.removeInviteToAnchorUser(userId);
+    if (inviteToAnchorRequestId) {
+      (_a = roomEngine.instance) == null ? void 0 : _a.cancelRequest({ requestId: inviteToAnchorRequestId });
+    }
+  }
+  function kickUserOffStage(userInfo) {
+    var _a;
+    (_a = roomEngine.instance) == null ? void 0 : _a.kickUserOffSeatByAdmin({
+      seatIndex: -1,
+      userId: userInfo.userId
+    });
+  }
+  const handleConfirm = async (onlyOneUserTakeStage, userId) => {
+    if (isMobile) {
+      basicStore.setSidebarOpenStatus(true);
+      basicStore.setSidebarName("apply");
+    } else {
+      if (onlyOneUserTakeStage) {
+        handleUserApply(userId, true);
+      } else {
+        basicStore.setShowApplyUserList(true);
+      }
+    }
+  };
+  const handleCancel = async (onlyOneUserTakeStage, userId) => {
+    if (!isMobile && onlyOneUserTakeStage) {
+      handleUserApply(userId, false);
+    }
+  };
+  function hideApplyList() {
+    basicStore.setShowApplyUserList(false);
+  }
+  function handleShowNotification() {
+    watch(applyToAnchorUserIdList, (newVal, oldVal) => {
+      if (newVal.length === oldVal.length && newVal === oldVal) {
+        return;
+      }
+      if (newVal.length === 0) {
+        notification && notification.close();
+        notification = null;
+        return;
+      }
+      const onlyOneUserTakeStage = newVal.length === 1;
+      const firstUser = applyToAnchorList.value[0];
+      const userName = (firstUser == null ? void 0 : firstUser.userName) || (firstUser == null ? void 0 : firstUser.userId);
+      const message = onlyOneUserTakeStage ? `${userName} ${t("Applying for the stage")}` : `${userName} ${t("and so on number people applying to stage", { number: applyToAnchorList.value.length })}`;
+      const confirmButtonText = isMobile ? t("Check") : onlyOneUserTakeStage ? t("Agree to the stage") : t("Check");
+      const cancelButtonText = isMobile ? void 0 : onlyOneUserTakeStage ? t("Reject") : t("Neglect");
+      const confirm = () => handleConfirm(onlyOneUserTakeStage, firstUser == null ? void 0 : firstUser.userId);
+      const cancel = () => handleCancel(onlyOneUserTakeStage, firstUser == null ? void 0 : firstUser.userId);
+      notification = Notification({ message, confirmButtonText, cancelButtonText, confirm, cancel });
+    });
+  }
+  return {
+    t,
+    roomStore,
+    showApplyUserList,
+    hideApplyList,
+    applyToAnchorUserCount,
+    applyToAnchorList,
+    // Process the user's application for accessing the stage (agree/reject)
+    handleUserApply,
+    // Allow ordinary users to take the stage
+    agreeUserOnStage,
+    // Reject ordinary users to take the stage
+    denyUserOnStage,
+    // Invite users to the stage
+    inviteUserOnStage,
+    // Cancel invite users to the stage
+    cancelInviteUserOnStage,
+    // Kick the user off the stage
+    kickUserOffStage,
+    // Handle all user requests
+    handleAllUserApply,
+    handleShowNotification
+  };
+}
+export {
+  useMasterApplyControl as default
+};

package/es/hooks/useMitt.d.ts

@@ -0,0 +1,2 @@
+declare const bus: import('mitt').Emitter<Record<import("mitt").EventType, unknown>>;
+export default bus;

package/es/hooks/useMitt.mjs

@@ -0,0 +1,5 @@
+import mitt from "mitt";
+const bus = mitt();
+export {
+  bus as default
+};

package/es/hooks/useRoomEngine.d.ts

@@ -0,0 +1 @@
+export default function useGetRoomEngine(): Record<string, any>;

package/es/hooks/useRoomEngine.mjs

@@ -0,0 +1,20 @@
+import TUIRoomEngine from "@tencentcloud/tuiroom-engine-electron";
+import { isVue3 } from "../utils/constants.mjs";
+const roomEngine = { instance: null };
+const vueVersion = isVue3 ? "vue3" : "vue2";
+function useGetRoomEngine() {
+  return roomEngine;
+}
+TUIRoomEngine.once("ready", () => {
+  roomEngine.instance = new TUIRoomEngine();
+  TUIRoomEngine.callExperimentalAPI(JSON.stringify({
+    api: "setFramework",
+    params: {
+      component: "TUIRoomKit",
+      language: vueVersion
+    }
+  }));
+});
+export {
+  useGetRoomEngine as default
+};

package/es/hooks/useZIndex.d.ts

@@ -0,0 +1,4 @@
+export default function (): {
+    currentZIndex: number;
+    nextZIndex: () => number;
+};

package/es/hooks/useZIndex.mjs

@@ -0,0 +1,17 @@
+import { ref, computed } from "vue";
+const zIndex = ref(0);
+const defaultInitialZIndex = 3e3;
+function useZIndex() {
+  const currentZIndex = computed(() => defaultInitialZIndex + zIndex.value);
+  const nextZIndex = () => {
+    zIndex.value = zIndex.value + 1;
+    return currentZIndex.value;
+  };
+  return {
+    currentZIndex: currentZIndex.value,
+    nextZIndex
+  };
+}
+export {
+  useZIndex as default
+};

package/es/index.d.ts

@@ -0,0 +1,9 @@
+import { default as RoomMessageCard } from './extension/RoomMessageCard/RoomMessageCard.vue';
+import { conference, RoomEvent } from './conference';
+import { default as TUIRoomEngine } from '@tencentcloud/tuiroom-engine-electron';
+import { default as PreConferenceView } from './preConference.vue';
+import { default as ConferenceMainView } from './conference.vue';
+
+export * from './components/common/base/index';
+export { ConferenceMainView, PreConferenceView, TUIRoomEngine, conference, RoomEvent, RoomMessageCard };
+export default ConferenceMainView;