tuikit-atomicx-vue3 0.1.0 → 3.3.0-beta.3

package/dist/states/ContactListState/ContactListState.js

@@ -0,0 +1,321 @@
+import { ref } from "vue";
+import TUIChatEngine, { TUIStore, StoreName, TUIGroupService, TUIFriendService, TUIUserService } from "@tencentcloud/chat-uikit-engine";
+const friendListRef = ref([]);
+const groupListRef = ref([]);
+const blackListRef = ref([]);
+const friendApplicationUnreadCountRef = ref(0);
+const friendGroupListRef = ref([]);
+const friendApplicationListRef = ref([]);
+const groupApplicationListRef = ref([]);
+function debounce(func, wait) {
+  let timeout;
+  return (...args) => {
+    clearTimeout(timeout);
+    timeout = setTimeout(() => func(...args), wait);
+  };
+}
+const addFriend = async (options) => {
+  try {
+    const params = {
+      to: options.userID,
+      source: options.addSource
+    };
+    if (options.remark) {
+      params.remark = options.remark;
+    }
+    if (options.groupName) {
+      params.groupName = options.groupName;
+    }
+    if (options.wording) {
+      params.wording = options.wording;
+    }
+    if (options.type) {
+      params.type = options.type;
+    }
+    const result = await TUIFriendService.addFriend(params);
+    return result;
+  } catch (error) {
+    console.error("[ContactListState addFriend] error", error);
+    throw error;
+  }
+};
+const markFriendApplicationAsRead = async () => {
+  try {
+    const result = await TUIFriendService.setFriendApplicationRead();
+    return result;
+  } catch (error) {
+    console.error("[ContactListState markFriendApplicationAsRead] error", error);
+    throw error;
+  }
+};
+const acceptFriendApplication = async (options) => {
+  try {
+    const result = await TUIFriendService.acceptFriendApplication({
+      userID: options.userID,
+      remark: options.remark || "",
+      type: options.type
+    });
+    return result;
+  } catch (error) {
+    console.error("[ContactListState acceptFriendApplication] error", error);
+    throw error;
+  }
+};
+const refuseFriendApplication = async (userID) => {
+  try {
+    const result = await TUIFriendService.refuseFriendApplication(userID);
+    return result;
+  } catch (error) {
+    console.error("[ContactListState refuseFriendApplication] error", error);
+    throw error;
+  }
+};
+const deleteFriend = async (options) => {
+  try {
+    const result = await TUIFriendService.deleteFriend(options);
+    return result;
+  } catch (error) {
+    console.error("[ContactListState deleteFriend] error", error);
+    throw error;
+  }
+};
+const setFriendRemark = async (options) => {
+  try {
+    const result = await TUIFriendService.updateFriend({
+      userID: options.userID,
+      remark: options.remark
+    });
+    return result;
+  } catch (error) {
+    console.error("[ContactListState setFriendRemark] error", error);
+    throw error;
+  }
+};
+const addToBlacklist = async (userIDList) => {
+  try {
+    const result = await TUIUserService.addToBlacklist({ userIDList });
+    return result;
+  } catch (error) {
+    console.error("[ContactListState addToBlacklist] error", error);
+    throw error;
+  }
+};
+const removeFromBlacklist = async (userIDList) => {
+  try {
+    const result = await TUIUserService.removeFromBlacklist({ userIDList });
+    return result;
+  } catch (error) {
+    console.error("[ContactListState removeFromBlacklist] error", error);
+    throw error;
+  }
+};
+const createFriendGroup = async (options) => {
+  try {
+    const result = await TUIFriendService.createFriendGroup(options);
+    return result;
+  } catch (error) {
+    console.error("[ContactListState createFriendGroup] error", error);
+    throw error;
+  }
+};
+const deleteFriendGroup = async (name) => {
+  try {
+    const result = await TUIFriendService.deleteFriendGroup(name);
+    return result;
+  } catch (error) {
+    console.error("[ContactListState deleteFriendGroup] error", error);
+    throw error;
+  }
+};
+const addToFriendGroup = async (options) => {
+  try {
+    const result = await TUIFriendService.addToFriendGroup(options);
+    return result;
+  } catch (error) {
+    console.error("[ContactListState addToFriendGroup] error", error);
+    throw error;
+  }
+};
+const removeFromFriendGroup = async (options) => {
+  try {
+    const result = await TUIFriendService.removeFromFriendGroup(options);
+    return result;
+  } catch (error) {
+    console.error("[ContactListState removeFromFriendGroup] error", error);
+    throw error;
+  }
+};
+const renameFriendGroup = async (options) => {
+  try {
+    const result = await TUIFriendService.renameFriendGroup(options);
+    return result;
+  } catch (error) {
+    console.error("[ContactListState renameFriendGroup] error", error);
+    throw error;
+  }
+};
+const joinGroup = async (options) => {
+  try {
+    const result = await TUIGroupService.joinGroup(options);
+    return result;
+  } catch (error) {
+    console.error("[ContactListState joinGroup] error", error);
+    throw error;
+  }
+};
+const setGroupApplicationList = (list) => {
+  groupApplicationListRef.value = list;
+};
+const acceptGroupApplication = async (options) => {
+  try {
+    const result = await TUIGroupService.handleGroupApplication({
+      handleAction: "Agree",
+      handleMessage: options.handleMessage || "",
+      application: options.application
+    });
+    const updatedGroupApplicationList = groupApplicationListRef.value.filter(
+      (application) => application !== options.application
+    );
+    setGroupApplicationList(updatedGroupApplicationList);
+    return result;
+  } catch (error) {
+    console.error("[ContactListState acceptGroupApplication] error", error);
+    throw error;
+  }
+};
+const refuseGroupApplication = async (options) => {
+  try {
+    const result = await TUIGroupService.handleGroupApplication({
+      handleAction: "Reject",
+      handleMessage: options.handleMessage || "",
+      application: options.application
+    });
+    const updatedGroupApplicationList = groupApplicationListRef.value.filter(
+      (application) => application !== options.application
+    );
+    setGroupApplicationList(updatedGroupApplicationList);
+    return result;
+  } catch (error) {
+    console.error("[ContactListState refuseGroupApplication] error", error);
+    throw error;
+  }
+};
+const setFriendList = (list) => {
+  friendListRef.value = list;
+};
+const setGroupList = (list) => {
+  groupListRef.value = list;
+};
+const setBlackList = (list) => {
+  blackListRef.value = list;
+};
+const setFriendApplicationUnreadCount = (count) => {
+  friendApplicationUnreadCountRef.value = count;
+};
+const setFriendGroupList = (list) => {
+  friendGroupListRef.value = list;
+};
+const setFriendApplicationList = (list) => {
+  friendApplicationListRef.value = list;
+};
+const onGroupListUpdated = (groupList) => {
+  setGroupList(groupList);
+};
+const onUserBlacklistUpdated = (userBlacklist) => {
+  setBlackList(userBlacklist);
+};
+const onFriendListUpdated = (friendList) => {
+  if (friendList.length > 0) {
+    const tempFriendList = friendList.map((item) => ({
+      ...item.profile,
+      remark: item.remark || ""
+    }));
+    setFriendList(tempFriendList);
+  } else {
+    setFriendList([]);
+  }
+};
+const onFriendGroupListUpdated = (friendGroupList) => {
+  setFriendGroupList(friendGroupList);
+};
+const onFriendApplicationListUpdated = (friendApplicationList) => {
+  const applicationSentToMe = friendApplicationList.filter(
+    (friendApplication) => friendApplication.type === TUIChatEngine.TYPES.SNS_APPLICATION_SENT_TO_ME
+  );
+  setFriendApplicationList(applicationSentToMe);
+};
+const onFriendApplicationUnreadCountUpdated = (count) => {
+  setFriendApplicationUnreadCount(count);
+};
+const getGroupApplicationList = debounce(async () => {
+  try {
+    const res = await TUIGroupService.getGroupApplicationList();
+    const { applicationList } = res.data;
+    setGroupApplicationList(applicationList);
+    return res;
+  } catch (error) {
+    console.error("[ContactListState getGroupApplicationList] error", error);
+    throw error;
+  }
+}, 300);
+const onGroupSystemNoticeList = (systemNoticeList) => {
+  const groupApplicationList = systemNoticeList.filter(
+    (item) => item.payload.operationType === 1 || item.payload.operationType === 23
+  );
+  if (groupApplicationList.length > 0) {
+    getGroupApplicationList();
+  }
+};
+const initContactListWatcher = () => {
+  TUIStore.watch(StoreName.USER, {
+    userProfile: (profile) => {
+      if (profile == null ? void 0 : profile.userID) {
+        getGroupApplicationList();
+      }
+    }
+  });
+  TUIStore.watch(StoreName.GRP, {
+    groupList: onGroupListUpdated,
+    groupSystemNoticeList: onGroupSystemNoticeList
+  });
+  TUIStore.watch(StoreName.USER, {
+    userBlacklist: onUserBlacklistUpdated
+  });
+  TUIStore.watch(StoreName.FRIEND, {
+    friendList: onFriendListUpdated,
+    friendApplicationList: onFriendApplicationListUpdated,
+    friendApplicationUnreadCount: onFriendApplicationUnreadCountUpdated,
+    friendGroupList: onFriendGroupListUpdated
+  });
+};
+initContactListWatcher();
+function useContactListState() {
+  return {
+    friendList: friendListRef,
+    groupList: groupListRef,
+    blackList: blackListRef,
+    friendApplicationUnreadCount: friendApplicationUnreadCountRef,
+    friendGroupList: friendGroupListRef,
+    friendApplicationList: friendApplicationListRef,
+    groupApplicationList: groupApplicationListRef,
+    addFriend,
+    markFriendApplicationAsRead,
+    acceptFriendApplication,
+    refuseFriendApplication,
+    addToBlacklist,
+    removeFromBlacklist,
+    deleteFriend,
+    setFriendRemark,
+    createFriendGroup,
+    deleteFriendGroup,
+    addToFriendGroup,
+    removeFromFriendGroup,
+    renameFriendGroup,
+    joinGroup,
+    acceptGroupApplication,
+    refuseGroupApplication
+  };
+}
+export {
+  useContactListState
+};

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

