tuikit-atomicx-vue3 0.1.0

package/dist/states/CoHostState.js

@@ -0,0 +1,181 @@
+import { useRoomEngine } from "../hooks/useRoomEngine.js";
+import { DeviceStatus } from "../types/device.js";
+import TUIRoomEngine, { TUILiveConnectionManagerEvents } from "@tencentcloud/tuiroom-engine-js";
+import { ref, computed } from "vue";
+import { useLoginState } from "./LoginState.js";
+import { useSeatStore } from "./SeatStore.js";
+import { useLiveState } from "./LiveState/index.js";
+import { CoHostStatus } from "../types/coHost.js";
+const roomEngine = useRoomEngine();
+const { loginUserInfo } = useLoginState();
+const { liveList } = useLiveState();
+const { coHostUserList } = useSeatStore();
+const sendCoHostUserListCache = ref([]);
+const receivedCoHostUserListCache = ref([]);
+const localCoHostStatus = computed(() => {
+  if (coHostUserList.value.find((seat) => {
+    var _a, _b;
+    return ((_a = seat.userInfo) == null ? void 0 : _a.userId) === ((_b = loginUserInfo.value) == null ? void 0 : _b.userId);
+  }))
+    return CoHostStatus.Connected;
+  if (receivedCoHostUserListCache.value.find((user) => {
+    var _a;
+    return user.userId === ((_a = loginUserInfo.value) == null ? void 0 : _a.userId);
+  }))
+    return CoHostStatus.Invited;
+  if (sendCoHostUserListCache.value.find((user) => {
+    var _a;
+    return user.userId === ((_a = loginUserInfo.value) == null ? void 0 : _a.userId);
+  }))
+    return CoHostStatus.Requesting;
+  return CoHostStatus.Disconnected;
+});
+const userListInCoHost = computed(() => {
+  return coHostUserList.value.map((seat) => seat.userInfo);
+});
+const receivedCoHostRequestList = computed(() => {
+  return receivedCoHostUserListCache.value.map((user) => ({
+    avatarUrl: user.avatarUrl,
+    joinConnectionTime: user.joinConnectionTime,
+    roomId: user.roomId,
+    userId: user.userId,
+    userName: user.userName
+  }));
+});
+const sendCoHostUserList = computed(() => {
+  return sendCoHostUserListCache.value.map((user) => ({
+    roomId: user.roomId,
+    userId: user.userId,
+    userName: user.userName,
+    avatarUrl: user.avatarUrl,
+    microphoneStatus: DeviceStatus.Off,
+    cameraStatus: DeviceStatus.Off,
+    onSeatTimestamp: 0,
+    networkQuality: void 0,
+    customInfo: {}
+  }));
+});
+const availableCoHostUserList = computed(() => {
+  return liveList.value.filter((live) => {
+    var _a;
+    const isLocalUser = live.liveOwner.userId === ((_a = loginUserInfo.value) == null ? void 0 : _a.userId);
+    const isInSeat = coHostUserList.value.some((seat) => {
+      var _a2;
+      return ((_a2 = seat.userInfo) == null ? void 0 : _a2.userId) === live.liveOwner.userId;
+    });
+    const isInSendUserList = sendCoHostUserListCache.value.find((u) => u.userId === live.liveOwner.userId);
+    const isInReceivedUserList = receivedCoHostUserListCache.value.find((u) => u.userId === live.liveOwner.userId);
+    return !isLocalUser && !isInSeat && !isInSendUserList && !isInReceivedUserList;
+  }).map((live) => ({
+    roomId: live.liveId,
+    userId: live.liveOwner.userId,
+    userName: live.liveOwner.userName,
+    avatarUrl: live.liveOwner.avatarUrl,
+    microphoneStatus: DeviceStatus.Off,
+    cameraStatus: DeviceStatus.Off,
+    onSeatTimestamp: 0,
+    networkQuality: void 0,
+    customInfo: {}
+  }));
+});
+const sendCoHostRequest = async (options) => {
+  var _a, _b;
+  const { userList, timeout, extensionInfo } = options;
+  await ((_b = (_a = roomEngine.instance) == null ? void 0 : _a.getLiveConnectionManager()) == null ? void 0 : _b.requestConnection(
+    userList.map((user) => user.roomId),
+    timeout,
+    extensionInfo
+  ));
+  sendCoHostUserListCache.value = userList.map((user) => ({
+    avatarUrl: user.avatarUrl,
+    joinConnectionTime: user.onSeatTimestamp,
+    roomId: user.roomId,
+    userId: user.userId,
+    userName: user.userName
+  }));
+};
+const cancelCoHostRequest = async (options) => {
+  var _a, _b;
+  const { userList } = options;
+  await ((_b = (_a = roomEngine.instance) == null ? void 0 : _a.getLiveConnectionManager()) == null ? void 0 : _b.cancelConnectionRequest(userList.map((user) => user.roomId)));
+  sendCoHostUserListCache.value = sendCoHostUserListCache.value.filter(
+    (user) => !userList.find((u) => u.userId === user.userId && u.roomId === user.roomId)
+  );
+};
+const acceptCoHostRequest = async (user) => {
+  var _a, _b;
+  await ((_b = (_a = roomEngine.instance) == null ? void 0 : _a.getLiveConnectionManager()) == null ? void 0 : _b.acceptConnection(user.roomId));
+  receivedCoHostUserListCache.value = receivedCoHostUserListCache.value.filter(
+    (u) => u.userId !== user.userId && u.roomId !== user.roomId
+  );
+};
+const rejectCoHostRequest = async (user) => {
+  var _a, _b;
+  await ((_b = (_a = roomEngine.instance) == null ? void 0 : _a.getLiveConnectionManager()) == null ? void 0 : _b.rejectConnection(user.roomId));
+  receivedCoHostUserListCache.value = receivedCoHostUserListCache.value.filter(
+    (u) => u.userId !== user.userId && u.roomId !== user.roomId
+  );
+};
+const exitCoHost = async () => {
+  var _a, _b;
+  return await ((_b = (_a = roomEngine.instance) == null ? void 0 : _a.getLiveConnectionManager()) == null ? void 0 : _b.disconnect());
+};
+const onConnectionRequestAccept = (invitee) => {
+  sendCoHostUserListCache.value = sendCoHostUserListCache.value.filter(
+    (user) => user.userId !== invitee.userId && user.roomId !== invitee.roomId
+  );
+};
+const onConnectionRequestReject = (invitee) => {
+  sendCoHostUserListCache.value = sendCoHostUserListCache.value.filter(
+    (user) => user.userId !== invitee.userId && user.roomId !== invitee.roomId
+  );
+};
+const onConnectionRequestTimeout = (invitee, inviter) => {
+  receivedCoHostUserListCache.value = receivedCoHostUserListCache.value.filter(
+    (user) => user.userId !== invitee.userId && user.roomId !== invitee.roomId
+  );
+  sendCoHostUserListCache.value = sendCoHostUserListCache.value.filter(
+    (user) => user.userId !== inviter.userId && user.roomId !== inviter.roomId
+  );
+};
+const onConnectionRequestCancelled = (invitee) => {
+  receivedCoHostUserListCache.value = receivedCoHostUserListCache.value.filter(
+    (user) => user.userId !== invitee.userId && user.roomId !== invitee.roomId
+  );
+};
+const onConnectionRequestReceived = (inviter) => {
+  receivedCoHostUserListCache.value.push(inviter);
+};
+const eventMap = [
+  { event: TUILiveConnectionManagerEvents.onConnectionRequestAccept, handler: onConnectionRequestAccept },
+  { event: TUILiveConnectionManagerEvents.onConnectionRequestCancelled, handler: onConnectionRequestCancelled },
+  { event: TUILiveConnectionManagerEvents.onConnectionRequestReceived, handler: onConnectionRequestReceived },
+  { event: TUILiveConnectionManagerEvents.onConnectionRequestReject, handler: onConnectionRequestReject },
+  { event: TUILiveConnectionManagerEvents.onConnectionRequestTimeout, handler: onConnectionRequestTimeout }
+];
+const bindEvent = () => {
+  eventMap.forEach(({ event, handler }) => {
+    var _a, _b;
+    (_b = (_a = roomEngine.instance) == null ? void 0 : _a.getLiveConnectionManager()) == null ? void 0 : _b.on(event, handler);
+  });
+};
+TUIRoomEngine.once("ready", () => {
+  bindEvent();
+});
+function useCoHostState() {
+  return {
+    localCoHostStatus,
+    userListInCoHost,
+    receivedCoHostRequestList,
+    sendCoHostUserList,
+    availableCoHostUserList,
+    sendCoHostRequest,
+    cancelCoHostRequest,
+    acceptCoHostRequest,
+    rejectCoHostRequest,
+    exitCoHost
+  };
+}
+export {
+  useCoHostState
+};

