stream-chat-react 12.15.0 → 13.0.0-rc.2

package/dist/components/ChannelList/ChannelList.d.ts

@@ -1,18 +1,19 @@
-import React, { ReactNode } from 'react';
-import { ChannelListMessengerProps } from './ChannelListMessenger';
-import { CustomQueryChannelsFn } from './hooks/usePaginatedChannels';
-import { ChannelPreviewUIComponentProps } from '../ChannelPreview/ChannelPreview';
-import { ChannelSearchProps } from '../ChannelSearch/ChannelSearch';
-import { EmptyStateIndicatorProps } from '../EmptyStateIndicator';
-import { LoadMorePaginatorProps } from '../LoadMore/LoadMorePaginator';
-import { ChatContextValue } from '../../context';
+import React from 'react';
+import type { ReactNode } from 'react';
 import type { Channel, ChannelFilters, ChannelOptions, ChannelSort, Event } from 'stream-chat';
+import type { CustomQueryChannelsFn } from './hooks/usePaginatedChannels';
+import type { ChannelListMessengerProps } from './ChannelListMessenger';
+import type { ChannelPreviewUIComponentProps } from '../ChannelPreview/ChannelPreview';
+import type { ChannelSearchProps } from '../ChannelSearch/ChannelSearch';
+import type { EmptyStateIndicatorProps } from '../EmptyStateIndicator';
+import type { LoadMorePaginatorProps } from '../LoadMore/LoadMorePaginator';
+import type { ChatContextValue } from '../../context';
 import type { ChannelAvatarProps } from '../Avatar';
 import type { TranslationContextValue } from '../../context/TranslationContext';
-import type { DefaultStreamChatGenerics, PaginatorProps } from '../../types/types';
-export type ChannelListProps<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
+import type { PaginatorProps } from '../../types/types';
+export type ChannelListProps = {
     /** Additional props for underlying ChannelSearch component and channel search controller, [available props](https://getstream.io/chat/docs/sdk/react/utility-components/channel_search/#props) */
-    additionalChannelSearchProps?: Omit<ChannelSearchProps<StreamChatGenerics>, 'setChannels'>;
+    additionalChannelSearchProps?: Omit<ChannelSearchProps, 'setChannels'>;
     /**
      * When the client receives `message.new`, `notification.message_new`, and `notification.added_to_channel` events, we automatically
      * push that channel to the top of the list. If the channel doesn't currently exist in the list, we grab the channel from
@@ -23,21 +24,21 @@ export type ChannelListProps<StreamChatGenerics extends DefaultStreamChatGeneric
     /** UI component to display an avatar, defaults to [Avatar](https://github.com/GetStream/stream-chat-react/blob/master/src/components/Avatar/Avatar.tsx) component and accepts the same props as: [ChannelAvatar](https://github.com/GetStream/stream-chat-react/blob/master/src/components/Avatar/ChannelAvatar.tsx) */
     Avatar?: React.ComponentType<ChannelAvatarProps>;
     /** Optional function to filter channels prior to loading in the DOM. Do not use any complex or async logic that would delay the loading of the ChannelList. We recommend using a pure function with array methods like filter/sort/reduce. */
-    channelRenderFilterFn?: (channels: Array<Channel<StreamChatGenerics>>) => Array<Channel<StreamChatGenerics>>;
+    channelRenderFilterFn?: (channels: Array<Channel>) => Array<Channel>;
     /** Custom UI component to display search results, defaults to and accepts same props as: [ChannelSearch](https://github.com/GetStream/stream-chat-react/blob/master/src/components/ChannelSearch/ChannelSearch.tsx) */
-    ChannelSearch?: React.ComponentType<ChannelSearchProps<StreamChatGenerics>>;
+    ChannelSearch?: React.ComponentType<ChannelSearchProps>;
     /** Set a channel (with this ID) to active and manually move it to the top of the list */
     customActiveChannel?: string;
     /** Custom function that handles the channel pagination. Has to build query filters, sort and options and query and append channels to the current channels state and update the hasNext pagination flag after each query. */
-    customQueryChannels?: CustomQueryChannelsFn<StreamChatGenerics>;
+    customQueryChannels?: CustomQueryChannelsFn;
     /** Custom UI component for rendering an empty list, defaults to and accepts same props as: [EmptyStateIndicator](https://github.com/GetStream/stream-chat-react/blob/master/src/components/EmptyStateIndicator/EmptyStateIndicator.tsx) */
     EmptyStateIndicator?: React.ComponentType<EmptyStateIndicatorProps>;
     /** An object containing channel query filters */
-    filters?: ChannelFilters<StreamChatGenerics>;
+    filters?: ChannelFilters;
     /** Custom function that generates the message preview in ChannelPreview component */
-    getLatestMessagePreview?: (channel: Channel<StreamChatGenerics>, t: TranslationContextValue['t'], userLanguage: TranslationContextValue['userLanguage'], isMessageAIGenerated?: ChatContextValue['isMessageAIGenerated']) => ReactNode;
+    getLatestMessagePreview?: (channel: Channel, t: TranslationContextValue['t'], userLanguage: TranslationContextValue['userLanguage'], isMessageAIGenerated?: ChatContextValue['isMessageAIGenerated']) => ReactNode;
     /** Custom UI component to display the container for the queried channels, defaults to and accepts same props as: [ChannelListMessenger](https://github.com/GetStream/stream-chat-react/blob/master/src/components/ChannelList/ChannelListMessenger.tsx) */
-    List?: React.ComponentType<ChannelListMessengerProps<StreamChatGenerics>>;
+    List?: React.ComponentType<ChannelListMessengerProps>;
     /** Custom UI component to display the loading error indicator, defaults to component that renders null */
     LoadingErrorIndicator?: React.ComponentType;
     /** Custom UI component to display the loading state, defaults to and accepts same props as: [LoadingChannels](https://github.com/GetStream/stream-chat-react/blob/master/src/components/Loading/LoadingChannels.tsx) */
@@ -45,29 +46,29 @@ export type ChannelListProps<StreamChatGenerics extends DefaultStreamChatGeneric
     /** When true, channels won't dynamically sort by most recent message */
     lockChannelOrder?: boolean;
     /** Function to override the default behavior when a user is added to a channel, corresponds to [notification.added\_to\_channel](https://getstream.io/chat/docs/javascript/event_object/?language=javascript) event */
-    onAddedToChannel?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, event: Event<StreamChatGenerics>) => void;
+    onAddedToChannel?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, event: Event) => void;
     /** Function to override the default behavior when a channel is deleted, corresponds to [channel.deleted](https://getstream.io/chat/docs/javascript/event_object/?language=javascript) event */
