@sendbird/uikit-chat-hooks 1.0.2 → 1.1.1

package/src/channel/useGroupChannelList/useGroupChannelListWithCollection.ts

@@ -0,0 +1,116 @@
+import { useEffect, useRef } from 'react';
+
+import type { SendbirdChatSDK, SendbirdGroupChannelCollection } from '@sendbird/uikit-utils';
+import { useAsyncEffect, useFreshCallback, useUniqId } from '@sendbird/uikit-utils';
+
+import { useAppFeatures } from '../../common/useAppFeatures';
+import { useChannelHandler } from '../../handler/useChannelHandler';
+import type { UseGroupChannelList, UseGroupChannelListOptions } from '../../types';
+import { useGroupChannelListReducer } from './reducer';
+
+const HOOK_NAME = 'useGroupChannelListWithCollection';
+
+const createGroupChannelListCollection = (
+  sdk: SendbirdChatSDK,
+  collectionCreator: UseGroupChannelListOptions['collectionCreator'],
+) => {
+  const passedCollection = collectionCreator?.();
+  if (passedCollection) return passedCollection;
+
+  const defaultOptions = {
+    includeEmpty: false,
+    limit: 5,
+    order: sdk.GroupChannelCollection.GroupChannelOrder.LATEST_LAST_MESSAGE,
+  };
+  const collectionBuilder = sdk.GroupChannel.createGroupChannelCollection();
+  const groupChannelFilter = new sdk.GroupChannelFilter();
+  groupChannelFilter.includeEmpty = defaultOptions.includeEmpty;
+
+  return collectionBuilder
+    .setFilter(groupChannelFilter)
+    .setLimit(defaultOptions.limit)
+    .setOrder(defaultOptions.order)
+    .build();
+};
+
+export const useGroupChannelListWithCollection: UseGroupChannelList = (sdk, userId, options) => {
+  const id = useUniqId(HOOK_NAME);
+  const { deliveryReceiptEnabled } = useAppFeatures(sdk);
+
+  const collectionRef = useRef<SendbirdGroupChannelCollection>();
+
+  const { loading, groupChannels, refreshing, setChannels, deleteChannels, updateRefreshing, updateLoading } =
+    useGroupChannelListReducer();
+
+  const updateChannelsAndMarkAsDelivered = (markAsDelivered: boolean) => {
+    const channels = collectionRef.current?.channelList ?? [];
+    setChannels(channels, true);
+    if (markAsDelivered && deliveryReceiptEnabled) channels.forEach((channel) => sdk.markAsDelivered(channel.url));
+  };
+
+  const init = useFreshCallback(async (uid?: string) => {
+    if (collectionRef.current) collectionRef.current?.dispose();
+
+    if (uid) {
+      collectionRef.current = createGroupChannelListCollection(sdk, options?.collectionCreator);
+
+      if (collectionRef.current?.hasMore) {
+        await collectionRef.current?.loadMore();
+        updateChannelsAndMarkAsDelivered(true);
+      }
+
+      collectionRef.current?.setGroupChannelCollectionHandler({
+        onChannelsAdded() {
+          updateChannelsAndMarkAsDelivered(true);
+        },
+        onChannelsUpdated() {
+          updateChannelsAndMarkAsDelivered(true);
+        },
+        onChannelsDeleted() {
+          updateChannelsAndMarkAsDelivered(false);
+        },
+      });
+    }
+  });
+
+  useEffect(() => {
+    return () => {
+      if (collectionRef.current) collectionRef.current?.dispose();
+    };
+  }, []);
+
+  useAsyncEffect(async () => {
+    updateLoading(true);
+    await init(userId);
+    updateLoading(false);
+  }, [init, userId]);
+
+  useChannelHandler(sdk, `${HOOK_NAME}_${id}`, {
+    onUserBanned: (channel, user) => {
+      const isMe = user.userId === userId;
+      if (isMe) deleteChannels([channel.url]);
+      else updateChannelsAndMarkAsDelivered(false);
+    },
+  });
+
+  const refresh = useFreshCallback(async () => {
+    updateRefreshing(true);
+    await init(userId);
+    updateRefreshing(false);
+  });
+
+  const next = useFreshCallback(async () => {
+    if (collectionRef.current?.hasMore) {
+      await collectionRef.current?.loadMore();
+      updateChannelsAndMarkAsDelivered(true);
+    }
+  });
+
+  return {
+    loading,
+    groupChannels,
+    refresh,
+    refreshing,
+    next,
+  };
+};

