stream-chat-react 11.21.0 → 12.0.0-rc.1

package/dist/components/Message/hooks/useReactionHandler.js

@@ -1,146 +1,121 @@
-import { __assign, __awaiter, __generator, __spreadArray } from "tslib";
 import { useCallback, useEffect, useRef, useState } from 'react';
 import throttle from 'lodash.throttle';
 import { useChannelActionContext } from '../../../context/ChannelActionContext';
 import { useChannelStateContext } from '../../../context/ChannelStateContext';
 import { useChatContext } from '../../../context/ChatContext';
-export var reactionHandlerWarning = "Reaction handler was called, but it is missing one of its required arguments.\nMake sure the ChannelAction and ChannelState contexts are properly set and the hook is initialized with a valid message.";
-export var useReactionHandler = function (message) {
-    var updateMessage = useChannelActionContext('useReactionHandler').updateMessage;
-    var _a = useChannelStateContext('useReactionHandler'), channel = _a.channel, channelCapabilities = _a.channelCapabilities;
-    var client = useChatContext('useReactionHandler').client;
-    var createMessagePreview = useCallback(function (add, reaction, message) {
-        var _a, _b;
-        var newReactionGroups = (message === null || message === void 0 ? void 0 : message.reaction_groups) || {};
-        var reactionType = reaction.type;
-        var hasReaction = !!newReactionGroups[reactionType];
+export const reactionHandlerWarning = `Reaction handler was called, but it is missing one of its required arguments.
+Make sure the ChannelAction and ChannelState contexts are properly set and the hook is initialized with a valid message.`;
+export const useReactionHandler = (message) => {
+    const { updateMessage } = useChannelActionContext('useReactionHandler');
+    const { channel, channelCapabilities } = useChannelStateContext('useReactionHandler');
+    const { client } = useChatContext('useReactionHandler');
+    const createMessagePreview = useCallback((add, reaction, message) => {
+        const newReactionGroups = message?.reaction_groups || {};
+        const reactionType = reaction.type;
+        const hasReaction = !!newReactionGroups[reactionType];
         if (add) {
-            var timestamp = new Date().toISOString();
+            const timestamp = new Date().toISOString();
             newReactionGroups[reactionType] = hasReaction
-                ? __assign(__assign({}, newReactionGroups[reactionType]), { count: newReactionGroups[reactionType].count + 1 }) : {
-                count: 1,
-                first_reaction_at: timestamp,
-                last_reaction_at: timestamp,
-                sum_scores: 1,
-            };
+                ? { ...newReactionGroups[reactionType], count: newReactionGroups[reactionType].count + 1 }
+                : {
+                    count: 1,
+                    first_reaction_at: timestamp,
+                    last_reaction_at: timestamp,
+                    sum_scores: 1,
+                };
         }
         else {
             if (hasReaction && newReactionGroups[reactionType].count > 1) {
-                newReactionGroups[reactionType] = __assign(__assign({}, newReactionGroups[reactionType]), { count: newReactionGroups[reactionType].count - 1 });
+                newReactionGroups[reactionType] = {
+                    ...newReactionGroups[reactionType],
+                    count: newReactionGroups[reactionType].count - 1,
+                };
             }
             else {
                 delete newReactionGroups[reactionType];
             }
         }
-        var newReactions = add
-            ? __spreadArray([reaction], ((message === null || message === void 0 ? void 0 : message.latest_reactions) || []), true) : (_a = message.latest_reactions) === null || _a === void 0 ? void 0 : _a.filter(function (item) { return !(item.type === reaction.type && item.user_id === reaction.user_id); });
-        var newOwnReactions = add
-            ? __spreadArray([reaction], ((message === null || message === void 0 ? void 0 : message.own_reactions) || []), true) : (_b = message === null || message === void 0 ? void 0 : message.own_reactions) === null || _b === void 0 ? void 0 : _b.filter(function (item) { return item.type !== reaction.type; });
-        return __assign(__assign({}, message), { latest_reactions: newReactions || message.latest_reactions, own_reactions: newOwnReactions, reaction_groups: newReactionGroups });
+        const newReactions = add
+            ? [reaction, ...(message?.latest_reactions || [])]
+            : message.latest_reactions?.filter((item) => !(item.type === reaction.type && item.user_id === reaction.user_id));
+        const newOwnReactions = add
+            ? [reaction, ...(message?.own_reactions || [])]
+            : message?.own_reactions?.filter((item) => item.type !== reaction.type);
+        return {
+            ...message,
+            latest_reactions: newReactions || message.latest_reactions,
+            own_reactions: newOwnReactions,
+            reaction_groups: newReactionGroups,
+        };
     }, 
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [client.user, client.userID]);
-    var createReactionPreview = function (type) {
-        var _a;
-        return ({
-            message_id: message === null || message === void 0 ? void 0 : message.id,
-            score: 1,
-            type: type,
-            user: client.user,
-            user_id: (_a = client.user) === null || _a === void 0 ? void 0 : _a.id,
-        });
-    };
-    var toggleReaction = throttle(function (id, type, add) { return __awaiter(void 0, void 0, void 0, function () {
-        var newReaction, tempMessage, messageResponse, _a, error_1;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    if (!message || !channelCapabilities['send-reaction'])
-                        return [2 /*return*/];
-                    newReaction = createReactionPreview(type);
-                    tempMessage = createMessagePreview(add, newReaction, message);
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 6, , 7]);
-                    updateMessage(tempMessage);
-                    if (!add) return [3 /*break*/, 3];
-                    return [4 /*yield*/, channel.sendReaction(id, { type: type })];
-                case 2:
-                    _a = _b.sent();
-                    return [3 /*break*/, 5];
-                case 3: return [4 /*yield*/, channel.deleteReaction(id, type)];
-                case 4:
-                    _a = _b.sent();
-                    _b.label = 5;
-                case 5:
-                    messageResponse = _a;
-                    updateMessage(messageResponse.message);
-                    return [3 /*break*/, 7];
-                case 6:
-                    error_1 = _b.sent();
-                    // revert to the original message if the API call fails
-                    updateMessage(message);
-                    return [3 /*break*/, 7];
-                case 7: return [2 /*return*/];
+    const createReactionPreview = (type) => ({
+        message_id: message?.id,
+        score: 1,
+        type,
+        user: client.user,
+        user_id: client.user?.id,
+    });
+    const toggleReaction = throttle(async (id, type, add) => {
+        if (!message || !channelCapabilities['send-reaction'])
+            return;
+        const newReaction = createReactionPreview(type);
+        const tempMessage = createMessagePreview(add, newReaction, message);
+        try {
+            updateMessage(tempMessage);
+            const messageResponse = add
+                ? await channel.sendReaction(id, { type })
+                : await channel.deleteReaction(id, type);
+            updateMessage(messageResponse.message);
+        }
+        catch (error) {
+            // revert to the original message if the API call fails
+            updateMessage(message);
+        }
+    }, 1000);
+    return async (reactionType, event) => {
+        if (event?.preventDefault) {
+            event.preventDefault();
+        }
+        if (!message) {
+            return console.warn(reactionHandlerWarning);
+        }
+        let userExistingReaction = null;
+        if (message.own_reactions) {
+            message.own_reactions.forEach((reaction) => {
+                // own user should only ever contain the current user id
+                // just in case we check to prevent bugs with message updates from breaking reactions
+                if (reaction.user && client.userID === reaction.user.id && reaction.type === reactionType) {
+                    userExistingReaction = reaction;
+                }
+                else if (reaction.user && client.userID !== reaction.user.id) {
+                    console.warn(`message.own_reactions contained reactions from a different user, this indicates a bug`);
+                }
+            });
+        }
+        try {
+            if (userExistingReaction) {
+                await toggleReaction(message.id, userExistingReaction.type, false);
             }
-        });
-    }); }, 1000);
-    return function (reactionType, event) { return __awaiter(void 0, void 0, void 0, function () {
-        var userExistingReaction, error_2;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (event === null || event === void 0 ? void 0 : event.preventDefault) {
-                        event.preventDefault();
-                    }
-                    if (!message) {
-                        return [2 /*return*/, console.warn(reactionHandlerWarning)];
-                    }
-                    userExistingReaction = null;
-                    if (message.own_reactions) {
-                        message.own_reactions.forEach(function (reaction) {
-                            // own user should only ever contain the current user id
-                            // just in case we check to prevent bugs with message updates from breaking reactions
-                            if (reaction.user && client.userID === reaction.user.id && reaction.type === reactionType) {
-                                userExistingReaction = reaction;
-                            }
-                            else if (reaction.user && client.userID !== reaction.user.id) {
-                                console.warn("message.own_reactions contained reactions from a different user, this indicates a bug");
-                            }
-                        });
-                    }
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 6, , 7]);
-                    if (!userExistingReaction) return [3 /*break*/, 3];
-                    return [4 /*yield*/, toggleReaction(message.id, userExistingReaction.type, false)];
-                case 2:
-                    _a.sent();
-                    return [3 /*break*/, 5];
-                case 3: return [4 /*yield*/, toggleReaction(message.id, reactionType, true)];
-                case 4:
-                    _a.sent();
-                    _a.label = 5;
-                case 5: return [3 /*break*/, 7];
-                case 6:
-                    error_2 = _a.sent();
-                    console.log({ error: error_2 });
-                    return [3 /*break*/, 7];
-                case 7: return [2 /*return*/];
+            else {
+                await toggleReaction(message.id, reactionType, true);
             }
-        });
-    }); };
+        }
+        catch (error) {
+            console.log({ error });
+        }
+    };
 };
