tuikit-atomicx-vue3 0.1.0 → 0.1.1

package/dist/states/GroupSettingState/GroupSettingState.js

@@ -0,0 +1,456 @@
+import { ref } from "vue";
+import { TUIStore, StoreName, TUIChatEngine, TUIGroupService } from "@tencentcloud/chat-uikit-engine";
+import { FULL_PERMISSION_MATRIX } from "./permissions.js";
+import { GroupInviteType, GroupMemberRole } from "./types.js";
+import { GroupPermission, GroupType } from "./types.js";
+const currentConversationRef = ref(void 0);
+const groupIDRef = ref(void 0);
+const groupTypeRef = ref(void 0);
+const groupNameRef = ref(void 0);
+const avatarRef = ref(void 0);
+const introductionRef = ref(void 0);
+const notificationRef = ref(void 0);
+const isMutedRef = ref(void 0);
+const isPinnedRef = ref(void 0);
+const groupOwnerRef = ref(void 0);
+const adminMembersRef = ref([]);
+const allMembersRef = ref([]);
+const memberCountRef = ref(void 0);
+const maxMemberCountRef = ref(void 0);
+const currentUserIDRef = ref(void 0);
+const currentUserRoleRef = ref(void 0);
+const nameCardRef = ref(void 0);
+const isMuteAllMembersRef = ref(void 0);
+const isInGroupRef = ref(void 0);
+const inviteOptionRef = ref(void 0);
+async function getGroupMemberList(params) {
+  var _a;
+  const targetGroupID = (params == null ? void 0 : params.groupID) || groupIDRef.value;
+  if (!targetGroupID) {
+    throw new Error("getGroupMemberList::groupID is required");
+  }
+  const result = await TUIGroupService.getGroupMemberList({
+    groupID: targetGroupID,
+    count: (params == null ? void 0 : params.count) || 100,
+    offset: (params == null ? void 0 : params.offset) || 0
+  });
+  if ((_a = result == null ? void 0 : result.data) == null ? void 0 : _a.memberList) {
+    const newMembers = result.data.memberList.map((member) => ({
+      userID: member.userID,
+      nick: member.nick || member.userID,
+      avatar: member.avatar || "",
+      role: member.role,
+      joinTime: member.joinTime,
+      muteUntil: member.muteUntil || "",
+      memberCustomField: member.memberCustomField || ""
+    }));
+    const currentMembers = allMembersRef.value || [];
+    const offset = (params == null ? void 0 : params.offset) || 0;
+    let updatedMembers;
+    if (offset === 0) {
+      updatedMembers = newMembers;
+    } else {
+      updatedMembers = [...currentMembers];
+      newMembers.forEach((newMember, index) => {
+        const targetIndex = offset + index;
+        if (targetIndex < updatedMembers.length) {
+          updatedMembers[targetIndex] = newMember;
+        } else {
+          updatedMembers.push(newMember);
+        }
+      });
+    }
+    const owner = updatedMembers.find((member) => member.role === GroupMemberRole.OWNER);
+    const admins = updatedMembers.filter((member) => member.role === GroupMemberRole.ADMIN);
+    if (owner) {
+      groupOwnerRef.value = owner;
+    }
+    adminMembersRef.value = admins;
+    allMembersRef.value = updatedMembers;
+    return updatedMembers;
+  }
+  throw new Error("getGroupMemberList::getGroupMemberList failed");
+}
+async function updateGroupProfile(params) {
+  const targetGroupID = params.groupID || groupIDRef.value;
+  if (!targetGroupID) {
+    throw new Error("updateGroupProfile::groupID is required");
+  }
+  const updateParams = { groupID: targetGroupID };
+  if (params.name !== void 0) {
+    if (typeof params.name !== "string") {
+      throw new Error("updateGroupProfile::name must be a string");
+    }
+    if (params.name.length === 0) {
+      throw new Error("updateGroupProfile::name cannot be empty");
+    }
+    if (params.name.length > 25) {
+      throw new Error("updateGroupProfile::name must be less than or equal to 25 characters");
+    }
+    if (params.name === groupNameRef.value) {
+      throw new Error("updateGroupProfile::name cannot be the same as current value");
+    }
+    updateParams.name = params.name;
+  }
+  if (params.introduction !== void 0) {
+    if (typeof params.introduction !== "string") {
+      throw new Error("updateGroupProfile::introduction must be a string");
+    }
+    if (params.introduction.length > 100) {
+      throw new Error("updateGroupProfile::introduction must be less than 100 characters");
+    }
+    if (params.introduction === introductionRef.value) {
+      throw new Error("updateGroupProfile::introduction cannot be the same as current value");
+    }
+    updateParams.introduction = params.introduction;
+  }
+  if (params.notification !== void 0) {
+    if (typeof params.notification !== "string") {
+      throw new Error("updateGroupProfile::notification must be a string");
+    }
+    if (params.notification.length > 100) {
+      throw new Error("updateGroupProfile::notification must be less than 100 characters");
+    }
+    if (params.notification === notificationRef.value) {
+      throw new Error("updateGroupProfile::notification cannot be the same as current value");
+    }
+    updateParams.notification = params.notification;
+  }
+  if (params.avatar !== void 0) {
+    if (typeof params.avatar !== "string") {
+      throw new Error("updateGroupProfile::avatar must be a string");
+    }
+    if (params.avatar.length > 500) {
+      throw new Error("updateGroupProfile::avatar must be less than 500 characters");
+    }
+    if (params.avatar === avatarRef.value) {
+      throw new Error("updateGroupProfile::avatar cannot be the same as current value");
+    }
+    updateParams.avatar = params.avatar;
+  }
+  await TUIGroupService.updateGroupProfile(updateParams);
+  if (params.name !== void 0) {
+    groupNameRef.value = params.name;
+  }
+  if (params.introduction !== void 0) {
+    introductionRef.value = params.introduction;
+  }
+  if (params.notification !== void 0) {
+    notificationRef.value = params.notification;
+  }
+  if (params.avatar !== void 0) {
+    avatarRef.value = params.avatar;
+  }
+}
+async function addGroupMember(params) {
+  const targetGroupID = params.groupID || groupIDRef.value;
+  if (!targetGroupID) {
+    throw new Error("addGroupMember::groupID is required");
+  }
+  const result = await TUIGroupService.addGroupMember({
+    groupID: targetGroupID,
+    userIDList: params.userIDList
+  });
+  getGroupMemberList({ count: 100 });
+  return result;
+}
+async function deleteGroupMember(params) {
+  var _a, _b;
+  const targetGroupID = params.groupID || groupIDRef.value;
+  if (!targetGroupID) {
+    throw new Error("deleteGroupMember::groupID is required");
+  }
+  await TUIGroupService.deleteGroupMember({
+    groupID: targetGroupID,
+    userIDList: params.userIDList
+  });
+  const newAllMembers = (_a = allMembersRef.value) == null ? void 0 : _a.filter((member) => !params.userIDList.includes(member.userID));
+  const newAdminMembers = (_b = adminMembersRef.value) == null ? void 0 : _b.filter((member) => !params.userIDList.includes(member.userID));
+  allMembersRef.value = newAllMembers;
+  adminMembersRef.value = newAdminMembers;
+}
+async function changeGroupOwner(params) {
+  const targetGroupID = params.groupID || groupIDRef.value;
+  if (!targetGroupID) {
+    return;
+  }
+  await TUIGroupService.changeGroupOwner({
+    groupID: targetGroupID,
+    newOwnerID: params.newOwnerID
+  });
+}
+async function setGroupMemberRole(params) {
+  const targetGroupID = params.groupID || groupIDRef.value;
+  if (!targetGroupID) {
+    return;
+  }
+  await TUIGroupService.setGroupMemberRole({
+    groupID: targetGroupID,
+    userID: params.userID,
+    role: params.role
+  });
+  getGroupMemberList({ count: 100 });
+}
+async function setGroupMemberNameCard(params) {
+  const targetGroupID = params.groupID || groupIDRef.value;
+  if (!targetGroupID || !currentUserIDRef.value) {
+    return;
+  }
+  nameCardRef.value = params.nameCard;
+  await TUIGroupService.setGroupMemberNameCard({
+    groupID: targetGroupID,
+    userID: params.userID || currentUserIDRef.value,
+    nameCard: params.nameCard
+  });
+}
+async function setChatPinned(value) {
+  if (!currentConversationRef.value) {
+    throw new Error("setChatPinned::currentConversation is required");
+  }
+  if (value !== currentConversationRef.value.isPinned) {
+    isPinnedRef.value = value;
+    await currentConversationRef.value.pinConversation();
+  }
+}
+async function setChatMuted(value) {
+  if (!currentConversationRef.value) {
+    throw new Error("setChatMuted::currentConversation is required");
+  }
+  if (value !== currentConversationRef.value.isMuted) {
+    isMutedRef.value = value;
+    try {
+      await currentConversationRef.value.muteConversation();
+    } catch (error) {
+      isMutedRef.value = !value;
+      throw error;
+    }
+  }
+}
+async function setGroupMemberMuteTime(params) {
+  const targetGroupID = params.groupID || groupIDRef.value;
+  if (!targetGroupID) {
+    throw new Error("setGroupMemberMuteTime::groupID is required");
+  }
+  await TUIGroupService.setGroupMemberMuteTime({
+    groupID: targetGroupID,
+    userID: params.userID,
+    muteTime: params.time
+  });
+  getGroupMemberList({ count: 100 });
+}
+async function setMuteAllMember(value) {
+  if (!groupIDRef.value) {
+    throw new Error("setMuteAllMember::groupID is required");
+  }
+  await TUIGroupService.updateGroupProfile({
+    groupID: groupIDRef.value,
+    muteAllMembers: value
+  });
+  isMuteAllMembersRef.value = value;
+}
+async function dismissGroup(groupID) {
+  const targetGroupID = groupID || groupIDRef.value;
+  if (!targetGroupID) {
+    throw new Error("dismissGroup::groupID is required");
+  }
+  await TUIGroupService.dismissGroup(targetGroupID);
+}
+async function quitGroup(groupID) {
+  const targetGroupID = groupID || groupIDRef.value;
+  if (!targetGroupID) {
+    throw new Error("quitGroup::groupID is required");
+  }
+  await TUIGroupService.quitGroup(targetGroupID);
+}
+function hasPermission(permission, role, groupType) {
+  const targetGroupType = groupType || groupTypeRef.value;
+  const targetUserRole = role || currentUserRoleRef.value || GroupMemberRole.COMMON;
+  if (!targetGroupType || !targetUserRole) {
+    throw new Error("hasPermission::groupType or userRole is required");
+  }
+  const _hasPermission = FULL_PERMISSION_MATRIX[targetGroupType][targetUserRole][permission];
+  if (typeof _hasPermission !== "boolean") {
+    throw new Error(`hasPermission::${permission}-${targetGroupType}-${targetUserRole} is not defined`);
+  }
+  return _hasPermission;
+}
+function canOperateOnMember(targetMember) {
+  if (!currentUserIDRef.value || !allMembersRef.value) {
+    return false;
+  }
+  const currentUser = allMembersRef.value.find((member) => member.userID === currentUserIDRef.value);
+  if (!currentUser) {
+    return false;
+  }
+  if (currentUser.userID === targetMember.userID) {
+    return false;
+  }
+  if (currentUser.role === GroupMemberRole.OWNER) {
+    return true;
+  }
+  if (currentUser.role === GroupMemberRole.ADMIN) {
+    return targetMember.role === GroupMemberRole.COMMON;
+  }
+  return false;
+}
+function getAvailablePermissions() {
+  if (!groupTypeRef.value || !currentUserIDRef.value || !allMembersRef.value) {
+    return [];
+  }
+  const currentUser = allMembersRef.value.find((member) => member.userID === currentUserIDRef.value);
+  if (!currentUser) {
+    return [];
+  }
+  return FULL_PERMISSION_MATRIX[groupTypeRef.value][currentUser.role] ? Object.keys(FULL_PERMISSION_MATRIX[groupTypeRef.value][currentUser.role]) : [];
+}
+function reset() {
+  currentConversationRef.value = void 0;
+  groupIDRef.value = void 0;
+  groupTypeRef.value = void 0;
+  groupNameRef.value = void 0;
+  avatarRef.value = void 0;
+  introductionRef.value = void 0;
+  notificationRef.value = void 0;
+  isMutedRef.value = void 0;
+  isPinnedRef.value = void 0;
+  groupOwnerRef.value = void 0;
+  adminMembersRef.value = [];
+  allMembersRef.value = [];
+  memberCountRef.value = void 0;
+  maxMemberCountRef.value = void 0;
+  currentUserIDRef.value = void 0;
+  currentUserRoleRef.value = void 0;
+  nameCardRef.value = void 0;
+  isMuteAllMembersRef.value = void 0;
+  isInGroupRef.value = void 0;
+  inviteOptionRef.value = void 0;
+}
+function initWatcher() {
+  TUIStore.watch(StoreName.CONV, {
+    currentConversation: (conversation) => {
+      var _a;
+      if (conversation && conversation.type === "GROUP") {
+        const prevConversationID = (_a = currentConversationRef.value) == null ? void 0 : _a.conversationID;
+        if (prevConversationID !== conversation.conversationID) {
+          allMembersRef.value = void 0;
+          adminMembersRef.value = void 0;
+          groupOwnerRef.value = void 0;
+        }
+        currentConversationRef.value = conversation;
+        const {
+          groupProfile: {
+            groupID,
+            name,
+            avatar,
+            introduction,
+            muteAllMembers,
+            memberCount,
+            maxMemberCount,
+            notification,
+            type,
+            inviteOption,
+            selfInfo: {
+              role,
+              userID,
+              nameCard
+            }
+          },
+          isMuted,
+          isPinned,
+          operationType
+        } = conversation;
+        groupIDRef.value = groupID;
+        groupTypeRef.value = type;
+        groupNameRef.value = name;
+        avatarRef.value = avatar;
+        introductionRef.value = introduction;
+        isMutedRef.value = isMuted;
+        isPinnedRef.value = isPinned;
+        isMuteAllMembersRef.value = muteAllMembers;
+        memberCountRef.value = memberCount;
+        currentUserIDRef.value = userID;
+        currentUserRoleRef.value = role;
+        nameCardRef.value = nameCard;
+        maxMemberCountRef.value = maxMemberCount;
+        notificationRef.value = notification;
+        switch (inviteOption) {
+          case TUIChatEngine.TYPES.JOIN_OPTIONS_FREE_ACCESS:
+            inviteOptionRef.value = GroupInviteType.FREE_ACCESS;
+            break;
+          case TUIChatEngine.TYPES.JOIN_OPTIONS_NEED_PERMISSION:
+            inviteOptionRef.value = GroupInviteType.NEED_PERMISSION;
+            break;
+          case TUIChatEngine.TYPES.JOIN_OPTIONS_DISABLE_INVITE:
+            inviteOptionRef.value = GroupInviteType.DISABLE_APPLY;
+            break;
+          default:
+            inviteOptionRef.value = GroupInviteType.DISABLE_APPLY;
+        }
+        if ([4, 5, 8].includes(operationType)) {
+          isInGroupRef.value = false;
+        } else if (operationType === 0) {
+          isInGroupRef.value = true;
+        }
+      } else {
+        reset();
+      }
+    }
+  });
+  TUIStore.watch(StoreName.GRP, {
+    groupProfile: (groupProfile) => {
+      if (typeof groupProfile === "object" && groupProfile && "groupID" in groupProfile) {
+        groupIDRef.value = groupProfile.groupID;
+      }
+    }
+  });
+}
+initWatcher();
+function useGroupSettingState() {
+  return {
+    // State
+    groupID: groupIDRef,
+    groupType: groupTypeRef,
+    groupName: groupNameRef,
+    avatar: avatarRef,
+    introduction: introductionRef,
+    notification: notificationRef,
+    isMuted: isMutedRef,
+    isPinned: isPinnedRef,
+    groupOwner: groupOwnerRef,
+    adminMembers: adminMembersRef,
+    allMembers: allMembersRef,
+    memberCount: memberCountRef,
+    maxMemberCount: maxMemberCountRef,
+    currentUserID: currentUserIDRef,
+    currentUserRole: currentUserRoleRef,
+    nameCard: nameCardRef,
+    isMuteAllMembers: isMuteAllMembersRef,
+    isInGroup: isInGroupRef,
+    inviteOption: inviteOptionRef,
+    // Permission utilities
+    hasPermission,
+    canOperateOnMember,
+    getAvailablePermissions,
+    // Business actions
+    getGroupMemberList,
+    updateGroupProfile,
+    addGroupMember,
+    deleteGroupMember,
+    changeGroupOwner,
+    setGroupMemberRole,
+    setGroupMemberNameCard,
+    setChatPinned,
+    setChatMuted,
+    setGroupMemberMuteTime,
+    setMuteAllMember,
+    dismissGroup,
+    quitGroup
+  };
+}
+export {
+  GroupInviteType,
+  GroupMemberRole,
+  GroupPermission,
+  GroupType,
+  useGroupSettingState
+};

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

@@ -0,0 +1,2 @@
+export { useGroupSettingState, GroupPermission, GroupType, GroupMemberRole, GroupInviteType, } from './GroupSettingState';
+export type { GroupMember, } from './GroupSettingState';

package/dist/states/GroupSettingState/index.js

@@ -0,0 +1,9 @@
+import { useGroupSettingState } from "./GroupSettingState.js";
+import { GroupInviteType, GroupMemberRole, GroupPermission, GroupType } from "./types.js";
+export {
+  GroupInviteType,
+  GroupMemberRole,
+  GroupPermission,
+  GroupType,
+  useGroupSettingState
+};

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

@@ -0,0 +1,3 @@
+import { CompletePermissionMatrix } from './types';
+
+export declare const FULL_PERMISSION_MATRIX: CompletePermissionMatrix;