stream-chat-react 13.14.1 → 14.0.0-beta.1

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

@@ -1,373 +0,0 @@
-import { useCallback, useEffect, useMemo, useRef } from 'react';
-import { extractSortValue, findLastPinnedChannelIndex, isChannelArchived, isChannelPinned, moveChannelUpwards, shouldConsiderArchivedChannels, shouldConsiderPinnedChannels, } from '../utils';
-import { useChatContext } from '../../../context';
-import { getChannel } from '../../../utils';
-const shared = ({ customHandler, event, setChannels, }) => {
-    if (typeof customHandler === 'function') {
-        return customHandler(setChannels, event);
-    }
-    setChannels((channels) => {
-        const channelIndex = channels.findIndex((channel) => channel.cid === event.cid);
-        if (channelIndex < 0)
-            return channels;
-        channels.splice(channelIndex, 1);
-        return [...channels];
-    });
-};
-export const useChannelListShapeDefaults = () => {
-    const { client } = useChatContext();
-    const handleMessageNew = useCallback(({ allowNewMessagesFromUnfilteredChannels, customHandler, event, filters, lockChannelOrder, setChannels, sort, }) => {
-        if (typeof customHandler === 'function') {
-            return customHandler(setChannels, event);
-        }
-        const channelType = event.channel_type;
-        const channelId = event.channel_id;
-        if (!channelType || !channelId)
-            return;
-        setChannels((currentChannels) => {
-            const targetChannel = client.channel(channelType, channelId);
-            const targetChannelIndex = currentChannels.indexOf(targetChannel);
-            const targetChannelExistsWithinList = targetChannelIndex >= 0;
-            const isTargetChannelPinned = isChannelPinned(targetChannel);
-            const isTargetChannelArchived = isChannelArchived(targetChannel);
-            const considerArchivedChannels = shouldConsiderArchivedChannels(filters);
-            const considerPinnedChannels = shouldConsiderPinnedChannels(sort);
-            if (
-            // filter is defined, target channel is archived and filter option is set to false
-            (considerArchivedChannels && isTargetChannelArchived && !filters.archived) ||
-                // filter is defined, target channel isn't archived and filter option is set to true
-                (considerArchivedChannels && !isTargetChannelArchived && filters.archived) ||
-                // sort option is defined, target channel is pinned
-                (considerPinnedChannels && isTargetChannelPinned) ||
-                // list order is locked
-                lockChannelOrder ||
-                // target channel is not within the loaded list and loading from cache is disallowed
-                (!targetChannelExistsWithinList && !allowNewMessagesFromUnfilteredChannels)) {
-                return currentChannels;
-            }
-            return moveChannelUpwards({
-                channels: currentChannels,
-                channelToMove: targetChannel,
-                channelToMoveIndexWithinChannels: targetChannelIndex,
-                sort,
-            });
-        });
-    }, [client]);
-    const handleNotificationMessageNew = useCallback(async ({ allowNewMessagesFromUnfilteredChannels, customHandler, event, filters, setChannels, sort, }) => {
-        if (typeof customHandler === 'function') {
-            return customHandler(setChannels, event);
-        }
-        if (!event.channel) {
-            return;
-        }
-        const channel = await getChannel({
-            client,
-            id: event.channel.id,
-            type: event.channel.type,
-        });
-        const considerArchivedChannels = shouldConsiderArchivedChannels(filters);
-        if (isChannelArchived(channel) && considerArchivedChannels && !filters.archived) {
-            return;
-        }
-        if (!allowNewMessagesFromUnfilteredChannels) {
-            return;
-        }
-        setChannels((channels) => moveChannelUpwards({
-            channels,
-            channelToMove: channel,
-            sort,
-        }));
-    }, [client]);
-    const handleNotificationAddedToChannel = useCallback(async ({ allowNewMessagesFromUnfilteredChannels, customHandler, event, setChannels, sort, }) => {
-        if (typeof customHandler === 'function') {
-            return customHandler(setChannels, event);
-        }
-        if (!event.channel || !allowNewMessagesFromUnfilteredChannels) {
-            return;
-        }
-        const channel = await getChannel({
-            client,
-            id: event.channel.id,
-            members: event.channel.members?.reduce((newMembers, { user, user_id }) => {
-                const userId = user_id || user?.id;
-                if (userId)
-                    newMembers.push(userId);
-                return newMembers;
-            }, []),
-            type: event.channel.type,
-        });
-        // membership has been reset (target channel shouldn't be pinned nor archived)
-        setChannels((channels) => moveChannelUpwards({
-            channels,
-            channelToMove: channel,
-            sort,
-        }));
-    }, [client]);
-    const handleNotificationRemovedFromChannel = useCallback(({ customHandler, event, setChannels, }) => {
-        if (typeof customHandler === 'function') {
-            return customHandler(setChannels, event);
-        }
-        setChannels((channels) => channels.filter((channel) => channel.cid !== event.channel?.cid));
-    }, []);
-    const handleMemberUpdated = useCallback(({ event, filters, lockChannelOrder, setChannels, sort, }) => {
-        if (!event.member?.user ||
-            event.member.user.id !== client.userID ||
-            !event.channel_type) {
-            return;
-        }
-        const channelType = event.channel_type;
-        const channelId = event.channel_id;
-        const considerPinnedChannels = shouldConsiderPinnedChannels(sort);
-        const considerArchivedChannels = shouldConsiderArchivedChannels(filters);
-        // `pinned_at` nor `archived` properties are set or channel list order is locked, return early
-        if ((!considerPinnedChannels && !considerArchivedChannels) || lockChannelOrder) {
-            return;
-        }
-        const pinnedAtSort = extractSortValue({ atIndex: 0, sort, targetKey: 'pinned_at' });
-        setChannels((currentChannels) => {
-            const targetChannel = client.channel(channelType, channelId);
-            // assumes that channel instances are not changing
-            const targetChannelIndex = currentChannels.indexOf(targetChannel);
-            const targetChannelExistsWithinList = targetChannelIndex >= 0;
-            const isTargetChannelArchived = isChannelArchived(targetChannel);
-            const isTargetChannelPinned = isChannelPinned(targetChannel);
-            const newChannels = [...currentChannels];
-            if (targetChannelExistsWithinList) {
-                newChannels.splice(targetChannelIndex, 1);
-            }
-            // handle archiving (remove channel)
-            if ((considerArchivedChannels && isTargetChannelArchived && !filters.archived) ||
-                (considerArchivedChannels && !isTargetChannelArchived && filters.archived)) {
-                return newChannels;
-            }
-            let lastPinnedChannelIndex = null;
-            // calculate last pinned channel index only if `pinned_at` sort is set to
-            // ascending order or if it's in descending order while the pin is being removed, otherwise
-            // we move to the top (index 0)
-            if (pinnedAtSort === 1 || (pinnedAtSort === -1 && !isTargetChannelPinned)) {
-                lastPinnedChannelIndex = findLastPinnedChannelIndex({ channels: newChannels });
-            }
-            const newTargetChannelIndex = typeof lastPinnedChannelIndex === 'number' ? lastPinnedChannelIndex + 1 : 0;
-            newChannels.splice(newTargetChannelIndex, 0, targetChannel);
-            return newChannels;
-        });
-    }, [client]);
-    const handleChannelDeleted = useCallback((p) => shared(p), []);
-    const handleChannelHidden = useCallback((p) => shared(p), []);
-    const handleChannelVisible = useCallback(async ({ customHandler, event, filters, setChannels, sort, }) => {
-        if (typeof customHandler === 'function') {
-            return customHandler(setChannels, event);
-        }
-        if (!event.channel_id && !event.channel_type) {
-            return;
-        }
-        const channel = await getChannel({
-            client,
-            id: event.channel_id,
-            type: event.channel_type,
-        });
-        const considerArchivedChannels = shouldConsiderArchivedChannels(filters);
-        if (isChannelArchived(channel) && considerArchivedChannels && !filters.archived) {
-            return;
-        }
-        setChannels((channels) => moveChannelUpwards({
-            channels,
-            channelToMove: channel,
-            sort,
-        }));
-    }, [client]);
-    const handleChannelTruncated = useCallback(({ customHandler, event, setChannels }) => {
-        if (typeof customHandler === 'function') {
-            return customHandler(setChannels, event);
-        }
-        // TODO: not sure whether this is needed
-        setChannels((channels) => [...channels]);
-        // if (forceUpdate) {
-        //   forceUpdate();
-        // }
-    }, []);
-    const handleChannelUpdated = useCallback(({ customHandler, event, setChannels }) => {
-        if (typeof customHandler === 'function') {
-            return customHandler(setChannels, event);
-        }
-        setChannels((channels) => {
-            const channelIndex = channels.findIndex((channel) => channel.cid === event.channel?.cid);
-            if (channelIndex > -1 && event.channel) {
-                const newChannels = channels;
-                newChannels[channelIndex].data = {
-                    ...event.channel,
-                    hidden: event.channel?.hidden ?? newChannels[channelIndex].data?.hidden,
-                    own_capabilities: event.channel?.own_capabilities ??
-                        newChannels[channelIndex].data?.own_capabilities,
-                };
-                return [...newChannels];
-            }
-            return channels;
-        });
-        // if (forceUpdate) {
-        //   forceUpdate();
-        // }
-    }, []);
-    const handleUserPresenceChanged = useCallback(({ event, setChannels }) => {
-        setChannels((channels) => {
-            const newChannels = channels.map((channel) => {
-                if (!event.user?.id || !channel.state.members[event.user.id]) {
-                    return channel;
-                }
-                // FIXME: oh no...
-                const newChannel = channel;
-                newChannel.state.members[event.user.id].user = event.user;
-                return newChannel;
-            });
-            return newChannels;
-        });
-    }, []);
-    return useMemo(() => ({
-        handleChannelDeleted,
-        handleChannelHidden,
-        handleChannelTruncated,
-        handleChannelUpdated,
-        handleChannelVisible,
-        handleMemberUpdated,
-        handleMessageNew,
-        handleNotificationAddedToChannel,
-        handleNotificationMessageNew,
-        handleNotificationRemovedFromChannel,
-        handleUserPresenceChanged,
-    }), [
-        handleChannelDeleted,
-        handleChannelHidden,
-        handleChannelTruncated,
-        handleChannelUpdated,
-        handleChannelVisible,
-        handleMemberUpdated,
-        handleMessageNew,
-        handleNotificationAddedToChannel,
-        handleNotificationMessageNew,
-        handleNotificationRemovedFromChannel,
-        handleUserPresenceChanged,
-    ]);
-};
-export const usePrepareShapeHandlers = ({ allowNewMessagesFromUnfilteredChannels, customHandleChannelListShape, filters, lockChannelOrder, onAddedToChannel, onChannelDeleted, onChannelHidden, onChannelTruncated, onChannelUpdated, onChannelVisible, onMessageNew, onMessageNewHandler, onRemovedFromChannel, setChannels, sort, }) => {
-    const defaults = useChannelListShapeDefaults();
-    const defaultHandleChannelListShapeRef = useRef(undefined);
-    const customHandleChannelListShapeRef = useRef(undefined);
-    customHandleChannelListShapeRef.current = (event) => {
-        customHandleChannelListShape?.({ defaults, event, setChannels });
-    };
-    defaultHandleChannelListShapeRef.current = (event) => {
-        switch (event.type) {
-            case 'message.new':
-                defaults.handleMessageNew({
-                    allowNewMessagesFromUnfilteredChannels,
-                    customHandler: onMessageNewHandler,
-                    event,
-                    filters,
-                    lockChannelOrder,
-                    setChannels,
-                    sort,
-                });
-                break;
-            case 'notification.message_new':
-                defaults.handleNotificationMessageNew({
-                    allowNewMessagesFromUnfilteredChannels,
-                    customHandler: onMessageNew,
-                    event,
-                    filters,
-                    lockChannelOrder,
-                    setChannels,
-                    sort,
-                });
-                break;
-            case 'notification.added_to_channel':
-                defaults.handleNotificationAddedToChannel({
-                    allowNewMessagesFromUnfilteredChannels,
-                    customHandler: onAddedToChannel,
-                    event,
-                    lockChannelOrder,
-                    setChannels,
-                    sort,
-                });
-                break;
-            case 'notification.removed_from_channel':
-                defaults.handleNotificationRemovedFromChannel({
-                    customHandler: onRemovedFromChannel,
-                    event,
-                    setChannels,
-                });
-                break;
-            case 'channel.deleted':
-                defaults.handleChannelDeleted({
-                    customHandler: onChannelDeleted,
-                    event,
-                    setChannels,
-                });
-                break;
-            case 'channel.hidden':
-                defaults.handleChannelHidden({
-                    customHandler: onChannelHidden,
-                    event,
-                    setChannels,
-                });
-                break;
-            case 'channel.visible':
-                defaults.handleChannelVisible({
-                    customHandler: onChannelVisible,
-                    event,
-                    filters,
-                    setChannels,
-                    sort,
-                });
-                break;
-            case 'channel.truncated':
-                defaults.handleChannelTruncated({
-                    customHandler: onChannelTruncated,
-                    event,
-                    setChannels,
-                });
-                break;
-            case 'channel.updated':
-                defaults.handleChannelUpdated({
-                    customHandler: onChannelUpdated,
-                    event,
-                    setChannels,
-                });
-                break;
-            case 'user.presence.changed':
-                defaults.handleUserPresenceChanged({ event, setChannels });
-                break;
-            case 'member.updated':
-                defaults.handleMemberUpdated({
-                    event,
-                    filters,
-                    lockChannelOrder,
-                    setChannels,
-                    sort,
-                });
-                break;
-            default:
-                break;
-        }
-    };
-    const defaultFn = useCallback((e) => {
-        defaultHandleChannelListShapeRef.current?.(e);
-    }, []);
-    const customFn = useMemo(() => {
-        if (!customHandleChannelListShape)
-            return null;
-        return (e) => {
-            customHandleChannelListShapeRef.current?.(e);
-        };
-    }, [customHandleChannelListShape]);
-    return {
-        customHandler: customFn,
-        defaultHandler: defaultFn,
-    };
-};
-export const useChannelListShape = (handler) => {
-    const { client } = useChatContext();
-    useEffect(() => {
-        const subscription = client.on('all', handler);
-        return subscription.unsubscribe;
-    }, [client, handler]);
-};

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