-    onChannelDeleted?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, event: Event<StreamChatGenerics>) => void;
+    onChannelDeleted?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, event: Event) => void;
     /** Function to override the default behavior when a channel is hidden, corresponds to [channel.hidden](https://getstream.io/chat/docs/javascript/event_object/?language=javascript) event */
-    onChannelHidden?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, event: Event<StreamChatGenerics>) => void;
+    onChannelHidden?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, event: Event) => void;
     /** Function to override the default behavior when a channel is truncated, corresponds to [channel.truncated](https://getstream.io/chat/docs/javascript/event_object/?language=javascript) event */
-    onChannelTruncated?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, event: Event<StreamChatGenerics>) => void;
+    onChannelTruncated?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, event: Event) => void;
     /** Function to override the default behavior when a channel is updated, corresponds to [channel.updated](https://getstream.io/chat/docs/javascript/event_object/?language=javascript) event */
-    onChannelUpdated?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, event: Event<StreamChatGenerics>) => void;
+    onChannelUpdated?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, event: Event) => void;
     /** Function to override the default channel visible behavior, corresponds to [channel.visible](https://getstream.io/chat/docs/javascript/event_object/?language=javascript) event */
-    onChannelVisible?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, event: Event<StreamChatGenerics>) => void;
+    onChannelVisible?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, event: Event) => void;
     /** Function to override the default behavior when a message is received on a channel not being watched, corresponds to [notification.message\_new](https://getstream.io/chat/docs/javascript/event_object/?language=javascript) event */
-    onMessageNew?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, event: Event<StreamChatGenerics>) => void;
+    onMessageNew?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, event: Event) => void;
     /** Function to override the default behavior when a message is received on a channel being watched, handles [message.new](https://getstream.io/chat/docs/javascript/event_object/?language=javascript) event */
-    onMessageNewHandler?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, event: Event<StreamChatGenerics>) => void;
+    onMessageNewHandler?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, event: Event) => void;
     /** Function to override the default behavior when a user gets removed from a channel, corresponds to [notification.removed\_from\_channel](https://getstream.io/chat/docs/javascript/event_object/?language=javascript) event */
-    onRemovedFromChannel?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, event: Event<StreamChatGenerics>) => void;
+    onRemovedFromChannel?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, event: Event) => void;
     /** An object containing channel query options */
     options?: ChannelOptions;
     /** Custom UI component to handle channel pagination logic, defaults to and accepts same props as: [LoadMorePaginator](https://github.com/GetStream/stream-chat-react/blob/master/src/components/LoadMore/LoadMorePaginator.tsx) */
     Paginator?: React.ComponentType<PaginatorProps | LoadMorePaginatorProps>;
     /** Custom UI component to display the channel preview in the list, defaults to and accepts same props as: [ChannelPreviewMessenger](https://github.com/GetStream/stream-chat-react/blob/master/src/components/ChannelPreview/ChannelPreviewMessenger.tsx) */
-    Preview?: React.ComponentType<ChannelPreviewUIComponentProps<StreamChatGenerics>>;
+    Preview?: React.ComponentType<ChannelPreviewUIComponentProps>;
     /**
      * Custom interval during which the recovery channel list queries will be prevented.
      * This is to avoid firing unnecessary queries during internet connection fluctuation.
@@ -76,7 +77,7 @@ export type ChannelListProps<StreamChatGenerics extends DefaultStreamChatGeneric
      */
     recoveryThrottleIntervalMs?: number;
     /** Function to override the default behavior when rendering channels, so this function is called instead of rendering the Preview directly */
-    renderChannels?: (channels: Channel<StreamChatGenerics>[], channelPreview: (item: Channel<StreamChatGenerics>) => React.ReactNode) => React.ReactNode;
+    renderChannels?: (channels: Channel[], channelPreview: (item: Channel) => React.ReactNode) => React.ReactNode;
     /** If true, sends the list's currently loaded channels to the `List` component as the `loadedChannels` prop */
     sendChannelsToList?: boolean;
     /** Last channel will be set as active channel if true, defaults to true */
@@ -84,7 +85,7 @@ export type ChannelListProps<StreamChatGenerics extends DefaultStreamChatGeneric
     /** Whether or not to load the list with a search component, defaults to false */
     showChannelSearch?: boolean;
     /** An object containing channel query sort parameters */
