tuikit-atomicx-vue3 0.1.0 → 0.1.1

package/dist/rtc/server.js

@@ -0,0 +1,115 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { ref } from "vue";
+import TUIChatEngine from "@tencentcloud/chat-uikit-engine";
+import TUICore, { TUIConstants, TUILogin } from "@tencentcloud/tui-core";
+import TUIRoomEngine from "@tencentcloud/tuiroom-engine-js";
+import { useLoginState } from "../states/LoginState.js";
+const _RTCLoginServer = class _RTCLoginServer {
+  constructor() {
+    __publicField(this, "isReady", false);
+    __publicField(this, "isEngineLoggingIn", false);
+    __publicField(this, "isLogin", ref(false));
+    __publicField(this, "resolveList", []);
+    __publicField(this, "rejectList", []);
+    this.init();
+  }
+  static getInstance() {
+    if (!_RTCLoginServer.instance) {
+      _RTCLoginServer.instance = new _RTCLoginServer();
+    }
+    return _RTCLoginServer.instance;
+  }
+  init() {
+    if (!this.isReady) {
+      this.isReady = true;
+      TUICore.registerEvent(
+        TUIConstants.TUILogin.EVENT.LOGIN_STATE_CHANGED,
+        TUIConstants.TUILogin.EVENT_SUB_KEY.USER_LOGIN_SUCCESS,
+        this
+      );
+    }
+  }
+  /**
+   * @param { TUIInitParam } params
+   */
+  onNotifyEvent(eventName, subKey) {
+    if (eventName === TUIConstants.TUILogin.EVENT.LOGIN_STATE_CHANGED) {
+      switch (subKey) {
+        case TUIConstants.TUILogin.EVENT_SUB_KEY.USER_LOGIN_SUCCESS:
+          this.login();
+          break;
+        case TUIConstants.TUILogin.EVENT_SUB_KEY.USER_LOGOUT_SUCCESS:
+          this.logout();
+          break;
+      }
+    }
+  }
+  async login() {
+    const {
+      chat,
+      SDKAppID,
+      userID,
+      userSig
+    } = TUILogin.getContext();
+    if (this.isEngineLoggingIn) {
+      return new Promise((resolve, reject) => {
+        this.resolveList.push(resolve);
+        this.rejectList.push(reject);
+      });
+    }
+    try {
+      this.isEngineLoggingIn = true;
+      await TUIChatEngine.login({
+        chat,
+        SDKAppID,
+        userID,
+        userSig
+      });
+      const res = await TUIRoomEngine.login({
+        sdkAppId: SDKAppID,
+        userId: userID,
+        userSig,
+        tim: chat
+      });
+      this.isLogin.value = true;
+      this.resolveList.forEach((resolve) => {
+        resolve();
+      });
+      this.rejectList = [];
+      this.resolveList = [];
+      const { loginUserInfo } = useLoginState();
+      const result = await chat.getUserProfile({ userIDList: [userID] });
+      const localUserInfo = result.data[0];
+      if (!localUserInfo.value) {
+        loginUserInfo.value = {
+          userId: localUserInfo.userID,
+          userName: localUserInfo.nick,
+          avatarUrl: localUserInfo.avatar,
+          customInfo: localUserInfo.profileCustomField
+        };
+      }
+      return res;
+    } catch (error) {
+      this.rejectList.forEach((reject) => {
+        reject(error);
+      });
+      this.rejectList = [];
+      this.resolveList = [];
+      throw error;
+    } finally {
+      this.isEngineLoggingIn = false;
+    }
+  }
+  logout() {
+    TUIRoomEngine.logout();
+    this.isLogin.value = false;
+    this.isEngineLoggingIn = false;
+  }
+};
+__publicField(_RTCLoginServer, "instance");
+let RTCLoginServer = _RTCLoginServer;
+export {
+  RTCLoginServer as default
+};

package/dist/states/BarrageListState/BarrageListState.js