@@ -1,3 +0,0 @@
-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/useChannelMembershipState.js

@@ -1,6 +0,0 @@
-import { useSelectedChannelState } from './useSelectedChannelState';
-const selector = (c) => c.state.membership;
-const keys = ['member.updated'];
-export function useChannelMembershipState(channel) {
-    return useSelectedChannelState({ channel, selector, stateChangeEventKeys: keys });
-}

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

@@ -1,2 +0,0 @@
-import type { Channel, Event } from 'stream-chat';
-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/useChannelTruncatedListener.js

@@ -1,20 +0,0 @@
-import { useEffect } from 'react';
-import { useChatContext } from '../../../context/ChatContext';
-export const useChannelTruncatedListener = (setChannels, customHandler, forceUpdate) => {
-    const { client } = useChatContext('useChannelTruncatedListener');
-    useEffect(() => {
-        const handleEvent = (event) => {
-            setChannels((channels) => [...channels]);
-            if (customHandler && typeof customHandler === 'function') {
-                customHandler(setChannels, event);
-            }
-            if (forceUpdate) {
-                forceUpdate();
-            }
-        };
-        client.on('channel.truncated', handleEvent);
-        return () => {
-            client.off('channel.truncated', handleEvent);
-        };
-    }, [client, customHandler, forceUpdate, setChannels]);
-};

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