package/dist/states/ConversationListState/ConversationListState.d.ts

@@ -0,0 +1,13 @@
+import { Ref } from 'vue';
+import { IConversationModel } from '@tencentcloud/chat-uikit-engine';
+
+interface IConversationListStoreState {
+    currentConversation: Ref<IConversationModel | undefined>;
+    currentConversationID: Ref<string | undefined>;
+    conversationList: Ref<IConversationModel[] | undefined>;
+}
+interface IConversationListStoreAction {
+    switchConversation: (conversationID: string) => void;
+}
+declare function useConversationListState(): IConversationListStoreState & IConversationListStoreAction;
+export { useConversationListState };

package/dist/states/ConversationListState/ConversationListState.js

@@ -0,0 +1,40 @@
+import { ref } from "vue";
+import ChatEngine, { TUIStore, StoreName, TUIConversationService } from "@tencentcloud/chat-uikit-engine";
+import { TUILogin } from "@tencentcloud/tui-core";
+const conversationListRef = ref(void 0);
+const currentConversationRef = ref(void 0);
+const currentConversationIDRef = ref(void 0);
+function initConversationWatcher() {
+  TUIStore.watch(StoreName.CONV, {
+    conversationList: (list) => {
+      conversationListRef.value = list;
+    },
+    currentConversationID: (ID) => {
+      currentConversationIDRef.value = ID;
+    },
+    currentConversation: (conversation) => {
+      currentConversationRef.value = conversation;
+    }
+  });
+}
+initConversationWatcher();
+function useConversationListState() {
+  return {
+    conversationList: conversationListRef,
+    currentConversation: currentConversationRef,
+    currentConversationID: currentConversationIDRef,
+    switchConversation(conversationID) {
+      const { chat, SDKAppID, userID, userSig } = TUILogin.getContext();
+      ChatEngine.login({
+        chat,
+        SDKAppID,
+        userID,
+        userSig
+      });
+      TUIConversationService.switchConversation(conversationID);
+    }
+  };
+}
+export {
+  useConversationListState
+};

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

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