-    sort?: ChannelSort<StreamChatGenerics>;
+    sort?: ChannelSort;
     /** An object containing query parameters for fetching channel watchers */
     watchers?: {
         limit?: number;
@@ -94,4 +95,4 @@ export type ChannelListProps<StreamChatGenerics extends DefaultStreamChatGeneric
 /**
  * Renders a preview list of Channels, allowing you to select the Channel you want to open
  */
-export declare const ChannelList: <SCG extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(props: ChannelListProps<SCG>) => React.JSX.Element;
+export declare const ChannelList: (props: ChannelListProps) => React.JSX.Element;

package/dist/components/ChannelList/ChannelList.js

@@ -1,21 +1,20 @@
 import React, { useCallback, useEffect, useRef, useState } from 'react';
 import clsx from 'clsx';
-import { ChannelListMessenger } from './ChannelListMessenger';
 import { useConnectionRecoveredListener } from './hooks/useConnectionRecoveredListener';
 import { useMobileNavigation } from './hooks/useMobileNavigation';
-import { usePaginatedChannels, } from './hooks/usePaginatedChannels';
+import { usePaginatedChannels } from './hooks/usePaginatedChannels';
 import { useChannelListShape, usePrepareShapeHandlers, } from './hooks/useChannelListShape';
-import { MAX_QUERY_CHANNELS_LIMIT, moveChannelUpwards } from './utils';
+import { useStateStore } from '../../store';
+import { ChannelListMessenger } from './ChannelListMessenger';
 import { Avatar as DefaultAvatar } from '../Avatar';
-import { ChannelPreview, } from '../ChannelPreview/ChannelPreview';
-import { ChannelSearch as DefaultChannelSearch, } from '../ChannelSearch/ChannelSearch';
-import { EmptyStateIndicator as DefaultEmptyStateIndicator, } from '../EmptyStateIndicator';
+import { ChannelPreview } from '../ChannelPreview/ChannelPreview';
+import { ChannelSearch as DefaultChannelSearch } from '../ChannelSearch/ChannelSearch';
+import { EmptyStateIndicator as DefaultEmptyStateIndicator } from '../EmptyStateIndicator';
 import { LoadingChannels } from '../Loading/LoadingChannels';
 import { LoadMorePaginator } from '../LoadMore/LoadMorePaginator';
+import { ChannelListContextProvider, useChatContext, useComponentContext, } from '../../context';
 import { NullComponent } from '../UtilityComponents';
-import { ChannelListContextProvider, useComponentContext, } from '../../context';
-import { useChatContext } from '../../context/ChatContext';
-import { useStateStore } from '../../store';
+import { MAX_QUERY_CHANNELS_LIMIT, moveChannelUpwards } from './utils';
 const DEFAULT_FILTERS = {};
 const DEFAULT_OPTIONS = {};
 const DEFAULT_SORT = {};
@@ -44,7 +43,6 @@ const UnMemoizedChannelList = (props) => {
             // FIXME: this is wrong...
             let customActiveChannelObject = channels.find((chan) => chan.id === customActiveChannel);
             if (!customActiveChannelObject) {
-                //@ts-expect-error valid query
                 [customActiveChannelObject] = await client.queryChannels({
                     id: customActiveChannel,
                 });

package/dist/components/ChannelList/ChannelListMessenger.d.ts

@@ -1,11 +1,11 @@
-import React, { PropsWithChildren } from 'react';
+import React from 'react';
+import type { PropsWithChildren } from 'react';
 import type { APIErrorResponse, Channel, ErrorFromResponse } from 'stream-chat';
-import type { DefaultStreamChatGenerics } from '../../types/types';
-export type ChannelListMessengerProps<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
+export type ChannelListMessengerProps = {
     /** Whether the channel query request returned an errored response */
     error: ErrorFromResponse<APIErrorResponse> | null;
     /** The channels currently loaded in the list, only defined if `sendChannelsToList` on `ChannelList` is true */
-    loadedChannels?: Channel<StreamChatGenerics>[];
+    loadedChannels?: Channel[];
     /** Whether the channels are currently loading */
     loading?: boolean;
     /** Custom UI component to display the loading error indicator, defaults to component that renders null */
@@ -13,9 +13,9 @@ export type ChannelListMessengerProps<StreamChatGenerics extends DefaultStreamCh
     /** Custom UI component to display a loading indicator, defaults to and accepts same props as: [LoadingChannels](https://github.com/GetStream/stream-chat-react/blob/master/src/components/Loading/LoadingChannels.tsx) */
     LoadingIndicator?: React.ComponentType;
     /** Local state hook that resets the currently loaded channels */
-    setChannels?: React.Dispatch<React.SetStateAction<Channel<StreamChatGenerics>[]>>;
+    setChannels?: React.Dispatch<React.SetStateAction<Channel[]>>;
 };
 /**
  * A preview list of channels, allowing you to select the channel you want to open
  */
-export declare const ChannelListMessenger: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(props: PropsWithChildren<ChannelListMessengerProps<StreamChatGenerics>>) => React.JSX.Element;
+export declare const ChannelListMessenger: (props: PropsWithChildren<ChannelListMessengerProps>) => React.JSX.Element;

package/dist/components/ChannelList/hooks/useChannelDeletedListener.d.ts

@@ -1,3 +1,2 @@
 import type { Channel, Event } from 'stream-chat';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-export declare const useChannelDeletedListener: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, customHandler?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, event: Event<StreamChatGenerics>) => void) => void;
+export declare const useChannelDeletedListener: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, customHandler?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, event: Event) => void) => void;