@@ -1,2 +0,0 @@
-import type { Channel, Event } from 'stream-chat';
-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/useChannelUpdatedListener.js

@@ -1,33 +0,0 @@
-import { useEffect } from 'react';
-import { useChatContext } from '../../../context/ChatContext';
-export const useChannelUpdatedListener = (setChannels, customHandler, forceUpdate) => {
-    const { client } = useChatContext('useChannelUpdatedListener');
-    useEffect(() => {
-        const handleEvent = (event) => {
-            setChannels((channels) => {
-                const channelIndex = channels.findIndex((channel) => channel.cid === event.channel?.cid);
-                if (channelIndex > -1 && event.channel) {
-                    const newChannels = channels;
-                    newChannels[channelIndex].data = {
-                        ...event.channel,
-                        hidden: event.channel?.hidden ?? newChannels[channelIndex].data?.hidden,
-                        own_capabilities: event.channel?.own_capabilities ??
-                            newChannels[channelIndex].data?.own_capabilities,
-                    };
-                    return [...newChannels];
-                }
-                return channels;
-            });
-            if (forceUpdate) {
-                forceUpdate();
-            }
-            if (customHandler && typeof customHandler === 'function') {
-                customHandler(setChannels, event);
-            }
-        };
-        client.on('channel.updated', handleEvent);
-        return () => {
-            client.off('channel.updated', handleEvent);
-        };
-    }, [client, customHandler, forceUpdate, setChannels]);
-};

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