package/src/channel/useGroupChannelList/useGroupChannelListWithQuery.ts

@@ -0,0 +1,114 @@
+import { useRef } from 'react';
+import type Sendbird from 'sendbird';
+
+import type { SendbirdChannel, SendbirdChatSDK } from '@sendbird/uikit-utils';
+import { useAsyncEffect, useFreshCallback } from '@sendbird/uikit-utils';
+
+import { useAppFeatures } from '../../common/useAppFeatures';
+import { useChannelHandler } from '../../handler/useChannelHandler';
+import type { UseGroupChannelList, UseGroupChannelListOptions } from '../../types';
+import { useGroupChannelListReducer } from './reducer';
+
+const HOOK_NAME = 'useGroupChannelListWithQuery';
+
+const createGroupChannelListQuery = (
+  sdk: SendbirdChatSDK,
+  queryCreator: UseGroupChannelListOptions['queryCreator'],
+) => {
+  const passedQuery = queryCreator?.();
+  if (passedQuery) return passedQuery;
+
+  const defaultOptions = {
+    includeEmpty: false,
+    limit: 20,
+    order: 'latest_last_message',
+  } as const;
+  const defaultQuery = sdk.GroupChannel.createMyGroupChannelListQuery();
+  defaultQuery.limit = defaultOptions.limit;
+  defaultQuery.order = defaultOptions.order;
+  defaultQuery.includeEmpty = defaultOptions.includeEmpty;
+  return defaultQuery;
+};
+
+export const useGroupChannelListWithQuery: UseGroupChannelList = (sdk, userId, options) => {
+  const { deliveryReceiptEnabled } = useAppFeatures(sdk);
+  const queryRef = useRef<Sendbird.GroupChannelListQuery>();
+
+  const {
+    loading,
+    groupChannels,
+    refreshing,
+    updateChannels,
+    setChannels,
+    deleteChannels,
+    updateRefreshing,
+    updateLoading,
+    updateOrder,
+  } = useGroupChannelListReducer();
+
+  const updateChannelsAndMarkAsDelivered = (channels: SendbirdChannel[]) => {
+    updateChannels(channels);
+    if (deliveryReceiptEnabled) channels.forEach((channel) => sdk.markAsDelivered(channel.url));
+  };
+
+  const init = useFreshCallback(async (uid?: string) => {
+    if (uid) {
+      queryRef.current = createGroupChannelListQuery(sdk, options?.queryCreator);
+      updateOrder(queryRef.current?.order);
+
+      if (queryRef.current?.hasNext) {
+        const channels = await queryRef.current.next();
+
+        setChannels(channels, true);
+        if (deliveryReceiptEnabled) channels.forEach((channel) => sdk.markAsDelivered(channel.url));
+      }
+    }
+  });
+
+  useAsyncEffect(async () => {
+    updateLoading(true);
+    await init(userId);
+    updateLoading(false);
+  }, [init, userId]);
+
+  useChannelHandler(sdk, HOOK_NAME, {
+    onChannelChanged: (channel) => updateChannelsAndMarkAsDelivered([channel]),
+    onChannelFrozen: (channel) => updateChannels([channel]),
+    onChannelUnfrozen: (channel) => updateChannels([channel]),
+    onChannelMemberCountChanged: (channels) => updateChannels(channels),
+    onChannelDeleted: (url) => deleteChannels([url]),
+    onUserJoined: (channel) => updateChannelsAndMarkAsDelivered([channel]),
+    onUserLeft: (channel, user) => {
+      const isMe = user.userId === userId;
+      if (isMe) deleteChannels([channel.url]);
+      else updateChannelsAndMarkAsDelivered([channel]);
+    },
+    onUserBanned(channel, user) {
+      const isMe = user.userId === userId;
+      if (isMe) deleteChannels([channel.url]);
+      else updateChannelsAndMarkAsDelivered([channel]);
+    },
+  });
+
+  const refresh = useFreshCallback(async () => {
+    updateRefreshing(true);
+    await init(userId);
+    updateRefreshing(false);
+  });
+
+  const next = useFreshCallback(async () => {
+    if (queryRef.current?.hasNext) {
+      const channels = await queryRef.current.next();
+      setChannels(channels, false);
+      if (deliveryReceiptEnabled) channels.forEach((channel) => sdk.markAsDelivered(channel.url));
+    }
+  });
+
+  return {
+    loading,
+    groupChannels,
+    refresh,
+    refreshing,
+    next,
+  };
+};

