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

package/dist/states/SearchState.d.ts

@@ -0,0 +1,267 @@
+import { ISearchType as SearchType, SearchCloudGroupsParams, SearchCloudMessagesParams, SearchCloudUsersParams } from '@tencentcloud/chat-uikit-engine';
+import { VariantType } from '../types/search';
+import { SearchResult } from '../types/engine';
+
+export declare function useSearchState(variant?: VariantType): {
+    keyword: import('vue').ComputedRef<string>;
+    results: import('vue').ComputedRef<Map<SearchType, {
+        resultList: [] | {
+            messageList: {
+                ID: string;
+                type: import("@tencentcloud/chat").default.TYPES;
+                payload: any;
+                conversationID: string;
+                conversationType: import("@tencentcloud/chat").default.TYPES;
+                to: string;
+                from: string;
+                flow: string;
+                time: number;
+                status: string;
+                isRevoked: boolean;
+                priority: import("@tencentcloud/chat").default.TYPES;
+                nick: string;
+                avatar: string;
+                isPeerRead: boolean;
+                nameCard: string;
+                atUserList: string[];
+                cloudCustomData: string;
+                isDeleted: boolean;
+                isModified: boolean;
+                needReadReceipt: boolean;
+                readReceiptInfo: any;
+                isBroadcastMessage: boolean;
+                isSupportExtension: boolean;
+                receiverList?: string[] | undefined;
+                revoker: string;
+                sequence: number;
+                progress: number;
+                revokerInfo: {
+                    userID: string;
+                    nick: string;
+                    avatar: string;
+                };
+                revokeReason: string;
+                hasRiskContent: boolean;
+                reactionList: {
+                    reactionID: string;
+                    totalUserCount: number;
+                    partialUserList: {
+                        userID: string;
+                        nick: string;
+                        avatar: string;
+                    }[];
+                }[];
+                updateProperties: (options: import('@tencentcloud/chat').Message) => void;
+                getMessage: () => import('@tencentcloud/chat').Message;
+                modifyMessage: (options: import('@tencentcloud/chat-uikit-engine').ModifyMessageParams) => Promise<any>;
+                revokeMessage: () => Promise<any>;
+                resendMessage: () => Promise<any>;
+                deleteMessage: () => Promise<any>;
+                quoteMessage: () => import('@tencentcloud/chat').Message;
+                replyMessage: () => import('@tencentcloud/chat').Message;
+                setMessageExtensions: (extensions: object[]) => Promise<any>;
+                deleteMessageExtensions: (keyList?: string[]) => Promise<any>;
+                getMessageExtensions: () => Promise<any>;
+                getSignalingInfo: () => Record<string, any> | null;
+                getMessageContent: () => Record<string, any>;
+            }[];
+            messageCount: number;
+            conversation?: {
+                conversationID: string;
+                type: string;
+                subType: string;
+                unreadCount: number;
+                lastMessage?: {
+                    nick: string;
+                    nameCard: string;
+                    lastTime: number | string;
+                    lastSequence: string;
+                    fromAccount: string;
+                    isRevoked: boolean;
+                    revoker?: string | undefined;
+                    isPeerRead: boolean;
+                    messageForShow: string;
+                    type: string;
+                    payload: any;
+                } | undefined;
+                groupProfile?: any;
+                userProfile?: any;
+                groupAtInfoList?: any[] | undefined;
+                remark: string;
+                isPinned: boolean;
+                messageRemindType: string;
+                markList: string[];
+                customData: string;
+                conversationGroupList: any[];
+                draftText: string;
+                isMuted: boolean;
+                operationType: number;
+                _conversation: any;
+                updateProperties: (options: import('@tencentcloud/chat').Conversation) => void;
+                updateOperationType: (operationType: number) => void;
+                getConversation: () => any;
+                deleteConversation: () => Promise<any>;
+                pinConversation: () => Promise<any>;
+                muteConversation: () => Promise<any>;
+                setMessageRead: () => Promise<any>;
+                getAvatar: () => string;
+                getShowName: () => string;
+                getGroupAtInfo: () => string;
+                getLastMessage: (key: string) => string | null;
+            } | undefined;
+        }[] | {
+            profile: {
+                userID: string;
+                nick: string;
+                gender: import("@tencentcloud/chat").default.TYPES;
+                birthday: number;
+                location: string;
+                selfSignature: string;
+                allowType: import("@tencentcloud/chat").default.TYPES;
+                language: number;
+                avatar: string;
+                messageSettings: number;
+                adminForbidType: import("@tencentcloud/chat").default.TYPES;
+                level: number;
+                role: number;
+                lastUpdatedNumber: number;
+                profileCustomField: Array<any>;
+            };
+            relation: import("@tencentcloud/chat").default.TYPES.SNS_TYPE_NO_RELATION | import("@tencentcloud/chat").default.TYPES.SNS_TYPE_A_WITH_B | import("@tencentcloud/chat").default.TYPES.SNS_TYPE_B_WITH_A | import("@tencentcloud/chat").default.TYPES.SNS_TYPE_BOTH_WAY;
+        }[] | {
+            groupInfo: {
+                groupID: string;
+                name: string;
+                avatar: string;
+                type: import("@tencentcloud/chat").default.TYPES;
+                introduction: string;
+                notification: string;
+                ownerID: string;
+                createTime: string;
+                infoSequence: number;
+                lastInfoTime: number;
+                selfInfo: any;
+                lastMessage: any;
+                nextMessageSeq: number;
+                memberCount: number;
+                maxMemberCount: number;
+                muteAllMembers: boolean;
+                joinOption: import("@tencentcloud/chat").default.TYPES;
+                groupCustomField: Array<any>;
+                isSupportTopic: boolean;
+            };
+            conversation?: {
+                conversationID: string;
+                type: string;
+                subType: string;
+                unreadCount: number;
+                lastMessage?: {
+                    nick: string;
+                    nameCard: string;
+                    lastTime: number | string;
+                    lastSequence: string;
+                    fromAccount: string;
+                    isRevoked: boolean;
+                    revoker?: string | undefined;
+                    isPeerRead: boolean;
+                    messageForShow: string;
+                    type: string;
+                    payload: any;
+                } | undefined;
+                groupProfile?: any;
+                userProfile?: any;
+                groupAtInfoList?: any[] | undefined;
+                remark: string;
+                isPinned: boolean;
+                messageRemindType: string;
+                markList: string[];
+                customData: string;
+                conversationGroupList: any[];
+                draftText: string;
+                isMuted: boolean;
+                operationType: number;
+                _conversation: any;
+                updateProperties: (options: import('@tencentcloud/chat').Conversation) => void;
+                updateOperationType: (operationType: number) => void;
+                getConversation: () => any;
+                deleteConversation: () => Promise<any>;
+                pinConversation: () => Promise<any>;
+                muteConversation: () => Promise<any>;
+                setMessageRead: () => Promise<any>;
+                getAvatar: () => string;
+                getShowName: () => string;
+                getGroupAtInfo: () => string;
+                getLastMessage: (key: string) => string | null;
+            } | undefined;
+        }[];
+        hasMore: boolean;
+        cursor: string;
+        totalCount: number;
+        params: {
+            senderUserIDList?: string[] | undefined;
+            messageTypeList?: any[] | undefined;
+            conversationID?: string | undefined;
+            timePosition?: number | undefined;
+            timePeriod?: number | undefined;
+            keyword?: string | undefined;
+            keywordList?: string[] | undefined;
+            keywordListMatchType?: "or" | "and" | undefined;
+            cursor?: string | undefined;
+            count?: number | undefined;
+        } | {
+            gender?: string | undefined;
+            miniBirthday?: number | undefined;
+            maxBirthday?: number | undefined;
+            keyword?: string | undefined;
+            keywordList?: string[] | undefined;
+            keywordListMatchType?: "or" | "and" | undefined;
+            cursor?: string | undefined;
+            count?: number | undefined;
+        } | {
+            groupTypeList?: any[] | undefined;
+            keyword?: string | undefined;
+            keywordList?: string[] | undefined;
+            keywordListMatchType?: "or" | "and" | undefined;
+            cursor?: string | undefined;
+            count?: number | undefined;
+        };
+    }> & Omit<Map<SearchType, SearchResult<SearchType>>, keyof Map<any, any>>>;
+    isLoading: import('vue').ComputedRef<boolean>;
+    error: import('vue').ComputedRef<Error | null>;
+    searchAdvancedParams: import('vue').ComputedRef<Map<SearchType, {
+        senderUserIDList?: string[] | undefined;
+        messageTypeList?: any[] | undefined;
+        conversationID?: string | undefined;
+        timePosition?: number | undefined;
+        timePeriod?: number | undefined;
+        keyword?: string | undefined;
+        keywordList?: string[] | undefined;
+        keywordListMatchType?: "or" | "and" | undefined;
+        cursor?: string | undefined;
+        count?: number | undefined;
+    } | {
+        gender?: string | undefined;
+        miniBirthday?: number | undefined;
+        maxBirthday?: number | undefined;
+        keyword?: string | undefined;
+        keywordList?: string[] | undefined;
+        keywordListMatchType?: "or" | "and" | undefined;
+        cursor?: string | undefined;
+        count?: number | undefined;
+    } | {
+        groupTypeList?: any[] | undefined;
+        keyword?: string | undefined;
+        keywordList?: string[] | undefined;
+        keywordListMatchType?: "or" | "and" | undefined;
+        cursor?: string | undefined;
+        count?: number | undefined;
+    }> & Omit<Map<SearchType, SearchCloudMessagesParams | SearchCloudUsersParams | SearchCloudGroupsParams>, keyof Map<any, any>>>;
+    selectedSearchType: import('vue').ComputedRef<"all" | SearchType>;
+    setKeyword: (k: string) => void;
+    loadMore: (type?: SearchType) => Promise<void>;
+    setSelectedType: (type: SearchType | "all") => void;
+    setSearchMessageAdvancedParams: (params: SearchCloudMessagesParams) => void;
+    setSearchUserAdvancedParams: (params: SearchCloudUsersParams) => void;
+    setSearchGroupAdvancedParams: (params: SearchCloudGroupsParams) => void;
+};
+export default useSearchState;