@@ -1,2 +0,0 @@
-import type { Channel, Event } from 'stream-chat';
-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/useChannelVisibleListener.js

@@ -1,26 +0,0 @@
-import { useEffect } from 'react';
-import uniqBy from 'lodash.uniqby';
-import { getChannel } from '../../../utils/getChannel';
-import { useChatContext } from '../../../context/ChatContext';
-export const useChannelVisibleListener = (setChannels, customHandler) => {
-    const { client } = useChatContext('useChannelVisibleListener');
-    useEffect(() => {
-        const handleEvent = async (event) => {
-            if (customHandler && typeof customHandler === 'function') {
-                customHandler(setChannels, event);
-            }
-            else if (event.type && event.channel_type && event.channel_id) {
-                const channel = await getChannel({
-                    client,
-                    id: event.channel_id,
-                    type: event.channel_type,
-                });
-                setChannels((channels) => uniqBy([channel, ...channels], 'cid'));
-            }
-        };
-        client.on('channel.visible', handleEvent);
-        return () => {
-            client.off('channel.visible', handleEvent);
-        };
-    }, [client, customHandler, setChannels]);
-};

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

@@ -1 +0,0 @@
-export declare const useConnectionRecoveredListener: (forceUpdate?: () => void) => void;

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

@@ -1,16 +0,0 @@
-import { useEffect } from 'react';
-import { useChatContext } from '../../../context/ChatContext';
-export const useConnectionRecoveredListener = (forceUpdate) => {
-    const { client } = useChatContext('useConnectionRecoveredListener');
-    useEffect(() => {
-        const handleEvent = () => {
-            if (forceUpdate) {
-                forceUpdate();
-            }
-        };
-        client.on('connection.recovered', handleEvent);
-        return () => {
-            client.off('connection.recovered', handleEvent);
-        };
-    }, [client, forceUpdate]);
-};

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