@@ -0,0 +1 @@
+export { useContactListState } from './ContactListState';

package/dist/states/ContactListState/index.js

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

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

@@ -1,13 +1,28 @@
 import { Ref } from 'vue';
-import { IConversationModel } from '@tencentcloud/chat-uikit-engine';
+import { default as TUIChatEngine, SetConversationDraftParams } from '@tencentcloud/chat-uikit-engine';
+import { ConversationModel, CreateGroupParams } from '../../types';
 
-interface IConversationListStoreState {
-    currentConversation: Ref<IConversationModel | undefined>;
-    currentConversationID: Ref<string | undefined>;
-    conversationList: Ref<IConversationModel[] | undefined>;
+interface ConversationListState {
+    conversationList: Ref<ConversationModel[] | undefined>;
+    activeConversation: Ref<ConversationModel | undefined>;
+    totalUnRead: Ref<number>;
+    netStatus: Ref<typeof TUIChatEngine.TYPES.NET_STATE_CONNECTED | typeof TUIChatEngine.TYPES.NET_STATE_CONNECTING | typeof TUIChatEngine.TYPES.NET_STATE_DISCONNECTED>;
 }
-interface IConversationListStoreAction {
-    switchConversation: (conversationID: string) => void;
+interface ConversationListAction {
+    setActiveConversation: (conversationID: string) => void;
+    setCurrentConversation: (conversation: ConversationModel | undefined) => void;
+    createC2CConversation: (userID: string) => Promise<ConversationModel>;
+    createGroupConversation: (options: CreateGroupParams) => Promise<ConversationModel>;
+    pinConversation: (conversationID: string, isPin: boolean) => Promise<unknown>;
+    deleteConversation: (conversationID: string) => Promise<unknown>;
+    muteConversation: (conversationID: string, isMute: boolean) => Promise<unknown>;
+    setConversationDraft: (options: SetConversationDraftParams) => Promise<unknown>;
+    markConversationUnread: (conversationID: string, isUnread: boolean) => void;
+    setConversationList: (conversationList: ConversationModel[]) => void;
+    setTotalUnRead: (totalUnRead: number) => void;
+    getConversation: (conversationID: string) => ConversationModel | undefined;
 }
-declare function useConversationListState(): IConversationListStoreState & IConversationListStoreAction;
+type UseConversationListStateReturn = Omit<ConversationListState & ConversationListAction, 'setConversationList' | 'setTotalUnRead' | 'getConversation' | 'setCurrentConversation'>;
+declare function useConversationListState(): UseConversationListStateReturn;
 export { useConversationListState };
+export default useConversationListState;

package/dist/states/ConversationListState/ConversationListState.js

@@ -1,19 +1,103 @@
 import { ref } from "vue";
-import ChatEngine, { TUIStore, StoreName, TUIConversationService } from "@tencentcloud/chat-uikit-engine";
-import { TUILogin } from "@tencentcloud/tui-core";
+import TUIChatEngine, { TUIStore, StoreName, TUIConversationService, TUIGroupService } from "@tencentcloud/chat-uikit-engine";
 const conversationListRef = ref(void 0);
-const currentConversationRef = ref(void 0);
-const currentConversationIDRef = ref(void 0);
+const activeConversationRef = ref(void 0);
+const totalUnReadRef = ref(0);
+const netStatusRef = ref(TUIChatEngine.TYPES.NET_STATE_CONNECTED);
+const setConversationList = (conversationList) => {
+  conversationListRef.value = conversationList;
+};
+const setTotalUnRead = (totalUnRead) => {
+  totalUnReadRef.value = totalUnRead;
+};
+const setCurrentConversation = (conversation) => {
+  activeConversationRef.value = conversation;
+};
+const getConversation = (conversationID) => {
+  var _a;
+  return (_a = conversationListRef.value) == null ? void 0 : _a.find((item) => item.conversationID === conversationID);
+};
+const markConversationUnread = (conversationID, isUnread) => {
+  const conversation = getConversation(conversationID);
+  const { markList = [], unreadCount = 0 } = conversation || {};
+  const isMarked = markList.includes(TUIChatEngine.TYPES.CONV_MARK_TYPE_UNREAD);
+  const isHasUnreadCount = unreadCount > 0;
+  const isNotNeedMarkUnread = isUnread && (isHasUnreadCount || isMarked);
+  const isNotNeedMarkRead = !isUnread && !isHasUnreadCount && !isMarked;
+  if (!conversation || isNotNeedMarkUnread || isNotNeedMarkRead) {
+    return Promise.resolve();
+  }
+  if (isHasUnreadCount && !isUnread) {
+    return conversation == null ? void 0 : conversation.setMessageRead();
+  }
+  return TUIConversationService.markConversation({
+    conversationIDList: [conversationID],
+    markType: TUIChatEngine.TYPES.CONV_MARK_TYPE_UNREAD,
+    enableMark: isUnread
+  });
+};
+const setActiveConversation = async (conversationID) => {
+  const currentActiveConversation = activeConversationRef.value;
+  if (conversationID !== (currentActiveConversation == null ? void 0 : currentActiveConversation.conversationID)) {
+    if (conversationID) {
+      markConversationUnread(conversationID, false);
+    }
+    await TUIConversationService.switchConversation(conversationID);
+  }
+};
+const pinConversation = (conversationID, isPin) => {
+  const conversation = getConversation(conversationID);
+  if (!conversation || (conversation == null ? void 0 : conversation.isPinned) === isPin) {
+    return Promise.resolve();
+  }
+  return conversation == null ? void 0 : conversation.pinConversation();
+};
+const deleteConversation = (conversationID) => {
+  const conversation = getConversation(conversationID);
+  if (!conversation) {
+    return Promise.resolve();
+  }
+  return conversation == null ? void 0 : conversation.deleteConversation();
+};
+const muteConversation = (conversationID, isMuted) => {
+  const conversation = getConversation(conversationID);
+  if (!conversation || (conversation == null ? void 0 : conversation.isMuted) === isMuted) {
+    return Promise.resolve();
+  }
+  return conversation == null ? void 0 : conversation.muteConversation();
+};
+const setConversationDraft = (options) => TUIConversationService.setConversationDraft(options);
+const createC2CConversation = async (userID) => {
+  const response = await TUIConversationService.getConversationProfile(`C2C${userID}`);
+  return response.data.conversation;
+};
+const createGroupConversation = async (options) => {
+  const { groupID, ...otherOptions } = options;
+  const params = otherOptions;
+  if (options.type !== TUIChatEngine.TYPES.GRP_COMMUNITY) {
+    params.groupID = groupID || "";
+  }
+  const res = await TUIGroupService.createGroup(params);
+  const { type } = res.data.group;
+  if (type === TUIChatEngine.TYPES.GRP_AVCHATROOM) {
+    await TUIGroupService.joinGroup({
+      groupID: res.data.group.groupID,
+      applyMessage: ""
+    });
+  }
+  const response = await TUIConversationService.getConversationProfile(`GROUP${res.data.group.groupID}`);
+  return response.data.conversation;
+};
 function initConversationWatcher() {
   TUIStore.watch(StoreName.CONV, {
     conversationList: (list) => {
-      conversationListRef.value = list;
-    },
-    currentConversationID: (ID) => {
-      currentConversationIDRef.value = ID;
+      setConversationList(list);
     },
     currentConversation: (conversation) => {
-      currentConversationRef.value = conversation;
+      setCurrentConversation(conversation ?? void 0);
+    },
+    totalUnreadCount: (count) => {
+      setTotalUnRead(count);
     }
   });
 }
@@ -21,20 +105,20 @@ 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);
-    }
+    activeConversation: activeConversationRef,
+    totalUnRead: totalUnReadRef,
+    netStatus: netStatusRef,
+    setActiveConversation,
+    markConversationUnread,
+    pinConversation,
+    deleteConversation,
+    muteConversation,
+    setConversationDraft,
+    createC2CConversation,
+    createGroupConversation
   };
 }
 export {
+  useConversationListState as default,
   useConversationListState
 };

