stream-chat-react 11.22.0 → 12.0.0-rc.2

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

@@ -1,17 +1,19 @@
-import { __assign, __spreadArray } from "tslib";
 import { useEffect } from 'react';
 import { useChatContext } from '../../../context/ChatContext';
-export var useChannelUpdatedListener = function (setChannels, customHandler, forceUpdate) {
-    var client = useChatContext('useChannelUpdatedListener').client;
-    useEffect(function () {
-        var handleEvent = function (event) {
-            setChannels(function (channels) {
-                var _a, _b, _c, _d, _e, _f;
-                var channelIndex = channels.findIndex(function (channel) { var _a; return channel.cid === ((_a = event.channel) === null || _a === void 0 ? void 0 : _a.cid); });
+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) {
-                    var newChannels = channels;
-                    newChannels[channelIndex].data = __assign(__assign({}, event.channel), { hidden: (_b = (_a = event.channel) === null || _a === void 0 ? void 0 : _a.hidden) !== null && _b !== void 0 ? _b : (_c = newChannels[channelIndex].data) === null || _c === void 0 ? void 0 : _c.hidden, own_capabilities: (_e = (_d = event.channel) === null || _d === void 0 ? void 0 : _d.own_capabilities) !== null && _e !== void 0 ? _e : (_f = newChannels[channelIndex].data) === null || _f === void 0 ? void 0 : _f.own_capabilities });
-                    return __spreadArray([], newChannels, true);
+                    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;
             });
@@ -23,7 +25,7 @@ export var useChannelUpdatedListener = function (setChannels, customHandler, for
             }
         };
         client.on('channel.updated', handleEvent);
-        return function () {
+        return () => {
             client.off('channel.updated', handleEvent);
         };
         // eslint-disable-next-line react-hooks/exhaustive-deps

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

@@ -1,4 +1,3 @@
 import type { Channel, Event } from 'stream-chat';
 import type { DefaultStreamChatGenerics } from '../../../types/types';
-export declare const useChannelVisibleListener: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(setChannels: import("react").Dispatch<import("react").SetStateAction<Channel<StreamChatGenerics>[]>>, customHandler?: ((setChannels: import("react").Dispatch<import("react").SetStateAction<Channel<StreamChatGenerics>[]>>, event: Event<StreamChatGenerics>) => void) | undefined) => void;
-//# sourceMappingURL=useChannelVisibleListener.d.ts.map
+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;

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

@@ -1,36 +1,25 @@
-import { __awaiter, __generator, __spreadArray } from "tslib";
 import { useEffect } from 'react';
 import uniqBy from 'lodash.uniqby';
 import { getChannel } from '../../../utils/getChannel';
 import { useChatContext } from '../../../context/ChatContext';
-export var useChannelVisibleListener = function (setChannels, customHandler) {
-    var client = useChatContext('useChannelVisibleListener').client;
-    useEffect(function () {
-        var handleEvent = function (event) { return __awaiter(void 0, void 0, void 0, function () {
-            var channel_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!(customHandler && typeof customHandler === 'function')) return [3 /*break*/, 1];
-                        customHandler(setChannels, event);
-                        return [3 /*break*/, 3];
-                    case 1:
-                        if (!(event.type && event.channel_type && event.channel_id)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, getChannel({
-                                client: client,
-                                id: event.channel_id,
-                                type: event.channel_type,
-                            })];
-                    case 2:
-                        channel_1 = _a.sent();
-                        setChannels(function (channels) { return uniqBy(__spreadArray([channel_1], channels, true), 'cid'); });
-                        _a.label = 3;
-                    case 3: return [2 /*return*/];
-                }
-            });
-        }); };
+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 function () {
+        return () => {
             client.off('channel.visible', handleEvent);
         };
         // eslint-disable-next-line react-hooks/exhaustive-deps

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

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

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

@@ -1,15 +1,15 @@
 import { useEffect } from 'react';
 import { useChatContext } from '../../../context/ChatContext';
-export var useConnectionRecoveredListener = function (forceUpdate) {
-    var client = useChatContext('useConnectionRecoveredListener').client;
-    useEffect(function () {
-        var handleEvent = function () {
+export const useConnectionRecoveredListener = (forceUpdate) => {
+    const { client } = useChatContext('useConnectionRecoveredListener');
+    useEffect(() => {
+        const handleEvent = () => {
             if (forceUpdate) {
                 forceUpdate();
             }
         };
         client.on('connection.recovered', handleEvent);
-        return function () {
+        return () => {
             client.off('connection.recovered', handleEvent);
         };
         // eslint-disable-next-line react-hooks/exhaustive-deps

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

@@ -1,4 +1,3 @@
 import type { Channel, Event } from 'stream-chat';
 import type { DefaultStreamChatGenerics } from '../../../types/types';
-export declare const useMessageNewListener: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(setChannels: import("react").Dispatch<import("react").SetStateAction<Channel<StreamChatGenerics>[]>>, customHandler?: ((setChannels: import("react").Dispatch<import("react").SetStateAction<Channel<StreamChatGenerics>[]>>, event: Event<StreamChatGenerics>) => void) | undefined, lockChannelOrder?: boolean, allowNewMessagesFromUnfilteredChannels?: boolean) => void;
-//# sourceMappingURL=useMessageNewListener.d.ts.map
+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;

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

@@ -1,32 +1,29 @@
-import { __spreadArray } from "tslib";
 import { useEffect } from 'react';
 import uniqBy from 'lodash.uniqby';
 import { moveChannelUp } from '../utils';
 import { useChatContext } from '../../../context/ChatContext';
-export var useMessageNewListener = function (setChannels, customHandler, lockChannelOrder, allowNewMessagesFromUnfilteredChannels) {
-    if (lockChannelOrder === void 0) { lockChannelOrder = false; }
-    if (allowNewMessagesFromUnfilteredChannels === void 0) { allowNewMessagesFromUnfilteredChannels = true; }
-    var client = useChatContext('useMessageNewListener').client;
-    useEffect(function () {
-        var handleEvent = function (event) {
+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(function (channels) {
-                    var channelInList = channels.filter(function (channel) { return channel.cid === event.cid; }).length > 0;
+                setChannels((channels) => {
+                    const channelInList = channels.filter((channel) => channel.cid === event.cid).length > 0;
                     if (!channelInList && allowNewMessagesFromUnfilteredChannels && event.channel_type) {
-                        var channel = client.channel(event.channel_type, event.channel_id);
-                        return uniqBy(__spreadArray([channel], channels, true), 'cid');
+                        const channel = client.channel(event.channel_type, event.channel_id);
+                        return uniqBy([channel, ...channels], 'cid');
                     }
                     if (!lockChannelOrder)
-                        return moveChannelUp({ channels: channels, cid: event.cid || '' });
+                        return moveChannelUp({ channels, cid: event.cid || '' });
                     return channels;
                 });
             }
         };
         client.on('message.new', handleEvent);
-        return function () {
+        return () => {
             client.off('message.new', handleEvent);
         };
         // eslint-disable-next-line react-hooks/exhaustive-deps

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

@@ -1,2 +1 @@
 export declare const useMobileNavigation: (channelListRef: React.RefObject<HTMLDivElement>, navOpen: boolean, closeMobileNav?: () => void) => void;
-//# sourceMappingURL=useMobileNavigation.d.ts.map

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

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

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

@@ -1,4 +1,3 @@
 import type { Channel, Event } from 'stream-chat';
 import type { DefaultStreamChatGenerics } from '../../../types/types';
-export declare const useNotificationAddedToChannelListener: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(setChannels: import("react").Dispatch<import("react").SetStateAction<Channel<StreamChatGenerics>[]>>, customHandler?: ((setChannels: import("react").Dispatch<import("react").SetStateAction<Channel<StreamChatGenerics>[]>>, event: Event<StreamChatGenerics>) => void) | undefined, allowNewMessagesFromUnfilteredChannels?: boolean) => void;
-//# sourceMappingURL=useNotificationAddedToChannelListener.d.ts.map
+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;

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

@@ -1,46 +1,32 @@
-import { __awaiter, __generator, __spreadArray } from "tslib";
 import { useEffect } from 'react';
 import uniqBy from 'lodash.uniqby';
 import { getChannel } from '../../../utils/getChannel';
 import { useChatContext } from '../../../context/ChatContext';
-export var useNotificationAddedToChannelListener = function (setChannels, customHandler, allowNewMessagesFromUnfilteredChannels) {
-    if (allowNewMessagesFromUnfilteredChannels === void 0) { allowNewMessagesFromUnfilteredChannels = true; }
-    var client = useChatContext('useNotificationAddedToChannelListener').client;
-    useEffect(function () {
-        var handleEvent = function (event) { return __awaiter(void 0, void 0, void 0, function () {
-            var channel_1;
-            var _a, _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (!(customHandler && typeof customHandler === 'function')) return [3 /*break*/, 1];
-                        customHandler(setChannels, event);
-                        return [3 /*break*/, 3];
-                    case 1:
-                        if (!(allowNewMessagesFromUnfilteredChannels && ((_a = event.channel) === null || _a === void 0 ? void 0 : _a.type))) return [3 /*break*/, 3];
-                        return [4 /*yield*/, getChannel({
-                                client: client,
-                                id: event.channel.id,
-                                members: (_b = event.channel.members) === null || _b === void 0 ? void 0 : _b.reduce(function (acc, _a) {
-                                    var user = _a.user, user_id = _a.user_id;
-                                    var userId = user_id || (user === null || user === void 0 ? void 0 : user.id);
-                                    if (userId) {
-                                        acc.push(userId);
-                                    }
-                                    return acc;
-                                }, []),
-                                type: event.channel.type,
-                            })];
-                    case 2:
-                        channel_1 = _c.sent();
-                        setChannels(function (channels) { return uniqBy(__spreadArray([channel_1], channels, true), 'cid'); });
-                        _c.label = 3;
-                    case 3: return [2 /*return*/];
-                }
-            });
-        }); };
+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 function () {
+        return () => {
             client.off('notification.added_to_channel', handleEvent);
         };
         // eslint-disable-next-line react-hooks/exhaustive-deps

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

@@ -1,4 +1,3 @@
 import type { Channel, Event } from 'stream-chat';
 import type { DefaultStreamChatGenerics } from '../../../types/types';
-export declare const useNotificationMessageNewListener: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(setChannels: import("react").Dispatch<import("react").SetStateAction<Channel<StreamChatGenerics>[]>>, customHandler?: ((setChannels: import("react").Dispatch<import("react").SetStateAction<Channel<StreamChatGenerics>[]>>, event: Event<StreamChatGenerics>) => void) | undefined, allowNewMessagesFromUnfilteredChannels?: boolean) => void;
-//# sourceMappingURL=useNotificationMessageNewListener.d.ts.map
+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;

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

@@ -1,38 +1,25 @@
-import { __awaiter, __generator, __spreadArray } from "tslib";
 import { useEffect } from 'react';
 import uniqBy from 'lodash.uniqby';
 import { getChannel } from '../../../utils/getChannel';
 import { useChatContext } from '../../../context/ChatContext';
-export var useNotificationMessageNewListener = function (setChannels, customHandler, allowNewMessagesFromUnfilteredChannels) {
-    if (allowNewMessagesFromUnfilteredChannels === void 0) { allowNewMessagesFromUnfilteredChannels = true; }
-    var client = useChatContext('useNotificationMessageNewListener').client;
-    useEffect(function () {
-        var handleEvent = function (event) { return __awaiter(void 0, void 0, void 0, function () {
-            var channel_1;
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!(customHandler && typeof customHandler === 'function')) return [3 /*break*/, 1];
-                        customHandler(setChannels, event);
-                        return [3 /*break*/, 3];
-                    case 1:
-                        if (!(allowNewMessagesFromUnfilteredChannels && ((_a = event.channel) === null || _a === void 0 ? void 0 : _a.type))) return [3 /*break*/, 3];
-                        return [4 /*yield*/, getChannel({
-                                client: client,
-                                id: event.channel.id,
-                                type: event.channel.type,
-                            })];
-                    case 2:
-                        channel_1 = _b.sent();
-                        setChannels(function (channels) { return uniqBy(__spreadArray([channel_1], channels, true), 'cid'); });
-                        _b.label = 3;
-                    case 3: return [2 /*return*/];
-                }
-            });
-        }); };
+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 function () {
+        return () => {
             client.off('notification.message_new', handleEvent);
         };
         // eslint-disable-next-line react-hooks/exhaustive-deps

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

@@ -1,4 +1,3 @@
 import type { Channel, Event } from 'stream-chat';
 import type { DefaultStreamChatGenerics } from '../../../types/types';
-export declare const useNotificationRemovedFromChannelListener: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(setChannels: import("react").Dispatch<import("react").SetStateAction<Channel<StreamChatGenerics>[]>>, customHandler?: ((setChannels: import("react").Dispatch<import("react").SetStateAction<Channel<StreamChatGenerics>[]>>, event: Event<StreamChatGenerics>) => void) | undefined) => void;
-//# sourceMappingURL=useNotificationRemovedFromChannelListener.d.ts.map
+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;

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

@@ -1,18 +1,18 @@
 import { useEffect } from 'react';
 import { useChatContext } from '../../../context/ChatContext';
-export var useNotificationRemovedFromChannelListener = function (setChannels, customHandler) {
-    var client = useChatContext('useNotificationRemovedFromChannelListener').client;
-    useEffect(function () {
-        var handleEvent = function (event) {
+export const useNotificationRemovedFromChannelListener = (setChannels, customHandler) => {
+    const { client } = useChatContext('useNotificationRemovedFromChannelListener');
+    useEffect(() => {
+        const handleEvent = (event) => {
             if (customHandler && typeof customHandler === 'function') {
                 customHandler(setChannels, event);
             }
             else {
-                setChannels(function (channels) { return channels.filter(function (channel) { var _a; return channel.cid !== ((_a = event.channel) === null || _a === void 0 ? void 0 : _a.cid); }); });
+                setChannels((channels) => channels.filter((channel) => channel.cid !== event.channel?.cid));
             }
         };
         client.on('notification.removed_from_channel', handleEvent);
-        return function () {
+        return () => {
             client.off('notification.removed_from_channel', handleEvent);
         };
         // eslint-disable-next-line react-hooks/exhaustive-deps

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

@@ -10,11 +10,10 @@ export type CustomQueryChannelParams<StreamChatGenerics extends DefaultStreamCha
     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: Channel<StreamChatGenerics>[], setChannels: import("react").Dispatch<import("react").SetStateAction<Channel<StreamChatGenerics>[]>>) => void, recoveryThrottleIntervalMs?: number, customQueryChannels?: CustomQueryChannelsFn<StreamChatGenerics> | undefined) => {
+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>[];
     hasNextPage: boolean;
     loadNextPage: () => void;
     setChannels: import("react").Dispatch<import("react").SetStateAction<Channel<StreamChatGenerics>[]>>;
 };
 export {};
-//# sourceMappingURL=usePaginatedChannels.d.ts.map

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

@@ -1,83 +1,67 @@
-import { __assign, __awaiter, __generator, __spreadArray } from "tslib";
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import uniqBy from 'lodash.uniqby';
 import { MAX_QUERY_CHANNELS_LIMIT } from '../utils';
 import { useChatContext } from '../../../context/ChatContext';
 import { DEFAULT_INITIAL_CHANNEL_PAGE_SIZE } from '../../../constants/limits';
-var RECOVER_LOADED_CHANNELS_THROTTLE_INTERVAL_IN_MS = 5000;
-var MIN_RECOVER_LOADED_CHANNELS_THROTTLE_INTERVAL_IN_MS = 2000;
-export var usePaginatedChannels = function (client, filters, sort, options, activeChannelHandler, recoveryThrottleIntervalMs, customQueryChannels) {
-    if (recoveryThrottleIntervalMs === void 0) { recoveryThrottleIntervalMs = RECOVER_LOADED_CHANNELS_THROTTLE_INTERVAL_IN_MS; }
-    var _a = useChatContext('usePaginatedChannels').channelsQueryState, error = _a.error, setError = _a.setError, setQueryInProgress = _a.setQueryInProgress;
-    var _b = useState([]), channels = _b[0], setChannels = _b[1];
-    var _c = useState(true), hasNextPage = _c[0], setHasNextPage = _c[1];
-    var lastRecoveryTimestamp = useRef();
-    var recoveryThrottleInterval = recoveryThrottleIntervalMs < MIN_RECOVER_LOADED_CHANNELS_THROTTLE_INTERVAL_IN_MS
+const RECOVER_LOADED_CHANNELS_THROTTLE_INTERVAL_IN_MS = 5000;
+const MIN_RECOVER_LOADED_CHANNELS_THROTTLE_INTERVAL_IN_MS = 2000;
+export const usePaginatedChannels = (client, filters, sort, options, activeChannelHandler, recoveryThrottleIntervalMs = RECOVER_LOADED_CHANNELS_THROTTLE_INTERVAL_IN_MS, customQueryChannels) => {
+    const { channelsQueryState: { error, setError, setQueryInProgress }, } = useChatContext('usePaginatedChannels');
+    const [channels, setChannels] = useState([]);
+    const [hasNextPage, setHasNextPage] = useState(true);
+    const lastRecoveryTimestamp = useRef();
+    const recoveryThrottleInterval = recoveryThrottleIntervalMs < MIN_RECOVER_LOADED_CHANNELS_THROTTLE_INTERVAL_IN_MS
         ? MIN_RECOVER_LOADED_CHANNELS_THROTTLE_INTERVAL_IN_MS
-        : recoveryThrottleIntervalMs !== null && recoveryThrottleIntervalMs !== void 0 ? recoveryThrottleIntervalMs : RECOVER_LOADED_CHANNELS_THROTTLE_INTERVAL_IN_MS;
+        : recoveryThrottleIntervalMs ?? RECOVER_LOADED_CHANNELS_THROTTLE_INTERVAL_IN_MS;
     // memoize props
-    var filterString = useMemo(function () { return JSON.stringify(filters); }, [filters]);
-    var sortString = useMemo(function () { return JSON.stringify(sort); }, [sort]);
+    const filterString = useMemo(() => JSON.stringify(filters), [filters]);
+    const sortString = useMemo(() => JSON.stringify(sort), [sort]);
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    var queryChannels = function (queryType) {
-        if (queryType === void 0) { queryType = 'load-more'; }
-        return __awaiter(void 0, void 0, void 0, function () {
-            var offset, newOptions, channelQueryResponse, newChannels, err_1;
-            var _a, _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        setError(null);
-                        if (queryType === 'reload') {
-                            setChannels([]);
-                        }
-                        setQueryInProgress(queryType);
-                        _c.label = 1;
-                    case 1:
-                        _c.trys.push([1, 6, , 7]);
-                        if (!customQueryChannels) return [3 /*break*/, 3];
-                        return [4 /*yield*/, customQueryChannels({
-                                currentChannels: channels,
-                                queryType: queryType,
-                                setChannels: setChannels,
-                                setHasNextPage: setHasNextPage,
-                            })];
-                    case 2:
-                        _c.sent();
-                        return [3 /*break*/, 5];
-                    case 3:
-                        offset = queryType === 'reload' ? 0 : channels.length;
-                        newOptions = __assign({ limit: (_a = options === null || options === void 0 ? void 0 : options.limit) !== null && _a !== void 0 ? _a : MAX_QUERY_CHANNELS_LIMIT, message_limit: (_b = options === null || options === void 0 ? void 0 : options.message_limit) !== null && _b !== void 0 ? _b : DEFAULT_INITIAL_CHANNEL_PAGE_SIZE, offset: offset }, options);
-                        return [4 /*yield*/, client.queryChannels(filters, sort || {}, newOptions)];
-                    case 4:
-                        channelQueryResponse = _c.sent();
-                        newChannels = queryType === 'reload'
-                            ? channelQueryResponse
-                            : uniqBy(__spreadArray(__spreadArray([], channels, true), channelQueryResponse, true), 'cid');
-                        setChannels(newChannels);
-                        setHasNextPage(channelQueryResponse.length >= newOptions.limit);
-                        // Set active channel only on load of first page
-                        if (!offset && activeChannelHandler) {
-                            activeChannelHandler(newChannels, setChannels);
-                        }
-                        _c.label = 5;
-                    case 5: return [3 /*break*/, 7];
-                    case 6:
-                        err_1 = _c.sent();
-                        console.warn(err_1);
-                        setError(err_1);
-                        return [3 /*break*/, 7];
-                    case 7:
-                        setQueryInProgress(null);
-                        return [2 /*return*/];
+    const queryChannels = async (queryType = 'load-more') => {
+        setError(null);
+        if (queryType === 'reload') {
+            setChannels([]);
+        }
+        setQueryInProgress(queryType);
+        try {
+            if (customQueryChannels) {
+                await customQueryChannels({
+                    currentChannels: channels,
+                    queryType: queryType,
+                    setChannels,
+                    setHasNextPage,
+                });
+            }
+            else {
+                const offset = queryType === 'reload' ? 0 : channels.length;
+                const newOptions = {
+                    limit: options?.limit ?? MAX_QUERY_CHANNELS_LIMIT,
+                    message_limit: options?.message_limit ?? DEFAULT_INITIAL_CHANNEL_PAGE_SIZE,
+                    offset,
+                    ...options,
+                };
+                const channelQueryResponse = await client.queryChannels(filters, sort || {}, newOptions);
+                const newChannels = queryType === 'reload'
+                    ? channelQueryResponse
+                    : uniqBy([...channels, ...channelQueryResponse], 'cid');
+                setChannels(newChannels);
+                setHasNextPage(channelQueryResponse.length >= newOptions.limit);
+                // Set active channel only on load of first page
+                if (!offset && activeChannelHandler) {
+                    activeChannelHandler(newChannels, setChannels);
                 }
-            });
-        });
+            }
+        }
+        catch (err) {
+            console.warn(err);
+            setError(err);
+        }
+        setQueryInProgress(null);
     };
-    var throttleRecover = useCallback(function () {
-        var now = Date.now();
-        var isFirstRecovery = !lastRecoveryTimestamp.current;
-        var timeElapsedSinceLastRecoveryMs = lastRecoveryTimestamp.current
+    const throttleRecover = useCallback(() => {
+        const now = Date.now();
+        const isFirstRecovery = !lastRecoveryTimestamp.current;
+        const timeElapsedSinceLastRecoveryMs = lastRecoveryTimestamp.current
             ? now - lastRecoveryTimestamp.current
             : 0;
         if (!isFirstRecovery && timeElapsedSinceLastRecoveryMs < recoveryThrottleInterval && !error) {
@@ -86,25 +70,25 @@ export var usePaginatedChannels = function (client, filters, sort, options, acti
         lastRecoveryTimestamp.current = now;
         queryChannels('reload');
     }, [error, queryChannels, recoveryThrottleInterval]);
-    var loadNextPage = function () {
+    const loadNextPage = () => {
         queryChannels();
     };
-    useEffect(function () {
+    useEffect(() => {
         if (client.recoverStateOnReconnect)
             return;
-        var unsubscribe = client.on('connection.recovered', throttleRecover).unsubscribe;
-        return function () {
+        const { unsubscribe } = client.on('connection.recovered', throttleRecover);
+        return () => {
             unsubscribe();
         };
     }, [client, throttleRecover]);
-    useEffect(function () {
+    useEffect(() => {
         queryChannels('reload');
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [filterString, sortString]);
     return {
-        channels: channels,
-        hasNextPage: hasNextPage,
-        loadNextPage: loadNextPage,
-        setChannels: setChannels,
+        channels,
+        hasNextPage,
+        loadNextPage,
+        setChannels,
     };
 };

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

@@ -1,4 +1,3 @@
 import type { Channel } from 'stream-chat';
 import type { DefaultStreamChatGenerics } from '../../../types/types';
-export declare const useUserPresenceChangedListener: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(setChannels: import("react").Dispatch<import("react").SetStateAction<Channel<StreamChatGenerics>[]>>) => void;
-//# sourceMappingURL=useUserPresenceChangedListener.d.ts.map
+export declare const useUserPresenceChangedListener: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(setChannels: React.Dispatch<React.SetStateAction<Array<Channel<StreamChatGenerics>>>>) => void;