package/dist/components/ChannelList/hooks/useChannelHiddenListener.d.ts

@@ -1,3 +1,2 @@
 import type { Channel, Event } from 'stream-chat';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-export declare const useChannelHiddenListener: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, customHandler?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, event: Event<StreamChatGenerics>) => void) => void;
+export declare const useChannelHiddenListener: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, customHandler?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, event: Event) => void) => void;

package/dist/components/ChannelList/hooks/useChannelListShape.d.ts

@@ -1,60 +1,60 @@
-import { Dispatch, SetStateAction } from 'react';
-import { Channel, Event, ExtendableGenerics } from 'stream-chat';
-import { ChannelListProps } from '../ChannelList';
-type SetChannels<SCG extends ExtendableGenerics> = Dispatch<SetStateAction<Channel<SCG>[]>>;
-type BaseParameters<SCG extends ExtendableGenerics> = {
-    event: Event<SCG>;
-    setChannels: SetChannels<SCG>;
+import type { Channel, Event } from 'stream-chat';
+import type { Dispatch, SetStateAction } from 'react';
+import type { ChannelListProps } from '../ChannelList';
+type SetChannels = Dispatch<SetStateAction<Channel[]>>;
+type BaseParameters = {
+    event: Event;
+    setChannels: SetChannels;
 };
-type RepeatedParameters<SCG extends ExtendableGenerics> = {
-    customHandler?: (setChannels: BaseParameters<SCG>['setChannels'], event: BaseParameters<SCG>['event']) => void;
+type RepeatedParameters = {
+    customHandler?: (setChannels: BaseParameters['setChannels'], event: BaseParameters['event']) => void;
 };
-type HandleMessageNewParameters<SCG extends ExtendableGenerics> = BaseParameters<SCG> & RepeatedParameters<SCG> & {
+type HandleMessageNewParameters = BaseParameters & RepeatedParameters & {
     allowNewMessagesFromUnfilteredChannels: boolean;
     lockChannelOrder: boolean;
-} & Required<Pick<ChannelListProps<SCG>, 'filters' | 'sort'>>;
-type HandleNotificationMessageNewParameters<SCG extends ExtendableGenerics> = BaseParameters<SCG> & RepeatedParameters<SCG> & {
+} & Required<Pick<ChannelListProps, 'filters' | 'sort'>>;
+type HandleNotificationMessageNewParameters = BaseParameters & RepeatedParameters & {
     allowNewMessagesFromUnfilteredChannels: boolean;
     lockChannelOrder: boolean;
-} & Required<Pick<ChannelListProps<SCG>, 'filters' | 'sort'>>;
-type HandleNotificationRemovedFromChannelParameters<SCG extends ExtendableGenerics> = BaseParameters<SCG> & RepeatedParameters<SCG>;
-type HandleNotificationAddedToChannelParameters<SCG extends ExtendableGenerics> = BaseParameters<SCG> & RepeatedParameters<SCG> & {
+} & Required<Pick<ChannelListProps, 'filters' | 'sort'>>;
+type HandleNotificationRemovedFromChannelParameters = BaseParameters & RepeatedParameters;
+type HandleNotificationAddedToChannelParameters = BaseParameters & RepeatedParameters & {
     allowNewMessagesFromUnfilteredChannels: boolean;
     lockChannelOrder: boolean;
-} & Required<Pick<ChannelListProps<SCG>, 'sort'>>;
-type HandleMemberUpdatedParameters<SCG extends ExtendableGenerics> = BaseParameters<SCG> & {
+} & Required<Pick<ChannelListProps, 'sort'>>;
+type HandleChannelVisibleParameters = BaseParameters & RepeatedParameters & Required<Pick<ChannelListProps, 'sort' | 'filters'>>;
+type HandleMemberUpdatedParameters = BaseParameters & {
     lockChannelOrder: boolean;
-} & Required<Pick<ChannelListProps<SCG>, 'sort' | 'filters'>>;
-type HandleChannelDeletedParameters<SCG extends ExtendableGenerics> = BaseParameters<SCG> & RepeatedParameters<SCG>;
-type HandleChannelHiddenParameters<SCG extends ExtendableGenerics> = BaseParameters<SCG> & RepeatedParameters<SCG>;
-type HandleChannelVisibleParameters<SCG extends ExtendableGenerics> = BaseParameters<SCG> & RepeatedParameters<SCG> & Required<Pick<ChannelListProps<SCG>, 'sort' | 'filters'>>;
-type HandleChannelTruncatedParameters<SCG extends ExtendableGenerics> = BaseParameters<SCG> & RepeatedParameters<SCG>;
-type HandleChannelUpdatedParameters<SCG extends ExtendableGenerics> = BaseParameters<SCG> & RepeatedParameters<SCG>;
-type HandleUserPresenceChangedParameters<SCG extends ExtendableGenerics> = BaseParameters<SCG>;
-export declare const useChannelListShapeDefaults: <SCG extends ExtendableGenerics>() => {
-    handleChannelDeleted: (p: HandleChannelDeletedParameters<SCG>) => void;
-    handleChannelHidden: (p: HandleChannelHiddenParameters<SCG>) => void;
-    handleChannelTruncated: ({ customHandler, event, setChannels }: HandleChannelTruncatedParameters<SCG>) => void;
-    handleChannelUpdated: ({ customHandler, event, setChannels }: HandleChannelUpdatedParameters<SCG>) => void;
-    handleChannelVisible: ({ customHandler, event, filters, setChannels, sort, }: HandleChannelVisibleParameters<SCG>) => Promise<void>;
-    handleMemberUpdated: ({ event, filters, lockChannelOrder, setChannels, sort, }: HandleMemberUpdatedParameters<SCG>) => void;
-    handleMessageNew: ({ allowNewMessagesFromUnfilteredChannels, customHandler, event, filters, lockChannelOrder, setChannels, sort, }: HandleMessageNewParameters<SCG>) => void;
-    handleNotificationAddedToChannel: ({ allowNewMessagesFromUnfilteredChannels, customHandler, event, setChannels, sort, }: HandleNotificationAddedToChannelParameters<SCG>) => Promise<void>;
-    handleNotificationMessageNew: ({ allowNewMessagesFromUnfilteredChannels, customHandler, event, filters, setChannels, sort, }: HandleNotificationMessageNewParameters<SCG>) => Promise<void>;
-    handleNotificationRemovedFromChannel: ({ customHandler, event, setChannels, }: HandleNotificationRemovedFromChannelParameters<SCG>) => void;
-    handleUserPresenceChanged: ({ event, setChannels }: HandleUserPresenceChangedParameters<SCG>) => void;
+} & Required<Pick<ChannelListProps, 'sort' | 'filters'>>;
+type HandleChannelDeletedParameters = BaseParameters & RepeatedParameters;
+type HandleChannelHiddenParameters = BaseParameters & RepeatedParameters;
+type HandleChannelTruncatedParameters = BaseParameters & RepeatedParameters;
+type HandleChannelUpdatedParameters = BaseParameters & RepeatedParameters;
+type HandleUserPresenceChangedParameters = BaseParameters;
+export declare const useChannelListShapeDefaults: () => {
+    handleChannelDeleted: (p: HandleChannelDeletedParameters) => void;
+    handleChannelHidden: (p: HandleChannelHiddenParameters) => void;
+    handleChannelTruncated: ({ customHandler, event, setChannels }: HandleChannelTruncatedParameters) => void;
+    handleChannelUpdated: ({ customHandler, event, setChannels }: HandleChannelUpdatedParameters) => void;
+    handleChannelVisible: ({ customHandler, event, filters, setChannels, sort, }: HandleChannelVisibleParameters) => Promise<void>;
+    handleMemberUpdated: ({ event, filters, lockChannelOrder, setChannels, sort, }: HandleMemberUpdatedParameters) => void;
+    handleMessageNew: ({ allowNewMessagesFromUnfilteredChannels, customHandler, event, filters, lockChannelOrder, setChannels, sort, }: HandleMessageNewParameters) => void;
+    handleNotificationAddedToChannel: ({ allowNewMessagesFromUnfilteredChannels, customHandler, event, setChannels, sort, }: HandleNotificationAddedToChannelParameters) => Promise<void>;
+    handleNotificationMessageNew: ({ allowNewMessagesFromUnfilteredChannels, customHandler, event, filters, setChannels, sort, }: HandleNotificationMessageNewParameters) => Promise<void>;
+    handleNotificationRemovedFromChannel: ({ customHandler, event, setChannels, }: HandleNotificationRemovedFromChannelParameters) => void;
+    handleUserPresenceChanged: ({ event, setChannels }: HandleUserPresenceChangedParameters) => void;
 };
-type UseDefaultHandleChannelListShapeParameters<SCG extends ExtendableGenerics> = Required<Pick<ChannelListProps<SCG>, 'allowNewMessagesFromUnfilteredChannels' | 'lockChannelOrder' | 'filters' | 'sort'>> & Pick<ChannelListProps<SCG>, 'onAddedToChannel' | 'onChannelDeleted' | 'onChannelHidden' | 'onChannelTruncated' | 'onChannelUpdated' | 'onChannelVisible' | 'onMessageNew' | 'onMessageNewHandler' | 'onRemovedFromChannel'> & {
-    setChannels: SetChannels<SCG>;
+type UseDefaultHandleChannelListShapeParameters = Required<Pick<ChannelListProps, 'allowNewMessagesFromUnfilteredChannels' | 'lockChannelOrder' | 'filters' | 'sort'>> & Pick<ChannelListProps, 'onAddedToChannel' | 'onChannelDeleted' | 'onChannelHidden' | 'onChannelTruncated' | 'onChannelUpdated' | 'onChannelVisible' | 'onMessageNew' | 'onMessageNewHandler' | 'onRemovedFromChannel'> & {
+    setChannels: SetChannels;
     customHandleChannelListShape?: (data: {
         defaults: ReturnType<typeof useChannelListShapeDefaults>;
-        event: Event<SCG>;
-        setChannels: SetChannels<SCG>;
+        event: Event;
+        setChannels: SetChannels;
     }) => void;
 };
-export declare const usePrepareShapeHandlers: <SCG extends ExtendableGenerics>({ allowNewMessagesFromUnfilteredChannels, customHandleChannelListShape, filters, lockChannelOrder, onAddedToChannel, onChannelDeleted, onChannelHidden, onChannelTruncated, onChannelUpdated, onChannelVisible, onMessageNew, onMessageNewHandler, onRemovedFromChannel, setChannels, sort, }: UseDefaultHandleChannelListShapeParameters<SCG>) => {
-    customHandler: ((e: Event<SCG>) => void) | null;
-    defaultHandler: (e: Event<SCG>) => void;
+export declare const usePrepareShapeHandlers: ({ allowNewMessagesFromUnfilteredChannels, customHandleChannelListShape, filters, lockChannelOrder, onAddedToChannel, onChannelDeleted, onChannelHidden, onChannelTruncated, onChannelUpdated, onChannelVisible, onMessageNew, onMessageNewHandler, onRemovedFromChannel, setChannels, sort, }: UseDefaultHandleChannelListShapeParameters) => {
+    customHandler: ((e: Event) => void) | null;
+    defaultHandler: (e: Event) => void;
 };
-export declare const useChannelListShape: <SCG extends ExtendableGenerics>(handler: (e: Event<SCG>) => void) => void;
+export declare const useChannelListShape: (handler: (e: Event) => void) => void;
 export {};

package/dist/components/ChannelList/hooks/useChannelListShape.js

@@ -1,4 +1,3 @@
-// const defaults = useChannelListShapeDefaults();
 import { useCallback, useEffect, useMemo, useRef } from 'react';
 import { extractSortValue, findLastPinnedChannelIndex, isChannelArchived, isChannelPinned, moveChannelUpwards, shouldConsiderArchivedChannels, shouldConsiderPinnedChannels, } from '../utils';
 import { useChatContext } from '../../../context';
@@ -258,7 +257,6 @@ export const usePrepareShapeHandlers = ({ allowNewMessagesFromUnfilteredChannels
     const defaultHandleChannelListShapeRef = useRef(undefined);
     const customHandleChannelListShapeRef = useRef(undefined);
     customHandleChannelListShapeRef.current = (event) => {
-        // @ts-expect-error can't use ReturnType<typeof useChannelListShapeDefaults<SCG>> until we upgrade prettier to at least v2.7.0
         customHandleChannelListShape?.({ defaults, event, setChannels });
     };
     defaultHandleChannelListShapeRef.current = (event) => {

package/dist/components/ChannelList/hooks/useChannelMembershipState.d.ts

@@ -1,3 +1,3 @@
-import type { Channel, ChannelMemberResponse, ExtendableGenerics } from 'stream-chat';
-export declare function useChannelMembershipState<SCG extends ExtendableGenerics>(channel: Channel<SCG>): ChannelMemberResponse<SCG>;
-export declare function useChannelMembershipState<SCG extends ExtendableGenerics>(channel?: Channel<SCG> | undefined): ChannelMemberResponse<SCG> | undefined;
+import type { Channel, ChannelMemberResponse } from 'stream-chat';
+export declare function useChannelMembershipState(channel: Channel): ChannelMemberResponse;
+export declare function useChannelMembershipState(channel?: Channel | undefined): ChannelMemberResponse | undefined;

package/dist/components/ChannelList/hooks/useChannelTruncatedListener.d.ts

@@ -1,3 +1,2 @@
 import type { Channel, Event } from 'stream-chat';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-export declare const useChannelTruncatedListener: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, customHandler?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, event: Event<StreamChatGenerics>) => void, forceUpdate?: () => void) => void;
+export declare const useChannelTruncatedListener: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, customHandler?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, event: Event) => void, forceUpdate?: () => void) => void;

package/dist/components/ChannelList/hooks/useChannelUpdatedListener.d.ts

@@ -1,3 +1,2 @@
 import type { Channel, Event } from 'stream-chat';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-export declare const useChannelUpdatedListener: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, customHandler?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, event: Event<StreamChatGenerics>) => void, forceUpdate?: () => void) => void;
+export declare const useChannelUpdatedListener: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, customHandler?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, event: Event) => void, forceUpdate?: () => void) => void;