package/src/channel/useGroupChannelMessages/useGroupChannelMessagesWithCollection.ts

@@ -62,18 +62,17 @@ export const useGroupChannelMessagesWithCollection: UseGroupChannelMessages = (s
     try {
       if (deliveryReceiptEnabled) sdk.markAsDelivered(activeChannel.url);
     } catch (e) {
-      Logger.error(`[${HOOK_NAME}/channelMarkAs/Delivered]`, e);
+      Logger.warn(`[${HOOK_NAME}/channelMarkAs/Delivered]`, e);
     }
     try {
       await sdk.markAsReadWithChannelUrls([activeChannel.url]);
     } catch (e) {
-      Logger.error(`[${HOOK_NAME}/channelMarkAs/Read]`, e);
+      Logger.warn(`[${HOOK_NAME}/channelMarkAs/Read]`, e);
     }
   };
 
   const updateChannel = (channel: SendbirdChannel) => {
     if (channel.isGroupChannel() && !isDifferentChannel(channel, activeChannel)) {
-      setActiveChannel(channel);
       forceUpdate();
     }
   };
@@ -100,7 +99,7 @@ export const useGroupChannelMessagesWithCollection: UseGroupChannelMessages = (s
             }
           })
           .onApiResult((err, messages) => {
-            if (err) Logger.error(`[${HOOK_NAME}/onApiResult]`, err);
+            if (err) Logger.warn(`[${HOOK_NAME}/onApiResult]`, err);
             else {
               Logger.debug(`[${HOOK_NAME}/onApiResult]`, 'message length:', messages.length);
               updateMessages(messages, true, sdk.currentUser.userId);
@@ -153,24 +152,19 @@ export const useGroupChannelMessagesWithCollection: UseGroupChannelMessages = (s
     [sdk, activeChannel.url, options?.collectionCreator],
   );
 
-  useChannelHandler(
-    sdk,
-    HOOK_NAME,
-    {
-      onUserBanned(channel, bannedUser) {
-        disposeManuallyAfterUnmounted();
-        if (channel.isGroupChannel() && !isDifferentChannel(channel, activeChannel)) {
-          if (bannedUser.userId === sdk.currentUser.userId) {
-            options?.onChannelDeleted?.();
-          } else {
-            setActiveChannel(channel);
-            forceUpdate();
-          }
+  useChannelHandler(sdk, HOOK_NAME, {
+    onUserBanned(channel, bannedUser) {
+      disposeManuallyAfterUnmounted();
+      if (channel.isGroupChannel() && !isDifferentChannel(channel, activeChannel)) {
+        if (bannedUser.userId === sdk.currentUser.userId) {
+          options?.onChannelDeleted?.();
+        } else {
+          setActiveChannel(channel);
+          forceUpdate();
         }
-      },
+      }
     },
-    [sdk],
-  );
+  });
 
   useEffect(() => {
     // NOTE: Cache read is heavy synchronous task, and it prevents smooth ui transition

package/src/channel/useGroupChannelMessages/useGroupChannelMessagesWithQuery.ts

@@ -49,12 +49,12 @@ export const useGroupChannelMessagesWithQuery: UseGroupChannelMessages = (sdk, c
     try {
       if (deliveryReceiptEnabled) sdk.markAsDelivered(activeChannel.url);
     } catch (e) {
-      Logger.error(`[${HOOK_NAME}/channelMarkAs/Delivered]`, e);
+      Logger.warn(`[${HOOK_NAME}/channelMarkAs/Delivered]`, e);
     }
     try {
       await sdk.markAsReadWithChannelUrls([activeChannel.url]);
     } catch (e) {
-      Logger.error(`[${HOOK_NAME}/channelMarkAs/Read]`, e);
+      Logger.warn(`[${HOOK_NAME}/channelMarkAs/Read]`, e);
     }
   };
 
@@ -80,58 +80,53 @@ export const useGroupChannelMessagesWithQuery: UseGroupChannelMessages = (sdk, c
     }
   };
 
-  useChannelHandler(
-    sdk,
-    HOOK_NAME,
-    {
-      // Messages
-      onMessageReceived(eventChannel, message) {
-        if (isDifferentChannel(activeChannel, eventChannel)) return;
-        channelMarkAs();
-        updateNextMessages([message], false, sdk.currentUser.userId);
-      },
-      onMessageUpdated(eventChannel, message) {
-        if (isDifferentChannel(activeChannel, eventChannel)) return;
-        updateMessages([message], false, sdk.currentUser.userId);
-      },
-      onMessageDeleted(eventChannel, messageId) {
-        if (isDifferentChannel(activeChannel, eventChannel)) return;
-        deleteMessages([messageId], []);
-        deleteNextMessages([messageId], []);
-      },
-      // Channels
-      onChannelChanged: channelUpdater,
-      onChannelFrozen: channelUpdater,
-      onChannelUnfrozen: channelUpdater,
-      onChannelHidden: channelUpdater,
-      onChannelMemberCountChanged(channels) {
-        const channel = channels.find((c) => !isDifferentChannel(c, activeChannel));
-        if (channel) channelUpdater(channel);
-      },
-      onChannelDeleted(channelUrl: string) {
-        if (activeChannel.url === channelUrl) options?.onChannelDeleted?.();
-      },
-      // Users
-      onOperatorUpdated: channelUpdater,
-      onUserLeft: channelUpdater,
-      onUserEntered: channelUpdater,
-      onUserExited: channelUpdater,
-      onUserJoined: channelUpdater,
-      onUserUnbanned: channelUpdater,
-      onUserMuted: channelUpdater,
-      onUserUnmuted: channelUpdater,
-      onUserBanned(eventChannel, bannedUser) {
-        if (isDifferentChannel(activeChannel, eventChannel)) return;
-
-        if (bannedUser.userId === sdk.currentUser.userId) {
-          options?.onChannelDeleted?.();
-        } else {
-          channelUpdater(eventChannel);
-        }
-      },
+  useChannelHandler(sdk, HOOK_NAME, {
+    // Messages
+    onMessageReceived(eventChannel, message) {
+      if (isDifferentChannel(activeChannel, eventChannel)) return;
+      channelMarkAs();
+      updateNextMessages([message], false, sdk.currentUser.userId);
     },
-    [sdk],
-  );
+    onMessageUpdated(eventChannel, message) {
+      if (isDifferentChannel(activeChannel, eventChannel)) return;
+      updateMessages([message], false, sdk.currentUser.userId);
+    },
+    onMessageDeleted(eventChannel, messageId) {
+      if (isDifferentChannel(activeChannel, eventChannel)) return;
+      deleteMessages([messageId], []);
+      deleteNextMessages([messageId], []);
+    },
+    // Channels
+    onChannelChanged: channelUpdater,
+    onChannelFrozen: channelUpdater,
+    onChannelUnfrozen: channelUpdater,
+    onChannelHidden: channelUpdater,
+    onChannelMemberCountChanged(channels) {
+      const channel = channels.find((c) => !isDifferentChannel(c, activeChannel));
+      if (channel) channelUpdater(channel);
+    },
+    onChannelDeleted(channelUrl: string) {
+      if (activeChannel.url === channelUrl) options?.onChannelDeleted?.();
+    },
+    // Users
+    onOperatorUpdated: channelUpdater,
+    onUserLeft: channelUpdater,
+    onUserEntered: channelUpdater,
+    onUserExited: channelUpdater,
+    onUserJoined: channelUpdater,
+    onUserUnbanned: channelUpdater,
+    onUserMuted: channelUpdater,
+    onUserUnmuted: channelUpdater,
+    onUserBanned(eventChannel, bannedUser) {
+      if (isDifferentChannel(activeChannel, eventChannel)) return;
+
+      if (bannedUser.userId === sdk.currentUser.userId) {
+        options?.onChannelDeleted?.();
+      } else {
+        channelUpdater(eventChannel);
+      }
+    },
+  });
 
   useAsyncEffect(async () => {
     updateLoading(true);

package/src/common/useAppFeatures.ts

@@ -1,28 +1,11 @@
-import { useMemo } from 'react';
-
 import { ApplicationAttributes, PremiumFeatures, SendbirdChatSDK } from '@sendbird/uikit-utils';
 
 export const useAppFeatures = (sdk: SendbirdChatSDK) => {
-  const deliveryReceiptEnabled = useMemo(() => {
-    return Boolean(sdk.appInfo?.premiumFeatureList?.includes?.(PremiumFeatures.delivery_receipt));
-  }, [sdk.appInfo?.premiumFeatureList]);
-
-  const broadcastChannelEnabled = useMemo(() => {
-    return Boolean(sdk.appInfo?.applicationAttributes?.includes?.(ApplicationAttributes.allow_broadcast_channel));
-  }, [sdk.appInfo?.applicationAttributes]);
-
-  const superGroupChannelEnabled = useMemo(() => {
-    return Boolean(sdk.appInfo?.applicationAttributes?.includes?.(ApplicationAttributes.allow_super_group_channel));
-  }, [sdk.appInfo?.applicationAttributes]);
-
-  const reactionEnabled = useMemo(() => {
-    return Boolean(sdk.appInfo?.applicationAttributes?.includes?.(ApplicationAttributes.reactions));
-  }, [sdk.appInfo?.applicationAttributes]);
-
+  const { premiumFeatureList = [], applicationAttributes = [] } = sdk.appInfo ?? {};
   return {
-    deliveryReceiptEnabled,
-    broadcastChannelEnabled,
-    superGroupChannelEnabled,
-    reactionEnabled,
+    deliveryReceiptEnabled: Boolean(premiumFeatureList.includes(PremiumFeatures.delivery_receipt)),
+    broadcastChannelEnabled: Boolean(applicationAttributes.includes(ApplicationAttributes.allow_broadcast_channel)),
+    superGroupChannelEnabled: Boolean(applicationAttributes.includes(ApplicationAttributes.allow_super_group_channel)),
+    reactionEnabled: Boolean(applicationAttributes.includes(ApplicationAttributes.reactions)),
   };
 };

package/src/common/useMessageOutgoingStatus.ts

@@ -0,0 +1,56 @@
+import type {
+  SendbirdAdminMessage,
+  SendbirdChatSDK,
+  SendbirdFileMessage,
+  SendbirdGroupChannel,
+  SendbirdUserMessage,
+} from '@sendbird/uikit-utils';
+import { isDifferentChannel, isMyMessage, useForceUpdate, useUniqId } from '@sendbird/uikit-utils';
+
+import { useChannelHandler } from '../handler/useChannelHandler';
+import { useAppFeatures } from './useAppFeatures';
+
+const HOOK_NAME = 'useMessageOutgoingStatus';
+
+export type SBUOutgoingStatus = 'NONE' | 'PENDING' | 'FAILED' | 'UNDELIVERED' | 'DELIVERED' | 'UNREAD' | 'READ';
+
+export const useMessageOutgoingStatus = (
+  sdk: SendbirdChatSDK,
+  channel: SendbirdGroupChannel,
+  message?: SendbirdFileMessage | SendbirdUserMessage | SendbirdAdminMessage | null,
+): SBUOutgoingStatus => {
+  const features = useAppFeatures(sdk);
+  const forceUpdate = useForceUpdate();
+  const currentUser = sdk.currentUser;
+
+  const uniqId = useUniqId(HOOK_NAME);
+  useChannelHandler(sdk, `${HOOK_NAME}_${uniqId}`, {
+    onDeliveryReceiptUpdated(eventChannel) {
+      if (isDifferentChannel(channel, eventChannel)) return;
+      if (!isMyMessage(message, currentUser?.userId)) return;
+
+      forceUpdate();
+    },
+    onReadReceiptUpdated(eventChannel) {
+      if (isDifferentChannel(channel, eventChannel)) return;
+      if (!isMyMessage(message, currentUser?.userId)) return;
+
+      forceUpdate();
+    },
+  });
+
+  if (!message) return 'NONE';
+
+  if (message.sendingStatus === 'pending') return 'PENDING';
+
+  if (message.sendingStatus === 'failed') return 'FAILED';
+
+  if (channel.getUnreadMemberCount(message) === 0) return 'READ';
+
+  if (features.deliveryReceiptEnabled) {
+    if (channel.getUndeliveredMemberCount(message) === 0) return 'DELIVERED';
+    return 'UNDELIVERED';
+  }
+
+  return 'UNREAD';
+};

package/src/handler/useChannelHandler.ts

@@ -1,4 +1,4 @@
-import React, { useEffect } from 'react';
+import { useEffect, useLayoutEffect, useRef } from 'react';
 import type Sendbird from 'sendbird';
 
 import { Logger, SendbirdChatSDK } from '@sendbird/uikit-utils';
@@ -7,19 +7,25 @@ export const useChannelHandler = (
   sdk: SendbirdChatSDK,
   handlerId: string,
   hookHandler: Partial<Sendbird.ChannelHandler>,
-  deps: React.DependencyList = [],
 ) => {
+  const handlerRef = useRef(hookHandler);
+  useLayoutEffect(() => {
+    handlerRef.current = hookHandler;
+  });
+
   useEffect(() => {
     Logger.debug('[useChannelHandler] hook called by', handlerId);
 
     const handler = new sdk.ChannelHandler();
     const handlerKeys = Object.keys(handler) as (keyof typeof handler)[];
     handlerKeys.forEach((key) => {
-      const hookHandlerFn = hookHandler[key];
-      if (hookHandlerFn) handler[key] = hookHandlerFn as () => unknown;
+      handler[key] = (...args: unknown[]) => {
+        // @ts-ignore
+        handlerRef.current[key]?.(...args);
+      };
     });
 
     sdk.addChannelHandler(handlerId, handler);
     return () => sdk.removeChannelHandler(handlerId);
-  }, [sdk, handlerId, ...deps]);
+  }, [sdk, handlerId]);
 };

package/src/index.ts

@@ -2,11 +2,12 @@ export { useGroupChannelList } from './channel/useGroupChannelList';
 export { useGroupChannelMessages } from './channel/useGroupChannelMessages';
 export { useActiveGroupChannel } from './channel/useActiveGroupChannel';
 
-export { useUserList } from './common/useUserList';
+export { useAppFeatures } from './common/useAppFeatures';
+export { useMessageOutgoingStatus } from './common/useMessageOutgoingStatus';
 export { usePushTrigger } from './common/usePushTrigger';
-export { useTotalUnreadMessageCount } from './common/useTotalUnreadMessageCount';
 export { useTotalUnreadChannelCount } from './common/useTotalUnreadChannelCount';
-export { useAppFeatures } from './common/useAppFeatures';
+export { useTotalUnreadMessageCount } from './common/useTotalUnreadMessageCount';
+export { useUserList } from './common/useUserList';
 
 export { useChannelHandler } from './handler/useChannelHandler';
 export { useConnectionHandler } from './handler/useConnectionHandler';

package/src/types.ts

@@ -48,13 +48,6 @@ export interface UseGroupChannelList {
      * */
     refresh: () => Promise<void>;
 
-    /**
-     * Update channel, update or insert channel to state
-     * @param {SendbirdGroupChannel} channel
-     * @return {void}
-     * */
-    update: (channel: SendbirdGroupChannel) => void;
-
     /**
      * Get group channels state
      * */
@@ -68,7 +61,6 @@ export interface UseGroupChannelList {
   };
 }
 export type UseGroupChannelListOptions = {
-  sortComparator?: (a: SendbirdGroupChannel, b: SendbirdGroupChannel) => number;
   queryCreator?: () => Sendbird.GroupChannelListQuery;
   collectionCreator?: () => SendbirdGroupChannelCollection;
   enableCollectionWithoutLocalCache?: boolean;

package/lib/commonjs/channel/useGroupChannelList.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["useGroupChannelList","sdk","userId","options","isCacheEnabled","enableCollectionWithoutLocalCache","useGroupChannelListWithCollection","useGroupChannelListWithQuery"],"sources":["useGroupChannelList.ts"],"sourcesContent":["import type { UseGroupChannelList } from '../types';\nimport { useGroupChannelListWithCollection } from './useGroupChannelListWithCollection';\nimport { useGroupChannelListWithQuery } from './useGroupChannelListWithQuery';\n\nexport const useGroupChannelList: UseGroupChannelList = (sdk, userId, options) => {\n  if (sdk.isCacheEnabled || options?.enableCollectionWithoutLocalCache) {\n    return useGroupChannelListWithCollection(sdk, userId, options);\n  } else {\n    return useGroupChannelListWithQuery(sdk, userId, options);\n  }\n};\n"],"mappings":";;;;;;;AACA;;AACA;;AAEO,MAAMA,mBAAwC,GAAG,CAACC,GAAD,EAAMC,MAAN,EAAcC,OAAd,KAA0B;EAChF,IAAIF,GAAG,CAACG,cAAJ,IAAsBD,OAAtB,aAAsBA,OAAtB,eAAsBA,OAAO,CAAEE,iCAAnC,EAAsE;IACpE,OAAO,IAAAC,oEAAA,EAAkCL,GAAlC,EAAuCC,MAAvC,EAA+CC,OAA/C,CAAP;EACD,CAFD,MAEO;IACL,OAAO,IAAAI,0DAAA,EAA6BN,GAA7B,EAAkCC,MAAlC,EAA0CC,OAA1C,CAAP;EACD;AACF,CANM"}