tuikit-atomicx-vue3 0.1.0 → 0.1.1

package/src/components/ConversationList/ConversationCreate/ConversationCreateUserSelectList/ConversationCreateUserSelectList.vue

@@ -0,0 +1,206 @@
+<template>
+  <div :class="[$style.conversationCreateUserSelectList]">
+    <div :class="$style.conversationCreateUserSelectList__searchInput">
+      <TUIInput
+        v-model="searchValue"
+        :prefixIcon="IconSearchChat"
+        :placeholder="t('TUIConversation.Search')"
+        @change="searchValueChange"
+      />
+    </div>
+
+    <ConversationCreateSelectView
+      v-if="isCreateGroup"
+      :select-list="selectList"
+      :set-select-list="handleSelectListUpdate"
+    />
+
+    <div
+      v-if="!isCreateGroup"
+      role="presentation"
+      :class="[$style.conversationCreateUserSelectList__user, $style['conversationCreateUserSelectList__user--active']]"
+      @click="createGroup"
+    >
+      <IconSearchMore size="24px" />
+      <div :class="$style.conversationCreateUserSelectList__userName">
+        {{ t('TUIConversation.New group chat') }}
+      </div>
+    </div>
+
+    <div :class="[$style.conversationCreateUserSelectList__container, className]">
+      <div :class="$style.conversationCreateUserSelectList__list">
+        <div :class="$style.conversationCreateUserSelectList__groupContainer">
+          <div
+            v-for="(group, key) in friendList"
+            v-show="group.length !== 0"
+            :key="key"
+            :class="$style.conversationCreateUserSelectList__groupBox"
+          >
+            <div :class="$style.conversationCreateUserSelectList__title">
+              {{ key }}
+            </div>
+            <label
+              v-for="profile in group"
+              :key="profile.userID"
+              role="presentation"
+              :class="$style.conversationCreateUserSelectList__user"
+              :for="`userChecked-${key}-${profile.userID}`"
+              @click="handleUserItem(profile)"
+            >
+              <Avatar :src="profile.avatar" />
+              <div :class="$style.conversationCreateUserSelectList__userName">
+                {{ profile.nick || profile.userID }}
+              </div>
+              <div
+                v-if="isCreateGroup"
+                :class="$style.conversationCreateUserSelectList__userCheckbox"
+              >
+                <IconCheckSm
+                  v-if="selectList.find(item => item.userID === profile.userID)"
+                  :class="$style.conversationCreateUserSelectList__activeIcon"
+                />
+                <IconAddCircle v-else />
+              </div>
+            </label>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <div
+      v-if="isCreateGroup"
+      :class="$style.conversationCreateUserSelectList__nextContainer"
+    >
+      <TUIButton @click="next">
+        {{ t('TUIConversation.Next') }}
+      </TUIButton>
+    </div>
+  </div>
+</template>
+
+<script lang="ts" setup>
+import { ref, watch } from 'vue';
+import {
+  TUIInput,
+  TUIButton,
+  IconSearchMore,
+  IconCheckSm,
+  IconAddCircle,
+  IconSearchChat,
+  TUIToast,
+  useUIKit,
+} from '@tencentcloud/uikit-base-component-vue3';
+import { useContactListState } from '../../../../states/ContactListState';
+import { useConversationListState } from '../../../../states/ConversationListState';
+import { PageStateTypes } from '../../../../types';
+import { Avatar } from '../../../Avatar';
+import { ConversationCreateSelectView } from '../ConversationCreateSelectView';
+import { useConversationCreate } from '../hooks/useConversationCreate';
+import type {
+  ConversationCreateUserSelectListProps,
+  UserProfile,
+  ConversationCreateUsers,
+  ConversationModel,
+} from '../../../../types';
+
+const props = defineProps<ConversationCreateUserSelectListProps>();
+
+const emit = defineEmits<{
+  'update:is-create-group': [value: boolean];
+  'update:select-list': [list: UserProfile[]];
+  'update:page-state': [state: PageStateTypes];
+  'beforeCreateConversation': [userID: string];
+  'conversationCreated': [conversation: ConversationModel];
+}>();
+
+const { t } = useUIKit();
+const { friendList: friendListResult } = useContactListState();
+const { createC2CConversation } = useConversationListState();
+
+const searchValue = ref('');
+const conversationList = ref(props.conversationList);
+const friendList = ref<ConversationCreateUsers>({});
+
+const {
+  friendListSortResult,
+  getFriendListSortSearchResult,
+} = useConversationCreate(
+  conversationList,
+  friendListResult,
+);
+
+// Methods
+const searchValueChange = (value: string | number) => {
+  const stringValue = String(value);
+  searchValue.value = stringValue;
+  friendList.value = getFriendListSortSearchResult(stringValue);
+};
+
+const createGroup = () => {
+  emit('update:is-create-group', true);
+  props.setSelectList([]);
+  props.setIsCreateGroup(true);
+};
+
+const userSelectListChange = (profile: UserProfile) => {
+  const { userID } = profile;
+  const newList = [...props.selectList];
+
+  if (!newList.find(item => item.userID === userID)) {
+    newList.push(profile);
+  } else {
+    const index = newList.findIndex(item => item.userID === userID);
+    newList.splice(index, 1);
+  }
+  emit('update:select-list', newList);
+  props.setSelectList(newList);
+};
+
+const _createConversation = async (profile: UserProfile) => {
+  if (props.isCreateGroup) {
+    return;
+  }
+
+  const { userID } = profile;
+  emit('beforeCreateConversation', userID);
+  props.onBeforeCreateConversation?.(userID);
+
+  try {
+    const conversation = await createC2CConversation(userID);
+    emit('conversationCreated', conversation);
+    props.onConversationCreated?.(conversation);
+  } catch (error: any) {
+    TUIToast.error({ message: error.message });
+  }
+};
+
+const handleUserItem = (profile: UserProfile) => {
+  if (props.isCreateGroup) {
+    userSelectListChange(profile);
+  } else {
+    _createConversation(profile);
+  }
+};
+
+const next = () => {
+  if (!props.selectList || props.selectList.length === 0) {
+    TUIToast.error({ message: t('TUIConversation.Participant cannot be empty') });
+    return;
+  }
+  emit('update:page-state', PageStateTypes.CREATE_DETAIL);
+  props.setPageState(PageStateTypes.CREATE_DETAIL);
+};
+
+const handleSelectListUpdate = (list: UserProfile[]) => {
+  emit('update:select-list', list);
+  props.setSelectList(list);
+};
+
+watch(friendListSortResult, (newValue) => {
+  friendList.value = newValue;
+}, { immediate: true });
+</script>
+
+<style lang="scss" module>
+@import './ConversationCreateUserSelectList.scss';
+</style>

