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

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

@@ -5,5 +5,4 @@ export type EditHandlerReturnType = {
     editing: boolean;
     setEdit: ReactEventHandler;
 };
-export declare const useEditHandler: (customInitialState?: boolean, customSetEditing?: ((event?: React.BaseSyntheticEvent) => void) | undefined, customClearEditingHandler?: ((event?: React.BaseSyntheticEvent) => void) | undefined) => EditHandlerReturnType;
-//# sourceMappingURL=useEditHandler.d.ts.map
+export declare const useEditHandler: (customInitialState?: boolean, customSetEditing?: (event?: React.BaseSyntheticEvent) => void, customClearEditingHandler?: (event?: React.BaseSyntheticEvent) => void) => EditHandlerReturnType;

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

@@ -1,20 +1,19 @@
 import { useState } from 'react';
-export var useEditHandler = function (customInitialState, customSetEditing, customClearEditingHandler) {
-    if (customInitialState === void 0) { customInitialState = false; }
-    var _a = useState(customInitialState), editing = _a[0], setEditing = _a[1];
-    var setEdit = customSetEditing ||
-        (function (event) {
-            if (event === null || event === void 0 ? void 0 : event.preventDefault) {
+export const useEditHandler = (customInitialState = false, customSetEditing, customClearEditingHandler) => {
+    const [editing, setEditing] = useState(customInitialState);
+    const setEdit = customSetEditing ||
+        ((event) => {
+            if (event?.preventDefault) {
                 event.preventDefault();
             }
             setEditing(true);
         });
-    var clearEdit = customClearEditingHandler ||
-        (function (event) {
-            if (event === null || event === void 0 ? void 0 : event.preventDefault) {
+    const clearEdit = customClearEditingHandler ||
+        ((event) => {
+            if (event?.preventDefault) {
                 event.preventDefault();
             }
             setEditing(false);
         });
-    return { clearEdit: clearEdit, editing: editing, setEdit: setEdit };
+    return { clearEdit, editing, setEdit };
 };

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

@@ -7,5 +7,4 @@ export type FlagMessageNotifications<StreamChatGenerics extends DefaultStreamCha
     getSuccessNotification?: (message: StreamMessage<StreamChatGenerics>) => string;
     notify?: (notificationText: string, type: 'success' | 'error') => void;
 };
-export declare const useFlagHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message?: StreamMessage<StreamChatGenerics> | undefined, notifications?: FlagMessageNotifications<StreamChatGenerics>) => ReactEventHandler;
-//# sourceMappingURL=useFlagHandler.d.ts.map
+export declare const useFlagHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message?: StreamMessage<StreamChatGenerics>, notifications?: FlagMessageNotifications<StreamChatGenerics>) => ReactEventHandler;

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

@@ -1,43 +1,28 @@
-import { __awaiter, __generator } from "tslib";
 import { validateAndGetMessage } from '../utils';
 import { useChatContext } from '../../../context/ChatContext';
 import { useTranslationContext } from '../../../context/TranslationContext';
-export var missingUseFlagHandlerParameterWarning = 'useFlagHandler was called but it is missing one or more necessary parameters.';
-export var useFlagHandler = function (message, notifications) {
-    if (notifications === void 0) { notifications = {}; }
-    var client = useChatContext('useFlagHandler').client;
-    var t = useTranslationContext('useFlagHandler').t;
-    return function (event) { return __awaiter(void 0, void 0, void 0, function () {
-        var getErrorNotification, getSuccessNotification, notify, successMessage, e_1, errorMessage;
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    event.preventDefault();
-                    getErrorNotification = notifications.getErrorNotification, getSuccessNotification = notifications.getSuccessNotification, notify = notifications.notify;
-                    if (!client || !t || !notify || !(message === null || message === void 0 ? void 0 : message.id)) {
-                        console.warn(missingUseFlagHandlerParameterWarning);
-                        return [2 /*return*/];
-                    }
-                    if ((_a = client.user) === null || _a === void 0 ? void 0 : _a.banned) {
-                        return [2 /*return*/, notify(t('Error adding flag'), 'error')];
-                    }
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, client.flagMessage(message.id)];
-                case 2:
-                    _b.sent();
-                    successMessage = getSuccessNotification && validateAndGetMessage(getSuccessNotification, [message]);
-                    notify(successMessage || t('Message has been successfully flagged'), 'success');
-                    return [3 /*break*/, 4];
-                case 3:
-                    e_1 = _b.sent();
-                    errorMessage = getErrorNotification && validateAndGetMessage(getErrorNotification, [message]);
-                    notify(errorMessage || t('Error adding flag'), 'error');
-                    return [3 /*break*/, 4];
-                case 4: return [2 /*return*/];
-            }
-        });
-    }); };
+export const missingUseFlagHandlerParameterWarning = 'useFlagHandler was called but it is missing one or more necessary parameters.';
+export const useFlagHandler = (message, notifications = {}) => {
+    const { client } = useChatContext('useFlagHandler');
+    const { t } = useTranslationContext('useFlagHandler');
+    return async (event) => {
+        event.preventDefault();
+        const { getErrorNotification, getSuccessNotification, notify } = notifications;
+        if (!client || !t || !notify || !message?.id) {
+            console.warn(missingUseFlagHandlerParameterWarning);
+            return;
+        }
+        if (client.user?.banned) {
+            return notify(t('Error adding flag'), 'error');
+        }
+        try {
+            await client.flagMessage(message.id);
+            const successMessage = getSuccessNotification && validateAndGetMessage(getSuccessNotification, [message]);
+            notify(successMessage || t('Message has been successfully flagged'), 'success');
+        }
+        catch (e) {
+            const errorMessage = getErrorNotification && validateAndGetMessage(getErrorNotification, [message]);
+            notify(errorMessage || t('Error adding flag'), 'error');
+        }
+    };
 };

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

@@ -6,5 +6,4 @@ export type MarkUnreadHandlerNotifications<StreamChatGenerics extends DefaultStr
     getSuccessNotification?: (message: StreamMessage<StreamChatGenerics>) => string;
     notify?: (notificationText: string, type: 'success' | 'error') => void;
 };
