@sendbird/uikit-react 3.8.0 → 3.8.2

package/chunks/{bundle-LUte5Kb5.js → bundle-BgGUA_Do.js}

@@ -1,22 +1,22 @@
 import React__default, { useEffect, useState, useCallback, useRef, useReducer, useMemo } from 'react';
-import { U as UserProfileProvider } from './bundle-ubky9D9H.js';
+import { U as UserProfileProvider } from './bundle-5WxplyP9.js';
 import { useSendbirdStateContext } from '../useSendbirdStateContext.js';
-import { P as PREV_RESULT_SIZE, N as NEXT_RESULT_SIZE, T as ThreadReplySelectType } from './bundle-AI8e02c3.js';
-import { m as mergeAndSortMessages, p as passUnsuccessfullMessages, s as scrollIntoLast, f as pxToNumber, a as scrollToRenderedMessage, g as getAllEmojisMapFromEmojiContainer, h as getNicknamesMapFromMembers } from './bundle-ZmvX8uZ5.js';
-import { _ as __assign, a as __spreadArray } from './bundle-hKtwSqbO.js';
-import { f as format } from './bundle-h3JIYRTG.js';
+import { P as PREV_RESULT_SIZE, N as NEXT_RESULT_SIZE, T as ThreadReplySelectType } from './bundle-sTNKynXj.js';
+import { m as mergeAndSortMessages, p as passUnsuccessfullMessages, s as scrollIntoLast, a as scrollToRenderedMessage, g as getAllEmojisMapFromEmojiContainer, f as getNicknamesMapFromMembers } from './bundle-EoW7JC-6.js';
+import { _ as __assign, a as __spreadArray } from './bundle-HUCZoqot.js';
+import { f as format } from './bundle-o_MR5zP9.js';
 import { SendingStatus, ReplyType, MessageMetaArray } from '@sendbird/chat/message';
-import { K, S } from './bundle-9KsbryQI.js';
-import { R as RESET_MESSAGES, F as FETCH_INITIAL_MESSAGES_START, a as FETCH_INITIAL_MESSAGES_SUCCESS, c as FETCH_PREV_MESSAGES_SUCCESS, d as FETCH_NEXT_MESSAGES_SUCCESS, b as FETCH_INITIAL_MESSAGES_FAILURE, e as FETCH_PREV_MESSAGES_FAILURE, f as FETCH_NEXT_MESSAGES_FAILURE, S as SEND_MESSAGE_START, g as SEND_MESSAGE_SUCCESS, h as SEND_MESSAGE_FAILURE, i as SET_CURRENT_CHANNEL, j as SET_CHANNEL_INVALID, O as ON_MESSAGE_RECEIVED, k as ON_MESSAGE_UPDATED, l as ON_MESSAGE_THREAD_INFO_UPDATED, m as RESEND_MESSAGE_START, n as MARK_AS_READ, o as ON_MESSAGE_DELETED, p as ON_MESSAGE_DELETED_BY_REQ_ID, q as SET_EMOJI_CONTAINER, r as ON_REACTION_UPDATED, M as MESSAGE_LIST_PARAMS_CHANGED, s as ON_FILE_INFO_UPLOADED, t as channelActions } from './bundle-qst5L6aH.js';
-import { c as compareIds } from './bundle-_qiqf8_l.js';
-import { e as isSendableMessage, W as filterMessageListParams } from './bundle-EHReigfD.js';
+import { K, S } from './bundle-qReOreYH.js';
+import { R as RESET_MESSAGES, F as FETCH_INITIAL_MESSAGES_START, a as FETCH_INITIAL_MESSAGES_SUCCESS, c as FETCH_PREV_MESSAGES_SUCCESS, d as FETCH_NEXT_MESSAGES_SUCCESS, b as FETCH_INITIAL_MESSAGES_FAILURE, e as FETCH_PREV_MESSAGES_FAILURE, f as FETCH_NEXT_MESSAGES_FAILURE, S as SEND_MESSAGE_START, g as SEND_MESSAGE_SUCCESS, h as SEND_MESSAGE_FAILURE, i as SET_CURRENT_CHANNEL, j as SET_CHANNEL_INVALID, O as ON_MESSAGE_RECEIVED, k as ON_MESSAGE_UPDATED, l as ON_MESSAGE_THREAD_INFO_UPDATED, m as RESEND_MESSAGE_START, n as MARK_AS_READ, o as ON_MESSAGE_DELETED, p as ON_MESSAGE_DELETED_BY_REQ_ID, q as SET_EMOJI_CONTAINER, r as ON_REACTION_UPDATED, M as MESSAGE_LIST_PARAMS_CHANGED, s as ON_FILE_INFO_UPLOADED, t as ON_TYPING_STATUS_UPDATED, u as channelActions } from './bundle-GaBLtZQZ.js';
+import { c as compareIds } from './bundle-L1jL1HlF.js';
+import { N as isSendableMessage, W as filterMessageListParams } from './bundle-UW-TqfsF.js';
 import { GroupChannelHandler } from '@sendbird/chat/groupChannel';