package/src/components/ConversationList/ConversationCreate/ConversationGroupTypeInfo/ConversationGroupTypeInfo.scss

@@ -0,0 +1,63 @@
+.conversationGroupTypeInfo {
+  display: flex;
+  flex-direction: column;
+  padding: 0 10px;
+  overflow-y: scroll;
+  color: var(--text-color-primary);
+  scrollbar-width: none;
+  -ms-overflow-style: none;
+  &::-webkit-scrollbar {
+    display: none;
+  }
+
+  &__box {
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+    border-radius: 16px;
+    padding: 12px 16px;
+    margin-top: 12px;
+    cursor: pointer;
+    background-color: var(--bg-color-operate);
+    border: 1px solid var(--stroke-color-primary);
+
+    &:hover {
+      border: 1px solid var(--text-color-link);
+    }
+
+    &--active {
+      border: 1px solid var(--text-color-link);
+    }
+  }
+
+  &__title {
+    font-size: 16px;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+  }
+
+  &__description {
+    font-size: 12px;
+    line-height: 16px;
+    text-align: justify;
+    hyphens: auto;
+  }
+
+  &__document {
+    font-size: 16px;
+    text-align: justify;
+    text-decoration: none;
+    margin: 1rem auto;
+
+    &:link,
+    &:active,
+    &:visited {
+      color: var(--text-color-link);
+    }
+  }
+
+  &__activeIcon {
+    fill: var(--text-color-link) !important;
+  }
+}

package/src/components/ConversationList/ConversationCreate/ConversationGroupTypeInfo/ConversationGroupTypeInfo.vue