@@ -1,2 +0,0 @@
-import type { Channel, Event } from 'stream-chat';
-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/useMessageNewListener.js

@@ -1,38 +0,0 @@
-import { useEffect } from 'react';
-import uniqBy from 'lodash.uniqby';
-import { moveChannelUp } from '../utils';
-import { useChatContext } from '../../../context/ChatContext';
-export const useMessageNewListener = (setChannels, customHandler, lockChannelOrder = false, allowNewMessagesFromUnfilteredChannels = true) => {
-    const { client } = useChatContext('useMessageNewListener');
-    useEffect(() => {
-        const handleEvent = (event) => {
-            if (customHandler && typeof customHandler === 'function') {
-                customHandler(setChannels, event);
-            }
-            else {
-                setChannels((channels) => {
-                    const channelInList = channels.filter((channel) => channel.cid === event.cid).length > 0;
-                    if (!channelInList &&
-                        allowNewMessagesFromUnfilteredChannels &&
-                        event.channel_type) {
-                        const channel = client.channel(event.channel_type, event.channel_id);
-                        return uniqBy([channel, ...channels], 'cid');
-                    }
-                    if (!lockChannelOrder)
-                        return moveChannelUp({ channels, cid: event.cid || '' });
-                    return channels;
-                });
-            }
-        };
-        client.on('message.new', handleEvent);
-        return () => {
-            client.off('message.new', handleEvent);
-        };
-    }, [
-        allowNewMessagesFromUnfilteredChannels,
-        client,
-        customHandler,
-        lockChannelOrder,
-        setChannels,
-    ]);
-};

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

@@ -1 +0,0 @@
-export declare const useMobileNavigation: (channelListRef: React.RefObject<HTMLDivElement | null>, navOpen: boolean, closeMobileNav?: () => void) => void;

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