-export declare const useMarkUnreadHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message?: StreamMessage<StreamChatGenerics> | undefined, notifications?: MarkUnreadHandlerNotifications<StreamChatGenerics>) => ReactEventHandler;
-//# sourceMappingURL=useMarkUnreadHandler.d.ts.map
+export declare const useMarkUnreadHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message?: StreamMessage<StreamChatGenerics>, notifications?: MarkUnreadHandlerNotifications<StreamChatGenerics>) => ReactEventHandler;

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

@@ -1,45 +1,31 @@
-import { __awaiter, __generator } from "tslib";
 import { validateAndGetMessage } from '../utils';
 import { useChannelStateContext, useTranslationContext } from '../../../context';
-export var useMarkUnreadHandler = function (message, notifications) {
-    if (notifications === void 0) { notifications = {}; }
-    var getErrorNotification = notifications.getErrorNotification, getSuccessNotification = notifications.getSuccessNotification, notify = notifications.notify;
-    var channel = useChannelStateContext('useMarkUnreadHandler').channel;
-    var t = useTranslationContext('useMarkUnreadHandler').t;
-    return function (event) { return __awaiter(void 0, void 0, void 0, function () {
-        var successMessage, e_1, errorMessage;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    event.preventDefault();
-                    if (!(message === null || message === void 0 ? void 0 : message.id)) {
-                        console.warn('Mark unread handler does not have access to message id');
-                        return [2 /*return*/];
-                    }
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, channel.markUnread({ message_id: message.id })];
-                case 2:
-                    _a.sent();
-                    if (!notify)
-                        return [2 /*return*/];
-                    successMessage = getSuccessNotification && validateAndGetMessage(getSuccessNotification, [message]);
-                    if (successMessage)
-                        notify(successMessage, 'success');
-                    return [3 /*break*/, 4];
-                case 3:
-                    e_1 = _a.sent();
-                    if (!notify)
-                        return [2 /*return*/];
-                    errorMessage = getErrorNotification && validateAndGetMessage(getErrorNotification, [message]);
-                    if (getErrorNotification && !errorMessage)
-                        return [2 /*return*/];
-                    notify(errorMessage ||
-                        t('Error marking message unread. Cannot mark unread messages older than the newest 100 channel messages.'), 'error');
-                    return [3 /*break*/, 4];
-                case 4: return [2 /*return*/];
-            }
-        });
-    }); };
+export const useMarkUnreadHandler = (message, notifications = {}) => {
+    const { getErrorNotification, getSuccessNotification, notify } = notifications;
+    const { channel } = useChannelStateContext('useMarkUnreadHandler');
+    const { t } = useTranslationContext('useMarkUnreadHandler');
+    return async (event) => {
+        event.preventDefault();
+        if (!message?.id) {
+            console.warn('Mark unread handler does not have access to message id');
+            return;
+        }
+        try {
+            await channel.markUnread({ message_id: message.id });
+            if (!notify)
+                return;
+            const successMessage = getSuccessNotification && validateAndGetMessage(getSuccessNotification, [message]);
+            if (successMessage)
+                notify(successMessage, 'success');
+        }
+        catch (e) {
+            if (!notify)
+                return;
+            const errorMessage = getErrorNotification && validateAndGetMessage(getErrorNotification, [message]);
+            if (getErrorNotification && !errorMessage)
+                return;
+            notify(errorMessage ||
+                t('Error marking message unread. Cannot mark unread messages older than the newest 100 channel messages.'), 'error');
+        }
+    };
 };

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