@@ -0,0 +1,56 @@
+<template>
+  <div :class="$style.conversationGroupTypeInfo">
+    <div
+      v-for="{ type, name, des } in typeInfoList"
+      :key="type"
+      role="presentation"
+      :class="[$style.conversationGroupTypeInfo__box, {
+        [$style['conversationGroupTypeInfo__box--active']]: type === groupType
+      }]"
+      @click="selectGroupType(type)"
+    >
+      <div :class="$style.conversationGroupTypeInfo__title">
+        <IconCheckSm
+          v-if="type === groupType"
+          :class="$style.conversationGroupTypeInfo__activeIcon"
+        />
+        {{ t(`TUIConversation.${name}`) }}
+      </div>
+      <div :class="$style.conversationGroupTypeInfo__description">
+        {{ t(`TUIConversation.${des}`) }}
+      </div>
+    </div>
+    <a
+      :class="$style.conversationGroupTypeInfo__document"
+      target="_blank"
+      href="https://trtc.io/document/33529?platform=web&product=chat&menulabel=uikit#group-types"
+      rel="bookmark noreferrer"
+    >
+      {{ t('TUIConversation.Details') }}
+    </a>
+  </div>
+</template>
+
+<script lang="ts" setup>
+import { IconCheckSm, useUIKit } from '@tencentcloud/uikit-base-component-vue3';
+import { PageStateTypes } from '../../../../types';
+import { typeInfoList } from './type';
+import type { GroupType } from './type';
+
+const props = defineProps<{
+  groupType: GroupType;
+  setGroupType: (type: GroupType) => void;
+  setPageState: (state: PageStateTypes) => void;
+}>();
+
+const { t } = useUIKit();
+
+const selectGroupType = (type: GroupType) => {
+  props.setGroupType(type);
+  props.setPageState(PageStateTypes.CREATE_DETAIL);
+};
+</script>
+
+<style lang="scss" module>
+@import './ConversationGroupTypeInfo.scss';
+</style>

package/src/components/ConversationList/ConversationCreate/ConversationGroupTypeInfo/index.ts

@@ -0,0 +1,5 @@
+import ConversationGroupTypeInfo from './ConversationGroupTypeInfo.vue';
+
+export { ConversationGroupTypeInfo };
+export * from './ConversationGroupTypeInfo.vue';
+export * from './type';

package/src/components/ConversationList/ConversationCreate/ConversationGroupTypeInfo/type.ts

@@ -0,0 +1,21 @@
+export enum GroupType {
+  WORK = 'Private',
+  PUBLIC = 'Public',
+  MEETING = 'ChatRoom',
+  AVCHATROOM = 'AVChatRoom',
+  COMMUNITY = 'Community',
+}
+
+export interface ConversationGroupTypeInfoItem {
+  type: GroupType;
+  name: string;
+  des: string;
+}
+
+export const typeInfoList: ConversationGroupTypeInfoItem[] = [
+  { type: GroupType.WORK, name: 'Work', des: 'Users can join the group only via invitation by existing members. The invitation does not need to be agreed by the invitee or approved by the group owner. See the documentation for details.' },
+  { type: GroupType.PUBLIC, name: 'Public', des: 'After a public group is created, the group owner can designate group admins. To join the group, a user needs to search the group ID and send a request, which needs to be approved by the group owner or an admin before the user can join the group. See the documentation for details.' },
+  { type: GroupType.MEETING, name: 'Meeting', des: 'After the group is created, a user can join and quit the group freely and can view the messages sent before joining the group. It is suitable for scenarios that integrate Tencent Real-Time Communication (TRTC), such as audio and video conferences and online education. See the documentation for details.' },
+  { type: GroupType.AVCHATROOM, name: 'AVChatRoom', des: 'After a group is created, a user can join and quit the group freely. The group can have an unlimited number of members, but it does not store message history. It can be combined with Live Video Broadcasting (LVB) to support on-screen comment scenarios. See the documentation for details.' },
+  { type: GroupType.COMMUNITY, name: 'Community', des: 'After creation, you can enter and leave at will, support up to 100,000 people, support historical message storage, and after users search for group ID and initiate a group application, they can join the group without administrator approval. See product documentation for details.' },
+];

package/src/components/ConversationList/ConversationCreate/hooks/useConversationCreate.ts