-import { u as uuidv4 } from './bundle-bofQNMJb.js';
+import { u as uuidv4 } from './bundle-LutukB6f.js';
 import useInitialMessagesFetch from '../Channel/hooks/useInitialMessagesFetch.js';
-import { PUBSUB_TOPICS } from '../pubSub/topics.js';
-import { P as PublishingModuleType, u as useSendMultipleFilesMessage } from './bundle-TZXZa-F1.js';
-import { a as VOICE_MESSAGE_FILE_NAME, b as VOICE_MESSAGE_MIME_TYPE, M as META_ARRAY_VOICE_DURATION_KEY, i as META_ARRAY_MESSAGE_TYPE_KEY, j as META_ARRAY_MESSAGE_TYPE_VALUE__VOICE } from './bundle-WCTKBopn.js';
-import { g as getCaseResolvedThreadReplySelectType } from './bundle-5iuNyt5M.js';
+import { p as pubSubTopics, P as PublishingModuleType, b as PUBSUB_TOPICS, s as shouldPubSubPublishToChannel } from './bundle-Ey2KFn-R.js';
+import { a as VOICE_MESSAGE_FILE_NAME, b as VOICE_MESSAGE_MIME_TYPE, M as META_ARRAY_VOICE_DURATION_KEY, i as META_ARRAY_MESSAGE_TYPE_KEY, j as META_ARRAY_MESSAGE_TYPE_VALUE__VOICE } from './bundle-fRhlDZge.js';
+import { g as getCaseResolvedThreadReplySelectType } from './bundle-j2oaAFR4.js';
+import { u as useSendMultipleFilesMessage } from './bundle-n3JTobCF.js';
 
 /**
  * This function helps consider the every condition
@@ -56,6 +56,7 @@ var initialState = {
     isInvalid: false,
     readStatus: null,
     messageListParams: null,
+    typingMembers: [],
 };
 
 var getOldestMessageTimeStamp = function (messages) {
@@ -303,6 +304,14 @@ function channelReducer(state, action) {
             fileInfoList[index] = uploadableFileInfo;
         }
         return __assign(__assign({}, state), { localMessages: localMessages });
+    })
+        .with({ type: ON_TYPING_STATUS_UPDATED }, function (action) {
+        var _a;
+        var _b = action.payload, channel = _b.channel, typingMembers = _b.typingMembers;
+        if (!compareIds(channel.url, (_a = state === null || state === void 0 ? void 0 : state.currentGroupChannel) === null || _a === void 0 ? void 0 : _a.url)) {
+            return state;
+        }
+        return __assign(__assign({}, state), { typingMembers: typingMembers });
     })
         .otherwise(function () { return state; });
 }
@@ -486,6 +495,19 @@ function useHandleChannelEvents(_a, _b) {
                         }
                     }
                 },
+                onTypingStatusUpdated: function (channel) {
+                    if (compareIds(channel === null || channel === void 0 ? void 0 : channel.url, channelUrl)) {
+                        logger.info('Channel | onTypingStatusUpdated', { channel: channel });
+                        var typingMembers = channel.getTypingUsers();
+                        messagesDispatcher({
+                            type: ON_TYPING_STATUS_UPDATED,
+                            payload: {
+                                channel: channel,
+                                typingMembers: typingMembers,
+                            },
+                        });
+                    }
+                },
             };
             logger.info('Channel | useHandleChannelEvents: Setup event handler', { channelHandlerId: channelHandlerId, channelHandler: channelHandler });
             // Add this group channel handler to the Sendbird chat instance
@@ -794,7 +816,7 @@ function useUpdateMessageCallback(_a, _b) {
                     message: msg,
                 },
             });
-            pubSub.publish(PUBSUB_TOPICS.UPDATE_USER_MESSAGE, {
+            pubSub.publish(pubSubTopics.UPDATE_USER_MESSAGE, {
                 message: msg,
                 channel: currentGroupChannel,
                 publishingModules: [PublishingModuleType.CHANNEL],
@@ -933,7 +955,7 @@ function useSendMessageCallback(_a, _b) {
         currentGroupChannel
             .sendUserMessage(params)
             .onPending(function (pendingMsg) {
-            pubSub.publish(PUBSUB_TOPICS.SEND_MESSAGE_START, {
+            pubSub.publish(pubSubTopics.SEND_MESSAGE_START, {
                 /* pubSub is used instead of messagesDispatcher
                   to avoid redundantly calling `messageActionTypes.SEND_MESSAGE_START` */
                 message: pendingMsg,