@@ -50,14 +50,12 @@ const processMessageQueue = async () => {
   isProcessingQueue.value = true;
   try {
     let currentBatch = [];
-    let lastUpdateTime = Date.now();
     while (messageUpdateQueue.value.length > 0) {
       const messages = messageUpdateQueue.value.splice(0, 1)[0];
       currentBatch.push(...messages);
       const newMessageList = [...messageListRef.value || [], ...currentBatch];
       messageListRef.value = truncateMessageList(newMessageList);
       currentBatch = [];
-      lastUpdateTime = Date.now();
       if (messageUpdateQueue.value.length > 0) {
         await new Promise((resolve) => setTimeout(resolve, MESSAGE_QUEUE_PROCESS_DELAY));
       }

package/dist/states/C2CSettingState/C2CSettingState.d.ts

@@ -0,0 +1,19 @@
+import { Ref } from 'vue';
+
+interface C2CSettingState {
+    userID: Ref<string | undefined>;
+    nick: Ref<string | undefined>;
+    avatar: Ref<string | undefined>;
+    signature: Ref<string | undefined>;
+    remark: Ref<string | undefined>;
+    isMuted: Ref<boolean | undefined>;
+    isPinned: Ref<boolean | undefined>;
+    isContact: Ref<boolean | undefined>;
+}
+interface C2CSettingBusinessAction {
+    setChatPinned: (value: boolean) => void;
+    setChatMuted: (value: boolean) => void;
+    setUserRemark: (remark: string) => void;
+}
+declare function useC2CSettingState(): C2CSettingState & C2CSettingBusinessAction;
+export { useC2CSettingState, };

package/dist/states/C2CSettingState/C2CSettingState.js

@@ -0,0 +1,112 @@
+import { ref, watch } from "vue";
+import TUIChatEngine, { TUIFriendService, TUIStore, StoreName } from "@tencentcloud/chat-uikit-engine";
+const currentConversationRef = ref(void 0);
+const userIDRef = ref(void 0);
+const nickRef = ref(void 0);
+const avatarRef = ref(void 0);
+const signatureRef = ref(void 0);
+const remarkRef = ref(void 0);
+const isMutedRef = ref(void 0);
+const isPinnedRef = ref(void 0);
+const isContactRef = ref(void 0);
+function setChatPinned(value) {
+  var _a;
+  if (value === isPinnedRef.value) {
+    return;
+  }
+  (_a = currentConversationRef.value) == null ? void 0 : _a.pinConversation();
+}
+function setChatMuted(value) {
+  var _a;
+  if (value === isMutedRef.value) {
+    return;
+  }
+  (_a = currentConversationRef.value) == null ? void 0 : _a.muteConversation();
+}
+function setUserRemark(remark) {
+  if (!userIDRef.value) {
+    return;
+  }
+  TUIFriendService.updateFriend({
+    userID: userIDRef.value,
+    remark
+  });
+}
+function reset() {
+  currentConversationRef.value = void 0;
+  userIDRef.value = void 0;
+  nickRef.value = void 0;
+  avatarRef.value = void 0;
+  signatureRef.value = void 0;
+  remarkRef.value = void 0;
+  isMutedRef.value = void 0;
+  isPinnedRef.value = void 0;
+  isContactRef.value = void 0;
+}
+watch(userIDRef, (userID) => {
+  if (!userID) {
+    return;
+  }
+  TUIFriendService.checkFriend({
+    userIDList: [userID],
+    type: TUIChatEngine.TYPES.SNS_CHECK_TYPE_BOTH
+  }).then((res) => {
+    var _a, _b, _c;
+    const _relation = (_c = (_b = (_a = res == null ? void 0 : res.data) == null ? void 0 : _a.successUserIDList) == null ? void 0 : _b[0]) == null ? void 0 : _c.relation;
+    if (_relation === "CheckResult_Type_BothWay") {
+      isContactRef.value = true;
+    } else {
+      isContactRef.value = false;
+    }
+  });
+});
+function initWatcher() {
+  TUIStore.watch(StoreName.CONV, {
+    currentConversation: (conversation) => {
+      if (conversation && conversation.type === "C2C") {
+        currentConversationRef.value = conversation;
+        const {
+          userProfile: {
+            userID,
+            nick,
+            avatar,
+            selfSignature
+          },
+          remark,
+          isPinned,
+          isMuted
+        } = conversation;
+        userIDRef.value = userID;
+        nickRef.value = nick;
+        avatarRef.value = avatar;
+        signatureRef.value = selfSignature;
+        remarkRef.value = remark;
+        isPinnedRef.value = isPinned;
+        isMutedRef.value = isMuted;
+      } else {
+        reset();
+      }
+    }
+  });
+}
+initWatcher();
+function useC2CSettingState() {
+  return {
+    // State
+    userID: userIDRef,
+    nick: nickRef,
+    avatar: avatarRef,
+    signature: signatureRef,
+    remark: remarkRef,
+    isMuted: isMutedRef,
+    isPinned: isPinnedRef,
+    isContact: isContactRef,
+    // Business actions
+    setChatPinned,
+    setChatMuted,
+    setUserRemark
+  };
+}
+export {
+  useC2CSettingState
+};

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

@@ -0,0 +1 @@
+export { useC2CSettingState } from './C2CSettingState';

package/dist/states/C2CSettingState/index.js

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

package/dist/states/CoGuestState.js

@@ -1,12 +1,12 @@
 import { ref, computed, watch } from "vue";
 import TUIRoomEngine, { TUIRoomEvents, TUIRequestAction, TUIMediaDevice } from "@tencentcloud/tuiroom-engine-js";
 import { useRoomEngine } from "../hooks/useRoomEngine.js";
-import { LiveStatus } from "../types/live.js";
-import { CoGuestStatus } from "../types/coGuest.js";
 import { useLiveAudienceState } from "./LiveAudienceState.js";
 import { useLiveState } from "./LiveState/index.js";
 import { useLoginState } from "./LoginState.js";
 import { useSeatStore } from "./SeatStore.js";
+import { CoGuestStatus } from "../types/coGuest.js";
+import { LiveStatus } from "../types/live.js";
 const roomEngine = useRoomEngine();
 const { loginUserInfo } = useLoginState();
 const { audienceList } = useLiveAudienceState();

package/dist/states/CoHostState.js

@@ -1,11 +1,11 @@
 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";
+import { DeviceStatus } from "../types/device.js";
 const roomEngine = useRoomEngine();
 const { loginUserInfo } = useLoginState();
 const { liveList } = useLiveState();

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

@@ -0,0 +1,40 @@
+import { Ref } from 'vue';
+import { AddFriendParams, DeleteFriendParams, Friend, FriendApplication, FriendApplicationParams, FriendGroup, FriendGroupParams, FriendRemarkParams, GroupApplication, GroupApplicationParams, GroupModel, JoinGroupParams, RenameFriendGroupParams, UserProfile } from '../../types';
+
+interface ContactListState {
+    friendList: Ref<Friend[]>;
+    groupList: Ref<GroupModel[]>;
+    blackList: Ref<UserProfile[]>;
+    friendApplicationUnreadCount: Ref<number>;
+    friendGroupList: Ref<FriendGroup[]>;
+    friendApplicationList: Ref<FriendApplication[]>;
+    groupApplicationList: Ref<GroupApplication[]>;
+}
+interface ContactListAction {
+    addFriend: (options: AddFriendParams) => Promise<any>;
+    markFriendApplicationAsRead: () => Promise<any>;
+    acceptFriendApplication: (options: FriendApplicationParams) => Promise<any>;
+    refuseFriendApplication: (userID: string) => Promise<any>;
+    deleteFriend: (options: DeleteFriendParams) => Promise<any>;
+    setFriendRemark: (options: FriendRemarkParams) => Promise<any>;
+    addToBlacklist: (userIDList: string[]) => Promise<any>;
+    removeFromBlacklist: (userIDList: string[]) => Promise<any>;
+    createFriendGroup: (options: FriendGroupParams) => Promise<any>;
+    deleteFriendGroup: (name: string) => Promise<any>;
+    addToFriendGroup: (options: FriendGroupParams) => Promise<any>;
+    removeFromFriendGroup: (options: FriendGroupParams) => Promise<any>;
+    renameFriendGroup: (options: RenameFriendGroupParams) => Promise<any>;
+    joinGroup: (options: JoinGroupParams) => Promise<any>;
+    acceptGroupApplication: (options: GroupApplicationParams) => Promise<any>;
+    refuseGroupApplication: (options: GroupApplicationParams) => Promise<any>;
+    setFriendList: (friendList: Friend[]) => void;
+    setGroupList: (groupList: GroupModel[]) => void;
+    setBlackList: (blackList: UserProfile[]) => void;
+    setFriendApplicationUnreadCount: (count: number) => void;
+    setFriendGroupList: (friendGroupList: FriendGroup[]) => void;
+    setFriendApplicationList: (friendApplicationList: FriendApplication[]) => void;
+    setGroupApplicationList: (groupApplicationList: GroupApplication[]) => void;
+}
+type UseContactListStateReturn = Omit<ContactListState & ContactListAction, 'setFriendList' | 'setGroupList' | 'setBlackList' | 'setFriendApplicationUnreadCount' | 'setFriendGroupList' | 'setFriendApplicationList' | 'setGroupApplicationList'>;
+declare function useContactListState(): UseContactListStateReturn;
+export { useContactListState };

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("Add friend failed:", error);
+    throw error;
+  }
+};
+const markFriendApplicationAsRead = async () => {
+  try {
+    const result = await TUIFriendService.setFriendApplicationRead();
+    return result;
+  } catch (error) {
+    console.error("Mark friend application as read failed:", 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("Accept friend application failed:", error);
+    throw error;
+  }
+};
+const refuseFriendApplication = async (userID) => {
+  try {
+    const result = await TUIFriendService.refuseFriendApplication(userID);
+    return result;
+  } catch (error) {
+    console.error("Refuse friend application failed:", error);
+    throw error;
+  }
+};
+const deleteFriend = async (options) => {
+  try {
+    const result = await TUIFriendService.deleteFriend(options);
+    return result;
+  } catch (error) {
+    console.error("Delete friend failed:", 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("Set friend remark failed:", error);
+    throw error;
+  }
+};
+const addToBlacklist = async (userIDList) => {
+  try {
+    const result = await TUIUserService.addToBlacklist({ userIDList });
+    return result;
+  } catch (error) {
+    console.error("Add to blacklist failed:", error);
+    throw error;
+  }
+};
+const removeFromBlacklist = async (userIDList) => {
+  try {
+    const result = await TUIUserService.removeFromBlacklist({ userIDList });
+    return result;
+  } catch (error) {
+    console.error("Remove from blacklist failed:", error);
+    throw error;
+  }
+};
+const createFriendGroup = async (options) => {
+  try {
+    const result = await TUIFriendService.createFriendGroup(options);
+    return result;
+  } catch (error) {
+    console.error("Create friend group failed:", error);
+    throw error;
+  }
+};
+const deleteFriendGroup = async (name) => {
+  try {
+    const result = await TUIFriendService.deleteFriendGroup(name);
+    return result;
+  } catch (error) {
+    console.error("Delete friend group failed:", error);
+    throw error;
+  }
+};
+const addToFriendGroup = async (options) => {
+  try {
+    const result = await TUIFriendService.addToFriendGroup(options);
+    return result;
+  } catch (error) {
+    console.error("Add to friend group failed:", error);
+    throw error;
+  }
+};
+const removeFromFriendGroup = async (options) => {
+  try {
+    const result = await TUIFriendService.removeFromFriendGroup(options);
+    return result;
+  } catch (error) {
+    console.error("Remove from friend group failed:", error);
+    throw error;
+  }
+};
+const renameFriendGroup = async (options) => {
+  try {
+    const result = await TUIFriendService.renameFriendGroup(options);
+    return result;
+  } catch (error) {
+    console.error("Rename friend group failed:", error);
+    throw error;
+  }
+};
+const joinGroup = async (options) => {
+  try {
+    const result = await TUIGroupService.joinGroup(options);
+    return result;
+  } catch (error) {
+    console.error("Join group failed:", error);
+    throw error;
+  }
+};
+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("Accept group application failed:", 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("Refuse group application failed:", 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 setGroupApplicationList = (list) => {
+  groupApplicationListRef.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.log(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
+};