@@ -5,11 +5,10 @@ import type { StreamMessage } from '../../../context/ChannelStateContext';
 import type { DefaultStreamChatGenerics } from '../../../types/types';
 export type CustomMentionHandler<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = (event: React.BaseSyntheticEvent, mentioned_users: UserResponse<StreamChatGenerics>[]) => void;
 export type MentionedUserEventHandler<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> = (event: React.BaseSyntheticEvent, mentionedUsers: UserResponse<StreamChatGenerics>[]) => void;
-export declare const useMentionsHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message?: StreamMessage<StreamChatGenerics> | undefined, customMentionHandler?: {
-    onMentionsClick?: CustomMentionHandler<StreamChatGenerics> | undefined;
-    onMentionsHover?: CustomMentionHandler<StreamChatGenerics> | undefined;
-} | undefined) => {
+export declare const useMentionsHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message?: StreamMessage<StreamChatGenerics>, customMentionHandler?: {
+    onMentionsClick?: CustomMentionHandler<StreamChatGenerics>;
+    onMentionsHover?: CustomMentionHandler<StreamChatGenerics>;
+}) => {
     onMentionsClick: ReactEventHandler;
     onMentionsHover: ReactEventHandler;
 };
-//# sourceMappingURL=useMentionsHandler.d.ts.map

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

