tuikit-atomicx-vue3 3.3.4 → 3.4.1

package/dist/states/SearchState.js

@@ -1,435 +1,308 @@
-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 = {
+import { reactive as O, computed as u } from "vue";
+import H, { TUIStore as g, StoreName as C, ISearchType as c, TUISearchService as T, TUIGroupService as I, TUIUserService as _, TUIFriendService as b } from "@tencentcloud/chat-uikit-engine";
+import { VariantType as d } from "../types/search.js";
+import { debouncePromise as E } from "../utils/lodash.js";
+const i = {
   keyword: "",
   results: /* @__PURE__ */ new Map(),
-  isLoading: false,
+  isLoading: !1,
   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) => {
+}, h = O({
+  [d.STANDARD]: { ...i },
+  [d.EMBEDDED]: { ...i },
+  [d.EXACT]: { ...i },
+  [d.MINI]: { ...i }
+}), A = {
+  [c.MESSAGE]: E(async (e, r) => {
     try {
-      const res = await TUISearchService.searchCloudMessages({
-        ...params,
-        keyword
+      return await T.searchCloudMessages({
+        ...r,
+        keyword: e
       });
-      return res;
-    } catch (error) {
-      console.error("[searchState searchCloudMessages] error", error);
-      throw error;
+    } catch (s) {
+      throw console.error("[searchState searchCloudMessages] error", s), s;
     }
   }, 300),
-  [ISearchType.CHAT_MESSAGE]: debouncePromise(async (keyword, params) => {
+  [c.CHAT_MESSAGE]: E(async (e, r) => {
     try {
-      const res = await TUISearchService.searchCloudMessages({
-        ...params,
-        keyword
+      return await T.searchCloudMessages({
+        ...r,
+        keyword: e
       });
-      return res;
-    } catch (error) {
-      console.error("[searchState searchCloudMessages] error", error);
-      throw error;
+    } catch (s) {
+      throw console.error("[searchState searchCloudMessages] error", s), s;
     }
   }, 300),
-  [ISearchType.USER]: debouncePromise(async (keyword, params) => {
+  [c.USER]: E(async (e, r) => {
     try {
-      const res = await TUISearchService.searchCloudUsers({
-        ...params,
-        keyword
+      return await T.searchCloudUsers({
+        ...r,
+        keyword: e
       });
-      return res;
-    } catch (error) {
-      console.error("[searchState searchCloudUsers] error", error);
-      throw error;
+    } catch (s) {
+      throw console.error("[searchState searchCloudUsers] error", s), s;
     }
   }, 300),
-  [ISearchType.GROUP]: debouncePromise(async (keyword, params) => {
+  [c.GROUP]: E(async (e, r) => {
     try {
-      const res = await TUISearchService.searchCloudGroups({
-        ...params,
-        keyword
+      return await T.searchCloudGroups({
+        ...r,
+        keyword: e
       });
-      return res;
-    } catch (error) {
-      console.error("[searchState searchCloudGroups] error", error);
-      throw error;
+    } catch (s) {
+      throw console.error("[searchState searchCloudGroups] error", s), s;
     }
   }, 300)
-};
-const searchExactControllers = {
-  [ISearchType.USER]: debouncePromise(async (keyword) => {
+}, f = {
+  [c.USER]: E(async (e) => {
     try {
-      const searchResult = {
+      const r = {
         resultList: [],
-        hasMore: false,
+        hasMore: !1,
         cursor: "",
         totalCount: 0,
         params: {
-          keyword
+          keyword: e
         }
-      };
-      const res = await Promise.all([
-        TUIUserService.getUserProfile({
-          userIDList: [keyword]
+      }, s = await Promise.all([
+        _.getUserProfile({
+          userIDList: [e]
         }),
-        TUIFriendService.checkFriend({
-          userIDList: [keyword],
-          type: TUIChatEngine.TYPES.SNS_CHECK_TYPE_BOTH
+        b.checkFriend({
+          userIDList: [e],
+          type: H.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;
+      return s[0].data.length > 0 && (r.resultList = [
+        {
+          profile: s[0].data[0],
+          relation: s[1].data.successUserIDList[0]
+        }
+      ], r.totalCount = 1), r;
+    } catch (r) {
+      throw console.error("[searchState getUserProfile] error", r), r;
     }
   }, 300),
-  [ISearchType.GROUP]: debouncePromise(async (keyword) => {
+  [c.GROUP]: E(async (e) => {
     try {
-      const searchResult = {
+      const r = {
         resultList: [],
-        hasMore: false,
+        hasMore: !1,
         cursor: "",
         totalCount: 0,
         params: {
-          keyword
+          keyword: e
         }
-      };
-      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;
+      }, s = await I.searchGroupByID(e);
+      return s.data.group && (r.resultList = [
+        {
+          groupInfo: s.data.group
+        }
+      ], r.totalCount = 1), r;
+    } catch (r) {
+      throw console.error("[searchState searchGroupByID] error", r), r;
     }
   }, 300)
-};
-const setSearchExactResult = (result, type) => {
-  const state = searchStates[VariantType.EXACT];
-  const newResultList = /* @__PURE__ */ new Map();
-  newResultList.set(type, result);
-  Object.assign(state, {
-    results: newResultList
+}, P = (e, r) => {
+  const s = h[d.EXACT], a = /* @__PURE__ */ new Map();
+  a.set(r, e), Object.assign(s, {
+    results: a
   });
-};
-const searchExact = async (variant, type) => {
-  const { keyword } = searchStates[variant];
-  if (type) {
+}, v = async (e, r) => {
+  const { keyword: s } = h[e];
+  if (r)
     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;
+      const o = f[r], t = await (o == null ? void 0 : o(s));
+      P(t, r);
+    } catch (a) {
+      throw console.error(`[searchState search] error variant is ${e}, type is ${r}`, a), a;
     }
-  } else {
-    Object.keys(searchExactControllers).forEach(async (name) => {
-      const key = name;
+  else
+    Object.keys(f).forEach(async (a) => {
+      const o = a;
       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 t = f[o], n = await (t == null ? void 0 : t(s));
+        P(n, o);
+      } catch (t) {
+        throw console.error(`[searchState search] error variant is ${e}, type is ${o}`, t), t;
       }
     });
-  }
-};
-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);
-  }
+}, l = async (e, r) => {
+  const s = h[e];
+  if (s.keyword && Object.assign(h[e], {
+    isLoading: !0,
+    error: null
+  }), e === d.EXACT)
+    return v(e, r);
   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]
+    const a = [], o = r || s.selectedSearchType;
+    e === d.EMBEDDED ? a.push(
+      {
+        type: c.CHAT_MESSAGE,
+        search: A[c.CHAT_MESSAGE]
+      }
+    ) : o === "all" ? Object.keys(A).forEach((t) => {
+      t !== c.CHAT_MESSAGE && a.push({
+        type: t,
+        search: A[t]
       });
-    }
-    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);
+    }) : a.push({
+      type: o,
+      search: A[o]
+    }), await Promise.all(
+      a.map(async (t) => {
+        var S;
+        const n = s.searchAdvancedParams.get(t.type) || {};
+        return (S = t.search) == null ? void 0 : S.call(t, s.keyword, n);
       })
-    );
-    Object.assign(searchStates[variant], {
-      isLoading: false
+    ), Object.assign(h[e], {
+      isLoading: !1
     });
-  } catch (error) {
-    Object.assign(searchStates[variant], {
-      error,
-      isLoading: false
+  } catch (a) {
+    Object.assign(h[e], {
+      error: a,
+      isLoading: !1
     });
   }
   return Promise.resolve();
-};
-const setKeyword = (variant, k) => {
-  const state = searchStates[variant];
-  const { searchAdvancedParams, selectedSearchType } = state;
-  const newStates = {
-    ...state,
+}, L = (e, r) => {
+  const s = h[e], { searchAdvancedParams: a, selectedSearchType: o } = s, t = {
+    ...s,
     error: null,
-    isLoading: false,
-    keyword: k.trimEnd(),
+    isLoading: !1,
+    keyword: r.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);
-        }
+  if (r !== s.keyword) {
+    if (e === d.EMBEDDED) {
+      const { conversationID: n } = a.get(c.CHAT_MESSAGE);
+      t.searchAdvancedParams.set(c.CHAT_MESSAGE, {
+        conversationID: n
       });
-    } else {
-      search(variant);
     }
+    o !== "all" && t.searchAdvancedParams.set(o, a.get(o)), Object.assign(h[e], t), r && (e === d.EXACT ? l(e) : e !== d.EMBEDDED ? Object.keys(A).forEach((n) => {
+      n !== c.CHAT_MESSAGE && l(e, n);
+    }) : l(e));
   }
-};
-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) {
+}, D = (e) => {
+  Object.assign(h[e], i);
+}, j = (e, r) => {
+  const s = h[e];
+  if (e === d.EXACT && D(e), s.selectedSearchType === r)
     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 a = {
+    ...s,
+    selectedSearchType: r === c.CHAT_MESSAGE ? c.MESSAGE : r
+  }, o = [];
+  s.keyword && r === "all" && s.searchAdvancedParams.forEach((t, n) => {
+    (t || !s.results.has(n)) && (n !== c.CHAT_MESSAGE && o.push(n), a.results.delete(n), a.searchAdvancedParams.delete(n));
+  }), Object.assign(h[e], a), o.length > 0 && o.forEach((t) => {
+    l(e, t);
   });
-  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);
-    });
+}, G = (e, r) => {
+  const s = h[e], { searchAdvancedParams: a } = s, { conversationID: o } = r, t = o ? c.CHAT_MESSAGE : c.MESSAGE, n = /* @__PURE__ */ new Map([[t, r]]), S = [t], p = s.results.get(c.CHAT_MESSAGE);
+  if (!o && p) {
+    const y = p.params;
+    n.set(c.CHAT_MESSAGE, {
+      conversationID: y.conversationID,
+      ...r,
+      cursor: ""
+    }), S.push(c.CHAT_MESSAGE);
   }
-};
-const setSearchUserAdvancedParams = (variant, params) => {
-  const state = searchStates[variant];
-  const newSearchAdvancedParams = /* @__PURE__ */ new Map();
-  newSearchAdvancedParams.set(ISearchType.USER, {
-    ...params,
-    cursor: ""
+  const M = new Map([...a, ...n]);
+  Object.assign(h[e], {
+    searchAdvancedParams: M,
+    results: s.results
   });
-  Object.assign(searchStates[variant], {
-    searchAdvancedParams: new Map([...state.searchAdvancedParams, ...newSearchAdvancedParams])
+  const R = M.get(
+    o ? c.CHAT_MESSAGE : c.MESSAGE
+  ), { senderUserIDList: w = [], messageTypeList: U = [] } = R || {};
+  (s.keyword || (w == null ? void 0 : w.length) > 0 && U.length > 0) && S.forEach((y) => {
+    l(e, y);
   });
-  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,
+}, B = (e, r) => {
+  const s = h[e], a = /* @__PURE__ */ new Map();
+  a.set(c.USER, {
+    ...r,
     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) {
+  }), Object.assign(h[e], {
+    searchAdvancedParams: new Map([...s.searchAdvancedParams, ...a])
+  }), s.keyword && l(e, c.USER);
+}, N = (e, r) => {
+  const s = h[e], a = /* @__PURE__ */ new Map();
+  a.set(c.GROUP, {
+    ...r,
+    cursor: ""
+  }), Object.assign(h[e], {
+    searchAdvancedParams: new Map([...s.searchAdvancedParams, ...a])
+  }), s.keyword && l(e, c.GROUP);
+}, m = (e, r) => {
+  const { params: s = {} } = e;
+  Object.entries(h).forEach(([a, o]) => {
+    if (a === d.EXACT)
       return;
-    }
-    const currentParams = {
-      ...state.searchAdvancedParams.get(type),
-      keyword: state.keyword
+    const t = {
+      ...o.searchAdvancedParams.get(r),
+      keyword: o.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
+    if (JSON.stringify(s) === JSON.stringify(t)) {
+      const n = /* @__PURE__ */ new Map();
+      n.set(r, e);
+      const S = new Map([...o.results, ...n]), p = a === d.STANDARD, M = r === c.CHAT_MESSAGE;
+      Object.assign(h[a], {
+        selectedSearchType: p && M ? c.MESSAGE : o.selectedSearchType,
+        results: S
       });
     }
   });
-};
-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 });
+}, k = async (e, r) => {
+  var n;
+  const s = h[e], a = r || s.selectedSearchType, o = s.searchAdvancedParams.get(a) || {}, t = (n = s.results) == null ? void 0 : n.get(a);
+  o.cursor = (t == null ? void 0 : t.cursor) || "", Object.assign(h[e], {
+    searchAdvancedParams: new Map(s.searchAdvancedParams).set(a, o)
+  }), l(e, r);
+}, X = (e) => {
+  m(e, c.MESSAGE);
+}, x = (e) => {
+  m(e, c.CHAT_MESSAGE);
+}, $ = (e) => {
+  m(e, c.USER);
+}, K = (e) => {
+  m(e, c.GROUP);
+}, V = () => {
+  g.watch(C.CONV, {
+    currentConversationID: (e) => {
+      D(d.EMBEDDED), G(d.EMBEDDED, { conversationID: e });
     }
-  });
-  TUIStore.watch(StoreName.SEARCH, {
-    searchMessagesResult: onSearchMessageResultUpdated,
-    searchChatMessagesResult: onSearchChatMessageResultUpdated,
-    searchUserResult: onSearchUserResultUpdated,
-    searchGroupResult: onSearchGroupResultUpdated
+  }), g.watch(C.SEARCH, {
+    searchMessagesResult: X,
+    searchChatMessagesResult: x,
+    searchUserResult: $,
+    searchGroupResult: K
   });
 };
-initSearchWatcher();
-function useSearchState(variant) {
-  const currentVariant = !variant || variant !== VariantType.EMBEDDED && variant !== VariantType.EXACT ? VariantType.STANDARD : variant;
-  const state = computed(() => searchStates[currentVariant]);
+V();
+function q(e) {
+  const r = !e || e !== d.EMBEDDED && e !== d.EXACT ? d.STANDARD : e, s = u(() => h[r]);
   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)
+    keyword: u(() => s.value.keyword),
+    results: u(() => s.value.results),
+    isLoading: u(() => s.value.isLoading),
+    error: u(() => s.value.error),
+    searchAdvancedParams: u(() => s.value.searchAdvancedParams),
+    selectedSearchType: u(() => s.value.selectedSearchType),
+    setKeyword: (a) => L(r, a),
+    loadMore: (a) => k(r, a),
+    setSelectedType: (a) => j(r, a),
+    setSearchMessageAdvancedParams: (a) => G(r, a),
+    setSearchUserAdvancedParams: (a) => B(r, a),
+    setSearchGroupAdvancedParams: (a) => N(r, a)
   };
 }
 export {
-  useSearchState as default,
-  useSearchState
+  q as default,
+  q as useSearchState
 };