@@ -1,17 +0,0 @@
-import { useEffect } from 'react';
-export const useMobileNavigation = (channelListRef, navOpen, closeMobileNav) => {
-    useEffect(() => {
-        const handleClickOutside = (event) => {
-            if (closeMobileNav &&
-                channelListRef.current &&
-                !channelListRef.current.contains(event.target) &&
-                navOpen) {
-                closeMobileNav();
-            }
-        };
-        document.addEventListener('click', handleClickOutside);
-        return () => {
-            document.removeEventListener('click', handleClickOutside);
-        };
-    }, [channelListRef, closeMobileNav, navOpen]);
-};

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

@@ -1,2 +0,0 @@
-import type { Channel, Event } from 'stream-chat';
-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/useNotificationAddedToChannelListener.js

@@ -1,33 +0,0 @@
-import { useEffect } from 'react';
-import uniqBy from 'lodash.uniqby';
-import { getChannel } from '../../../utils/getChannel';
-import { useChatContext } from '../../../context/ChatContext';
-export const useNotificationAddedToChannelListener = (setChannels, customHandler, allowNewMessagesFromUnfilteredChannels = true) => {
-    const { client } = useChatContext('useNotificationAddedToChannelListener');
-    useEffect(() => {
-        const handleEvent = async (event) => {
-            if (customHandler && typeof customHandler === 'function') {
-                customHandler(setChannels, event);
-            }
-            else if (allowNewMessagesFromUnfilteredChannels && event.channel?.type) {
-                const channel = await getChannel({
-                    client,
-                    id: event.channel.id,
-                    members: event.channel.members?.reduce((acc, { user, user_id }) => {
-                        const userId = user_id || user?.id;
-                        if (userId) {
-                            acc.push(userId);
-                        }
-                        return acc;
-                    }, []),
-                    type: event.channel.type,
-                });
-                setChannels((channels) => uniqBy([channel, ...channels], 'cid'));
-            }
-        };
-        client.on('notification.added_to_channel', handleEvent);
-        return () => {
-            client.off('notification.added_to_channel', handleEvent);
-        };
-    }, [allowNewMessagesFromUnfilteredChannels, client, customHandler, setChannels]);
-};

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

@@ -1,2 +0,0 @@
-import type { Channel, Event } from 'stream-chat';
-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/useNotificationMessageNewListener.js

@@ -1,26 +0,0 @@
-import { useEffect } from 'react';
-import uniqBy from 'lodash.uniqby';
-import { getChannel } from '../../../utils/getChannel';
-import { useChatContext } from '../../../context/ChatContext';
-export const useNotificationMessageNewListener = (setChannels, customHandler, allowNewMessagesFromUnfilteredChannels = true) => {
-    const { client } = useChatContext('useNotificationMessageNewListener');
-    useEffect(() => {
-        const handleEvent = async (event) => {
-            if (customHandler && typeof customHandler === 'function') {
-                customHandler(setChannels, event);
-            }
-            else if (allowNewMessagesFromUnfilteredChannels && event.channel?.type) {
-                const channel = await getChannel({
-                    client,
-                    id: event.channel.id,
-                    type: event.channel.type,
-                });
-                setChannels((channels) => uniqBy([channel, ...channels], 'cid'));
-            }
-        };
-        client.on('notification.message_new', handleEvent);
-        return () => {
-            client.off('notification.message_new', handleEvent);
-        };
-    }, [allowNewMessagesFromUnfilteredChannels, client, customHandler, setChannels]);
-};

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

@@ -1,2 +0,0 @@
-import type { Channel, Event } from 'stream-chat';
-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/useNotificationRemovedFromChannelListener.js

@@ -1,19 +0,0 @@
-import { useEffect } from 'react';
-import { useChatContext } from '../../../context/ChatContext';
-export const useNotificationRemovedFromChannelListener = (setChannels, customHandler) => {
-    const { client } = useChatContext('useNotificationRemovedFromChannelListener');
-    useEffect(() => {
-        const handleEvent = (event) => {
-            if (customHandler && typeof customHandler === 'function') {
-                customHandler(setChannels, event);
-            }
-            else {
-                setChannels((channels) => channels.filter((channel) => channel.cid !== event.channel?.cid));
-            }
-        };
-        client.on('notification.removed_from_channel', handleEvent);
-        return () => {
-            client.off('notification.removed_from_channel', handleEvent);
-        };
-    }, [client, customHandler, setChannels]);
-};