package/dist/states/SearchState.js

@@ -0,0 +1,434 @@
+import { reactive, computed } from "vue";
+import TUIChatEngine, { TUIStore, StoreName, ISearchType, TUISearchService, TUIGroupService, TUIUserService, TUIFriendService } from "@tencentcloud/chat-uikit-engine";
+import { VariantType } from "../types/search.js";
+import { debouncePromise } from "../utils/lodash.js";
+const initState = {
+  keyword: "",
+  results: /* @__PURE__ */ new Map(),
+  isLoading: false,
+  error: null,
+  searchAdvancedParams: /* @__PURE__ */ new Map(),
+  selectedSearchType: "all"
+};
+const searchStates = reactive({
+  [VariantType.STANDARD]: { ...initState },
+  [VariantType.EMBEDDED]: { ...initState },
+  [VariantType.EXACT]: { ...initState },
+  [VariantType.MINI]: { ...initState }
+});
+const searchControllers = {
+  [ISearchType.MESSAGE]: debouncePromise(async (keyword, params) => {
+    try {
+      const res = await TUISearchService.searchCloudMessages({
+        ...params,
+        keyword
+      });
+      return res;
+    } catch (error) {
+      console.error("[searchState searchCloudMessages] error", error);
+      throw error;
+    }
+  }, 300),
+  [ISearchType.CHAT_MESSAGE]: debouncePromise(async (keyword, params) => {
+    try {
+      const res = await TUISearchService.searchCloudMessages({
+        ...params,
+        keyword
+      });
+      return res;
+    } catch (error) {
+      console.error("[searchState searchCloudMessages] error", error);
+      throw error;
+    }
+  }, 300),
+  [ISearchType.USER]: debouncePromise(async (keyword, params) => {
+    try {
+      const res = await TUISearchService.searchCloudUsers({
+        ...params,
+        keyword
+      });
+      return res;
+    } catch (error) {
+      console.error("[searchState searchCloudUsers] error", error);
+      throw error;
+    }
+  }, 300),
+  [ISearchType.GROUP]: debouncePromise(async (keyword, params) => {
+    try {
+      const res = await TUISearchService.searchCloudGroups({
+        ...params,
+        keyword
+      });
+      return res;
+    } catch (error) {
+      console.error("[searchState searchCloudGroups] error", error);
+      throw error;
+    }
+  }, 300)
+};
+const searchExactControllers = {
+  [ISearchType.USER]: debouncePromise(async (keyword) => {
+    try {
+      const searchResult = {
+        resultList: [],
+        hasMore: false,
+        cursor: "",
+        totalCount: 0,
+        params: {
+          keyword
+        }
+      };
+      const res = await Promise.all([
+        TUIUserService.getUserProfile({
+          userIDList: [keyword]
+        }),
+        TUIFriendService.checkFriend({
+          userIDList: [keyword],
+          type: TUIChatEngine.TYPES.SNS_CHECK_TYPE_BOTH
+        })
+      ]);
+      if (res[0].data.length > 0) {
+        searchResult.resultList = [
+          {
+            profile: res[0].data[0],
+            relation: res[1].data.successUserIDList[0]
+          }
+        ];
+        searchResult.totalCount = 1;
+      }
+      return searchResult;
+    } catch (error) {
+      console.error("[searchState getUserProfile] error", error);
+      throw error;
+    }
+  }, 300),
+  [ISearchType.GROUP]: debouncePromise(async (keyword) => {
+    try {
+      const searchResult = {
+        resultList: [],
+        hasMore: false,
+        cursor: "",
+        totalCount: 0,
+        params: {
+          keyword
+        }
+      };
+      const res = await TUIGroupService.searchGroupByID(keyword);
+      if (res.data.group) {
+        searchResult.resultList = [
+          {
+            groupInfo: res.data.group
+          }
+        ];
+        searchResult.totalCount = 1;
+      }
+      return searchResult;
+    } catch (error) {
+      console.error("[searchState searchGroupByID] error", error);
+      throw error;
+    }
+  }, 300)
+};
+const setSearchExactResult = (result, type) => {
+  const state = searchStates[VariantType.EXACT];
+  const newResultList = /* @__PURE__ */ new Map();
+  newResultList.set(type, result);
+  Object.assign(state, {
+    results: newResultList
+  });
+};
+const searchExact = async (variant, type) => {
+  const { keyword } = searchStates[variant];
+  if (type) {
+    try {
+      const searchType = type;
+      const search2 = searchExactControllers[searchType];
+      const res = await (search2 == null ? void 0 : search2(keyword));
+      setSearchExactResult(res, type);
+    } catch (error) {
+      console.error(`[searchState search] error variant is ${variant}, type is ${type}`, error);
+      throw error;
+    }
+  } else {
+    Object.keys(searchExactControllers).forEach(async (name) => {
+      const key = name;
+      try {
+        const search2 = searchExactControllers[key];
+        const res = await (search2 == null ? void 0 : search2(keyword));
+        setSearchExactResult(res, key);
+      } catch (error) {
+        console.error(`[searchState search] error variant is ${variant}, type is ${key}`, error);
+        throw error;
+      }
+    });
+  }
+};
+const search = async (variant, type) => {
+  const state = searchStates[variant];
+  if (state.keyword) {
+    Object.assign(searchStates[variant], {
+      isLoading: true,
+      error: null
+    });
+  }
+  if (variant === VariantType.EXACT) {
+    return searchExact(variant, type);
+  }
+  try {
+    const activeControllers = [];
+    const searchType = type || state.selectedSearchType;
+    if (variant === VariantType.EMBEDDED) {
+      activeControllers.push(
+        {
+          type: ISearchType.CHAT_MESSAGE,
+          search: searchControllers[ISearchType.CHAT_MESSAGE]
+        }
+      );
+    } else if (searchType === "all") {
+      Object.keys(searchControllers).forEach((key) => {
+        if (key !== ISearchType.CHAT_MESSAGE) {
+          activeControllers.push({
+            type: key,
+            search: searchControllers[key]
+          });
+        }
+      });
+    } else {
+      activeControllers.push({
+        type: searchType,
+        search: searchControllers[searchType]
+      });
+    }
+    await Promise.all(
+      activeControllers.map(async (controller) => {
+        var _a;
+        const typeParams = state.searchAdvancedParams.get(controller.type) || {};
+        return (_a = controller.search) == null ? void 0 : _a.call(controller, state.keyword, typeParams);
+      })
+    );
+    Object.assign(searchStates[variant], {
+      isLoading: false
+    });
+  } catch (error) {
+    Object.assign(searchStates[variant], {
+      error,
+      isLoading: false
+    });
+  }
+  return Promise.resolve();
+};
+const setKeyword = (variant, k) => {
+  const state = searchStates[variant];
+  const { searchAdvancedParams, selectedSearchType } = state;
+  const newStates = {
+    ...state,
+    isLoading: false,
+    keyword: k.trimEnd(),
+    searchAdvancedParams: /* @__PURE__ */ new Map(),
+    results: /* @__PURE__ */ new Map()
+  };
+  if (k === state.keyword) {
+    return;
+  }
+  if (variant === VariantType.EMBEDDED) {
+    const { conversationID } = searchAdvancedParams.get(ISearchType.CHAT_MESSAGE);
+    newStates.searchAdvancedParams.set(ISearchType.CHAT_MESSAGE, {
+      conversationID
+    });
+  }
+  if (selectedSearchType !== "all") {
+    newStates.searchAdvancedParams.set(selectedSearchType, searchAdvancedParams.get(selectedSearchType));
+  }
+  Object.assign(searchStates[variant], newStates);
+  if (k) {
+    if (variant === VariantType.EXACT) {
+      search(variant);
+    } else if (variant !== VariantType.EMBEDDED) {
+      Object.keys(searchControllers).forEach((key) => {
+        if (key !== ISearchType.CHAT_MESSAGE) {
+          search(variant, key);
+        }
+      });
+    } else {
+      search(variant);
+    }
+  }
+};
+const resetState = (variant) => {
+  Object.assign(searchStates[variant], initState);
+};
+const setSelectedType = (variant, type) => {
+  const state = searchStates[variant];
+  if (variant === VariantType.EXACT) {
+    resetState(variant);
+  }
+  if (state.selectedSearchType === type) {
+    return;
+  }
+  const updateState = {
+    ...state,
+    selectedSearchType: type === ISearchType.CHAT_MESSAGE ? ISearchType.MESSAGE : type
+  };
+  const updateList = [];
+  if (state.keyword && type === "all") {
+    state.searchAdvancedParams.forEach((value, key) => {
+      if (value || !state.results.has(key)) {
+        if (key !== ISearchType.CHAT_MESSAGE) {
+          updateList.push(key);
+        }
+        updateState.results.delete(key);
+        updateState.searchAdvancedParams.delete(key);
+      }
+    });
+  }
+  Object.assign(searchStates[variant], updateState);
+  if (updateList.length > 0) {
+    updateList.forEach((key) => {
+      search(variant, key);
+    });
+  }
+};
+const setSearchMessageAdvancedParams = (variant, params) => {
+  const state = searchStates[variant];
+  const { searchAdvancedParams } = state;
+  const { conversationID } = params;
+  const currentSearchType = conversationID ? ISearchType.CHAT_MESSAGE : ISearchType.MESSAGE;
+  const newSearchAdvancedParams = /* @__PURE__ */ new Map([[currentSearchType, params]]);
+  const updateList = [currentSearchType];
+  const chatMessageResults = state.results.get(ISearchType.CHAT_MESSAGE);
+  if (!conversationID && chatMessageResults) {
+    const chatMessageParams = chatMessageResults.params;
+    newSearchAdvancedParams.set(ISearchType.CHAT_MESSAGE, {
+      conversationID: chatMessageParams.conversationID,
+      ...params,
+      cursor: ""
+    });
+    updateList.push(ISearchType.CHAT_MESSAGE);
+  }
+  const paramsMap = new Map([...searchAdvancedParams, ...newSearchAdvancedParams]);
+  Object.assign(searchStates[variant], {
+    searchAdvancedParams: paramsMap,
+    results: state.results
+  });
+  const currentParams = paramsMap.get(
+    conversationID ? ISearchType.CHAT_MESSAGE : ISearchType.MESSAGE
+  );
+  const { senderUserIDList = [], messageTypeList = [] } = currentParams || {};
+  if (state.keyword || (senderUserIDList == null ? void 0 : senderUserIDList.length) > 0 && messageTypeList.length > 0) {
+    updateList.forEach((key) => {
+      search(variant, key);
+    });
+  }
+};
+const setSearchUserAdvancedParams = (variant, params) => {
+  const state = searchStates[variant];
+  const newSearchAdvancedParams = /* @__PURE__ */ new Map();
+  newSearchAdvancedParams.set(ISearchType.USER, {
+    ...params,
+    cursor: ""
+  });
+  Object.assign(searchStates[variant], {
+    searchAdvancedParams: new Map([...state.searchAdvancedParams, ...newSearchAdvancedParams])
+  });
+  if (state.keyword) {
+    search(variant, ISearchType.USER);
+  }
+};
+const setSearchGroupAdvancedParams = (variant, params) => {
+  const state = searchStates[variant];
+  const newSearchAdvancedParams = /* @__PURE__ */ new Map();
+  newSearchAdvancedParams.set(ISearchType.GROUP, {
+    ...params,
+    cursor: ""
+  });
+  Object.assign(searchStates[variant], {
+    searchAdvancedParams: new Map([...state.searchAdvancedParams, ...newSearchAdvancedParams])
+  });
+  if (state.keyword) {
+    search(variant, ISearchType.GROUP);
+  }
+};
+const setSearchResult = (result, type) => {
+  const { params = {} } = result;
+  Object.entries(searchStates).forEach(([variant, state]) => {
+    if (variant === VariantType.EXACT) {
+      return;
+    }
+    const currentParams = {
+      ...state.searchAdvancedParams.get(type),
+      keyword: state.keyword
+    };
+    if (JSON.stringify(params) === JSON.stringify(currentParams)) {
+      const newResultList = /* @__PURE__ */ new Map();
+      newResultList.set(type, result);
+      const newResults = new Map([...state.results, ...newResultList]);
+      const isSearchGlobal = variant === VariantType.STANDARD;
+      const isChatHistoryResults = type === ISearchType.CHAT_MESSAGE;
+      Object.assign(searchStates[variant], {
+        selectedSearchType: isSearchGlobal && isChatHistoryResults ? ISearchType.MESSAGE : state.selectedSearchType,
+        results: newResults
+      });
+    }
+  });
+};
+const loadMore = async (variant, type) => {
+  var _a;
+  const state = searchStates[variant];
+  const selectType = type || state.selectedSearchType;
+  const params = state.searchAdvancedParams.get(selectType) || {};
+  const searchResult = (_a = state.results) == null ? void 0 : _a.get(selectType);
+  params.cursor = (searchResult == null ? void 0 : searchResult.cursor) || "";
+  Object.assign(searchStates[variant], {
+    searchAdvancedParams: new Map(state.searchAdvancedParams).set(selectType, params)
+  });
+  search(variant, type);
+};
+const onSearchMessageResultUpdated = (result) => {
+  setSearchResult(result, ISearchType.MESSAGE);
+};
+const onSearchChatMessageResultUpdated = (result) => {
+  setSearchResult(result, ISearchType.CHAT_MESSAGE);
+};
+const onSearchUserResultUpdated = (result) => {
+  setSearchResult(result, ISearchType.USER);
+};
+const onSearchGroupResultUpdated = (result) => {
+  setSearchResult(result, ISearchType.GROUP);
+};
+const initSearchWatcher = () => {
+  TUIStore.watch(StoreName.CONV, {
+    currentConversationID: (ID) => {
+      resetState(VariantType.EMBEDDED);
+      setSearchMessageAdvancedParams(VariantType.EMBEDDED, { conversationID: ID });
+    }
+  });
+  TUIStore.watch(StoreName.SEARCH, {
+    searchMessagesResult: onSearchMessageResultUpdated,
+    searchChatMessagesResult: onSearchChatMessageResultUpdated,
+    searchUserResult: onSearchUserResultUpdated,
+    searchGroupResult: onSearchGroupResultUpdated
+  });
+};
+initSearchWatcher();
+function useSearchState(variant) {
+  const currentVariant = !variant || variant !== VariantType.EMBEDDED && variant !== VariantType.EXACT ? VariantType.STANDARD : variant;
+  const state = computed(() => searchStates[currentVariant]);
+  return {
+    keyword: computed(() => state.value.keyword),
+    results: computed(() => state.value.results),
+    isLoading: computed(() => state.value.isLoading),
+    error: computed(() => state.value.error),
+    searchAdvancedParams: computed(() => state.value.searchAdvancedParams),
+    selectedSearchType: computed(() => state.value.selectedSearchType),
+    setKeyword: (k) => setKeyword(currentVariant, k),
+    loadMore: (type) => loadMore(currentVariant, type),
+    setSelectedType: (type) => setSelectedType(currentVariant, type),
+    setSearchMessageAdvancedParams: (params) => setSearchMessageAdvancedParams(currentVariant, params),
+    setSearchUserAdvancedParams: (params) => setSearchUserAdvancedParams(currentVariant, params),
+    setSearchGroupAdvancedParams: (params) => setSearchGroupAdvancedParams(currentVariant, params)
+  };
+}
+export {
+  useSearchState as default,
+  useSearchState
+};