-export var useReactionClick = function (message, reactionSelectorRef, messageWrapperRef, closeReactionSelectorOnClick) {
-    var _a = useChannelStateContext('useReactionClick').channelCapabilities, channelCapabilities = _a === void 0 ? {} : _a;
-    var _b = useState(false), showDetailedReactions = _b[0], setShowDetailedReactions = _b[1];
-    var hasListener = useRef(false);
-    var isReactionEnabled = channelCapabilities['send-reaction'];
-    var messageDeleted = !!(message === null || message === void 0 ? void 0 : message.deleted_at);
-    var closeDetailedReactions = useCallback(function (event) {
-        var _a;
+export const useReactionClick = (message, reactionSelectorRef, messageWrapperRef, closeReactionSelectorOnClick) => {
+    const { channelCapabilities = {} } = useChannelStateContext('useReactionClick');
+    const [showDetailedReactions, setShowDetailedReactions] = useState(false);
+    const hasListener = useRef(false);
+    const isReactionEnabled = channelCapabilities['send-reaction'];
+    const messageDeleted = !!message?.deleted_at;
+    const closeDetailedReactions = useCallback((event) => {
         if (event.target instanceof HTMLElement &&
-            ((_a = reactionSelectorRef === null || reactionSelectorRef === void 0 ? void 0 : reactionSelectorRef.current) === null || _a === void 0 ? void 0 : _a.contains(event.target)) &&
+            reactionSelectorRef?.current?.contains(event.target) &&
             !closeReactionSelectorOnClick) {
             return;
         }
@@ -148,8 +123,8 @@ export var useReactionClick = function (message, reactionSelectorRef, messageWra
     }, 
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [setShowDetailedReactions, reactionSelectorRef]);
-    useEffect(function () {
-        var messageWrapper = messageWrapperRef === null || messageWrapperRef === void 0 ? void 0 : messageWrapperRef.current;
+    useEffect(() => {
+        const messageWrapper = messageWrapperRef?.current;
         if (showDetailedReactions && !hasListener.current) {
             hasListener.current = true;
             document.addEventListener('click', closeDetailedReactions);
@@ -164,7 +139,7 @@ export var useReactionClick = function (message, reactionSelectorRef, messageWra
             }
             hasListener.current = false;
         }
-        return function () {
+        return () => {
             if (hasListener.current) {
                 document.removeEventListener('click', closeDetailedReactions);
                 if (messageWrapper) {
@@ -174,8 +149,8 @@ export var useReactionClick = function (message, reactionSelectorRef, messageWra
             }
         };
     }, [showDetailedReactions, closeDetailedReactions, messageWrapperRef]);
-    useEffect(function () {
-        var messageWrapper = messageWrapperRef === null || messageWrapperRef === void 0 ? void 0 : messageWrapperRef.current;
+    useEffect(() => {
+        const messageWrapper = messageWrapperRef?.current;
         if (messageDeleted && hasListener.current) {
             document.removeEventListener('click', closeDetailedReactions);
             if (messageWrapper) {
@@ -184,14 +159,13 @@ export var useReactionClick = function (message, reactionSelectorRef, messageWra
             hasListener.current = false;
         }
     }, [messageDeleted, closeDetailedReactions, messageWrapperRef]);
-    var onReactionListClick = function (event) {
-        var _a;
-        (_a = event === null || event === void 0 ? void 0 : event.stopPropagation) === null || _a === void 0 ? void 0 : _a.call(event);
-        setShowDetailedReactions(function (prev) { return !prev; });
+    const onReactionListClick = (event) => {
+        event?.stopPropagation?.();
+        setShowDetailedReactions((prev) => !prev);
     };
     return {
-        isReactionEnabled: isReactionEnabled,
-        onReactionListClick: onReactionListClick,
-        showDetailedReactions: showDetailedReactions,
+        isReactionEnabled,
+        onReactionListClick,
+        showDetailedReactions,
     };
 };

package/dist/components/Message/hooks/useReactionsFetcher.d.ts

@@ -9,4 +9,3 @@ type FetchMessageReactionsNotifications<StreamChatGenerics extends DefaultStream
 };
 export declare function useReactionsFetcher<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message: StreamMessage<StreamChatGenerics>, notifications?: FetchMessageReactionsNotifications<StreamChatGenerics>): (reactionType?: ReactionType<StreamChatGenerics>, sort?: ReactionSort<StreamChatGenerics>) => Promise<ReactionResponse<DefaultStreamChatGenerics>[]>;
 export {};
-//# sourceMappingURL=useReactionsFetcher.d.ts.map

package/dist/components/Message/hooks/useReactionsFetcher.js

@@ -1,51 +1,30 @@
-import { __awaiter, __generator } from "tslib";
 import { useChatContext, useTranslationContext } from '../../../context';
-export var MAX_MESSAGE_REACTIONS_TO_FETCH = 1000;
-export function useReactionsFetcher(message, notifications) {
-    var _this = this;
-    if (notifications === void 0) { notifications = {}; }
-    var client = useChatContext('useRectionsFetcher').client;
-    var t = useTranslationContext('useReactionFetcher').t;
-    var getErrorNotification = notifications.getErrorNotification, notify = notifications.notify;
-    return function (reactionType, sort) { return __awaiter(_this, void 0, void 0, function () {
-        var e_1, errorMessage;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, fetchMessageReactions(client, message.id, reactionType, sort)];
-                case 1: return [2 /*return*/, _a.sent()];
-                case 2:
-                    e_1 = _a.sent();
-                    errorMessage = getErrorNotification === null || getErrorNotification === void 0 ? void 0 : getErrorNotification(message);
-                    notify === null || notify === void 0 ? void 0 : notify(errorMessage || t('Error fetching reactions'), 'error');
-                    throw e_1;
-                case 3: return [2 /*return*/];
-            }
-        });
-    }); };
+export const MAX_MESSAGE_REACTIONS_TO_FETCH = 1000;
+export function useReactionsFetcher(message, notifications = {}) {
+    const { client } = useChatContext('useRectionsFetcher');
+    const { t } = useTranslationContext('useReactionFetcher');
+    const { getErrorNotification, notify } = notifications;
+    return async (reactionType, sort) => {
+        try {
+            return await fetchMessageReactions(client, message.id, reactionType, sort);
+        }
+        catch (e) {
+            const errorMessage = getErrorNotification?.(message);
+            notify?.(errorMessage || t('Error fetching reactions'), 'error');
+            throw e;
+        }
+    };
 }
-function fetchMessageReactions(client, messageId, reactionType, sort) {
-    return __awaiter(this, void 0, void 0, function () {
-        var reactions, limit, next, hasNext, response;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    reactions = [];
-                    limit = 25;
-                    hasNext = true;
-                    _a.label = 1;
-                case 1:
-                    if (!(hasNext && reactions.length < MAX_MESSAGE_REACTIONS_TO_FETCH)) return [3 /*break*/, 3];
-                    return [4 /*yield*/, client.queryReactions(messageId, reactionType ? { type: reactionType } : {}, sort, { limit: limit, next: next })];
-                case 2:
-                    response = _a.sent();
-                    reactions.push.apply(reactions, response.reactions);
-                    next = response.next;
-                    hasNext = Boolean(next);
-                    return [3 /*break*/, 1];
-                case 3: return [2 /*return*/, reactions];
-            }
-        });
-    });
+async function fetchMessageReactions(client, messageId, reactionType, sort) {
+    const reactions = [];
+    const limit = 25;
+    let next;
+    let hasNext = true;
+    while (hasNext && reactions.length < MAX_MESSAGE_REACTIONS_TO_FETCH) {
+        const response = await client.queryReactions(messageId, reactionType ? { type: reactionType } : {}, sort, { limit, next });
+        reactions.push(...response.reactions);
+        next = response.next;
+        hasNext = Boolean(next);
+    }
+    return reactions;
 }

package/dist/components/Message/hooks/useRetryHandler.d.ts

@@ -1,4 +1,3 @@
 import { RetrySendMessage } from '../../../context/ChannelActionContext';
 import type { DefaultStreamChatGenerics } from '../../../types/types';
-export declare const useRetryHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(customRetrySendMessage?: RetrySendMessage<StreamChatGenerics> | undefined) => RetrySendMessage<StreamChatGenerics>;
-//# sourceMappingURL=useRetryHandler.d.ts.map
+export declare const useRetryHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(customRetrySendMessage?: RetrySendMessage<StreamChatGenerics>) => RetrySendMessage<StreamChatGenerics>;

package/dist/components/Message/hooks/useRetryHandler.js

@@ -1,19 +1,10 @@
-import { __awaiter, __generator } from "tslib";
 import { useChannelActionContext } from '../../../context/ChannelActionContext';
-export var useRetryHandler = function (customRetrySendMessage) {
-    var contextRetrySendMessage = useChannelActionContext('useRetryHandler').retrySendMessage;
-    var retrySendMessage = customRetrySendMessage || contextRetrySendMessage;
-    return function (message) { return __awaiter(void 0, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (!message) return [3 /*break*/, 2];
-                    return [4 /*yield*/, retrySendMessage(message)];
-                case 1:
-                    _a.sent();
-                    _a.label = 2;
-                case 2: return [2 /*return*/];
-            }
-        });
-    }); };
+export const useRetryHandler = (customRetrySendMessage) => {
+    const { retrySendMessage: contextRetrySendMessage } = useChannelActionContext('useRetryHandler');
+    const retrySendMessage = customRetrySendMessage || contextRetrySendMessage;
+    return async (message) => {
+        if (message) {
+            await retrySendMessage(message);
+        }
+    };
 };

package/dist/components/Message/hooks/useUserHandler.d.ts

@@ -4,11 +4,10 @@ import type { ReactEventHandler } from '../types';
 import type { StreamMessage } from '../../../context/ChannelStateContext';
 import type { DefaultStreamChatGenerics } from '../../../types/types';
 export type UserEventHandler<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = (event: React.BaseSyntheticEvent, user: User<StreamChatGenerics>) => void;
-export declare const useUserHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message?: StreamMessage<StreamChatGenerics> | undefined, eventHandlers?: {
-    onUserClickHandler?: UserEventHandler<StreamChatGenerics> | undefined;
-    onUserHoverHandler?: UserEventHandler<StreamChatGenerics> | undefined;
-} | undefined) => {
+export declare const useUserHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message?: StreamMessage<StreamChatGenerics>, eventHandlers?: {
+    onUserClickHandler?: UserEventHandler<StreamChatGenerics>;
+    onUserHoverHandler?: UserEventHandler<StreamChatGenerics>;
+}) => {
     onUserClick: ReactEventHandler;
     onUserHover: ReactEventHandler;
 };
-//# sourceMappingURL=useUserHandler.d.ts.map

package/dist/components/Message/hooks/useUserHandler.js

@@ -1,14 +1,14 @@
-export var useUserHandler = function (message, eventHandlers) { return ({
-    onUserClick: function (event) {
-        if (typeof (eventHandlers === null || eventHandlers === void 0 ? void 0 : eventHandlers.onUserClickHandler) !== 'function' || !(message === null || message === void 0 ? void 0 : message.user)) {
+export const useUserHandler = (message, eventHandlers) => ({
+    onUserClick: (event) => {
+        if (typeof eventHandlers?.onUserClickHandler !== 'function' || !message?.user) {
             return;
         }
         eventHandlers.onUserClickHandler(event, message.user);
     },
-    onUserHover: function (event) {
-        if (typeof (eventHandlers === null || eventHandlers === void 0 ? void 0 : eventHandlers.onUserHoverHandler) !== 'function' || !(message === null || message === void 0 ? void 0 : message.user)) {
+    onUserHover: (event) => {
+        if (typeof eventHandlers?.onUserHoverHandler !== 'function' || !message?.user) {
             return;
         }
         eventHandlers.onUserHoverHandler(event, message.user);
     },
-}); };
+});

package/dist/components/Message/hooks/useUserRole.d.ts

@@ -14,4 +14,3 @@ export declare const useUserRole: <StreamChatGenerics extends DefaultStreamChatG
     isMyMessage: boolean;
     isOwner: boolean;
 };
-//# sourceMappingURL=useUserRole.d.ts.map

package/dist/components/Message/hooks/useUserRole.js

@@ -1,51 +1,50 @@
 import { useChannelStateContext } from '../../../context/ChannelStateContext';
 import { useChatContext } from '../../../context/ChatContext';
-export var useUserRole = function (message, onlySenderCanEdit, disableQuotedMessages) {
-    var _a, _b, _c;
-    var _d = useChannelStateContext('useUserRole'), channel = _d.channel, _e = _d.channelCapabilities, channelCapabilities = _e === void 0 ? {} : _e;
-    var client = useChatContext('useUserRole').client;
+export const useUserRole = (message, onlySenderCanEdit, disableQuotedMessages) => {
+    const { channel, channelCapabilities = {} } = useChannelStateContext('useUserRole');
+    const { client } = useChatContext('useUserRole');
     /**
      * @deprecated as it relies on `membership.role` check which is already deprecated and shouldn't be used anymore.
      * `isAdmin` will be removed in future release. See `channelCapabilities`.
      */
-    var isAdmin = ((_a = client.user) === null || _a === void 0 ? void 0 : _a.role) === 'admin' || channel.state.membership.role === 'admin';
+    const isAdmin = client.user?.role === 'admin' || channel.state.membership.role === 'admin';
     /**
      * @deprecated as it relies on `membership.role` check which is already deprecated and shouldn't be used anymore.
      * `isOwner` will be removed in future release. See `channelCapabilities`.
      */
-    var isOwner = channel.state.membership.role === 'owner';
+    const isOwner = channel.state.membership.role === 'owner';
     /**
      * @deprecated as it relies on `membership.role` check which is already deprecated and shouldn't be used anymore.
      * `isModerator` will be removed in future release. See `channelCapabilities`.
      */
-    var isModerator = ((_b = client.user) === null || _b === void 0 ? void 0 : _b.role) === 'channel_moderator' ||
+    const isModerator = client.user?.role === 'channel_moderator' ||
         channel.state.membership.role === 'channel_moderator' ||
         channel.state.membership.role === 'moderator' ||
         channel.state.membership.is_moderator === true ||
         channel.state.membership.channel_role === 'channel_moderator';
-    var isMyMessage = client.userID === ((_c = message.user) === null || _c === void 0 ? void 0 : _c.id);
-    var canEdit = (!onlySenderCanEdit && channelCapabilities['update-any-message']) ||
+    const isMyMessage = client.userID === message.user?.id;
+    const canEdit = (!onlySenderCanEdit && channelCapabilities['update-any-message']) ||
         (isMyMessage && channelCapabilities['update-own-message']);
-    var canDelete = channelCapabilities['delete-any-message'] ||
+    const canDelete = channelCapabilities['delete-any-message'] ||
         (isMyMessage && channelCapabilities['delete-own-message']);
-    var canFlag = !isMyMessage && channelCapabilities['flag-message'];
-    var canMarkUnread = channelCapabilities['read-events'];
-    var canMute = !isMyMessage && channelCapabilities['mute-channel'];
-    var canQuote = !disableQuotedMessages && channelCapabilities['quote-message'];
-    var canReact = channelCapabilities['send-reaction'];
-    var canReply = channelCapabilities['send-reply'];
+    const canFlag = !isMyMessage && channelCapabilities['flag-message'];
+    const canMarkUnread = channelCapabilities['read-events'];
+    const canMute = !isMyMessage && channelCapabilities['mute-channel'];
+    const canQuote = !disableQuotedMessages && channelCapabilities['quote-message'];
+    const canReact = channelCapabilities['send-reaction'];
+    const canReply = channelCapabilities['send-reply'];
     return {
-        canDelete: canDelete,
-        canEdit: canEdit,
-        canFlag: canFlag,
-        canMarkUnread: canMarkUnread,
-        canMute: canMute,
-        canQuote: canQuote,
-        canReact: canReact,
-        canReply: canReply,
-        isAdmin: isAdmin,
-        isModerator: isModerator,
-        isMyMessage: isMyMessage,
-        isOwner: isOwner,
+        canDelete,
+        canEdit,
+        canFlag,
+        canMarkUnread,
+        canMute,
+        canQuote,
+        canReact,
+        canReply,
+        isAdmin,
+        isModerator,
+        isMyMessage,
+        isOwner,
     };
 };

package/dist/components/Message/icons.d.ts

@@ -2,13 +2,9 @@ import React from 'react';
 import type { PinIndicatorProps } from './types';
 import type { DefaultStreamChatGenerics, IconProps } from '../../types/types';
 export declare const ActionsIcon: ({ className }: IconProps) => React.JSX.Element;
-export declare const ReplyIcon: () => React.JSX.Element;
-export declare const DeliveredCheckIcon: () => React.JSX.Element;
 export declare const ReactionIcon: ({ className }: IconProps) => React.JSX.Element;
 export declare const ThreadIcon: ({ className }: IconProps) => React.JSX.Element;
-export declare const ErrorIcon: () => React.JSX.Element;
 export declare const PinIcon: () => React.JSX.Element;
 export declare const PinIndicator: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>({ message, t, }: PinIndicatorProps<StreamChatGenerics>) => React.JSX.Element | null;
 export declare const MessageDeliveredIcon: () => React.JSX.Element;
 export declare const MessageErrorIcon: () => React.JSX.Element;
-//# sourceMappingURL=icons.d.ts.map