package/dist/states/DeviceState.js

@@ -3,10 +3,10 @@ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { en
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import { ref } from "vue";
 import { DeviceStatus, DeviceError, AudioOutput } from "../types/device.js";
-import { TUIRoomEvents, TUIVideoStreamType } from "../types/types.js";
-import TUIRoomEngine, { TUIChangeReason, TUIVideoQuality, TUIRoomDeviceMangerEvents, TUIMediaDeviceType, TUIMediaDeviceState, TRTCVideoFillMode, TRTCVideoRotation, TRTCVideoMirrorType, TUIAudioRoute } from "@tencentcloud/tuiroom-engine-js";
+import TUIRoomEngine, { TUIChangeReason, TUIVideoQuality, TUIRoomDeviceMangerEvents, TUIMediaDeviceType, TUIMediaDeviceState, TRTCVideoFillMode, TRTCVideoRotation, TRTCVideoMirrorType, TUIAudioRoute, TUIErrorCode } from "@tencentcloud/tuiroom-engine-js";
 import { useRoomEngine, useDeviceManager } from "../hooks/useRoomEngine.js";
 import { useLoginState } from "./LoginState.js";
+import { TUIRoomEvents, TUIVideoStreamType } from "../types/types.js";
 const roomEngine = useRoomEngine();
 const deviceManager = useDeviceManager();
 const { loginUserInfo } = useLoginState();
@@ -45,10 +45,28 @@ const openLocalMicrophone = async () => {
   try {
     await ((_a = roomEngine.instance) == null ? void 0 : _a.openLocalMicrophone());
     microphoneStatus.value = DeviceStatus.On;
+    microphoneLastError.value = DeviceError.NoError;
   } catch (error) {
     if (error.code === 0 && error.message === "you have already mute the audio") {
       return;
     }
+    switch (error.code) {
+      case TUIErrorCode.ERR_MICROPHONE_START_FAILED:
+        microphoneLastError.value = DeviceError.NotSupportCapture;
+        break;
+      case TUIErrorCode.ERR_MICROPHONE_NOT_AUTHORIZED:
+        microphoneLastError.value = DeviceError.NoSystemPermission;
+        break;
+      case TUIErrorCode.ERR_MICROPHONE_OCCUPIED:
+        microphoneLastError.value = DeviceError.OccupiedError;
+        break;
+      case TUIErrorCode.ERR_MICROPHONE_DEVICE_EMPTY:
+        microphoneLastError.value = DeviceError.NoDeviceDetected;
+        break;
+      default:
+        microphoneLastError.value = DeviceError.UnknownError;
+        break;
+    }
     throw error;
   }
 };
@@ -286,21 +304,10 @@ function screenCaptureStopped() {
 }
 async function onDeviceChanged(eventInfo) {
   var _a, _b, _c, _d, _e, _f;
-  const { deviceId, type, state } = eventInfo;
+  const { type, state } = eventInfo;
   if (!deviceManager.instance) {
     return;
   }
-  ({
-    [TUIMediaDeviceType.kMediaDeviceTypeAudioInput]: "mic",
-    [TUIMediaDeviceType.kMediaDeviceTypeAudioOutput]: "speaker",
-    [TUIMediaDeviceType.kMediaDeviceTypeVideoCamera]: "camera",
-    [TUIMediaDeviceType.kMediaDeviceTypeUnknown]: "unknown"
-  });
-  ({
-    [TUIMediaDeviceState.kMediaDeviceStateAdd]: "add",
-    [TUIMediaDeviceState.kMediaDeviceStateRemove]: "remove",
-    [TUIMediaDeviceState.kMediaDeviceStateActive]: "active"
-  });
   if (type === TUIMediaDeviceType.kMediaDeviceTypeAudioInput) {
     microphoneList.value = await ((_a = deviceManager.instance) == null ? void 0 : _a.getDevicesList({
       type

package/dist/states/GroupSettingState/GroupSettingState.d.ts

@@ -0,0 +1,20 @@
+import { GroupMemberRole, GroupType, GroupPermission, GroupInviteType, GroupMember, GroupSettingState, GetGroupMemberListParams, UpdateGroupProfileParams, SetGroupMemberRoleParams, SetGroupMemberMuteTimeParams, SetGroupMemberNameCardParams, GroupPermissionUtils, AddGroupMemberParams, DeleteGroupMemberParams, ChangeGroupOwnerParams, AddGroupMemberResult } from './types';
+
+interface IGroupSettingBusinessAction extends GroupPermissionUtils {
+    setChatPinned: (value: boolean) => Promise<void>;
+    setChatMuted: (value: boolean) => Promise<void>;
+    getGroupMemberList: (params?: GetGroupMemberListParams) => Promise<GroupMember[]>;
+    updateGroupProfile: (params: UpdateGroupProfileParams) => Promise<void>;
+    addGroupMember: (params: AddGroupMemberParams) => Promise<AddGroupMemberResult>;
+    deleteGroupMember: (params: DeleteGroupMemberParams) => Promise<void>;
+    setGroupMemberRole: (params: SetGroupMemberRoleParams) => Promise<void>;
+    changeGroupOwner: (params: ChangeGroupOwnerParams) => Promise<void>;
+    setGroupMemberMuteTime: (params: SetGroupMemberMuteTimeParams) => Promise<void>;
+    setGroupMemberNameCard: (params: SetGroupMemberNameCardParams) => Promise<void>;
+    setMuteAllMember: (value: boolean) => Promise<void>;
+    dismissGroup: (groupID?: string) => Promise<void>;
+    quitGroup: (groupID?: string) => Promise<void>;
+}
+declare function useGroupSettingState(): GroupSettingState & IGroupSettingBusinessAction;
+export { useGroupSettingState, GroupPermission, GroupType, GroupMemberRole, GroupInviteType, };
+export type { GroupMember, };