@@ -1,17 +1,16 @@
 import { useChannelActionContext } from '../../../context/ChannelActionContext';
 function createEventHandler(fn, message) {
-    return function (event) {
-        var _a;
-        if (typeof fn !== 'function' || !((_a = message === null || message === void 0 ? void 0 : message.mentioned_users) === null || _a === void 0 ? void 0 : _a.length)) {
+    return (event) => {
+        if (typeof fn !== 'function' || !message?.mentioned_users?.length) {
             return;
         }
         fn(event, message.mentioned_users);
     };
 }
-export var useMentionsHandler = function (message, customMentionHandler) {
-    var _a = useChannelActionContext('useMentionsHandler'), contextOnMentionsClick = _a.onMentionsClick, contextOnMentionsHover = _a.onMentionsHover;
-    var onMentionsClick = (customMentionHandler === null || customMentionHandler === void 0 ? void 0 : customMentionHandler.onMentionsClick) || contextOnMentionsClick || (function () { return null; });
-    var onMentionsHover = (customMentionHandler === null || customMentionHandler === void 0 ? void 0 : customMentionHandler.onMentionsHover) || contextOnMentionsHover || (function () { return null; });
+export const useMentionsHandler = (message, customMentionHandler) => {
+    const { onMentionsClick: contextOnMentionsClick, onMentionsHover: contextOnMentionsHover, } = useChannelActionContext('useMentionsHandler');
+    const onMentionsClick = customMentionHandler?.onMentionsClick || contextOnMentionsClick || (() => null);
+    const onMentionsHover = customMentionHandler?.onMentionsHover || contextOnMentionsHover || (() => null);
     return {
         onMentionsClick: createEventHandler(onMentionsClick, message),
         onMentionsHover: createEventHandler(onMentionsHover, message),

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

@@ -8,5 +8,4 @@ export type MuteUserNotifications<StreamChatGenerics extends DefaultStreamChatGe
     getSuccessNotification?: (user: UserResponse<StreamChatGenerics>) => string;
     notify?: (notificationText: string, type: 'success' | 'error') => void;
 };
-export declare const useMuteHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message?: StreamMessage<StreamChatGenerics> | undefined, notifications?: MuteUserNotifications<StreamChatGenerics>) => ReactEventHandler;
-//# sourceMappingURL=useMuteHandler.d.ts.map
+export declare const useMuteHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message?: StreamMessage<StreamChatGenerics>, notifications?: MuteUserNotifications<StreamChatGenerics>) => ReactEventHandler;

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

@@ -1,69 +1,53 @@
-import { __awaiter, __generator } from "tslib";
 import { isUserMuted, validateAndGetMessage } from '../utils';
 import { useChannelStateContext } from '../../../context/ChannelStateContext';
 import { useChatContext } from '../../../context/ChatContext';
 import { useTranslationContext } from '../../../context/TranslationContext';
-export var missingUseMuteHandlerParamsWarning = 'useMuteHandler was called but it is missing one or more necessary parameter.';
-export var useMuteHandler = function (message, notifications) {
-    if (notifications === void 0) { notifications = {}; }
-    var mutes = useChannelStateContext('useMuteHandler').mutes;
-    var client = useChatContext('useMuteHandler').client;
-    var t = useTranslationContext('useMuteHandler').t;
-    return function (event) { return __awaiter(void 0, void 0, void 0, function () {
-        var getErrorNotification, getSuccessNotification, notify, successMessage, e_1, errorMessage, fallbackMessage, successMessage, e_2, errorMessage;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    event.preventDefault();
-                    getErrorNotification = notifications.getErrorNotification, getSuccessNotification = notifications.getSuccessNotification, notify = notifications.notify;
-                    if (!t || !(message === null || message === void 0 ? void 0 : message.user) || !notify || !client) {
-                        console.warn(missingUseMuteHandlerParamsWarning);
-                        return [2 /*return*/];
-                    }
-                    if (!!isUserMuted(message, mutes)) return [3 /*break*/, 5];
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, client.muteUser(message.user.id)];
-                case 2:
-                    _a.sent();
-                    successMessage = getSuccessNotification && validateAndGetMessage(getSuccessNotification, [message.user]);
-                    notify(successMessage ||
-                        t("{{ user }} has been muted", {
-                            user: message.user.name || message.user.id,
-                        }), 'success');
-                    return [3 /*break*/, 4];
-                case 3:
-                    e_1 = _a.sent();
-                    errorMessage = getErrorNotification && validateAndGetMessage(getErrorNotification, [message.user]);
-                    notify(errorMessage || t('Error muting a user ...'), 'error');
-                    return [3 /*break*/, 4];
-                case 4: return [3 /*break*/, 8];
-                case 5:
-                    _a.trys.push([5, 7, , 8]);
-                    return [4 /*yield*/, client.unmuteUser(message.user.id)];
-                case 6:
-                    _a.sent();
-                    fallbackMessage = t("{{ user }} has been unmuted", {
+export const missingUseMuteHandlerParamsWarning = 'useMuteHandler was called but it is missing one or more necessary parameter.';
+export const useMuteHandler = (message, notifications = {}) => {
+    const { mutes } = useChannelStateContext('useMuteHandler');
+    const { client } = useChatContext('useMuteHandler');
+    const { t } = useTranslationContext('useMuteHandler');
+    return async (event) => {
+        event.preventDefault();
+        const { getErrorNotification, getSuccessNotification, notify } = notifications;
+        if (!t || !message?.user || !notify || !client) {
+            console.warn(missingUseMuteHandlerParamsWarning);
+            return;
+        }
+        if (!isUserMuted(message, mutes)) {
+            try {
+                await client.muteUser(message.user.id);
+                const successMessage = getSuccessNotification && validateAndGetMessage(getSuccessNotification, [message.user]);
+                notify(successMessage ||
+                    t(`{{ user }} has been muted`, {
                         user: message.user.name || message.user.id,
-                    });
-                    successMessage = (getSuccessNotification &&
-                        validateAndGetMessage(getSuccessNotification, [message.user])) ||
-                        fallbackMessage;
-                    if (typeof successMessage === 'string') {
-                        notify(successMessage, 'success');
-                    }
-                    return [3 /*break*/, 8];
-                case 7:
-                    e_2 = _a.sent();
-                    errorMessage = (getErrorNotification && validateAndGetMessage(getErrorNotification, [message.user])) ||
-                        t('Error unmuting a user ...');
-                    if (typeof errorMessage === 'string') {
-                        notify(errorMessage, 'error');
-                    }
-                    return [3 /*break*/, 8];
-                case 8: return [2 /*return*/];
+                    }), 'success');
             }
-        });
-    }); };
+            catch (e) {
+                const errorMessage = getErrorNotification && validateAndGetMessage(getErrorNotification, [message.user]);
+                notify(errorMessage || t('Error muting a user ...'), 'error');
+            }
+        }
+        else {
+            try {
+                await client.unmuteUser(message.user.id);
+                const fallbackMessage = t(`{{ user }} has been unmuted`, {
+                    user: message.user.name || message.user.id,
+                });
+                const successMessage = (getSuccessNotification &&
+                    validateAndGetMessage(getSuccessNotification, [message.user])) ||
+                    fallbackMessage;
+                if (typeof successMessage === 'string') {
+                    notify(successMessage, 'success');
+                }
+            }
+            catch (e) {
+                const errorMessage = (getErrorNotification && validateAndGetMessage(getErrorNotification, [message.user])) ||
+                    t('Error unmuting a user ...');
+                if (typeof errorMessage === 'string') {
+                    notify(errorMessage, 'error');
+                }
+            }
+        }
+    };
 };

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