package/dist/components/ChannelList/hooks/useChannelVisibleListener.d.ts

@@ -1,3 +1,2 @@
 import type { Channel, Event } from 'stream-chat';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-export declare const useChannelVisibleListener: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, customHandler?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, event: Event<StreamChatGenerics>) => void) => void;
+export declare const useChannelVisibleListener: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, customHandler?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, event: Event) => void) => void;

package/dist/components/ChannelList/hooks/useConnectionRecoveredListener.d.ts

@@ -1,2 +1 @@
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-export declare const useConnectionRecoveredListener: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(forceUpdate?: () => void) => void;
+export declare const useConnectionRecoveredListener: (forceUpdate?: () => void) => void;

package/dist/components/ChannelList/hooks/useMessageNewListener.d.ts

@@ -1,3 +1,2 @@
 import type { Channel, Event } from 'stream-chat';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-export declare const useMessageNewListener: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, customHandler?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, event: Event<StreamChatGenerics>) => void, lockChannelOrder?: boolean, allowNewMessagesFromUnfilteredChannels?: boolean) => void;
+export declare const useMessageNewListener: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, customHandler?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, event: Event) => void, lockChannelOrder?: boolean, allowNewMessagesFromUnfilteredChannels?: boolean) => void;

package/dist/components/ChannelList/hooks/useNotificationAddedToChannelListener.d.ts