package/dist/states/ConversationListState/index.js

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

package/dist/states/DeviceState.d.ts

@@ -0,0 +1,191 @@
+import { DeviceStatus, TUIDeviceInfo } from '../types';
+import { DeviceError, AudioOutput } from '../types/device';
+import { TUIMediaDeviceType, TUIVideoQuality, TUIMediaDeviceState, TUIChangeReason } from '@tencentcloud/tuiroom-engine-js';
+
+export declare function onDeviceChanged(eventInfo: {
+    deviceId: string;
+    type: TUIMediaDeviceType;
+    state: TUIMediaDeviceState;
+}): Promise<void>;
+export declare function useDeviceState(): {
+    microphoneStatus: import('vue').Ref<DeviceStatus, DeviceStatus>;
+    microphoneList: import('vue').Ref<{
+        deviceId: string;
+        deviceName: string;
+        deviceProperties?: {
+            supportedResolution?: {
+                width: number;
+                height: number;
+            }[] | undefined;
+        } | undefined;
+    }[], TUIDeviceInfo[] | {
+        deviceId: string;
+        deviceName: string;
+        deviceProperties?: {
+            supportedResolution?: {
+                width: number;
+                height: number;
+            }[] | undefined;
+        } | undefined;
+    }[]>;
+    currentMicrophone: import('vue').Ref<{
+        deviceId: string;
+        deviceName: string;
+        deviceProperties?: {
+            supportedResolution?: {
+                width: number;
+                height: number;
+            }[] | undefined;
+        } | undefined;
+    } | null, TUIDeviceInfo | {
+        deviceId: string;
+        deviceName: string;
+        deviceProperties?: {
+            supportedResolution?: {
+                width: number;
+                height: number;
+            }[] | undefined;
+        } | undefined;
+    } | null>;
+    microphoneLastError: import('vue').Ref<DeviceError, DeviceError>;
+    isMicrophoneTesting: import('vue').Ref<boolean, boolean>;
+    audioVolume: import('vue').Ref<number, number>;
+    captureVolume: import('vue').Ref<number, number>;
+    outputVolume: import('vue').Ref<number, number>;
+    testAudioVolume: import('vue').Ref<number, number>;
+    cameraStatus: import('vue').Ref<DeviceStatus, DeviceStatus>;
+    cameraList: import('vue').Ref<{
+        deviceId: string;
+        deviceName: string;
+        deviceProperties?: {
+            supportedResolution?: {
+                width: number;
+                height: number;
+            }[] | undefined;
+        } | undefined;
+    }[], TUIDeviceInfo[] | {
+        deviceId: string;
+        deviceName: string;
+        deviceProperties?: {
+            supportedResolution?: {
+                width: number;
+                height: number;
+            }[] | undefined;
+        } | undefined;
+    }[]>;
+    currentCamera: import('vue').Ref<{
+        deviceId: string;
+        deviceName: string;
+        deviceProperties?: {
+            supportedResolution?: {
+                width: number;
+                height: number;
+            }[] | undefined;
+        } | undefined;
+    } | null, TUIDeviceInfo | {
+        deviceId: string;
+        deviceName: string;
+        deviceProperties?: {
+            supportedResolution?: {
+                width: number;
+                height: number;
+            }[] | undefined;
+        } | undefined;
+    } | null>;
+    cameraLastError: import('vue').Ref<DeviceError, DeviceError>;
+    isCameraTesting: import('vue').Ref<boolean, boolean>;
+    isCameraTestLoading: import('vue').Ref<boolean, boolean>;
+    isFrontCamera: import('vue').Ref<boolean, boolean>;
+    isLocalMirror: import('vue').Ref<boolean, boolean>;
+    localVideoQuality: import('vue').Ref<TUIVideoQuality, TUIVideoQuality>;
+    speakerList: import('vue').Ref<{
+        deviceId: string;
+        deviceName: string;
+        deviceProperties?: {
+            supportedResolution?: {
+                width: number;
+                height: number;
+            }[] | undefined;
+        } | undefined;
+    }[], TUIDeviceInfo[] | {
+        deviceId: string;
+        deviceName: string;
+        deviceProperties?: {
+            supportedResolution?: {
+                width: number;
+                height: number;
+            }[] | undefined;
+        } | undefined;
+    }[]>;
+    currentSpeaker: import('vue').Ref<{
+        deviceId: string;
+        deviceName: string;
+        deviceProperties?: {
+            supportedResolution?: {
+                width: number;
+                height: number;
+            }[] | undefined;
+        } | undefined;
+    } | null, TUIDeviceInfo | {
+        deviceId: string;
+        deviceName: string;
+        deviceProperties?: {
+            supportedResolution?: {
+                width: number;
+                height: number;
+            }[] | undefined;
+        } | undefined;
+    } | null>;
+    currentAudioOutput: import('vue').Ref<AudioOutput, AudioOutput>;
+    isSpeakerTesting: import('vue').Ref<boolean, boolean>;
+    screenStatus: import('vue').Ref<DeviceStatus, DeviceStatus>;
+    screenStatusReason: import('vue').Ref<TUIChangeReason | undefined, TUIChangeReason | undefined>;
+    openLocalMicrophone: () => Promise<void>;
+    closeLocalMicrophone: () => Promise<void>;
+    muteLocalAudio: () => Promise<void>;
+    unmuteLocalAudio: () => Promise<void>;
+    getMicrophoneList: () => Promise<void>;
+    setCurrentMicrophone: (options: {
+        deviceId: string;
+    }) => Promise<void>;
+    startMicrophoneTest: (options: {
+        interval?: number;
+    }) => Promise<void>;
+    stopMicrophoneTest: () => Promise<void>;
+    setCaptureVolume: (volume: number) => Promise<void>;
+    getSpeakerList: () => Promise<void>;
+    setCurrentSpeaker: (options: {
+        deviceId: string;
+    }) => Promise<void>;
+    setAudioOutput: (output: AudioOutput) => Promise<void>;
+    startSpeakerTest: (options: {
+        filePath: string;
+    }) => Promise<void>;
+    stopSpeakerTest: () => Promise<void>;
+    setOutputVolume: (volume: number) => Promise<void>;
+    openLocalCamera: () => Promise<void>;
+    closeLocalCamera: () => Promise<void>;
+    getCameraList: () => Promise<void>;
+    setCurrentCamera: (options: {
+        deviceId: string;
+    }) => Promise<void>;
+    switchCamera: (options: {
+        isFrontCamera: boolean;
+    }) => Promise<void>;
+    switchMirror: (options: {
+        mirror: boolean;
+    }) => Promise<void>;
+    updateVideoQuality: (options: {
+        quality: TUIVideoQuality;
+    }) => Promise<void>;
+    startCameraDeviceTest: (options: {
+        view: string;
+    }) => Promise<void>;
+    stopCameraDeviceTest: () => Promise<void>;
+    startScreenShare: (options?: {
+        screenAudio?: boolean;
+        view?: string;
+    }) => Promise<void>;
+    stopScreenShare: () => Promise<void>;
+};
+export default useDeviceState;