tuikit-atomicx-vue3 3.3.4 → 3.4.1

package/dist/states/ContactListState/ContactListState.js

@@ -1,321 +1,225 @@
-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);
+import { ref as n } from "vue";
+import G, { TUIStore as c, StoreName as i, TUIGroupService as s, TUIFriendService as o, TUIUserService as d } from "@tencentcloud/chat-uikit-engine";
+const L = n([]), h = n([]), F = n([]), y = n(0), m = n([]), A = n([]), p = n([]);
+function f(r, t) {
+  let e;
+  return (...a) => {
+    clearTimeout(e), e = setTimeout(() => r(...a), t);
   };
 }
-const addFriend = async (options) => {
+const S = async (r) => {
   try {
-    const params = {
-      to: options.userID,
-      source: options.addSource
+    const t = {
+      to: r.userID,
+      source: r.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;
+    return r.remark && (t.remark = r.remark), r.groupName && (t.groupName = r.groupName), r.wording && (t.wording = r.wording), r.type && (t.type = r.type), await o.addFriend(t);
+  } catch (t) {
+    throw console.error("[ContactListState addFriend] error", t), t;
   }
-};
-const markFriendApplicationAsRead = async () => {
+}, C = async () => {
   try {
-    const result = await TUIFriendService.setFriendApplicationRead();
-    return result;
-  } catch (error) {
-    console.error("[ContactListState markFriendApplicationAsRead] error", error);
-    throw error;
+    return await o.setFriendApplicationRead();
+  } catch (r) {
+    throw console.error("[ContactListState markFriendApplicationAsRead] error", r), r;
   }
-};
-const acceptFriendApplication = async (options) => {
+}, g = async (r) => {
   try {
-    const result = await TUIFriendService.acceptFriendApplication({
-      userID: options.userID,
-      remark: options.remark || "",
-      type: options.type
+    return await o.acceptFriendApplication({
+      userID: r.userID,
+      remark: r.remark || "",
+      type: r.type
     });
-    return result;
-  } catch (error) {
-    console.error("[ContactListState acceptFriendApplication] error", error);
-    throw error;
+  } catch (t) {
+    throw console.error("[ContactListState acceptFriendApplication] error", t), t;
   }
-};
-const refuseFriendApplication = async (userID) => {
+}, k = async (r) => {
   try {
-    const result = await TUIFriendService.refuseFriendApplication(userID);
-    return result;
-  } catch (error) {
-    console.error("[ContactListState refuseFriendApplication] error", error);
-    throw error;
+    return await o.refuseFriendApplication(r);
+  } catch (t) {
+    throw console.error("[ContactListState refuseFriendApplication] error", t), t;
   }
-};
-const deleteFriend = async (options) => {
+}, T = async (r) => {
   try {
-    const result = await TUIFriendService.deleteFriend(options);
-    return result;
-  } catch (error) {
-    console.error("[ContactListState deleteFriend] error", error);
-    throw error;
+    return await o.deleteFriend(r);
+  } catch (t) {
+    throw console.error("[ContactListState deleteFriend] error", t), t;
   }
-};
-const setFriendRemark = async (options) => {
+}, U = async (r) => {
   try {
-    const result = await TUIFriendService.updateFriend({
-      userID: options.userID,
-      remark: options.remark
+    return await o.updateFriend({
+      userID: r.userID,
+      remark: r.remark
     });
-    return result;
-  } catch (error) {
-    console.error("[ContactListState setFriendRemark] error", error);
-    throw error;
+  } catch (t) {
+    throw console.error("[ContactListState setFriendRemark] error", t), t;
   }
-};
-const addToBlacklist = async (userIDList) => {
+}, v = async (r) => {
   try {
-    const result = await TUIUserService.addToBlacklist({ userIDList });
-    return result;
-  } catch (error) {
-    console.error("[ContactListState addToBlacklist] error", error);
-    throw error;
+    return await d.addToBlacklist({ userIDList: r });
+  } catch (t) {
+    throw console.error("[ContactListState addToBlacklist] error", t), t;
   }
-};
-const removeFromBlacklist = async (userIDList) => {
+}, R = async (r) => {
   try {
-    const result = await TUIUserService.removeFromBlacklist({ userIDList });
-    return result;
-  } catch (error) {
-    console.error("[ContactListState removeFromBlacklist] error", error);
-    throw error;
+    return await d.removeFromBlacklist({ userIDList: r });
+  } catch (t) {
+    throw console.error("[ContactListState removeFromBlacklist] error", t), t;
   }
-};
-const createFriendGroup = async (options) => {
+}, I = async (r) => {
   try {
-    const result = await TUIFriendService.createFriendGroup(options);
-    return result;
-  } catch (error) {
-    console.error("[ContactListState createFriendGroup] error", error);
-    throw error;
+    return await o.createFriendGroup(r);
+  } catch (t) {
+    throw console.error("[ContactListState createFriendGroup] error", t), t;
   }
-};
-const deleteFriendGroup = async (name) => {
+}, N = async (r) => {
   try {
-    const result = await TUIFriendService.deleteFriendGroup(name);
-    return result;
-  } catch (error) {
-    console.error("[ContactListState deleteFriendGroup] error", error);
-    throw error;
+    return await o.deleteFriendGroup(r);
+  } catch (t) {
+    throw console.error("[ContactListState deleteFriendGroup] error", t), t;
   }
-};
-const addToFriendGroup = async (options) => {
+}, B = async (r) => {
   try {
-    const result = await TUIFriendService.addToFriendGroup(options);
-    return result;
-  } catch (error) {
-    console.error("[ContactListState addToFriendGroup] error", error);
-    throw error;
+    return await o.addToFriendGroup(r);
+  } catch (t) {
+    throw console.error("[ContactListState addToFriendGroup] error", t), t;
   }
-};
-const removeFromFriendGroup = async (options) => {
+}, D = async (r) => {
   try {
-    const result = await TUIFriendService.removeFromFriendGroup(options);
-    return result;
-  } catch (error) {
-    console.error("[ContactListState removeFromFriendGroup] error", error);
-    throw error;
+    return await o.removeFromFriendGroup(r);
+  } catch (t) {
+    throw console.error("[ContactListState removeFromFriendGroup] error", t), t;
   }
-};
-const renameFriendGroup = async (options) => {
+}, E = async (r) => {
   try {
-    const result = await TUIFriendService.renameFriendGroup(options);
-    return result;
-  } catch (error) {
-    console.error("[ContactListState renameFriendGroup] error", error);
-    throw error;
+    return await o.renameFriendGroup(r);
+  } catch (t) {
+    throw console.error("[ContactListState renameFriendGroup] error", t), t;
   }
-};
-const joinGroup = async (options) => {
+}, M = async (r) => {
   try {
-    const result = await TUIGroupService.joinGroup(options);
-    return result;
-  } catch (error) {
-    console.error("[ContactListState joinGroup] error", error);
-    throw error;
+    return await s.joinGroup(r);
+  } catch (t) {
+    throw console.error("[ContactListState joinGroup] error", t), t;
   }
-};
-const setGroupApplicationList = (list) => {
-  groupApplicationListRef.value = list;
-};
-const acceptGroupApplication = async (options) => {
+}, l = (r) => {
+  p.value = r;
+}, P = async (r) => {
   try {
-    const result = await TUIGroupService.handleGroupApplication({
+    const t = await s.handleGroupApplication({
       handleAction: "Agree",
-      handleMessage: options.handleMessage || "",
-      application: options.application
-    });
-    const updatedGroupApplicationList = groupApplicationListRef.value.filter(
-      (application) => application !== options.application
+      handleMessage: r.handleMessage || "",
+      application: r.application
+    }), e = p.value.filter(
+      (a) => a !== r.application
     );
-    setGroupApplicationList(updatedGroupApplicationList);
-    return result;
-  } catch (error) {
-    console.error("[ContactListState acceptGroupApplication] error", error);
-    throw error;
+    return l(e), t;
+  } catch (t) {
+    throw console.error("[ContactListState acceptGroupApplication] error", t), t;
   }
-};
-const refuseGroupApplication = async (options) => {
+}, j = async (r) => {
   try {
-    const result = await TUIGroupService.handleGroupApplication({
+    const t = await s.handleGroupApplication({
       handleAction: "Reject",
-      handleMessage: options.handleMessage || "",
-      application: options.application
-    });
-    const updatedGroupApplicationList = groupApplicationListRef.value.filter(
-      (application) => application !== options.application
+      handleMessage: r.handleMessage || "",
+      application: r.application
+    }), e = p.value.filter(
+      (a) => a !== r.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 || ""
+    return l(e), t;
+  } catch (t) {
+    throw console.error("[ContactListState refuseGroupApplication] error", t), t;
+  }
+}, u = (r) => {
+  L.value = r;
+}, _ = (r) => {
+  h.value = r;
+}, b = (r) => {
+  F.value = r;
+}, O = (r) => {
+  y.value = r;
+}, x = (r) => {
+  m.value = r;
+}, W = (r) => {
+  A.value = r;
+}, Y = (r) => {
+  _(r);
+}, q = (r) => {
+  b(r);
+}, z = (r) => {
+  if (r.length > 0) {
+    const t = r.map((e) => ({
+      ...e.profile,
+      remark: e.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
+    u(t);
+  } else
+    u([]);
+}, H = (r) => {
+  x(r);
+}, J = (r) => {
+  const t = r.filter(
+    (e) => e.type === G.TYPES.SNS_APPLICATION_SENT_TO_ME
   );
-  if (groupApplicationList.length > 0) {
-    getGroupApplicationList();
-  }
-};
-const initContactListWatcher = () => {
-  TUIStore.watch(StoreName.USER, {
-    userProfile: (profile) => {
-      if (profile == null ? void 0 : profile.userID) {
-        getGroupApplicationList();
-      }
+  W(t);
+}, K = (r) => {
+  O(r);
+}, w = f(async () => {
+  try {
+    const r = await s.getGroupApplicationList(), { applicationList: t } = r.data;
+    return l(t), r;
+  } catch (r) {
+    throw console.error("[ContactListState getGroupApplicationList] error", r), r;
+  }
+}, 300), Q = (r) => {
+  r.filter(
+    (e) => e.payload.operationType === 1 || e.payload.operationType === 23
+  ).length > 0 && w();
+}, V = () => {
+  c.watch(i.USER, {
+    userProfile: (r) => {
+      r != null && r.userID && w();
     }
-  });
-  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
+  }), c.watch(i.GRP, {
+    groupList: Y,
+    groupSystemNoticeList: Q
+  }), c.watch(i.USER, {
+    userBlacklist: q
+  }), c.watch(i.FRIEND, {
+    friendList: z,
+    friendApplicationList: J,
+    friendApplicationUnreadCount: K,
+    friendGroupList: H
   });
 };
-initContactListWatcher();
-function useContactListState() {
+V();
+function $() {
   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
+    friendList: L,
+    groupList: h,
+    blackList: F,
+    friendApplicationUnreadCount: y,
+    friendGroupList: m,
+    friendApplicationList: A,
+    groupApplicationList: p,
+    addFriend: S,
+    markFriendApplicationAsRead: C,
+    acceptFriendApplication: g,
+    refuseFriendApplication: k,
+    addToBlacklist: v,
+    removeFromBlacklist: R,
+    deleteFriend: T,
+    setFriendRemark: U,
+    createFriendGroup: I,
+    deleteFriendGroup: N,
+    addToFriendGroup: B,
+    removeFromFriendGroup: D,
+    renameFriendGroup: E,
+    joinGroup: M,
+    acceptGroupApplication: P,
+    refuseGroupApplication: j
   };
 }
 export {
-  useContactListState
+  $ as useContactListState
 };

package/dist/states/ContactListState/index.js

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