@@ -1,3 +1,2 @@
 import type { Channel, Event } from 'stream-chat';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-export declare const useNotificationAddedToChannelListener: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, customHandler?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, event: Event<StreamChatGenerics>) => void, allowNewMessagesFromUnfilteredChannels?: boolean) => void;
+export declare const useNotificationAddedToChannelListener: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, customHandler?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, event: Event) => void, allowNewMessagesFromUnfilteredChannels?: boolean) => void;

package/dist/components/ChannelList/hooks/useNotificationMessageNewListener.d.ts

@@ -1,3 +1,2 @@
 import type { Channel, Event } from 'stream-chat';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-export declare const useNotificationMessageNewListener: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, customHandler?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, event: Event<StreamChatGenerics>) => void, allowNewMessagesFromUnfilteredChannels?: boolean) => void;
+export declare const useNotificationMessageNewListener: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, customHandler?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, event: Event) => void, allowNewMessagesFromUnfilteredChannels?: boolean) => void;

package/dist/components/ChannelList/hooks/useNotificationRemovedFromChannelListener.d.ts

@@ -1,3 +1,2 @@
 import type { Channel, Event } from 'stream-chat';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-export declare const useNotificationRemovedFromChannelListener: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, customHandler?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>, event: Event<StreamChatGenerics>) => void) => void;