@@ -0,0 +1,132 @@
+import type { Ref } from 'vue';
+import { ref, computed, watch } from 'vue';
+import TUIChatEngine from '@tencentcloud/chat-uikit-engine';
+import { strChineseFirstPy } from '../static/word';
+import type { ConversationCreateUsers, ConversationModel, Friend, UserProfile } from '../../../../types';
+
+export const useConversationCreate = (
+  conversationList: Ref<ConversationModel[]>,
+  friendList: Ref<Friend[]>,
+) => {
+  const friendListSortResult = ref<ConversationCreateUsers>({});
+
+  const getFirstLetter = (str: string) => {
+    const temp = str.trim();
+    const uni = temp.charCodeAt(0);
+    if (uni > 40869 || uni < 19968) {
+      return temp.charAt(0);
+    }
+    return strChineseFirstPy.charAt(uni - 19968);
+  };
+
+  const getCategoryKey = (firstLetter: string): string => {
+    const upper = firstLetter.toUpperCase();
+
+    if (firstLetter >= 'a' && firstLetter <= 'z') {
+      return upper;
+    }
+
+    if (firstLetter >= 'A' && firstLetter <= 'Z') {
+      return firstLetter;
+    }
+
+    return '#';
+  };
+
+  const addProfileToCategory = (
+    sortResult: Record<string, Friend[] | UserProfile[]>,
+    profile: Friend,
+    category: string,
+  ) => {
+    const categoryList = sortResult[category];
+    if (!categoryList.find(item => item.userID === profile.userID)) {
+      categoryList.push(profile);
+    }
+  };
+
+  const handleData = (
+    profileList: Friend[],
+    frequentlyConversationProfile?: UserProfile[],
+  ) => {
+    const sortResult: Record<string, Friend[] | UserProfile[]> = {
+      '#': frequentlyConversationProfile || [],
+    };
+
+    for (let i = 65; i <= 90; i += 1) {
+      sortResult[String.fromCharCode(i)] = [];
+    }
+
+    profileList?.forEach((profile) => {
+      const { nick, userID } = profile;
+      const firstLetter = getFirstLetter(nick || userID);
+      const categoryKey = getCategoryKey(firstLetter);
+
+      addProfileToCategory(sortResult, profile, categoryKey);
+    });
+
+    Object.keys(sortResult).forEach((key) => {
+      sortResult[key].sort((a: Friend | UserProfile, b: Friend | UserProfile) => {
+        const nameA = (a.nick || a.userID).toLowerCase();
+        const nameB = (b.nick || b.userID).toLowerCase();
+        return nameA.localeCompare(nameB);
+      });
+    });
+
+    return sortResult;
+  };
+
+  const queryFriendList = (
+    list: Friend[],
+    frequentlyConversationProfile?: UserProfile[],
+  ) => {
+    const sortResult = handleData(
+      list,
+      frequentlyConversationProfile,
+    );
+    friendListSortResult.value = sortResult;
+  };
+
+  const getFriendListSortSearchResult = (searchValue: string) => {
+    if (!searchValue) {
+      return friendListSortResult.value;
+    }
+    const result: Record<string, Friend[] | UserProfile[]> = {};
+    Object.keys(friendListSortResult.value).forEach((key) => {
+      result[key] = friendListSortResult.value[key].filter(
+        ({ nick, userID }: { nick: string; userID: string }) => {
+          const tempNick = nick?.toLocaleLowerCase();
+          const tempSearchValue = searchValue.toLocaleLowerCase();
+          const userIDValue = userID.toLocaleLowerCase();
+          return tempNick
+            ? tempNick.includes(tempSearchValue)
+            : userIDValue.includes(tempSearchValue);
+        },
+      );
+    });
+
+    return result;
+  };
+
+  watch(
+    [friendList, conversationList],
+    ([newFriendList, newConversationList]) => {
+      let frequentlyConversationProfile: UserProfile[] = [];
+      if (newConversationList && newConversationList.length > 0) {
+        frequentlyConversationProfile = newConversationList
+          .filter((item: ConversationModel) => item?.type === TUIChatEngine.TYPES.CONV_C2C)
+          .slice(0, 5)
+          .map((item: ConversationModel) => item?.userProfile);
+      }
+
+      queryFriendList(newFriendList, frequentlyConversationProfile);
+    },
+    { immediate: true },
+  );
+
+  return {
+    friendListSortResult: computed(() => friendListSortResult.value),
+    getFirstLetter,
+    queryFriendList,
+    getFriendListSortSearchResult,
+  };
+};

package/src/components/ConversationList/ConversationCreate/index.ts

@@ -0,0 +1,8 @@
+export { default as ConversationCreate } from './ConversationCreate.vue';
+export { default as ConversationCreateButton } from './ConversationCreateButton/ConversationCreateButton.vue';
+export { default as ConversationCreateGroupDetail } from './ConversationCreateGroupDetail/ConversationCreateGroupDetail.vue';
+export { default as ConversationCreateSelectView } from './ConversationCreateSelectView/ConversationCreateSelectView.vue';
+export { default as ConversationCreateUserSelectList } from './ConversationCreateUserSelectList/ConversationCreateUserSelectList.vue';
+export { default as ConversationGroupTypeInfo } from './ConversationGroupTypeInfo/ConversationGroupTypeInfo.vue';
+export { useConversationCreate } from './hooks/useConversationCreate';
+export { typeInfoList } from './ConversationGroupTypeInfo';