tuikit-atomicx-vue3 4.4.0-beta.1 → 4.5.0

package/dist/states/CoGuestState.d.ts

@@ -1,5 +1,57 @@
 import { HostEvent, GuestEvent, SeatUserInfo, LiveUserInfo } from '../types';
 
+/**
+ * 连麦嘉宾状态管理 Hook
+ * @memberof module:CoGuestState
+ * @description 提供连麦嘉宾的状态管理和控制功能，包括申请连麦、邀请连麦、处理连麦请求等
+ * @returns {Object} 返回连麦状态管理对象
+ * @returns {ComputedRef<SeatUserInfo[]>} returns.connected - 已连麦用户列表
+ * @returns {ComputedRef<LiveUserInfo[]>} returns.invitees - 被邀请用户列表
+ * @returns {ComputedRef<LiveUserInfo[]>} returns.applicants - 申请连麦用户列表
+ * @returns {Ref<Array>} returns.candidates - 候选用户列表
+ * @returns {Function} returns.applyForSeat - 申请连麦座位函数
+ * @returns {Function} returns.cancelApplication - 取消连麦申请函数
+ * @returns {Function} returns.acceptApplication - 接受连麦申请函数
+ * @returns {Function} returns.rejectApplication - 拒绝连麦申请函数
+ * @returns {Function} returns.inviteToSeat - 邀请用户连麦函数
+ * @returns {Function} returns.cancelInvitation - 取消连麦邀请函数
+ * @returns {Function} returns.acceptInvitation - 接受连麦邀请函数
+ * @returns {Function} returns.rejectInvitation - 拒绝连麦邀请函数
+ * @returns {Function} returns.disConnect - 断开连麦连接函数
+ * @returns {Function} returns.subscribeEvent - 订阅连麦事件函数
+ * @returns {Function} returns.unsubscribeEvent - 取消订阅连麦事件函数
+ * @example
+ * ```typescript
+ * const {
+ *   connected,
+ *   invitees,
+ *   applicants,
+ *   candidates,
+ *   applyForSeat,
+ *   cancelApplication,
+ *   acceptApplication,
+ *   rejectApplication,
+ *   inviteToSeat,
+ *   cancelInvitation,
+ *   acceptInvitation,
+ *   rejectInvitation,
+ *   disConnect,
+ *   subscribeEvent,
+ *   unsubscribeEvent,
+ * } = useCoGuestState();
+ *
+ * // 申请连麦
+ * await applyForSeat({
+ *   seatIndex: 1,
+ *   timeout: 30000
+ * });
+ *
+ * // 订阅连麦事件
+ * subscribeEvent(GuestEvent.onHostInvitationReceived, (eventInfo) => {
+ *   console.log('收到连麦邀请:', eventInfo.hostUser);
+ * });
+ * ```
+ */
 export declare function useCoGuestState(): {
     connected: import('vue').ComputedRef<SeatUserInfo[]>;
     invitees: import('vue').ComputedRef<LiveUserInfo[]>;
@@ -30,7 +82,7 @@ export declare function useCoGuestState(): {
     rejectInvitation: (options: {
         inviterId: string;
     }) => Promise<void>;
-    disConnect: () => Promise<void | undefined>;
+    disConnect: () => Promise<any>;
     subscribeEvent: (event: HostEvent | GuestEvent, callback: (eventInfo: any) => void) => void;
     unsubscribeEvent: (event: HostEvent | GuestEvent, callback: (eventInfo: any) => void) => void;
 };

package/dist/states/CoGuestState.js

@@ -6,20 +6,20 @@ import { MetricsKey as E } from "../report/MetricsKey.js";
 import { useLoginState as C } from "./LoginState.js";
 import { useSeatStore as O } from "./SeatStore.js";
 import { useLiveListState as G } from "./LiveListState/LiveListState.js";
-import { NoResponseReason as T, HostEvent as v, GuestEvent as p } from "../types/coGuest.js";
+import { NoResponseReason as T, HostEvent as v, GuestEvent as m } from "../types/coGuest.js";
 const i = S(), { loginUserInfo: _ } = C(), { currentLive: H } = G(), {
   seatList: L,
   localUserId: A,
   userInfoMap: N,
   getUserInfo: y
-} = O(), n = k(/* @__PURE__ */ new Map()), c = k(/* @__PURE__ */ new Map()), m = /* @__PURE__ */ new Map(), M = (e, t) => {
+} = O(), n = k(/* @__PURE__ */ new Map()), c = k(/* @__PURE__ */ new Map()), p = /* @__PURE__ */ new Map(), M = (e, t) => {
   var s;
-  m.has(e) || m.set(e, []), (s = m.get(e)) == null || s.push(t);
+  p.has(e) || p.set(e, []), (s = p.get(e)) == null || s.push(t);
 }, K = (e, t) => {
-  const s = m.get(e);
-  s && (s.splice(s.indexOf(t), 1), s.length === 0 && m.delete(e));
+  const s = p.get(e);
+  s && (s.splice(s.indexOf(t), 1), s.length === 0 && p.delete(e));
 }, u = (e, t) => {
-  const s = m.get(e);
+  const s = p.get(e);
   s && s.forEach((a) => {
     try {
       a(t);
@@ -55,7 +55,7 @@ const i = S(), { loginUserInfo: _ } = C(), { currentLive: H } = G(), {
         switch (U) {
           case d.kRequestAccepted:
             u(
-              p.onGuestApplicationResponded,
+              m.onGuestApplicationResponded,
               {
                 isAccept: !0,
                 hostUser: {
@@ -68,7 +68,7 @@ const i = S(), { loginUserInfo: _ } = C(), { currentLive: H } = G(), {
             break;
           case d.kRequestRejected:
             u(
-              p.onGuestApplicationResponded,
+              m.onGuestApplicationResponded,
               {
                 isAccept: !1,
                 hostUser: {
@@ -81,7 +81,7 @@ const i = S(), { loginUserInfo: _ } = C(), { currentLive: H } = G(), {
             break;
           case d.kRequestTimeout:
             u(
-              p.onGuestApplicationNoResponse,
+              m.onGuestApplicationNoResponse,
               {
                 reason: T.timeout
               }
@@ -208,7 +208,7 @@ const i = S(), { loginUserInfo: _ } = C(), { currentLive: H } = G(), {
       break;
     case R.kRequestRemoteUserOnSeat:
       u(
-        p.onHostInvitationReceived,
+        m.onHostInvitationReceived,
         {
           hostUser: {
             userId: t,
@@ -216,7 +216,7 @@ const i = S(), { loginUserInfo: _ } = C(), { currentLive: H } = G(), {
             avatarUrl: o
           }
         }
-      ), c.value.set(t, e);
+      ), c.value.set(e.fromUser.userId, e);
       break;
   }
 }, Z = ({
@@ -263,7 +263,7 @@ const i = S(), { loginUserInfo: _ } = C(), { currentLive: H } = G(), {
       break;
     case R.kRequestRemoteUserOnSeat:
       u(
-        p.onHostInvitationCancelled,
+        m.onHostInvitationCancelled,
         {
           hostUser: {
             userId: e,
@@ -276,7 +276,7 @@ const i = S(), { loginUserInfo: _ } = C(), { currentLive: H } = G(), {
   }
 }, te = ({ seatIndex: e, userInfo: t }) => {
   u(
-    p.onKickedOffSeat,
+    m.onKickedOffSeat,
     {
       seatIndex: e,
       hostUser: {
@@ -310,7 +310,7 @@ h(
   },
   { immediate: !0 }
 );
-function pe() {
+function me() {
   return {
     // state
     connected: j,
@@ -333,5 +333,5 @@ function pe() {
   };
 }
 export {
-  pe as useCoGuestState
+  me as useCoGuestState
 };

package/dist/states/CoHostState/CoHostState.d.ts

@@ -2,7 +2,127 @@ import { Ref } from 'vue';
 import { TUIConnectionCode } from '@tencentcloud/tuiroom-engine-js';
 import { CoHostStatus, CoHostEvent, SeatUserInfo, CoHostLayoutTemplate } from '../../types';
 
+/**
+ * 连麦事件回调函数类型
+ * @memberof module:CoHostState
+ * @description 定义连麦事件的回调函数类型
+ * @typedef {Function} CoHostEventCallback
+ * @param {any} eventInfo - 事件信息对象
+ */
 export type CoHostEventCallback = (eventInfo: any) => void;
+/**
+ * 连麦状态管理组合式函数
+ * @memberof module:CoHostState
+ * @description 提供直播连麦功能的所有状态和操作方法，包括连麦邀请、接受、拒绝、退出以及事件监听
+ * @returns {Object} 连麦状态管理对象
+ * @returns {ComputedRef<CoHostStatus>} returns.coHostStatus - 当前用户连麦状态
+ * @returns {Ref<SeatUserInfo[]>} returns.connected - 已连麦用户列表
+ * @returns {Ref<SeatUserInfo | null>} returns.applicant - 连麦申请者信息
+ * @returns {Ref<SeatUserInfo[]>} returns.invitees - 连麦邀请列表
+ * @returns {ComputedRef<SeatUserInfo[]>} returns.candidates - 可邀请连麦的候选用户列表
+ * @returns {Function} returns.requestHostConnection - 请求连麦
+ * @returns {Function} returns.cancelHostConnection - 取消连麦请求
+ * @returns {Function} returns.acceptHostConnection - 接受连麦请求
+ * @returns {Function} returns.rejectHostConnection - 拒绝连麦请求
+ * @returns {Function} returns.exitHostConnection - 退出连麦
+ * @returns {Function} returns.subscribeEvent - 订阅连麦事件
+ * @returns {Function} returns.unsubscribeEvent - 取消订阅连麦事件
+ * @example
+ * ```typescript
+ * import { useCoHostState, CoHostEvent, CoHostStatus } from '@/states/CoHostState';
+ *
+ * // 在Vue组件中使用
+ * export default {
+ *   setup() {
+ *     const {
+ *       coHostStatus,
+ *       connected,
+ *       applicant,
+ *       invitees,
+ *       candidates,
+ *       requestHostConnection,
+ *       acceptHostConnection,
+ *       rejectHostConnection,
+ *       exitHostConnection,
+ *       subscribeEvent,
+ *       unsubscribeEvent
+ *     } = useCoHostState();
+ *
+ *     // 监听连麦状态变化
+ *     watch(coHostStatus, (status) => {
+ *       if (status === CoHostStatus.Connected) {
+ *         console.log('已连麦');
+ *       } else {
+ *         console.log('未连麦');
+ *       }
+ *     });
+ *
+ *     // 监听连麦事件
+ *     const handleCoHostEvents = () => {
+ *       // 连麦请求事件
+ *       subscribeEvent(CoHostEvent.onCoHostRequestReceived, (eventInfo) => {
+ *         const { inviter } = eventInfo;
+ *         console.log(`收到来自 ${inviter.userName} 的连麦请求`);
+ *       });
+ *
+ *       // 用户加入连麦事件
+ *       subscribeEvent(CoHostEvent.onCoHostUserJoined, (eventInfo) => {
+ *         console.log('用户加入连麦:', eventInfo.userInfo.userName);
+ *       });
+ *
+ *       // 用户离开连麦事件
+ *       subscribeEvent(CoHostEvent.onCoHostUserLeft, (eventInfo) => {
+ *         console.log('用户离开连麦:', eventInfo.userInfo.userName);
+ *       });
+ *     };
+ *
+ *     // 发起连麦请求
+ *     const startCoHost = async (targetUser: SeatUserInfo) => {
+ *       try {
+ *         await requestHostConnection({
+ *           liveId: targetUser.liveId,
+ *           layoutTemplate: CoHostLayoutTemplate.Grid,
+ *           timeout: 30,
+ *           extensionInfo: JSON.stringify({ type: 'music' })
+ *         });
+ *         console.log('连麦请求已发送');
+ *       } catch (error) {
+ *         console.error('发起连麦失败:', error);
+ *       }
+ *     };
+ *
+ *     // 处理连麦请求
+ *     const handleCoHostRequest = async (accept: boolean) => {
+ *       if (applicant.value) {
+ *         try {
+ *           if (accept) {
+ *             await acceptHostConnection({ liveId: applicant.value.liveId });
+ *           } else {
+ *             await rejectHostConnection({ liveId: applicant.value.liveId });
+ *           }
+ *         } catch (error) {
+ *           console.error('处理连麦请求失败:', error);
+ *         }
+ *       }
+ *     };
+ *
+ *     onMounted(() => {
+ *       handleCoHostEvents();
+ *     });
+ *
+ *     return {
+ *       coHostStatus,
+ *       connected,
+ *       applicant,
+ *       candidates,
+ *       startCoHost,
+ *       handleCoHostRequest,
+ *       exitHostConnection
+ *     };
+ *   }
+ * };
+ * ```
+ */
 export declare function useCoHostState(): {
     coHostStatus: import('vue').ComputedRef<CoHostStatus>;
     connected: Ref<SeatUserInfo[], SeatUserInfo[]>;

package/dist/states/ContactListState/ContactListState.d.ts

@@ -1,6 +1,11 @@
 import { Ref } from 'vue';
 import { AddFriendParams, DeleteFriendParams, Friend, FriendApplication, FriendApplicationParams, FriendGroup, FriendGroupParams, FriendRemarkParams, GroupApplication, GroupApplicationParams, GroupModel, JoinGroupParams, RenameFriendGroupParams, UserProfile } from '../../types';
 
+/**
+ * 联系人列表状态接口
+ * @interface ContactListState
+ * @description 定义联系人列表相关的响应式状态数据
+ */
 interface ContactListState {
     friendList: Ref<Friend[]>;
     groupList: Ref<GroupModel[]>;
@@ -10,6 +15,11 @@ interface ContactListState {
     friendApplicationList: Ref<FriendApplication[]>;
     groupApplicationList: Ref<GroupApplication[]>;
 }
+/**
+ * 联系人列表操作接口
+ * @interface ContactListAction
+ * @description 定义联系人列表相关的操作方法
+ */
 interface ContactListAction {
     addFriend: (options: AddFriendParams) => Promise<unknown>;
     markFriendApplicationAsRead: () => Promise<unknown>;
@@ -35,6 +45,52 @@ interface ContactListAction {
     setFriendApplicationList: (friendApplicationList: FriendApplication[]) => void;
     setGroupApplicationList: (groupApplicationList: GroupApplication[]) => void;
 }
+/**
+ * 联系人列表状态返回类型
+ * @description 排除内部设置方法的公开接口类型
+ */
 type UseContactListStateReturn = Omit<ContactListState & ContactListAction, 'setFriendList' | 'setGroupList' | 'setBlackList' | 'setFriendApplicationUnreadCount' | 'setFriendGroupList' | 'setFriendApplicationList' | 'setGroupApplicationList'>;
+/**
+ * 联系人列表状态管理Hook
+ * @memberof module:ContactListState
+ * @description 提供联系人列表相关的状态和操作方法，包括好友管理、群组管理、黑名单管理等功能
+ * @returns {UseContactListStateReturn} 联系人列表状态和操作方法
+ * @example
+ * ```typescript
+ * import { useContactListState } from './ContactListState';
+ *
+ * // 在组件中使用
+ * const {
+ *   friendList,
+ *   groupList,
+ *   blackList,
+ *   friendApplicationList,
+ *   addFriend,
+ *   deleteFriend,
+ *   addToBlacklist,
+ *   createFriendGroup,
+ *   joinGroup
+ * } = useContactListState();
+ *
+ * // 添加好友
+ * await addFriend({
+ *   userID: 'user123',
+ *   addSource: 'search',
+ *   remark: '新朋友'
+ * });
+ *
+ * // 创建好友分组
+ * await createFriendGroup({
+ *   name: '工作同事',
+ *   userIDList: ['user123']
+ * });
+ *
+ * // 加入群组
+ * await joinGroup({
+ *   groupID: 'group123',
+ *   applyMessage: '申请加入群组'
+ * });
+ * ```
+ */
 declare function useContactListState(): UseContactListStateReturn;
 export { useContactListState };

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

@@ -23,6 +23,42 @@ interface ConversationListAction {
     getConversation: (conversationID: string) => ConversationModel | undefined;
 }
 type UseConversationListStateReturn = Omit<ConversationListState & ConversationListAction, 'setConversationList' | 'setTotalUnRead' | 'getConversation' | 'setCurrentConversation'>;
+/**
+ * 会话列表状态管理 Hook
+ * @memberof module:ConversationListState
+ * @description 提供会话列表的状态管理和操作功能，包括会话切换、创建、删除、置顶、免打扰等
+ * @returns {UseConversationListStateReturn} 返回会话列表状态管理对象
+ * @returns {Ref<ConversationModel[]>} returns.conversationList - 会话列表
+ * @returns {Ref<ConversationModel>} returns.activeConversation - 当前活跃会话
+ * @returns {Ref<number>} returns.totalUnRead - 总未读消息数
+ * @returns {Ref<number>} returns.netStatus - 网络连接状态
+ * @returns {Function} returns.setActiveConversation - 设置活跃会话函数
+ * @returns {Function} returns.createC2CConversation - 创建单聊会话函数
+ * @returns {Function} returns.createGroupConversation - 创建群聊会话函数
+ * @returns {Function} returns.pinConversation - 置顶会话函数
+ * @returns {Function} returns.deleteConversation - 删除会话函数
+ * @returns {Function} returns.muteConversation - 会话免打扰函数
+ * @example
+ * ```typescript
+ * const {
+ *   conversationList,
+ *   activeConversation,
+ *   totalUnRead,
+ *   setActiveConversation,
+ *   createC2CConversation,
+ *   pinConversation
+ * } = useConversationListState();
+ *
+ * // 切换会话
+ * await setActiveConversation('C2Cuser123');
+ *
+ * // 创建单聊
+ * const conversation = await createC2CConversation('user123');
+ *
+ * // 置顶会话
+ * await pinConversation('C2Cuser123', true);
+ * ```
+ */
 declare function useConversationListState(): UseConversationListStateReturn;
 export { useConversationListState };
 export default useConversationListState;

package/dist/states/DeviceState/DeviceState.d.ts

@@ -1,12 +1,71 @@
-import { DeviceStatus, TUIDeviceInfo } from '../../types';
-import { DeviceError, VideoQuality, AudioRoute, MirrorType, NetworkInfo } from '../../types/device';
 import { TUIMediaDeviceType, TUIMediaDeviceState } from '@tencentcloud/tuiroom-engine-js';
+import { DeviceStatus, TUIDeviceInfo } from '../../types';
+import { DeviceError, VideoQuality, AudioRoute, MirrorType, NetworkQuality, NetworkInfo } from '../../types/device';
 
+/**
+ * 设备变化事件处理
+ * @memberof module:DeviceState
+ * @description 处理设备插拔、状态变化等事件，自动更新设备列表
+ * @param {Object} eventInfo - 设备事件信息
+ * @param {string} eventInfo.deviceId - 设备ID
+ * @param {TUIMediaDeviceType} eventInfo.type - 设备类型
+ * @param {TUIMediaDeviceState} eventInfo.state - 设备状态
+ * @returns {Promise<void>} 处理设备变化的Promise
+ * @example
+ * ```typescript
+ * // 内部使用，当设备状态变化时自动调用
+ * await onDeviceChanged({
+ *   deviceId: 'device-123',
+ *   type: TUIMediaDeviceType.kMediaDeviceTypeAudioInput,
+ *   state: TUIMediaDeviceState.kMediaDeviceStateActive
+ * });
+ * ```
+ */
 export declare function onDeviceChanged(eventInfo: {
     deviceId: string;
     type: TUIMediaDeviceType;
     state: TUIMediaDeviceState;
 }): Promise<void>;
+/**
+ * 设备状态管理 Hook
+ * @memberof module:DeviceState
+ * @description 提供音视频设备的状态管理和控制功能，包括麦克风、摄像头、扬声器和屏幕分享
+ * @returns {Object} 返回设备状态管理对象
+ * @returns {Ref<boolean>} returns.microphoneStatus - 麦克风开启状态
+ * @returns {Ref<TUIDeviceInfo[]>} returns.microphoneList - 麦克风设备列表
+ * @returns {Ref<TUIDeviceInfo | null>} returns.currentMicrophone - 当前选中的麦克风
+ * @returns {Ref<boolean>} returns.cameraStatus - 摄像头开启状态
+ * @returns {Ref<TUIDeviceInfo[]>} returns.cameraList - 摄像头设备列表
+ * @returns {Ref<TUIDeviceInfo | null>} returns.currentCamera - 当前选中的摄像头
+ * @returns {Ref<TUIDeviceInfo[]>} returns.speakerList - 扬声器设备列表
+ * @returns {Ref<TUIDeviceInfo | null>} returns.currentSpeaker - 当前选中的扬声器
+ * @returns {Ref<boolean>} returns.screenStatus - 屏幕分享状态
+ * @returns {Function} returns.openMicrophone - 开启麦克风函数
+ * @returns {Function} returns.closeMicrophone - 关闭麦克风函数
+ * @returns {Function} returns.openCamera - 开启摄像头函数
+ * @returns {Function} returns.closeCamera - 关闭摄像头函数
+ * @returns {Function} returns.startScreenShare - 开始屏幕分享函数
+ * @returns {Function} returns.stopScreenShare - 停止屏幕分享函数
+ * @example
+ * ```typescript
+ * const {
+ *   microphoneStatus,
+ *   cameraStatus,
+ *   openMicrophone,
+ *   closeCamera,
+ *   startScreenShare
+ * } = useDeviceState();
+ *
+ * // 开启麦克风
+ * await openMicrophone();
+ *
+ * // 关闭摄像头
+ * await closeCamera();
+ *
+ * // 开始屏幕分享
+ * await startScreenShare();
+ * ```
+ */
 export declare function useDeviceState(): {
     microphoneStatus: import('vue').Ref<DeviceStatus, DeviceStatus>;
     microphoneList: import('vue').Ref<{
@@ -139,15 +198,14 @@ export declare function useDeviceState(): {
     currentAudioRoute: import('vue').Ref<AudioRoute, AudioRoute>;
     isSpeakerTesting: import('vue').Ref<boolean, boolean>;
     screenStatus: import('vue').Ref<DeviceStatus, DeviceStatus>;
+    screenLastError: import('vue').Ref<DeviceError, DeviceError>;
     networkInfo: import('vue').Ref<{
-        userId: string;
-        quality: import('../..').NetworkQuality;
+        quality: NetworkQuality;
         upLoss: number;
         downLoss: number;
         delay: number;
     } | null, NetworkInfo | {
-        userId: string;
-        quality: import('../..').NetworkQuality;
+        quality: NetworkQuality;
         upLoss: number;
         downLoss: number;
         delay: number;
@@ -160,7 +218,7 @@ export declare function useDeviceState(): {
     setCurrentMicrophone: (options: {
         deviceId: string;
     }) => Promise<void>;
-    startMicrophoneTest: (options: {
+    startMicrophoneTest: (options?: {
         interval?: number;
     }) => Promise<void>;
     stopMicrophoneTest: () => Promise<void>;
@@ -190,10 +248,10 @@ export declare function useDeviceState(): {
     updateVideoQuality: (options: {
         quality: VideoQuality;
     }) => Promise<void>;
-    startCameraDeviceTest: (options: {
-        view: string;
+    startCameraTest: (options: {
+        view: string | HTMLDivElement;
     }) => Promise<void>;
-    stopCameraDeviceTest: () => Promise<void>;
+    stopCameraTest: () => Promise<void>;
     startScreenShare: (options?: {
         screenAudio?: boolean;
         view?: string;