+export declare const useNotificationRemovedFromChannelListener: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, customHandler?: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>, event: Event) => void) => void;

package/dist/components/ChannelList/hooks/usePaginatedChannels.d.ts

@@ -1,19 +1,18 @@
 /// <reference types="react" />
 import type { Channel, ChannelFilters, ChannelOptions, ChannelSort, StreamChat } from 'stream-chat';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
 import type { ChannelsQueryState } from '../../Chat/hooks/useChannelsQueryState';
 type AllowedQueryType = Extract<ChannelsQueryState['queryInProgress'], 'reload' | 'load-more'>;
-export type CustomQueryChannelParams<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
-    currentChannels: Array<Channel<StreamChatGenerics>>;
+export type CustomQueryChannelParams = {
+    currentChannels: Array<Channel>;
     queryType: AllowedQueryType;
-    setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>;
+    setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>;
     setHasNextPage: React.Dispatch<React.SetStateAction<boolean>>;
 };
-export type CustomQueryChannelsFn<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = (params: CustomQueryChannelParams<StreamChatGenerics>) => Promise<void>;
-export declare const usePaginatedChannels: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(client: StreamChat<StreamChatGenerics>, filters: ChannelFilters<StreamChatGenerics>, sort: ChannelSort<StreamChatGenerics>, options: ChannelOptions, activeChannelHandler: (channels: Array<Channel<StreamChatGenerics>>, setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>) => void, recoveryThrottleIntervalMs?: number, customQueryChannels?: CustomQueryChannelsFn<StreamChatGenerics>) => {
-    channels: Channel<StreamChatGenerics>[];
+export type CustomQueryChannelsFn = (params: CustomQueryChannelParams) => Promise<void>;
+export declare const usePaginatedChannels: (client: StreamChat, filters: ChannelFilters, sort: ChannelSort, options: ChannelOptions, activeChannelHandler: (channels: Array<Channel>, setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>) => void, recoveryThrottleIntervalMs?: number, customQueryChannels?: CustomQueryChannelsFn) => {
+    channels: Channel[];
     hasNextPage: boolean;
     loadNextPage: () => void;
-    setChannels: import("react").Dispatch<import("react").SetStateAction<Channel<StreamChatGenerics>[]>>;
+    setChannels: import("react").Dispatch<import("react").SetStateAction<Channel[]>>;
 };
 export {};

package/dist/components/ChannelList/hooks/usePaginatedChannels.js

@@ -52,9 +52,9 @@ export const usePaginatedChannels = (client, filters, sort, options, activeChann
                 }
             }
         }
-        catch (err) {
-            console.warn(err);
-            setError(err);
+        catch (error) {
+            console.warn(error);
+            setError(error);
         }
         setQueryInProgress(null);
     };

package/dist/components/ChannelList/hooks/useSelectedChannelState.d.ts