@@ -963,152 +985,56 @@ function useSendMessageCallback(_a, _b) {
 function useSendFileMessageCallback(_a, _b) {
     var currentGroupChannel = _a.currentGroupChannel, onBeforeSendFileMessage = _a.onBeforeSendFileMessage, imageCompression = _a.imageCompression;
     var logger = _b.logger, pubSub = _b.pubSub, scrollRef = _b.scrollRef, messagesDispatcher = _b.messagesDispatcher;
-    var sendMessage = useCallback(function (file, quoteMessage) {
+    var sendMessage = useCallback(function (compressedFile, quoteMessage) {
         if (quoteMessage === void 0) { quoteMessage = null; }
         return new Promise(function (resolve, reject) {
-            var _a = imageCompression !== null && imageCompression !== void 0 ? imageCompression : {}, compressionRate = _a.compressionRate, resizingWidth = _a.resizingWidth, resizingHeight = _a.resizingHeight;
-            var shouldCreateCustomParams = onBeforeSendFileMessage && typeof onBeforeSendFileMessage === 'function';
-            var compressibleFileType = file.type === 'image/jpg' || file.type === 'image/png' || file.type === 'image/jpeg';
-            var compressibleRatio = compressionRate > 0 && compressionRate < 1;
-            // pxToNumber returns null if values are invalid
-            var compressibleDiamensions = pxToNumber(resizingWidth) || pxToNumber(resizingHeight);
-            var canCompressImage = compressibleFileType && (compressibleRatio || compressibleDiamensions);
-            var createParamsDefault = function (fileToSend) {
-                var params = {
-                    file: fileToSend,
-                };
+            // Create FileMessageParams
+            var params = onBeforeSendFileMessage === null || onBeforeSendFileMessage === void 0 ? void 0 : onBeforeSendFileMessage(compressedFile, quoteMessage);
+            if (!params) {
+                params = { file: compressedFile };
                 if (quoteMessage) {
                     params.isReplyToChannel = true;
                     params.parentMessageId = quoteMessage.messageId;
                 }
-                return params;
-            };
-            if (canCompressImage) {
-                // Using image compression
-                try {
-                    // TODO: Extract image compression logic to utils.
-                    var image_1 = document.createElement('img');
-                    image_1.src = URL.createObjectURL(file);
-                    image_1.onload = function () {
-                        URL.revokeObjectURL(image_1.src);
-                        var canvas = document.createElement('canvas');
-                        var imageWdith = image_1.naturalWidth || image_1.width;
-                        var imageHeight = image_1.naturalHeight || image_1.height;
-                        var targetWidth = pxToNumber(resizingWidth) || imageWdith;
-                        var targetHeight = pxToNumber(resizingHeight) || imageHeight;
-                        // In canvas.toBlob(callback, mimeType, qualityArgument)
-                        // qualityArgument doesnt work
-                        // so in case compressibleDiamensions are not present, we use ratio
-                        if (file.type === 'image/png' && !compressibleDiamensions) {
-                            targetWidth *= compressionRate;
-                            targetHeight *= compressionRate;
-                        }
-                        canvas.width = targetWidth;
-                        canvas.height = targetHeight;
-                        var context = canvas.getContext('2d');
-                        context.drawImage(image_1, 0, 0, targetWidth, targetHeight);
-                        context.canvas.toBlob(function (newImageBlob) {
-                            var compressedFile = new File([newImageBlob], file.name, { type: file.type });
-                            if (shouldCreateCustomParams) {
-                                logger.info('Channel: Creating params using onBeforeSendFileMessage', onBeforeSendFileMessage);
-                            }
-                            var params = shouldCreateCustomParams
-                                ? onBeforeSendFileMessage(compressedFile, quoteMessage)
-                                : createParamsDefault(compressedFile);
-                            logger.info('Channel: Uploading file message start!', params);
-                            currentGroupChannel
-                                .sendFileMessage(params)
-                                .onPending(function (pendingMessage) {
-                                pubSub.publish(PUBSUB_TOPICS.SEND_MESSAGE_START, {
-                                    /* pubSub is used instead of messagesDispatcher
-                                      to avoid redundantly calling `messageActionTypes.SEND_MESSAGE_START` */
-                                    message: __assign(__assign({}, pendingMessage), { url: URL.createObjectURL(compressedFile), 
-                                        // pending thumbnail message seems to be failed
-                                        requestState: 'pending' }),
-                                    channel: currentGroupChannel,
-                                    publishingModules: [PublishingModuleType.CHANNEL],
-                                });
-                                setTimeout(function () { return scrollIntoLast(0, scrollRef); }, 1000);
-                            })
-                                .onFailed(function (err, failedMessage) {
-                                logger.error('Channel: Sending file message failed!', { failedMessage: failedMessage, err: err });
-                                // TODO: v4 - remove logic that modifies the original object.
-                                //  It makes the code difficult to track, likely causing unpredictable side effects.
-                                // @ts-ignore eslint-disable-next-line no-param-reassign
-                                failedMessage.localUrl = URL.createObjectURL(compressedFile);
-                                // @ts-ignore eslint-disable-next-line no-param-reassign
-                                failedMessage.file = compressedFile;
-                                messagesDispatcher({
-                                    type: SEND_MESSAGE_FAILURE,
-                                    payload: failedMessage,
-                                });
-                                reject(err);
-                            })
-                                .onSucceeded(function (succeededMessage) {
-                                logger.info('Channel: Sending file message success!', succeededMessage);
-                                messagesDispatcher({
-                                    type: SEND_MESSAGE_SUCCESS,
-                                    payload: succeededMessage,
-                                });
-                                resolve(succeededMessage);
-                            });
-                        }, file.type, compressionRate);
-                    };
-                }
-                catch (error) {
-                    logger.error('Channel: Sending file message failed!', error);
-                    reject(error);
-                }
             }
-            else {
-                // Not using image compression
-                if (shouldCreateCustomParams) {
-                    logger.info('Channel: creating params using onBeforeSendFileMessage', onBeforeSendFileMessage);
-                }
-                var params = onBeforeSendFileMessage
-                    ? onBeforeSendFileMessage(file, quoteMessage)
-                    : createParamsDefault(file);
-                logger.info('Channel: Uploading file message start!', params);
-                currentGroupChannel
-                    .sendFileMessage(params)
-                    .onPending(function (pendingMsg) {
-                    pubSub.publish(PUBSUB_TOPICS.SEND_MESSAGE_START, {
-                        /* pubSub is used instead of messagesDispatcher
-                          to avoid redundantly calling `messageActionTypes.SEND_MESSAGE_START` */
-                        message: __assign(__assign({}, pendingMsg), { 
-                            // TODO: v4 - remove logic that modifies the original object.
-                            //  It makes the code difficult to track, likely causing unpredictable side effects.
-                            url: URL.createObjectURL(file), 
-                            // pending thumbnail message seems to be failed
-                            requestState: 'pending' }),
-                        channel: currentGroupChannel,
-                        publishingModules: [PublishingModuleType.CHANNEL],
-                    });
-                    setTimeout(function () { return scrollIntoLast(0, scrollRef); }, 1000);
-                })
-                    .onFailed(function (error, message) {
-                    logger.error('Channel: Sending file message failed!', { message: message, error: error });
-                    // TODO: v4 - remove logic that modifies the original object.
-                    //  It makes the code difficult to track, likely causing unpredictable side effects.
-                    // @ts-ignore eslint-disable-next-line no-param-reassign
-                    message.localUrl = URL.createObjectURL(file);
-                    // @ts-ignore eslint-disable-next-line no-param-reassign
-                    message.file = file;
-                    messagesDispatcher({
-                        type: SEND_MESSAGE_FAILURE,
-                        payload: message,
-                    });
-                    reject(error);
-                })
-                    .onSucceeded(function (message) {
-                    logger.info('Channel: Sending message success!', message);
-                    messagesDispatcher({
-                        type: SEND_MESSAGE_SUCCESS,
-                        payload: message,
-                    });
-                    resolve(message);
+            // Send FileMessage
+            logger.info('Channel: Uploading file message start!', params);
+            currentGroupChannel
+                .sendFileMessage(params)
+                .onPending(function (pendingMessage) {
+                pubSub.publish(pubSubTopics.SEND_MESSAGE_START, {
+                    /* pubSub is used instead of messagesDispatcher
+                      to avoid redundantly calling `messageActionTypes.SEND_MESSAGE_START` */
+                    message: __assign(__assign({}, pendingMessage), { url: URL.createObjectURL(compressedFile), 
+                        // pending thumbnail message seems to be failed
+                        requestState: 'pending' }),
+                    channel: currentGroupChannel,
+                    publishingModules: [PublishingModuleType.CHANNEL],
                 });
-            }
+                setTimeout(function () { return scrollIntoLast(0, scrollRef); }, 1000);
+            })
+                .onFailed(function (err, failedMessage) {
+                logger.error('Channel: Sending file message failed!', { failedMessage: failedMessage, err: err });
+                // TODO: v4 - remove logic that modifies the original object.
+                //  It makes the code difficult to track, likely causing unpredictable side effects.
+                // @ts-ignore eslint-disable-next-line no-param-reassign
+                failedMessage.localUrl = URL.createObjectURL(compressedFile);
+                // @ts-ignore eslint-disable-next-line no-param-reassign
+                failedMessage.file = compressedFile;
+                messagesDispatcher({
+                    type: SEND_MESSAGE_FAILURE,
+                    payload: failedMessage,
+                });
+                reject(err);
+            })
+                .onSucceeded(function (succeededMessage) {
+                logger.info('Channel: Sending file message success!', succeededMessage);
+                messagesDispatcher({
+                    type: SEND_MESSAGE_SUCCESS,
+                    payload: succeededMessage,
+                });
+                resolve(succeededMessage);
+            });
         });
     }, [currentGroupChannel, onBeforeSendFileMessage, imageCompression]);
     return [sendMessage];
@@ -1224,7 +1150,7 @@ var useSendVoiceMessageCallback = function (_a, _b) {
         logger.info('Channel: Start sending voice message', messageParams);
         currentGroupChannel.sendFileMessage(messageParams)
             .onPending(function (pendingMessage) {
-            pubSub.publish(PUBSUB_TOPICS.SEND_MESSAGE_START, {
+            pubSub.publish(pubSubTopics.SEND_MESSAGE_START, {
                 /* pubSub is used instead of messagesDispatcher
                   to avoid redundantly calling `messageActionTypes.SEND_MESSAGE_START` */
                 message: pendingMessage,
@@ -1270,9 +1196,8 @@ var useHandleChannelPubsubEvents = function (_a) {
                 }
             }));
             subscriber.set(PUBSUB_TOPICS.SEND_MESSAGE_START, pubSub.subscribe(PUBSUB_TOPICS.SEND_MESSAGE_START, function (props) {
-                var _a = props, channel = _a.channel, message = _a.message, publishingModules = _a.publishingModules;
-                if (channelUrl === (channel === null || channel === void 0 ? void 0 : channel.url)
-                    && publishingModules.includes(PublishingModuleType.CHANNEL)) {
+                var channel = props.channel, message = props.message, publishingModules = props.publishingModules;
+                if (channelUrl === (channel === null || channel === void 0 ? void 0 : channel.url) && shouldPubSubPublishToChannel(publishingModules)) {
                     dispatcher({
                         type: SEND_MESSAGE_START,
                         payload: message,
@@ -1280,8 +1205,8 @@ var useHandleChannelPubsubEvents = function (_a) {
                 }
             }));
             subscriber.set(PUBSUB_TOPICS.ON_FILE_INFO_UPLOADED, pubSub.subscribe(PUBSUB_TOPICS.ON_FILE_INFO_UPLOADED, function (props) {
-                var _a = props, response = _a.response, publishingModules = _a.publishingModules;
-                if (channelUrl === response.channelUrl && publishingModules.includes(PublishingModuleType.CHANNEL)) {
+                var response = props.response, publishingModules = props.publishingModules;
+                if (channelUrl === response.channelUrl && shouldPubSubPublishToChannel(publishingModules)) {
                     dispatcher({
                         type: ON_FILE_INFO_UPLOADED,
                         payload: response,
@@ -1289,9 +1214,8 @@ var useHandleChannelPubsubEvents = function (_a) {
                 }
             }));
             subscriber.set(PUBSUB_TOPICS.SEND_MESSAGE_FAILED, pubSub.subscribe(PUBSUB_TOPICS.SEND_MESSAGE_FAILED, function (props) {
-                var _a = props, channel = _a.channel, message = _a.message, publishingModules = _a.publishingModules;
-                if (channelUrl === (channel === null || channel === void 0 ? void 0 : channel.url)
-                    && publishingModules.includes(PublishingModuleType.CHANNEL)) {
+                var channel = props.channel, message = props.message, publishingModules = props.publishingModules;
+                if (channelUrl === (channel === null || channel === void 0 ? void 0 : channel.url) && shouldPubSubPublishToChannel(publishingModules)) {
                     dispatcher({
                         type: SEND_MESSAGE_FAILURE,
                         payload: message,
@@ -1310,7 +1234,7 @@ var useHandleChannelPubsubEvents = function (_a) {
             }));
             subscriber.set(PUBSUB_TOPICS.UPDATE_USER_MESSAGE, pubSub.subscribe(PUBSUB_TOPICS.UPDATE_USER_MESSAGE, function (props) {
                 var channel = props.channel, message = props.message, fromSelector = props.fromSelector;
-                if (fromSelector && (channelUrl === (channel === null || channel === void 0 ? void 0 : channel.url))) {
+                if (fromSelector && (channelUrl === (channel === null || channel === void 0 ? void 0 : channel.url)) && channel.isGroupChannel()) {
                     dispatcher({
                         type: ON_MESSAGE_UPDATED,
                         payload: { channel: channel, message: message },
@@ -1368,7 +1292,7 @@ var ChannelProvider = function (props) {
     var _q = useState(false), isScrolled = _q[0], setIsScrolled = _q[1];
     var _r = useReducer(channelReducer, initialState), messagesStore = _r[0], messagesDispatcher = _r[1];
     var scrollRef = useRef(null);
-    var allMessages = messagesStore.allMessages, localMessages = messagesStore.localMessages, loading = messagesStore.loading, initialized = messagesStore.initialized, unreadSince = messagesStore.unreadSince, unreadSinceDate = messagesStore.unreadSinceDate, isInvalid = messagesStore.isInvalid, currentGroupChannel = messagesStore.currentGroupChannel, hasMorePrev = messagesStore.hasMorePrev, oldestMessageTimeStamp = messagesStore.oldestMessageTimeStamp, hasMoreNext = messagesStore.hasMoreNext, latestMessageTimeStamp = messagesStore.latestMessageTimeStamp, emojiContainer = messagesStore.emojiContainer, readStatus = messagesStore.readStatus;
+    var allMessages = messagesStore.allMessages, localMessages = messagesStore.localMessages, loading = messagesStore.loading, initialized = messagesStore.initialized, unreadSince = messagesStore.unreadSince, unreadSinceDate = messagesStore.unreadSinceDate, isInvalid = messagesStore.isInvalid, currentGroupChannel = messagesStore.currentGroupChannel, hasMorePrev = messagesStore.hasMorePrev, oldestMessageTimeStamp = messagesStore.oldestMessageTimeStamp, hasMoreNext = messagesStore.hasMoreNext, latestMessageTimeStamp = messagesStore.latestMessageTimeStamp, emojiContainer = messagesStore.emojiContainer, readStatus = messagesStore.readStatus, typingMembers = messagesStore.typingMembers;
     var isSuper = (currentGroupChannel === null || currentGroupChannel === void 0 ? void 0 : currentGroupChannel.isSuper) || false;
     var isBroadcast = (currentGroupChannel === null || currentGroupChannel === void 0 ? void 0 : currentGroupChannel.isBroadcast) || false;
     var usingReaction = getIsReactionEnabled({
@@ -1556,6 +1480,7 @@ var ChannelProvider = function (props) {
             latestMessageTimeStamp: latestMessageTimeStamp,
             emojiContainer: emojiContainer,
             readStatus: readStatus,
+            typingMembers: typingMembers,
             // utils
             scrollToMessage: scrollToMessage,
             quoteMessage: quoteMessage,
@@ -1591,4 +1516,4 @@ var ChannelProvider = function (props) {
 var useChannelContext = function () { return React__default.useContext(ChannelContext); };
 
 export { ChannelProvider as C, getIsReactionEnabled as g, useChannelContext as u };
-//# sourceMappingURL=bundle-LUte5Kb5.js.map
+//# sourceMappingURL=bundle-BgGUA_Do.js.map

package/chunks/{bundle-LUte5Kb5.js.map → bundle-BgGUA_Do.js.map}

@@ -1 +1 @@
-{"version":3,"file":"bundle-LUte5Kb5.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"bundle-BgGUA_Do.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/chunks/{bundle-cviP1IM2.js → bundle-EaGyVrR8.js}

@@ -1,5 +1,5 @@
-import { a as __spreadArray } from './bundle-hKtwSqbO.js';
-import { M as isUrl } from './bundle-EHReigfD.js';
+import { a as __spreadArray } from './bundle-HUCZoqot.js';
+import { L as isUrl } from './bundle-UW-TqfsF.js';
 
 var USER_MENTION_PREFIX = '@';
 
@@ -129,4 +129,4 @@ function getWhiteSpacePreservedText(text) {
 }
 
 export { TOKEN_TYPES as T, USER_MENTION_PREFIX as U, getWhiteSpacePreservedText as g, tokenizeMessage as t };
-//# sourceMappingURL=bundle-cviP1IM2.js.map
+//# sourceMappingURL=bundle-EaGyVrR8.js.map

package/chunks/{bundle-cviP1IM2.js.map → bundle-EaGyVrR8.js.map}

@@ -1 +1 @@
-{"version":3,"file":"bundle-cviP1IM2.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"bundle-EaGyVrR8.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/chunks/{bundle-ZmvX8uZ5.js → bundle-EoW7JC-6.js}

@@ -1,6 +1,6 @@
-import { a as __spreadArray } from './bundle-hKtwSqbO.js';
-import { f as format } from './bundle-h3JIYRTG.js';
-import { a as isReadMessage } from './bundle-EHReigfD.js';
+import { a as __spreadArray } from './bundle-HUCZoqot.js';
+import { f as format } from './bundle-o_MR5zP9.js';
+import { a as isReadMessage } from './bundle-UW-TqfsF.js';
 import { SendingStatus } from '@sendbird/chat/message';
 
 var scrollToRenderedMessage = function (scrollRef, initialTimeStamp, setIsScrolled) {
@@ -143,21 +143,9 @@ var passUnsuccessfullMessages = function (allMessages, newMessage) {
     }
     return __spreadArray(__spreadArray([], allMessages, true), [newMessage], false);
 };
-var pxToNumber = function (px) {
-    if (typeof px === 'number') {
-        return px;
-    }
-    if (typeof px === 'string') {
-        var parsed = Number.parseFloat(px);
-        if (!Number.isNaN(parsed)) {
-            return parsed;
-        }
-    }
-    return null;
-};
 var isAboutSame = function (a, b, px) {
     return Math.abs(a - b) <= px;
 };
 
-export { scrollToRenderedMessage as a, isDisabledBecauseMuted as b, isOperator as c, isSameGroup as d, isAboutSame as e, pxToNumber as f, getAllEmojisMapFromEmojiContainer as g, getNicknamesMapFromMembers as h, isDisabledBecauseFrozen as i, mergeAndSortMessages as m, passUnsuccessfullMessages as p, scrollIntoLast as s };
-//# sourceMappingURL=bundle-ZmvX8uZ5.js.map
+export { scrollToRenderedMessage as a, isDisabledBecauseMuted as b, isOperator as c, isSameGroup as d, isAboutSame as e, getNicknamesMapFromMembers as f, getAllEmojisMapFromEmojiContainer as g, isDisabledBecauseFrozen as i, mergeAndSortMessages as m, passUnsuccessfullMessages as p, scrollIntoLast as s };
+//# sourceMappingURL=bundle-EoW7JC-6.js.map

package/chunks/bundle-EoW7JC-6.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle-EoW7JC-6.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/chunks/bundle-Ey2KFn-R.js

@@ -0,0 +1,42 @@
+var PublishingModuleType;
+(function (PublishingModuleType) {
+    PublishingModuleType["CHANNEL"] = "CHANNEL";
+    PublishingModuleType["THREAD"] = "THREAD";
+})(PublishingModuleType || (PublishingModuleType = {}));
+// NOTE: To maintain compatibility with the sendbirdSelector provided to customers
+//  this utility function ensures that if publishingModules is not provided or its length is zero
+//  it will maintain the same behavior as before.
+var publishTo = function (target, modules) {
+    if (!modules || modules.length === 0)
+        return true;
+    else
+        return modules.includes(target);
+};
+function shouldPubSubPublishToChannel(modules) {
+    return publishTo(PublishingModuleType.CHANNEL, modules);
+}
+function shouldPubSubPublishToThread(modules) {
+    return publishTo(PublishingModuleType.THREAD, modules);
+}
+
+// NOTE: It seems not distinguish topics by channel type.
+var PUBSUB_TOPICS;
+(function (PUBSUB_TOPICS) {
+    // Group Channel
+    PUBSUB_TOPICS["USER_UPDATED"] = "USER_UPDATED";
+    PUBSUB_TOPICS["SEND_MESSAGE_START"] = "SEND_MESSAGE_START";
+    PUBSUB_TOPICS["SEND_MESSAGE_FAILED"] = "SEND_MESSAGE_FAILED";
+    PUBSUB_TOPICS["SEND_USER_MESSAGE"] = "SEND_USER_MESSAGE";
+    PUBSUB_TOPICS["SEND_FILE_MESSAGE"] = "SEND_FILE_MESSAGE";
+    PUBSUB_TOPICS["ON_FILE_INFO_UPLOADED"] = "ON_FILE_INFO_UPLOADED";
+    PUBSUB_TOPICS["UPDATE_USER_MESSAGE"] = "UPDATE_USER_MESSAGE";
+    PUBSUB_TOPICS["DELETE_MESSAGE"] = "DELETE_MESSAGE";
+    PUBSUB_TOPICS["LEAVE_CHANNEL"] = "LEAVE_CHANNEL";
+    PUBSUB_TOPICS["CREATE_CHANNEL"] = "CREATE_CHANNEL";
+    // Open Channel
+    PUBSUB_TOPICS["UPDATE_OPEN_CHANNEL"] = "UPDATE_OPEN_CHANNEL";
+})(PUBSUB_TOPICS || (PUBSUB_TOPICS = {}));
+var pubSubTopics = PUBSUB_TOPICS;
+
+export { PublishingModuleType as P, shouldPubSubPublishToThread as a, PUBSUB_TOPICS as b, pubSubTopics as p, shouldPubSubPublishToChannel as s };
+//# sourceMappingURL=bundle-Ey2KFn-R.js.map

package/chunks/bundle-Ey2KFn-R.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle-Ey2KFn-R.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/chunks/{bundle-FTgSGiKe.js → bundle-FxBVAeu9.js}

@@ -505,4 +505,4 @@ var locale = {
 var defaultLocale = locale;
 
 export { defaultLocale as d };
-//# sourceMappingURL=bundle-FTgSGiKe.js.map
+//# sourceMappingURL=bundle-FxBVAeu9.js.map