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

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

@@ -1,16 +0,0 @@
-export * from './useActionHandler';
-export * from './useDeleteHandler';
-export * from './useEditHandler';
-export * from './useFlagHandler';
-export * from './useMentionsHandler';
-export * from './useMarkUnreadHandler';
-export * from './useMuteHandler';
-export * from './useOpenThreadHandler';
-export * from './usePinHandler';
-export * from './useReactionHandler';
-export * from './useRetryHandler';
-export * from './useUserHandler';
-export * from './useUserRole';
-export * from './useReactionsFetcher';
-export * from './useMessageTextStreaming';
-export * from './useMessageReminder';

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

@@ -1,6 +0,0 @@
-import type React from 'react';
-import type { LocalMessage } from 'stream-chat';
-export type FormData = Record<string, string>;
-export type ActionHandlerReturnType = (dataOrName?: string | FormData, value?: string, event?: React.BaseSyntheticEvent) => Promise<void> | void;
-export declare const handleActionWarning = "Action 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 function useActionHandler(message?: LocalMessage): ActionHandlerReturnType;

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

@@ -1,35 +0,0 @@
-import { useChannelActionContext } from '../../../context/ChannelActionContext';
-import { useChannelStateContext } from '../../../context/ChannelStateContext';
-import { useStableCallback } from '../../../utils/useStableCallback';
-export const handleActionWarning = `Action 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 function useActionHandler(message) {
-    const { removeMessage, updateMessage } = useChannelActionContext('useActionHandler');
-    const { channel } = useChannelStateContext('useActionHandler');
-    return useStableCallback(async (dataOrName, value, event) => {
-        if (event)
-            event.preventDefault();
-        if (!message || !updateMessage || !removeMessage || !channel) {
-            console.warn(handleActionWarning);
-            return;
-        }
-        const messageId = message.id;
-        let formData = {};
-        // deprecated: value&name should be removed in favor of data obj
-        if (typeof dataOrName === 'string') {
-            formData[dataOrName] = value;
-        }
-        else {
-            formData = { ...dataOrName };
-        }
-        if (messageId) {
-            const data = await channel.sendAction(messageId, formData);
-            if (data?.message) {
-                updateMessage(data.message);
-            }
-            else {
-                removeMessage(message);
-            }
-        }
-    });
-}

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

@@ -1,7 +0,0 @@
-import type { LocalMessage } from 'stream-chat';
-import type { ReactEventHandler } from '../types';
-export type DeleteMessageNotifications = {
-    getErrorNotification?: (message: LocalMessage) => string;
-    notify?: (notificationText: string, type: 'success' | 'error') => void;
-};
-export declare const useDeleteHandler: (message?: LocalMessage, notifications?: DeleteMessageNotifications) => ReactEventHandler;

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

@@ -1,25 +0,0 @@
-import { validateAndGetMessage } from '../utils';
-import { useChannelActionContext } from '../../../context/ChannelActionContext';
-import { useChatContext } from '../../../context/ChatContext';
-import { useTranslationContext } from '../../../context/TranslationContext';
-export const useDeleteHandler = (message, notifications = {}) => {
-    const { getErrorNotification, notify } = notifications;
-    const { deleteMessage, updateMessage } = useChannelActionContext('useDeleteHandler');
-    const { client } = useChatContext('useDeleteHandler');
-    const { t } = useTranslationContext('useDeleteHandler');
-    return async (event, options) => {
-        event.preventDefault();
-        if (!message?.id || !client || !updateMessage) {
-            return;
-        }
-        try {
-            const deletedMessage = await deleteMessage(message, options);
-            updateMessage(deletedMessage);
-        }
-        catch (e) {
-            const errorMessage = getErrorNotification && validateAndGetMessage(getErrorNotification, [message]);
-            if (notify)
-                notify(errorMessage || t('Error deleting message'), 'error');
-        }
-    };
-};

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

@@ -1,8 +0,0 @@
-/// <reference types="react" />
-import type { ReactEventHandler } from '../types';
-export type EditHandlerReturnType = {
-    clearEdit: (event?: React.BaseSyntheticEvent) => void;
-    editing: boolean;
-    setEdit: ReactEventHandler;
-};
-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,19 +0,0 @@
-import { useState } from 'react';
-export const useEditHandler = (customInitialState = false, customSetEditing, customClearEditingHandler) => {
-    const [editing, setEditing] = useState(customInitialState);
-    const setEdit = customSetEditing ||
-        ((event) => {
-            if (event?.preventDefault) {
-                event.preventDefault();
-            }
-            setEditing(true);
-        });
-    const clearEdit = customClearEditingHandler ||
-        ((event) => {
-            if (event?.preventDefault) {
-                event.preventDefault();
-            }
-            setEditing(false);
-        });
-    return { clearEdit, editing, setEdit };
-};

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

@@ -1,9 +0,0 @@
-import type { LocalMessage } from 'stream-chat';
-import type { ReactEventHandler } from '../types';
-export declare const missingUseFlagHandlerParameterWarning = "useFlagHandler was called but it is missing one or more necessary parameters.";
-export type FlagMessageNotifications = {
-    getErrorNotification?: (message: LocalMessage) => string;
-    getSuccessNotification?: (message: LocalMessage) => string;
-    notify?: (notificationText: string, type: 'success' | 'error') => void;
-};
-export declare const useFlagHandler: (message?: LocalMessage, notifications?: FlagMessageNotifications) => ReactEventHandler;

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

@@ -1,29 +0,0 @@
-import { validateAndGetMessage } from '../utils';
-import { useChatContext } from '../../../context/ChatContext';
-import { useTranslationContext } from '../../../context/TranslationContext';
-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

@@ -1,8 +0,0 @@
-import type { LocalMessage } from 'stream-chat';
-import type { ReactEventHandler } from '../types';
-export type MarkUnreadHandlerNotifications = {
-    getErrorNotification?: (message: LocalMessage) => string;
-    getSuccessNotification?: (message: LocalMessage) => string;
-    notify?: (notificationText: string, type: 'success' | 'error') => void;
-};
-export declare const useMarkUnreadHandler: (message?: LocalMessage, notifications?: MarkUnreadHandlerNotifications) => ReactEventHandler;

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

@@ -1,32 +0,0 @@
-import { validateAndGetMessage } from '../utils';
-import { useChannelStateContext, useTranslationContext } from '../../../context';
-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

@@ -1,12 +0,0 @@
-import type React from 'react';
-import type { LocalMessage, UserResponse } from 'stream-chat';
-import type { ReactEventHandler } from '../types';
-export type CustomMentionHandler = (event: React.BaseSyntheticEvent, mentioned_users: UserResponse[]) => void;
-export type MentionedUserEventHandler = (event: React.BaseSyntheticEvent, mentionedUsers: UserResponse[]) => void;
-export declare const useMentionsHandler: (message?: LocalMessage, customMentionHandler?: {
-    onMentionsClick?: CustomMentionHandler;
-    onMentionsHover?: CustomMentionHandler;
-}) => {
-    onMentionsClick: ReactEventHandler;
-    onMentionsHover: ReactEventHandler;
-};

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

@@ -1,18 +0,0 @@
-import { useChannelActionContext } from '../../../context/ChannelActionContext';
-function createEventHandler(fn, message) {
-    return (event) => {
-        if (typeof fn !== 'function' || !message?.mentioned_users?.length) {
-            return;
-        }
-        fn(event, message.mentioned_users);
-    };
-}
-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/useMessageReminder.d.ts

@@ -1 +0,0 @@
-export declare const useMessageReminder: (messageId: string) => import("stream-chat").Reminder | undefined;

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

@@ -1,11 +0,0 @@
-import { useCallback } from 'react';
-import { useChatContext } from '../../../context';
-import { useStateStore } from '../../../store';
-export const useMessageReminder = (messageId) => {
-    const { client } = useChatContext();
-    const reminderSelector = useCallback((state) => ({
-        reminder: state.reminders.get(messageId),
-    }), [messageId]);
-    const { reminder } = useStateStore(client.reminders.state, reminderSelector);
-    return reminder;
-};

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

@@ -1,16 +0,0 @@
-import type { StreamedMessageTextProps } from '../StreamedMessageText';
-export type UseMessageTextStreamingProps = Pick<StreamedMessageTextProps, 'streamingLetterIntervalMs' | 'renderingLetterCount'> & {
-    text: string;
-};
-/**
- * A hook that returns text in a streamed, typewriter fashion. The speed of streaming is
- * configurable.
- * @param {number} [streamingLetterIntervalMs=30] - The timeout between each typing animation in milliseconds.
- * @param {number} [renderingLetterCount=2] - The number of letters to be rendered each time we update.
- * @param {string} text - The text that we want to render in a typewriter fashion.
- * @returns {{ streamedMessageText: string }} - A substring of the text property, up until we've finished rendering the typewriter animation.
- */
-export declare const useMessageTextStreaming: ({ renderingLetterCount, streamingLetterIntervalMs, text, }: UseMessageTextStreamingProps) => {
-    readonly skipAnimation: import("../../../utils/useStableCallback").StableCallback<[], void>;
-    readonly streamedMessageText: string;
-};

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

@@ -1,37 +0,0 @@
-import { useEffect, useRef, useState } from 'react';
-import { useStableCallback } from '../../../utils/useStableCallback';
-const DEFAULT_LETTER_INTERVAL = 30;
-const DEFAULT_RENDERING_LETTER_COUNT = 2;
-/**
- * A hook that returns text in a streamed, typewriter fashion. The speed of streaming is
- * configurable.
- * @param {number} [streamingLetterIntervalMs=30] - The timeout between each typing animation in milliseconds.
- * @param {number} [renderingLetterCount=2] - The number of letters to be rendered each time we update.
- * @param {string} text - The text that we want to render in a typewriter fashion.
- * @returns {{ streamedMessageText: string }} - A substring of the text property, up until we've finished rendering the typewriter animation.
- */
-export const useMessageTextStreaming = ({ renderingLetterCount = DEFAULT_RENDERING_LETTER_COUNT, streamingLetterIntervalMs = DEFAULT_LETTER_INTERVAL, text, }) => {
-    const [streamedMessageText, setStreamedMessageText] = useState(text);
-    const textCursor = useRef(text.length);
-    useEffect(() => {
-        const textLength = text.length;
-        const interval = setInterval(() => {
-            if (!text || textCursor.current >= textLength) {
-                clearInterval(interval);
-                return;
-            }
-            const newCursorValue = textCursor.current + renderingLetterCount;
-            const newText = text.substring(0, newCursorValue);
-            textCursor.current += newText.length - textCursor.current;
-            setStreamedMessageText(newText);
-        }, streamingLetterIntervalMs);
-        return () => {
-            clearInterval(interval);
-        };
-    }, [streamingLetterIntervalMs, renderingLetterCount, text]);
-    const skipAnimation = useStableCallback(() => {
-        textCursor.current = text.length;
-        setStreamedMessageText(text);
-    });
-    return { skipAnimation, streamedMessageText };
-};

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

@@ -1,9 +0,0 @@
-import type { LocalMessage, UserResponse } from 'stream-chat';
-import type { ReactEventHandler } from '../types';
-export declare const missingUseMuteHandlerParamsWarning = "useMuteHandler was called but it is missing one or more necessary parameter.";
-export type MuteUserNotifications = {
-    getErrorNotification?: (user: UserResponse) => string;
-    getSuccessNotification?: (user: UserResponse) => string;
-    notify?: (notificationText: string, type: 'success' | 'error') => void;
-};
-export declare const useMuteHandler: (message?: LocalMessage, notifications?: MuteUserNotifications) => ReactEventHandler;

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

@@ -1,56 +0,0 @@
-import { isUserMuted, validateAndGetMessage } from '../utils';
-import { useChannelStateContext } from '../../../context/ChannelStateContext';
-import { useChatContext } from '../../../context/ChatContext';
-import { useTranslationContext } from '../../../context/TranslationContext';
-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,
-                    }), '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,3 +0,0 @@
-import type { LocalMessage } from 'stream-chat';
-import type { ReactEventHandler } from '../types';
-export declare const useOpenThreadHandler: (message?: LocalMessage, customOpenThread?: (message: LocalMessage, event: React.BaseSyntheticEvent) => void) => ReactEventHandler;

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

@@ -1,12 +0,0 @@
-import { useChannelActionContext } from '../../../context/ChannelActionContext';
-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;
-        }
-        openThread(message, event);
-    };
-};

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

@@ -1,28 +0,0 @@
-import type { LocalMessage } from 'stream-chat';
-import type { ReactEventHandler } from '../types';
-export type PinEnabledUserRoles<T extends string = string> = Partial<Record<T, boolean>> & {
-    admin?: boolean;
-    anonymous?: boolean;
-    channel_member?: boolean;
-    channel_moderator?: boolean;
-    guest?: boolean;
-    member?: boolean;
-    moderator?: boolean;
-    owner?: boolean;
-    user?: boolean;
-};
-export type PinPermissions<T extends string = string, U extends string = string> = Partial<Record<T, PinEnabledUserRoles<U>>> & {
-    commerce?: PinEnabledUserRoles<U>;
-    gaming?: PinEnabledUserRoles<U>;
-    livestream?: PinEnabledUserRoles<U>;
-    messaging?: PinEnabledUserRoles<U>;
-    team?: PinEnabledUserRoles<U>;
-};
-export type PinMessageNotifications = {
-    getErrorNotification?: (message: LocalMessage) => string;
-    notify?: (notificationText: string, type: 'success' | 'error') => void;
-};
-export declare const usePinHandler: (message: LocalMessage, _permissions?: PinPermissions, notifications?: PinMessageNotifications) => {
-    canPin: boolean;
-    handlePin: ReactEventHandler;
-};

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

@@ -1,59 +0,0 @@
-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 const usePinHandler = (message, 
-// @deprecated in favor of `channelCapabilities` - TODO: remove in next major release
-_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);
-            }
-            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

@@ -1,4 +0,0 @@
-import type React from 'react';
-import type { LocalMessage } from 'stream-chat';
-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: (message?: LocalMessage) => (reactionType: string, event?: React.BaseSyntheticEvent) => Promise<void>;

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

@@ -1,119 +0,0 @@
-import { useCallback } from 'react';
-import throttle from 'lodash.throttle';
-import { useThreadContext } from '../../Threads';
-import { useChannelActionContext } from '../../../context/ChannelActionContext';
-import { useChannelStateContext } from '../../../context/ChannelStateContext';
-import { useChatContext } from '../../../context/ChatContext';
-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 thread = useThreadContext();
-    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) {
-            const timestamp = new Date().toISOString();
-            newReactionGroups[reactionType] = hasReaction
-                ? {
-                    ...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] = {
-                    ...newReactionGroups[reactionType],
-                    count: newReactionGroups[reactionType].count - 1,
-                };
-            }
-            else {
-                delete newReactionGroups[reactionType];
-            }
-        }
-        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]);
-    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);
-            thread?.upsertReplyLocally({ message: tempMessage });
-            const messageResponse = add
-                ? await channel.sendReaction(id, { type })
-                : await channel.deleteReaction(id, type);
-            // seems useless as we're expecting WS event to come in and replace this anyway
-            updateMessage(messageResponse.message);
-        }
-        catch (error) {
-            // revert to the original message if the API call fails
-            updateMessage(message);
-            thread?.upsertReplyLocally({ 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);
-            }
-            else {
-                await toggleReaction(message.id, reactionType, true);
-            }
-        }
-        catch (error) {
-            console.log({ error });
-        }
-    };
-};

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

@@ -1,9 +0,0 @@
-import type { LocalMessage, ReactionResponse, ReactionSort } from 'stream-chat';
-import type { ReactionType } from '../../Reactions/types';
-export declare const MAX_MESSAGE_REACTIONS_TO_FETCH = 1000;
-type FetchMessageReactionsNotifications = {
-    getErrorNotification?: (message: LocalMessage) => string;
-    notify?: (notificationText: string, type: 'success' | 'error') => void;
-};
-export declare function useReactionsFetcher(message: LocalMessage, notifications?: FetchMessageReactionsNotifications): (reactionType?: ReactionType, sort?: ReactionSort) => Promise<ReactionResponse[]>;
-export {};