@@ -1,11 +1,11 @@
-import type { Channel, EventTypes, ExtendableGenerics } from 'stream-chat';
-export declare function useSelectedChannelState<SCG extends ExtendableGenerics, O>(_: {
-    channel: Channel<SCG>;
-    selector: (channel: Channel<SCG>) => O;
+import type { Channel, EventTypes } from 'stream-chat';
+export declare function useSelectedChannelState<O>(_: {
+    channel: Channel;
+    selector: (channel: Channel) => O;
     stateChangeEventKeys?: EventTypes[];
 }): O;
-export declare function useSelectedChannelState<SCG extends ExtendableGenerics, O>(_: {
-    selector: (channel: Channel<SCG>) => O;
-    channel?: Channel<SCG> | undefined;
+export declare function useSelectedChannelState<O>(_: {
+    selector: (channel: Channel) => O;
+    channel?: Channel | undefined;
     stateChangeEventKeys?: EventTypes[];
 }): O | undefined;

package/dist/components/ChannelList/hooks/useUserPresenceChangedListener.d.ts

@@ -1,3 +1,2 @@
 import type { Channel } from 'stream-chat';
-import type { DefaultStreamChatGenerics } from '../../../types/types';
-export declare const useUserPresenceChangedListener: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>) => void;
+export declare const useUserPresenceChangedListener: (setChannels: React.Dispatch<React.SetStateAction<Array<Channel>>>) => void;

package/dist/components/ChannelList/utils.d.ts

@@ -1,56 +1,55 @@
-import type { Channel, ChannelSort, ChannelSortBase, ExtendableGenerics } from 'stream-chat';
-import type { DefaultStreamChatGenerics } from '../../types/types';
+import type { Channel, ChannelSort, ChannelSortBase } from 'stream-chat';
 import type { ChannelListProps } from './ChannelList';
 export declare const MAX_QUERY_CHANNELS_LIMIT = 30;
-type MoveChannelUpParams<SCG extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
-    channels: Array<Channel<SCG>>;
+type MoveChannelUpParams = {
+    channels: Array<Channel>;
     cid: string;
-    activeChannel?: Channel<SCG>;
+    activeChannel?: Channel;
 };
 /**
  * @deprecated
  */
-export declare const moveChannelUp: <SCG extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>({ activeChannel, channels, cid, }: MoveChannelUpParams<SCG>) => Channel<SCG>[];
+export declare const moveChannelUp: ({ activeChannel, channels, cid }: MoveChannelUpParams) => Channel[];
 /**
  * Expects channel array sorted by `{ pinned_at: -1 }`.
  *
  * TODO: add support for the `{ pinned_at: 1 }`
  */
-export declare function findLastPinnedChannelIndex<SCG extends ExtendableGenerics>({ channels, }: {
-    channels: Channel<SCG>[];
+export declare function findLastPinnedChannelIndex({ channels }: {
+    channels: Channel[];
 }): number | null;
-type MoveChannelUpwardsParams<SCG extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = {
-    channels: Array<Channel<SCG>>;
-    channelToMove: Channel<SCG>;
-    sort: ChannelSort<SCG>;
+type MoveChannelUpwardsParams = {
+    channels: Array<Channel>;
+    channelToMove: Channel;
+    sort: ChannelSort;
     /**
      * If the index of the channel within `channels` list which is being moved upwards
      * (`channelToMove`) is known, you can supply it to skip extra calculation.
      */
     channelToMoveIndexWithinChannels?: number;
 };
-export declare const moveChannelUpwards: <SCG extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>({ channels, channelToMove, channelToMoveIndexWithinChannels, sort, }: MoveChannelUpwardsParams<SCG>) => Channel<SCG>[];
+export declare const moveChannelUpwards: ({ channels, channelToMove, channelToMoveIndexWithinChannels, sort, }: MoveChannelUpwardsParams) => Channel[];
 /**
  * Returns `true` only if object with `pinned_at` property is first within the `sort` array
  * or if `pinned_at` key of the `sort` object gets picked first when using `for...in` looping mechanism
  * and value of the `pinned_at` is either `1` or `-1`.
  */
-export declare const shouldConsiderPinnedChannels: <SCG extends ExtendableGenerics>(sort: ChannelListProps<SCG>['sort']) => boolean;
-export declare const extractSortValue: <SCG extends ExtendableGenerics>({ atIndex, sort, targetKey, }: {
+export declare const shouldConsiderPinnedChannels: (sort: ChannelListProps['sort']) => boolean;
+export declare const extractSortValue: ({ atIndex, sort, targetKey, }: {
     atIndex: number;
-    targetKey: keyof ChannelSortBase<SCG>;
-    sort?: ChannelListProps<SCG>['sort'];
-}) => NonNullable<ChannelSortBase<SCG>["created_at" | "pinned_at" | "updated_at" | keyof SCG["channelType"] | "has_unread" | "last_message_at" | "last_updated" | "member_count" | "unread_count"]> | null;
+    targetKey: keyof ChannelSortBase;
+    sort?: ChannelListProps['sort'];
+}) => import("stream-chat").AscDesc | null;
 /**
  * Returns `true` only if `archived` property is of type `boolean` within `filters` object.
  */
-export declare const shouldConsiderArchivedChannels: <SCG extends ExtendableGenerics>(filters: ChannelListProps<SCG>['filters']) => boolean;
+export declare const shouldConsiderArchivedChannels: (filters: ChannelListProps['filters']) => boolean;
 /**
  * Returns `true` only if `pinned_at` property is of type `string` within `membership` object.
  */
-export declare const isChannelPinned: <SCG extends ExtendableGenerics>(channel: Channel<SCG>) => boolean;
+export declare const isChannelPinned: (channel: Channel) => boolean;
 /**
  * Returns `true` only if `archived_at` property is of type `string` within `membership` object.
  */
-export declare const isChannelArchived: <SCG extends ExtendableGenerics>(channel: Channel<SCG>) => boolean;
+export declare const isChannelArchived: (channel: Channel) => boolean;
 export {};

package/dist/components/ChannelList/utils.js

@@ -3,7 +3,7 @@ export const MAX_QUERY_CHANNELS_LIMIT = 30;
 /**
  * @deprecated
  */
-export const moveChannelUp = ({ activeChannel, channels, cid, }) => {
+export const moveChannelUp = ({ activeChannel, channels, cid }) => {
     // get index of channel to move up
     const channelIndex = channels.findIndex((channel) => channel.cid === cid);
     if (!activeChannel && channelIndex <= 0)
@@ -17,7 +17,7 @@ export const moveChannelUp = ({ activeChannel, channels, cid, }) => {
  *
  * TODO: add support for the `{ pinned_at: 1 }`
  */
-export function findLastPinnedChannelIndex({ channels, }) {
+export function findLastPinnedChannelIndex({ channels }) {
     let lastPinnedChannelIndex = null;
     for (const channel of channels) {
         if (!isChannelPinned(channel))