@@ -1,5 +1,4 @@
 import type { ReactEventHandler } from '../types';
 import type { StreamMessage } from '../../../context/ChannelStateContext';
 import type { DefaultStreamChatGenerics } from '../../../types/types';
-export declare const useOpenThreadHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message?: StreamMessage<StreamChatGenerics> | undefined, customOpenThread?: ((message: StreamMessage<StreamChatGenerics>, event: React.BaseSyntheticEvent) => void) | undefined) => ReactEventHandler;
-//# sourceMappingURL=useOpenThreadHandler.d.ts.map
+export declare const useOpenThreadHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message?: StreamMessage<StreamChatGenerics>, customOpenThread?: (message: StreamMessage<StreamChatGenerics>, event: React.BaseSyntheticEvent) => void) => ReactEventHandler;

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

@@ -1,8 +1,8 @@
 import { useChannelActionContext } from '../../../context/ChannelActionContext';
-export var useOpenThreadHandler = function (message, customOpenThread) {
-    var channelOpenThread = useChannelActionContext('useOpenThreadHandler').openThread;
-    var openThread = customOpenThread || channelOpenThread;
-    return function (event) {
+export const useOpenThreadHandler = (message, customOpenThread) => {
+    const { openThread: channelOpenThread } = useChannelActionContext('useOpenThreadHandler');
+    const openThread = customOpenThread || channelOpenThread;
+    return (event) => {
         if (!openThread || !message) {
             console.warn('Open thread handler was called but it is missing one of its parameters');
             return;

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

@@ -27,4 +27,3 @@ export declare const usePinHandler: <StreamChatGenerics extends DefaultStreamCha
     canPin: boolean;
     handlePin: ReactEventHandler;
 };
-//# sourceMappingURL=usePinHandler.d.ts.map

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

@@ -1,65 +1,59 @@
-import { __assign, __awaiter, __generator } from "tslib";
 import { defaultPinPermissions, validateAndGetMessage } from '../utils';
 import { useChannelActionContext } from '../../../context/ChannelActionContext';
 import { useChannelStateContext } from '../../../context/ChannelStateContext';
 import { useChatContext } from '../../../context/ChatContext';
 import { useTranslationContext } from '../../../context/TranslationContext';
-export var usePinHandler = function (message, 
+export const usePinHandler = (message, 
 // @deprecated in favor of `channelCapabilities` - TODO: remove in next major release
-_permissions, // eslint-disable-line
-notifications) {
-    if (_permissions === void 0) { _permissions = defaultPinPermissions; }
-    if (notifications === void 0) { notifications = {}; }
-    var getErrorNotification = notifications.getErrorNotification, notify = notifications.notify;
-    var updateMessage = useChannelActionContext('usePinHandler').updateMessage;
-    var _a = useChannelStateContext('usePinHandler').channelCapabilities, channelCapabilities = _a === void 0 ? {} : _a;
-    var client = useChatContext('usePinHandler').client;
-    var t = useTranslationContext('usePinHandler').t;
-    var canPin = !!channelCapabilities['pin-message'];
-    var handlePin = function (event) { return __awaiter(void 0, void 0, void 0, function () {
-        var optimisticMessage, e_1, errorMessage, optimisticMessage, e_2, errorMessage;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    event.preventDefault();
-                    if (!message)
-                        return [2 /*return*/];
-                    if (!!message.pinned) return [3 /*break*/, 5];
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 4]);
-                    optimisticMessage = __assign(__assign({}, message), { pinned: true, pinned_at: new Date(), pinned_by: client.user });
-                    updateMessage(optimisticMessage);
-                    return [4 /*yield*/, client.pinMessage(message)];
-                case 2:
-                    _a.sent();
-                    return [3 /*break*/, 4];
-                case 3:
-                    e_1 = _a.sent();
-                    errorMessage = getErrorNotification && validateAndGetMessage(getErrorNotification, [message]);
-                    if (notify)
-                        notify(errorMessage || t('Error pinning message'), 'error');
-                    updateMessage(message);
-                    return [3 /*break*/, 4];
-                case 4: return [3 /*break*/, 8];
-                case 5:
-                    _a.trys.push([5, 7, , 8]);
-                    optimisticMessage = __assign(__assign({}, message), { pin_expires: null, pinned: false, pinned_at: null, pinned_by: null });
-                    updateMessage(optimisticMessage);
-                    return [4 /*yield*/, client.unpinMessage(message)];
-                case 6:
-                    _a.sent();
-                    return [3 /*break*/, 8];
-                case 7:
-                    e_2 = _a.sent();
-                    errorMessage = getErrorNotification && validateAndGetMessage(getErrorNotification, [message]);
-                    if (notify)
-                        notify(errorMessage || t('Error removing message pin'), 'error');
-                    updateMessage(message);
-                    return [3 /*break*/, 8];
-                case 8: return [2 /*return*/];
+_permissions = defaultPinPermissions, // eslint-disable-line
+notifications = {}) => {
+    const { getErrorNotification, notify } = notifications;
+    const { updateMessage } = useChannelActionContext('usePinHandler');
+    const { channelCapabilities = {} } = useChannelStateContext('usePinHandler');
+    const { client } = useChatContext('usePinHandler');
+    const { t } = useTranslationContext('usePinHandler');
+    const canPin = !!channelCapabilities['pin-message'];
+    const handlePin = async (event) => {
+        event.preventDefault();
+        if (!message)
+            return;
+        if (!message.pinned) {
+            try {
+                const optimisticMessage = {
+                    ...message,
+                    pinned: true,
+                    pinned_at: new Date(),
+                    pinned_by: client.user,
+                };
+                updateMessage(optimisticMessage);
+                await client.pinMessage(message);
             }
-        });
-    }); };
-    return { canPin: canPin, handlePin: handlePin };
+            catch (e) {
+                const errorMessage = getErrorNotification && validateAndGetMessage(getErrorNotification, [message]);
+                if (notify)
+                    notify(errorMessage || t('Error pinning message'), 'error');
+                updateMessage(message);
+            }
+        }
+        else {
+            try {
+                const optimisticMessage = {
+                    ...message,
+                    pin_expires: null,
+                    pinned: false,
+                    pinned_at: null,
+                    pinned_by: null,
+                };
+                updateMessage(optimisticMessage);
+                await client.unpinMessage(message);
+            }
+            catch (e) {
+                const errorMessage = getErrorNotification && validateAndGetMessage(getErrorNotification, [message]);
+                if (notify)
+                    notify(errorMessage || t('Error removing message pin'), 'error');
+                updateMessage(message);
+            }
+        }
+    };
+    return { canPin, handlePin };
 };

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

@@ -3,10 +3,9 @@ import { StreamMessage } from '../../../context/ChannelStateContext';
 import type { ReactEventHandler } from '../types';
 import type { DefaultStreamChatGenerics } from '../../../types/types';
 export declare const 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 declare const useReactionHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message?: StreamMessage<StreamChatGenerics> | undefined) => (reactionType: string, event?: React.BaseSyntheticEvent) => Promise<void>;
-export declare const useReactionClick: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message?: StreamMessage<StreamChatGenerics> | undefined, reactionSelectorRef?: RefObject<HTMLDivElement | null>, messageWrapperRef?: RefObject<HTMLDivElement | null>, closeReactionSelectorOnClick?: boolean) => {
+export declare const useReactionHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message?: StreamMessage<StreamChatGenerics>) => (reactionType: string, event?: React.BaseSyntheticEvent) => Promise<void>;
+export declare const useReactionClick: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(message?: StreamMessage<StreamChatGenerics>, reactionSelectorRef?: RefObject<HTMLDivElement | null>, messageWrapperRef?: RefObject<HTMLDivElement | null>, closeReactionSelectorOnClick?: boolean) => {
     isReactionEnabled: boolean;
     onReactionListClick: ReactEventHandler;
     showDetailedReactions: boolean;
 };
-//# sourceMappingURL=useReactionHandler.d.ts.map