@sendbird/uikit-react 3.18.2 → 3.18.4

package/cjs/chunks/bundle-CYSJJmTZ.js

@@ -0,0 +1,823 @@
+'use strict';
+
+var _tslib = require('./bundle-Bd2CeRt-.js');
+var React = require('react');
+var message = require('@sendbird/chat/message');
+var utils = require('./bundle--7hPuXVE.js');
+var UserProfileContext = require('./bundle-Bdq9hoDy.js');
+var SendbirdContext = require('./bundle-DiOxeQAO.js');
+var SendbirdChat = require('@sendbird/chat');
+var groupChannel = require('@sendbird/chat/groupChannel');
+var uuid = require('./bundle-DhODbqF3.js');
+var compareIds = require('./bundle-kCEJbgLb.js');
+var uikitTools = require('@sendbird/uikit-tools');
+var Thread_context_types = require('../Thread/context/types.js');
+var useSendbird = require('./bundle-QhRhypRr.js');
+var useDeepCompareEffect = require('./bundle-CsAon8YT.js');
+var pubSub_topics = require('./bundle-BmMGEkJA.js');
+var consts = require('./bundle-CrpqUlR3.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultCompat(React);
+
+function useToggleReactionCallback(_a, _b) {
+    var currentChannel = _a.currentChannel;
+    var logger = _b.logger;
+    return React.useCallback(function (message, key, isReacted) {
+        var _a, _b;
+        if (isReacted) {
+            (_a = currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.deleteReaction) === null || _a === void 0 ? void 0 : _a.call(currentChannel, message, key).then(function (res) {
+                logger.info('Thread | useToggleReactionsCallback: Delete reaction succeeded.', res);
+            }).catch(function (err) {
+                logger.warning('Thread | useToggleReactionsCallback: Delete reaction failed.', err);
+            });
+            return;
+        }
+        (_b = currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.addReaction) === null || _b === void 0 ? void 0 : _b.call(currentChannel, message, key).then(function (res) {
+            logger.info('Thread | useToggleReactionsCallback: Add reaction succeeded.', res);
+        }).catch(function (err) {
+            logger.warning('Thread | useToggleReactionsCallback: Add reaction failed.', err);
+        });
+    }, [currentChannel]);
+}
+
+var scrollToLastAfterSend = function () {
+    setTimeout(function () { return utils.scrollIntoLast(); }, consts.SCROLL_BOTTOM_DELAY_FOR_SEND);
+};
+var attachLocalFilePreview = function (pendingMessage, file) {
+    var localUrl = URL.createObjectURL(file);
+    var localFileMessage = pendingMessage;
+    localFileMessage.localUrl = localUrl;
+    localFileMessage.file = file;
+    return localUrl;
+};
+function useThreadMessageActions(state, _a) {
+    var logger = _a.logger, pubSub = _a.pubSub, isMentionEnabled = _a.isMentionEnabled;
+    var currentChannel = state.currentChannel, onBeforeSendUserMessage = state.onBeforeSendUserMessage, onBeforeSendFileMessage = state.onBeforeSendFileMessage, onBeforeSendVoiceMessage = state.onBeforeSendVoiceMessage, onBeforeSendMultipleFilesMessage = state.onBeforeSendMultipleFilesMessage, dsSendUserMessage = state.dsSendUserMessage, dsSendFileMessage = state.dsSendFileMessage, dsSendMultipleFilesMessage = state.dsSendMultipleFilesMessage, dsUpdateUserMessage = state.dsUpdateUserMessage, dsResendMessage = state.dsResendMessage, dsDeleteMessage = state.dsDeleteMessage;
+    var sendMessage = React.useCallback(function (props) {
+        var _a;
+        var message = props.message, quoteMessage = props.quoteMessage, mentionTemplate = props.mentionTemplate, mentionedUsers = props.mentionedUsers;
+        var createDefaultParams = function () {
+            var params = {};
+            params.message = message;
+            var mentionedUsersLength = (mentionedUsers === null || mentionedUsers === void 0 ? void 0 : mentionedUsers.length) || 0;
+            if (isMentionEnabled && mentionedUsersLength) {
+                params.mentionedUsers = mentionedUsers;
+            }
+            if (isMentionEnabled && mentionTemplate && mentionedUsersLength) {
+                params.mentionedMessageTemplate = mentionTemplate;
+            }
+            if (quoteMessage) {
+                params.isReplyToChannel = true;
+                params.parentMessageId = quoteMessage.messageId;
+            }
+            return params;
+        };
+        var params = (_a = onBeforeSendUserMessage === null || onBeforeSendUserMessage === void 0 ? void 0 : onBeforeSendUserMessage(message, quoteMessage)) !== null && _a !== void 0 ? _a : createDefaultParams();
+        if (!dsSendUserMessage || !currentChannel)
+            return;
+        logger.info('Thread | useThreadMessageActions: Sending user message start.', params);
+        dsSendUserMessage(params, function () { return scrollToLastAfterSend(); })
+            .then(function (sentMessage) {
+            pubSub.publish(pubSub_topics.pubSubTopics.SEND_USER_MESSAGE, {
+                channel: currentChannel,
+                message: sentMessage,
+                publishingModules: [pubSub_topics.PublishingModuleType.THREAD],
+            });
+        })
+            .catch(function (error) {
+            logger.info('Thread | useThreadMessageActions: Sending user message failed.', error);
+        });
+    }, [dsSendUserMessage, onBeforeSendUserMessage, currentChannel, isMentionEnabled]);
+    var sendFileMessage = React.useCallback(function (file, quoteMessage) {
+        var _a;
+        var createParamsDefault = function () {
+            var params = {};
+            params.file = file;
+            if (quoteMessage) {
+                params.isReplyToChannel = true;
+                params.parentMessageId = quoteMessage.messageId;
+            }
+            return params;
+        };
+        var params = (_a = onBeforeSendFileMessage === null || onBeforeSendFileMessage === void 0 ? void 0 : onBeforeSendFileMessage(file, quoteMessage)) !== null && _a !== void 0 ? _a : createParamsDefault();
+        if (!dsSendFileMessage || !currentChannel)
+            return Promise.resolve(null);
+        logger.info('Thread | useThreadMessageActions: Sending file message start.', params);
+        var localPreviewUrl;
+        return dsSendFileMessage(params, function (pendingMessage) {
+            localPreviewUrl = attachLocalFilePreview(pendingMessage, file);
+            scrollToLastAfterSend();
+        })
+            .then(function (sentMessage) {
+            if (localPreviewUrl)
+                URL.revokeObjectURL(localPreviewUrl);
+            pubSub.publish(pubSub_topics.pubSubTopics.SEND_FILE_MESSAGE, {
+                channel: currentChannel,
+                message: sentMessage,
+                publishingModules: [pubSub_topics.PublishingModuleType.THREAD],
+            });
+            return sentMessage;
+        });
+    }, [dsSendFileMessage, onBeforeSendFileMessage, currentChannel]);
+    var sendVoiceMessage = React.useCallback(function (file, duration, quoteMessage) {
+        var params = (onBeforeSendVoiceMessage && typeof onBeforeSendVoiceMessage === 'function')
+            ? onBeforeSendVoiceMessage(file, quoteMessage)
+            : {
+                file: file,
+                fileName: consts.VOICE_MESSAGE_FILE_NAME,
+                mimeType: consts.VOICE_MESSAGE_MIME_TYPE,
+                metaArrays: [
+                    new message.MessageMetaArray({ key: consts.META_ARRAY_VOICE_DURATION_KEY, value: ["".concat(duration)] }),
+                    new message.MessageMetaArray({ key: consts.META_ARRAY_MESSAGE_TYPE_KEY, value: [consts.META_ARRAY_MESSAGE_TYPE_VALUE__VOICE] }),
+                ],
+            };
+        if (quoteMessage) {
+            params.isReplyToChannel = true;
+            params.parentMessageId = quoteMessage.messageId;
+        }
+        if (!dsSendFileMessage || !currentChannel)
+            return;
+        logger.info('Thread | useThreadMessageActions: Sending voice message start.', params);
+        var localPreviewUrl;
+        dsSendFileMessage(params, function (pendingMessage) {
+            localPreviewUrl = attachLocalFilePreview(pendingMessage, file);
+            scrollToLastAfterSend();
+        })
+            .then(function (sentMessage) {
+            if (localPreviewUrl)
+                URL.revokeObjectURL(localPreviewUrl);
+            pubSub.publish(pubSub_topics.pubSubTopics.SEND_FILE_MESSAGE, {
+                channel: currentChannel,
+                message: sentMessage,
+                publishingModules: [pubSub_topics.PublishingModuleType.THREAD],
+            });
+        })
+            .catch(function (error) {
+            logger.info('Thread | useThreadMessageActions: Sending voice message failed.', error);
+        });
+    }, [dsSendFileMessage, onBeforeSendVoiceMessage, currentChannel]);
+    var sendMultipleFilesMessage = React.useCallback(function (files, quoteMessage) {
+        var _a;
+        var createParamsDefault = function () {
+            var params = {
+                fileInfoList: files.map(function (file) { return ({
+                    file: file,
+                    fileName: file.name,
+                    fileSize: file.size,
+                    mimeType: file.type,
+                }); }),
+            };
+            if (quoteMessage) {
+                params.isReplyToChannel = true;
+                params.parentMessageId = quoteMessage.messageId;
+            }
+            return params;
+        };
+        var params = (_a = onBeforeSendMultipleFilesMessage === null || onBeforeSendMultipleFilesMessage === void 0 ? void 0 : onBeforeSendMultipleFilesMessage(files, quoteMessage)) !== null && _a !== void 0 ? _a : createParamsDefault();
+        if (!dsSendMultipleFilesMessage || !currentChannel)
+            return Promise.resolve(null);
+        logger.info('Thread | useThreadMessageActions: Sending multiple files message start.', params);
+        return dsSendMultipleFilesMessage(params, function () { return scrollToLastAfterSend(); })
+            .then(function (sentMessage) {
+            pubSub.publish(pubSub_topics.pubSubTopics.SEND_FILE_MESSAGE, {
+                channel: currentChannel,
+                message: sentMessage,
+                publishingModules: [pubSub_topics.PublishingModuleType.THREAD],
+            });
+            return sentMessage;
+        });
+    }, [dsSendMultipleFilesMessage, onBeforeSendMultipleFilesMessage, currentChannel]);
+    var updateMessage = React.useCallback(function (props) {
+        var messageId = props.messageId, message = props.message, mentionedUsers = props.mentionedUsers, mentionedUserIds = props.mentionedUserIds, mentionTemplate = props.mentionTemplate;
+        var params = {};
+        params.message = message;
+        if (isMentionEnabled && mentionedUserIds) {
+            params.mentionedUserIds = mentionedUserIds;
+        }
+        else if (isMentionEnabled && mentionedUsers) {
+            params.mentionedUsers = mentionedUsers;
+        }
+        if (isMentionEnabled && mentionTemplate) {
+            params.mentionedMessageTemplate = mentionTemplate;
+        }
+        else {
+            params.mentionedMessageTemplate = message;
+        }
+        if (!dsUpdateUserMessage || !currentChannel)
+            return;
+        logger.info('Thread | useThreadMessageActions: Message update start.', params);
+        dsUpdateUserMessage(messageId, params)
+            .then(function (updatedMessage) {
+            pubSub.publish(pubSub_topics.pubSubTopics.UPDATE_USER_MESSAGE, {
+                fromSelector: true,
+                channel: currentChannel,
+                message: updatedMessage,
+                publishingModules: [pubSub_topics.PublishingModuleType.THREAD],
+            });
+        })
+            .catch(function (error) {
+            logger.warning('Thread | useThreadMessageActions: Message update failed.', error);
+        });
+    }, [dsUpdateUserMessage, currentChannel, isMentionEnabled]);
+    var deleteMessage = React.useCallback(function (message) {
+        if (!dsDeleteMessage)
+            return Promise.resolve();
+        logger.info('Thread | useThreadMessageActions: Deleting message.', message);
+        return dsDeleteMessage(message);
+    }, [dsDeleteMessage]);
+    var resendMessage = React.useCallback(function (failedMessage) {
+        if (!(failedMessage === null || failedMessage === void 0 ? void 0 : failedMessage.isResendable) || !dsResendMessage || !currentChannel) {
+            logger.warning('Thread | useThreadMessageActions: Message is not resendable.', failedMessage);
+            return;
+        }
+        logger.info('Thread | useThreadMessageActions: Resending message start.', failedMessage);
+        dsResendMessage(failedMessage)
+            .then(function (sentMessage) {
+            var _a;
+            var isUserMessage = (_a = sentMessage === null || sentMessage === void 0 ? void 0 : sentMessage.isUserMessage) === null || _a === void 0 ? void 0 : _a.call(sentMessage);
+            pubSub.publish(isUserMessage ? pubSub_topics.pubSubTopics.SEND_USER_MESSAGE : pubSub_topics.pubSubTopics.SEND_FILE_MESSAGE, {
+                channel: currentChannel,
+                message: sentMessage,
+                publishingModules: [pubSub_topics.PublishingModuleType.THREAD],
+            });
+        })
+            .catch(function (error) {
+            logger.warning('Thread | useThreadMessageActions: Resending message failed.', error);
+        });
+    }, [dsResendMessage, currentChannel]);
+    return React.useMemo(function () { return ({
+        sendMessage: sendMessage,
+        sendFileMessage: sendFileMessage,
+        sendVoiceMessage: sendVoiceMessage,
+        sendMultipleFilesMessage: sendMultipleFilesMessage,
+        updateMessage: updateMessage,
+        deleteMessage: deleteMessage,
+        resendMessage: resendMessage,
+    }); }, [
+        sendMessage,
+        sendFileMessage,
+        sendVoiceMessage,
+        sendMultipleFilesMessage,
+        updateMessage,
+        deleteMessage,
+        resendMessage,
+    ]);
+}
+
+var useThread = function () {
+    var store = React.useContext(ThreadContext);
+    if (!store)
+        throw new Error('useThread must be used within a ThreadProvider');
+    // SendbirdStateContext config
+    var config = useSendbird.useSendbird().state.config;
+    var logger = config.logger, pubSub = config.pubSub;
+    var isMentionEnabled = config.groupChannel.enableMention;
+    var state = SendbirdContext.shimExports.useSyncExternalStore(store.subscribe, store.getState);
+    var currentChannel = state.currentChannel;
+    var toggleReaction = useToggleReactionCallback({ currentChannel: currentChannel }, { logger: logger });
+    var initializeThreadFetcher = React.useCallback(function (callback) {
+        var _a = store.getState(), resetWithStartingPoint = _a.resetWithStartingPoint, anchorMessage = _a.message, parentMessage = _a.parentMessage;
+        if (!resetWithStartingPoint)
+            return;
+        // Mirror ThreadProvider's initial startingPoint: anchor at the specific reply when entering from
+        // one, otherwise open at the latest edge (MAX). parentMessage.createdAt would anchor at the oldest
+        // edge (replies are created after the parent), hiding the latest replies behind hasMoreNext.
+        var startingPoint = (anchorMessage && parentMessage && anchorMessage.messageId !== parentMessage.messageId)
+            ? anchorMessage.createdAt
+            : Number.MAX_SAFE_INTEGER;
+        resetWithStartingPoint(startingPoint).then(function () {
+            setTimeout(function () { return callback === null || callback === void 0 ? void 0 : callback(store.getState().allThreadMessages); });
+        });
+    }, [store]);
+    var fetchPrevThreads = React.useCallback(function (callback) {
+        var loadPrevious = store.getState().loadPrevious;
+        if (!loadPrevious)
+            return;
+        loadPrevious().then(function () {
+            setTimeout(function () { return callback === null || callback === void 0 ? void 0 : callback(store.getState().allThreadMessages); });
+        });
+    }, [store]);
+    var fetchNextThreads = React.useCallback(function (callback) {
+        var loadNext = store.getState().loadNext;
+        if (!loadNext)
+            return;
+        loadNext().then(function () {
+            setTimeout(function () { return callback === null || callback === void 0 ? void 0 : callback(store.getState().allThreadMessages); });
+        });
+    }, [store]);
+    var messageActions = useThreadMessageActions(state, { logger: logger, pubSub: pubSub, isMentionEnabled: isMentionEnabled });
+    var simpleActions = {
+        setCurrentUserId: React.useCallback(function (currentUserId) { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { currentUserId: currentUserId })); }); }, [store]),
+        getChannelStart: React.useCallback(function () { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { channelState: Thread_context_types.ChannelStateTypes.LOADING, currentChannel: null })); }); }, [store]),
+        getChannelSuccess: React.useCallback(function (groupChannel) { return store.setState(function (state) {
+            var _a, _b;
+            return (_tslib.__assign(_tslib.__assign({}, state), { channelState: Thread_context_types.ChannelStateTypes.INITIALIZED, currentChannel: groupChannel, 
+                // only support in normal group channel
+                isMuted: ((_b = (_a = groupChannel === null || groupChannel === void 0 ? void 0 : groupChannel.members) === null || _a === void 0 ? void 0 : _a.find(function (member) { return (member === null || member === void 0 ? void 0 : member.userId) === state.currentUserId; })) === null || _b === void 0 ? void 0 : _b.isMuted) || false, isChannelFrozen: (groupChannel === null || groupChannel === void 0 ? void 0 : groupChannel.isFrozen) || false }));
+        }); }, [store]),
+        getChannelFailure: React.useCallback(function () { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { channelState: Thread_context_types.ChannelStateTypes.INVALID, currentChannel: null })); }); }, [store]),
+        getParentMessageStart: React.useCallback(function () { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { parentMessageState: Thread_context_types.ParentMessageStateTypes.LOADING, parentMessage: null })); }); }, [store]),
+        getParentMessageSuccess: React.useCallback(function (parentMessage) { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { parentMessageState: Thread_context_types.ParentMessageStateTypes.INITIALIZED, parentMessage: parentMessage })); }); }, [store]),
+        getParentMessageFailure: React.useCallback(function () { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { parentMessageState: Thread_context_types.ParentMessageStateTypes.INVALID, parentMessage: null })); }); }, [store]),
+        setEmojiContainer: React.useCallback(function (emojiContainer) { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { emojiContainer: emojiContainer })); }); }, [store]),
+        onUserMuted: React.useCallback(function (channel, user) { return store.setState(function (state) {
+            var _a;
+            if (((_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url) !== (channel === null || channel === void 0 ? void 0 : channel.url) || state.currentUserId !== (user === null || user === void 0 ? void 0 : user.userId)) {
+                return state;
+            }
+            return _tslib.__assign(_tslib.__assign({}, state), { isMuted: true });
+        }); }, [store]),
+        onUserUnmuted: React.useCallback(function (channel, user) { return store.setState(function (state) {
+            var _a;
+            if (((_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url) !== (channel === null || channel === void 0 ? void 0 : channel.url) || state.currentUserId !== (user === null || user === void 0 ? void 0 : user.userId)) {
+                return state;
+            }
+            return _tslib.__assign(_tslib.__assign({}, state), { isMuted: false });
+        }); }, [store]),
+        onUserBanned: React.useCallback(function (channel, user) {
+            store.setState(function (state) {
+                var _a;
+                if (((_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url) !== (channel === null || channel === void 0 ? void 0 : channel.url)) {
+                    return state;
+                }
+                // Only reset state when the current user is banned
+                if (state.currentUserId === (user === null || user === void 0 ? void 0 : user.userId)) {
+                    return _tslib.__assign(_tslib.__assign({}, state), { channelState: Thread_context_types.ChannelStateTypes.NIL, threadListState: Thread_context_types.ThreadListStateTypes.NIL, parentMessageState: Thread_context_types.ParentMessageStateTypes.NIL, currentChannel: null, parentMessage: null, threadMessages: [], allThreadMessages: [], localThreadMessages: [], hasMorePrev: false, hasMoreNext: false });
+                }
+                // Another user banned: update channel info and nicknames map
+                return _tslib.__assign(_tslib.__assign({}, state), { currentChannel: channel, nicknamesMap: utils.getNicknamesMapFromMembers(channel === null || channel === void 0 ? void 0 : channel.members) });
+            });
+        }, [store]),
+        onUserUnbanned: React.useCallback(function () { return store.setState(function (state) {
+            return _tslib.__assign({}, state);
+        }); }, [store]),
+        onUserLeft: React.useCallback(function (channel, user) {
+            store.setState(function (state) {
+                var _a;
+                if (((_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url) !== (channel === null || channel === void 0 ? void 0 : channel.url)) {
+                    return state;
+                }
+                // Only reset state when the current user has left
+                if (state.currentUserId === (user === null || user === void 0 ? void 0 : user.userId)) {
+                    return _tslib.__assign(_tslib.__assign({}, state), { channelState: Thread_context_types.ChannelStateTypes.NIL, threadListState: Thread_context_types.ThreadListStateTypes.NIL, parentMessageState: Thread_context_types.ParentMessageStateTypes.NIL, currentChannel: null, parentMessage: null, threadMessages: [], allThreadMessages: [], localThreadMessages: [], hasMorePrev: false, hasMoreNext: false });
+                }
+                // Another user left: update channel info and nicknames map
+                return _tslib.__assign(_tslib.__assign({}, state), { currentChannel: channel, nicknamesMap: utils.getNicknamesMapFromMembers(channel === null || channel === void 0 ? void 0 : channel.members) });
+            });
+        }, [store]),
+        onChannelFrozen: React.useCallback(function () { return store.setState(function (state) {
+            return _tslib.__assign(_tslib.__assign({}, state), { isChannelFrozen: true });
+        }); }, [store]),
+        onChannelUnfrozen: React.useCallback(function () { return store.setState(function (state) {
+            return _tslib.__assign(_tslib.__assign({}, state), { isChannelFrozen: false });
+        }); }, [store]),
+        onOperatorUpdated: React.useCallback(function (channel) { return store.setState(function (state) {
+            var _a;
+            if ((channel === null || channel === void 0 ? void 0 : channel.url) === ((_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url)) {
+                return _tslib.__assign(_tslib.__assign({}, state), { currentChannel: channel });
+            }
+            return state;
+        }); }, [store]),
+        onTypingStatusUpdated: React.useCallback(function (channel, typingMembers) { return store.setState(function (state) {
+            var _a;
+            if (!utils.compareIds(channel.url, (_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url)) {
+                return state;
+            }
+            return _tslib.__assign(_tslib.__assign({}, state), { typingMembers: typingMembers });
+        }); }, [store]),
+    };
+    /**
+     * These low-level dispatchers were removed when the @sendbird/uikit-tools collection took over
+     * thread state management. They are retained for backward compatibility (existing customer code
+     * referencing them still compiles) but no longer mutate state — the collection owns it now. Each
+     * logs a deprecation warning when called so a direct caller is not left with a silent no-op.
+     * Signatures are supplied by casting, which keeps the parameters off the runtime function.
+     */
+    var backwardCompatActions = React.useMemo(function () {
+        var warn = function (name) { return function () {
+            var _a;
+            (_a = logger === null || logger === void 0 ? void 0 : logger.warning) === null || _a === void 0 ? void 0 : _a.call(logger, "[Thread] useThread().actions.".concat(name, " is deprecated and no longer has any effect; thread state is now managed by the @sendbird/uikit-tools collection."));
+        }; };
+        return {
+            onMessageReceived: warn('onMessageReceived'),
+            onReactionUpdated: warn('onReactionUpdated'),
+            onFileInfoUpdated: warn('onFileInfoUpdated'),
+            sendMessageStart: warn('sendMessageStart'),
+            sendMessageSuccess: warn('sendMessageSuccess'),
+            sendMessageFailure: warn('sendMessageFailure'),
+            resendMessageStart: warn('resendMessageStart'),
+            onMessageUpdated: warn('onMessageUpdated'),
+            onMessageDeleted: warn('onMessageDeleted'),
+            onMessageDeletedByReqId: warn('onMessageDeletedByReqId'),
+            initializeThreadListStart: warn('initializeThreadListStart'),
+            initializeThreadListSuccess: warn('initializeThreadListSuccess'),
+            initializeThreadListFailure: warn('initializeThreadListFailure'),
+            getPrevMessagesStart: warn('getPrevMessagesStart'),
+            getPrevMessagesSuccess: warn('getPrevMessagesSuccess'),
+            getPrevMessagesFailure: warn('getPrevMessagesFailure'),
+            getNextMessagesStart: warn('getNextMessagesStart'),
+            getNextMessagesSuccess: warn('getNextMessagesSuccess'),
+            getNextMessagesFailure: warn('getNextMessagesFailure'),
+        };
+    }, [logger]);
+    var actions = React.useMemo(function () { return (_tslib.__assign(_tslib.__assign(_tslib.__assign(_tslib.__assign({}, simpleActions), { toggleReaction: toggleReaction, initializeThreadFetcher: initializeThreadFetcher, fetchPrevThreads: fetchPrevThreads, fetchNextThreads: fetchNextThreads }), messageActions), backwardCompatActions)); }, [
+        simpleActions,
+        toggleReaction,
+        initializeThreadFetcher,
+        fetchPrevThreads,
+        fetchNextThreads,
+        messageActions,
+        backwardCompatActions,
+    ]);
+    return { state: state, actions: actions };
+};
+
+function useGetChannel(_a, _b) {
+    var channelUrl = _a.channelUrl, sdkInit = _a.sdkInit, message = _a.message;
+    var sdk = _b.sdk, logger = _b.logger;
+    var _c = useThread().actions, getChannelStart = _c.getChannelStart, getChannelSuccess = _c.getChannelSuccess, getChannelFailure = _c.getChannelFailure;
+    React.useEffect(function () {
+        var _a, _b;
+        // validation check
+        if (sdkInit && channelUrl && (sdk === null || sdk === void 0 ? void 0 : sdk.groupChannel)) {
+            logger.info('Thread | useInitialize: Get channel started');
+            getChannelStart();
+            (_b = (_a = sdk.groupChannel).getChannel) === null || _b === void 0 ? void 0 : _b.call(_a, channelUrl).then(function (groupChannel) {
+                logger.info('Thread | useInitialize: Get channel succeeded', groupChannel);
+                getChannelSuccess(groupChannel);
+            }).catch(function (error) {
+                logger.info('Thread | useInitialize: Get channel failed', error);
+                getChannelFailure();
+            });
+        }
+    }, [message, sdkInit]);
+    /**
+     * We don't use channelUrl here,
+     * because Thread must operate independently of the channel.
+     */
+}
+
+function useGetAllEmoji(_a, _b) {
+    var sdk = _a.sdk;
+    var logger = _b.logger;
+    var setEmojiContainer = useThread().actions.setEmojiContainer;
+    React.useEffect(function () {
+        if (sdk === null || sdk === void 0 ? void 0 : sdk.getAllEmoji) { // validation check
+            sdk === null || sdk === void 0 ? void 0 : sdk.getAllEmoji().then(function (emojiContainer) {
+                logger.info('Thread | useGetAllEmoji: Getting emojis succeeded.', emojiContainer);
+                setEmojiContainer(emojiContainer);
+            }).catch(function (error) {
+                logger.info('Thread | useGetAllEmoji: Getting emojis failed.', error);
+            });
+        }
+    }, [sdk]);
+}
+
+function useGetParentMessage(_a, _b) {
+    var channelUrl = _a.channelUrl, sdkInit = _a.sdkInit, parentMessage = _a.parentMessage;
+    var sdk = _b.sdk, logger = _b.logger;
+    var _c = useThread().actions, getParentMessageStart = _c.getParentMessageStart, getParentMessageSuccess = _c.getParentMessageSuccess, getParentMessageFailure = _c.getParentMessageFailure;
+    React.useEffect(function () {
+        var _a, _b, _c;
+        // validation check
+        if (sdkInit && ((_a = sdk === null || sdk === void 0 ? void 0 : sdk.message) === null || _a === void 0 ? void 0 : _a.getMessage) && parentMessage) {
+            getParentMessageStart();
+            var params = {
+                channelUrl: channelUrl,
+                channelType: SendbirdChat.ChannelType.GROUP,
+                messageId: parentMessage.messageId,
+                includeMetaArray: true,
+                includeReactions: true,
+                includeThreadInfo: true,
+                includeParentMessageInfo: true,
+            };
+            logger.info('Thread | useGetParentMessage: Get parent message start.', params);
+            (_c = (_b = sdk.message).getMessage) === null || _c === void 0 ? void 0 : _c.call(_b, params).then(function (parentMsg) {
+                logger.info('Thread | useGetParentMessage: Get parent message succeeded.', parentMessage);
+                // @ts-ignore
+                parentMsg.ogMetaData = (parentMessage === null || parentMessage === void 0 ? void 0 : parentMessage.ogMetaData) || null; // ogMetaData is not included for now
+                // @ts-ignore
+                getParentMessageSuccess(parentMsg);
+            }).catch(function (error) {
+                logger.info('Thread | useGetParentMessage: Get parent message failed.', error);
+                getParentMessageFailure();
+            });
+        }
+    }, [sdkInit, parentMessage === null || parentMessage === void 0 ? void 0 : parentMessage.messageId]);
+    /**
+     * We don't use channelUrl here,
+     * because Thread must operate independently of the channel.
+     */
+}
+
+function useHandleChannelEvents(_a, _b) {
+    var sdk = _a.sdk, currentChannel = _a.currentChannel;
+    var logger = _b.logger;
+    var _c = useThread().actions, onUserMuted = _c.onUserMuted, onUserUnmuted = _c.onUserUnmuted, onUserBanned = _c.onUserBanned, onUserUnbanned = _c.onUserUnbanned, onUserLeft = _c.onUserLeft, onChannelFrozen = _c.onChannelFrozen, onChannelUnfrozen = _c.onChannelUnfrozen, onOperatorUpdated = _c.onOperatorUpdated, onTypingStatusUpdated = _c.onTypingStatusUpdated;
+    React.useEffect(function () {
+        var _a, _b, _c;
+        var handlerId = uuid.uuidv4();
+        // validation check
+        if (((_a = sdk === null || sdk === void 0 ? void 0 : sdk.groupChannel) === null || _a === void 0 ? void 0 : _a.addGroupChannelHandler)
+            && currentChannel) {
+            var channelHandlerParams = {
+                // user status change
+                onUserMuted: function (channel, user) {
+                    logger.info('Thread | useHandleChannelEvents: onUserMuted', { channel: channel, user: user });
+                    onUserMuted(channel, user);
+                },
+                onUserUnmuted: function (channel, user) {
+                    logger.info('Thread | useHandleChannelEvents: onUserUnmuted', { channel: channel, user: user });
+                    onUserUnmuted(channel, user);
+                },
+                onUserBanned: function (channel, user) {
+                    logger.info('Thread | useHandleChannelEvents: onUserBanned', { channel: channel, user: user });
+                    onUserBanned(channel, user);
+                },
+                onUserUnbanned: function (channel, user) {
+                    logger.info('Thread | useHandleChannelEvents: onUserUnbanned', { channel: channel, user: user });
+                    onUserUnbanned();
+                },
+                onUserLeft: function (channel, user) {
+                    logger.info('Thread | useHandleChannelEvents: onUserLeft', { channel: channel, user: user });
+                    onUserLeft(channel, user);
+                },
+                // channel status change
+                onChannelFrozen: function (channel) {
+                    logger.info('Thread | useHandleChannelEvents: onChannelFrozen', { channel: channel });
+                    onChannelFrozen();
+                },
+                onChannelUnfrozen: function (channel) {
+                    logger.info('Thread | useHandleChannelEvents: onChannelUnfrozen', { channel: channel });
+                    onChannelUnfrozen();
+                },
+                onOperatorUpdated: function (channel, users) {
+                    logger.info('Thread | useHandleChannelEvents: onOperatorUpdated', { channel: channel, users: users });
+                    onOperatorUpdated(channel);
+                },
+                onTypingStatusUpdated: function (channel) {
+                    if (compareIds.compareIds(channel === null || channel === void 0 ? void 0 : channel.url, currentChannel.url)) {
+                        logger.info('Channel | onTypingStatusUpdated', { channel: channel });
+                        var typingMembers = channel.getTypingUsers();
+                        onTypingStatusUpdated(channel, typingMembers);
+                    }
+                },
+            };
+            var channelHandler = new groupChannel.GroupChannelHandler(channelHandlerParams);
+            (_c = (_b = sdk.groupChannel).addGroupChannelHandler) === null || _c === void 0 ? void 0 : _c.call(_b, handlerId, channelHandler);
+            logger.info('Thread | useHandleChannelEvents: Added channelHandler in Thread', { handlerId: handlerId, channelHandler: channelHandler });
+        }
+        return function () {
+            var _a, _b, _c;
+            // validation check
+            if (handlerId && ((_a = sdk === null || sdk === void 0 ? void 0 : sdk.groupChannel) === null || _a === void 0 ? void 0 : _a.removeGroupChannelHandler)) {
+                (_c = (_b = sdk.groupChannel).removeGroupChannelHandler) === null || _c === void 0 ? void 0 : _c.call(_b, handlerId);
+                logger.info('Thread | useHandleChannelEvents: Removed channelHandler in Thread.', handlerId);
+            }
+        };
+    }, [
+        sdk === null || sdk === void 0 ? void 0 : sdk.groupChannel,
+        currentChannel,
+    ]);
+}
+
+function useSetCurrentUserId(_a) {
+    var user = _a.user;
+    var setCurrentUserId = useThread().actions.setCurrentUserId;
+    React.useEffect(function () {
+        setCurrentUserId(user === null || user === void 0 ? void 0 : user.userId);
+    }, [user === null || user === void 0 ? void 0 : user.userId]);
+}
+
+var initialState = function () { return ({
+    channelUrl: '',
+    message: null,
+    onHeaderActionClick: undefined,
+    onMoveToParentMessage: undefined,
+    onBeforeSendUserMessage: undefined,
+    onBeforeSendFileMessage: undefined,
+    onBeforeSendVoiceMessage: undefined,
+    onBeforeSendMultipleFilesMessage: undefined,
+    onBeforeDownloadFileMessage: undefined,
+    isMultipleFilesMessageEnabled: undefined,
+    filterEmojiCategoryIds: undefined,
+    currentChannel: null,
+    threadMessages: [],
+    allThreadMessages: [],
+    localThreadMessages: [],
+    parentMessage: null,
+    channelState: Thread_context_types.ChannelStateTypes.NIL,
+    parentMessageState: Thread_context_types.ParentMessageStateTypes.NIL,
+    threadListState: Thread_context_types.ThreadListStateTypes.NIL,
+    hasMorePrev: false,
+    hasMoreNext: false,
+    emojiContainer: {},
+    isMuted: false,
+    isChannelFrozen: false,
+    currentUserId: '',
+    typingMembers: [],
+    nicknamesMap: null,
+}); };
+var ThreadContext = React__default.default.createContext(null);
+var createThreadStore = function (props) { return SendbirdContext.createStore(_tslib.__assign(_tslib.__assign({}, initialState()), props)); };
+var InternalThreadProvider = function (props) {
+    var children = props.children;
+    var defaultProps = {
+        channelUrl: props === null || props === void 0 ? void 0 : props.channelUrl,
+        message: props === null || props === void 0 ? void 0 : props.message,
+        onHeaderActionClick: props === null || props === void 0 ? void 0 : props.onHeaderActionClick,
+        onMoveToParentMessage: props === null || props === void 0 ? void 0 : props.onMoveToParentMessage,
+        onBeforeSendUserMessage: props === null || props === void 0 ? void 0 : props.onBeforeSendUserMessage,
+        onBeforeSendFileMessage: props === null || props === void 0 ? void 0 : props.onBeforeSendFileMessage,
+        onBeforeSendVoiceMessage: props === null || props === void 0 ? void 0 : props.onBeforeSendVoiceMessage,
+        onBeforeSendMultipleFilesMessage: props === null || props === void 0 ? void 0 : props.onBeforeSendMultipleFilesMessage,
+        onBeforeDownloadFileMessage: props === null || props === void 0 ? void 0 : props.onBeforeDownloadFileMessage,
+        isMultipleFilesMessageEnabled: props === null || props === void 0 ? void 0 : props.isMultipleFilesMessageEnabled,
+        filterEmojiCategoryIds: props === null || props === void 0 ? void 0 : props.filterEmojiCategoryIds,
+    };
+    var storeRef = React.useRef(createThreadStore(defaultProps));
+    return (React__default.default.createElement(ThreadContext.Provider, { value: storeRef.current }, children));
+};
+var ThreadManager = function (props) {
+    var message$1 = props.message, channelUrl = props.channelUrl, onHeaderActionClick = props.onHeaderActionClick, onMoveToParentMessage = props.onMoveToParentMessage, onBeforeSendUserMessage = props.onBeforeSendUserMessage, onBeforeSendFileMessage = props.onBeforeSendFileMessage, onBeforeSendVoiceMessage = props.onBeforeSendVoiceMessage, onBeforeSendMultipleFilesMessage = props.onBeforeSendMultipleFilesMessage, onBeforeDownloadFileMessage = props.onBeforeDownloadFileMessage, isMultipleFilesMessageEnabled = props.isMultipleFilesMessageEnabled, filterEmojiCategoryIds = props.filterEmojiCategoryIds;
+    var _a = useThread().state, currentChannel = _a.currentChannel, parentMessage = _a.parentMessage, parentMessageState = _a.parentMessageState;
+    var updateState = useThreadStore().updateState;
+    var propsParentMessage = utils.getParentMessageFrom(message$1);
+    // Context from SendbirdProvider
+    var _b = useSendbird.useSendbird().state, stores = _b.stores, config = _b.config;
+    // // stores
+    var sdkStore = stores.sdkStore, userStore = stores.userStore;
+    var sdk = sdkStore.sdk;
+    var user = userStore.user;
+    var sdkInit = sdkStore === null || sdkStore === void 0 ? void 0 : sdkStore.initialized;
+    // // config
+    var logger = config.logger;
+    var isReactionEnabled = config.groupChannel.enableReactions;
+    // Initialization
+    useSetCurrentUserId({ user: user });
+    useGetChannel({
+        channelUrl: channelUrl,
+        sdkInit: sdkInit,
+        message: message$1,
+    }, { sdk: sdk, logger: logger });
+    useGetParentMessage({
+        channelUrl: channelUrl,
+        sdkInit: sdkInit,
+        parentMessage: propsParentMessage,
+    }, { sdk: sdk, logger: logger });
+    useGetAllEmoji({ sdk: sdk }, { logger: logger });
+    // Handle channel events
+    useHandleChannelEvents({
+        sdk: sdk,
+        currentChannel: currentChannel,
+    }, { logger: logger });
+    var startingPoint = (message$1 && propsParentMessage && message$1.messageId !== propsParentMessage.messageId)
+        ? message$1.createdAt
+        : Number.MAX_SAFE_INTEGER;
+    var threadDataSource = uikitTools.useGroupChannelThreadMessages(sdk, currentChannel, (propsParentMessage !== null && propsParentMessage !== void 0 ? propsParentMessage : parentMessage), {
+        startingPoint: startingPoint,
+        isReactionEnabled: isReactionEnabled,
+        logger: logger,
+        onParentMessageUpdated: function (updatedParentMessage) {
+            updateState({ parentMessage: updatedParentMessage });
+        },
+        onParentMessageDeleted: function () {
+            updateState({
+                parentMessage: null,
+                parentMessageState: Thread_context_types.ParentMessageStateTypes.NIL,
+                threadMessages: [],
+                allThreadMessages: [],
+                localThreadMessages: [],
+            });
+        },
+        onChannelDeleted: function () {
+            updateState({
+                currentChannel: null,
+                channelState: Thread_context_types.ChannelStateTypes.NIL,
+                threadListState: Thread_context_types.ThreadListStateTypes.NIL,
+                // Clear the parent too: the channel is gone, so a stale parentMessage would keep the
+                // composer enabled (ThreadMessageInput only disables on parentMessage === null) while sends
+                // silently no-op. Mirrors the current-user-banned reset.
+                parentMessage: null,
+                parentMessageState: Thread_context_types.ParentMessageStateTypes.NIL,
+                threadMessages: [],
+                allThreadMessages: [],
+                localThreadMessages: [],
+                hasMorePrev: false,
+                hasMoreNext: false,
+            });
+        },
+        onCurrentUserBanned: function () {
+            updateState({
+                currentChannel: null,
+                channelState: Thread_context_types.ChannelStateTypes.NIL,
+                threadListState: Thread_context_types.ThreadListStateTypes.NIL,
+                parentMessage: null,
+                parentMessageState: Thread_context_types.ParentMessageStateTypes.NIL,
+                threadMessages: [],
+                allThreadMessages: [],
+                localThreadMessages: [],
+                hasMorePrev: false,
+                hasMoreNext: false,
+            });
+        },
+        onChannelUpdated: function (channel) {
+            updateState({
+                currentChannel: channel,
+                isChannelFrozen: (channel === null || channel === void 0 ? void 0 : channel.isFrozen) || false,
+            });
+        },
+    });
+    var threadListState = threadDataSource.loading && config.isOnline && parentMessageState === Thread_context_types.ParentMessageStateTypes.INITIALIZED
+        ? Thread_context_types.ThreadListStateTypes.LOADING
+        : threadDataSource.initialized
+            ? Thread_context_types.ThreadListStateTypes.INITIALIZED
+            : Thread_context_types.ThreadListStateTypes.NIL;
+    var hasMorePrev = threadDataSource.hasPrevious();
+    var hasMoreNext = threadDataSource.hasNext();
+    var store = React.useContext(ThreadContext);
+    var messagesSyncKey = threadDataSource.messages
+        .map(function (message) {
+        var uploadParams = message.messageParams;
+        var uploadState = (uploadParams === null || uploadParams === void 0 ? void 0 : uploadParams.fileInfoList)
+            ? uploadParams.fileInfoList.map(function (info) { var _a; return (_a = info.fileUrl) !== null && _a !== void 0 ? _a : ''; }).join(',')
+            : '';
+        return "".concat(JSON.stringify(message.serialize()), "#").concat(uploadState);
+    })
+        .join('~');
+    React.useEffect(function () {
+        if (!parentMessage)
+            return;
+        // core-ts scopes the collection to this thread's replies (belongsToThread on the event/fetch and
+        // send/resend paths), so mirror them as-is. Split into the legacy public shape: allThreadMessages =
+        // succeeded (server) messages, localThreadMessages = pending/failed; threadMessages = all of them.
+        var scopedMessages = threadDataSource.messages;
+        var localThreadMessages = scopedMessages.filter(function (m) {
+            var sendingStatus = m.sendingStatus;
+            return sendingStatus === message.SendingStatus.PENDING || sendingStatus === message.SendingStatus.FAILED;
+        });
+        var allThreadMessages = scopedMessages.filter(function (m) { return !localThreadMessages.includes(m); });
+        store === null || store === void 0 ? void 0 : store.setState(function (prev) { return (_tslib.__assign(_tslib.__assign({}, prev), { threadMessages: scopedMessages, allThreadMessages: allThreadMessages, localThreadMessages: localThreadMessages, hasMorePrev: hasMorePrev, hasMoreNext: hasMoreNext, threadListState: threadListState })); }, true);
+    }, [store, messagesSyncKey, parentMessage === null || parentMessage === void 0 ? void 0 : parentMessage.messageId, hasMorePrev, hasMoreNext, threadListState]);
+    React.useEffect(function () {
+        store === null || store === void 0 ? void 0 : store.setState(function (prev) { return (_tslib.__assign(_tslib.__assign({}, prev), { loadPrevious: threadDataSource.loadPrevious, loadNext: threadDataSource.loadNext, resetWithStartingPoint: threadDataSource.resetWithStartingPoint, dsSendUserMessage: threadDataSource.sendUserMessage, dsSendFileMessage: threadDataSource.sendFileMessage, dsSendMultipleFilesMessage: threadDataSource.sendMultipleFilesMessage, dsUpdateUserMessage: threadDataSource.updateUserMessage, dsResendMessage: threadDataSource.resendMessage, dsDeleteMessage: threadDataSource.deleteMessage })); }, true);
+    }, [store]);
+    // memo
+    var nicknamesMap = React.useMemo(function () { return ((config.groupChannel.replyType !== 'none' && currentChannel)
+        ? utils.getNicknamesMapFromMembers(currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.members)
+        : new Map()); }, [currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.members]);
+    useDeepCompareEffect.useDeepCompareEffect(function () {
+        updateState({
+            channelUrl: channelUrl,
+            message: message$1,
+            onHeaderActionClick: onHeaderActionClick,
+            onMoveToParentMessage: onMoveToParentMessage,
+            onBeforeSendUserMessage: onBeforeSendUserMessage,
+            onBeforeSendFileMessage: onBeforeSendFileMessage,
+            onBeforeSendVoiceMessage: onBeforeSendVoiceMessage,
+            onBeforeSendMultipleFilesMessage: onBeforeSendMultipleFilesMessage,
+            onBeforeDownloadFileMessage: onBeforeDownloadFileMessage,
+            isMultipleFilesMessageEnabled: isMultipleFilesMessageEnabled,
+            filterEmojiCategoryIds: filterEmojiCategoryIds,
+            nicknamesMap: nicknamesMap,
+        });
+    }, [
+        channelUrl,
+        message$1,
+        onHeaderActionClick,
+        onMoveToParentMessage,
+        onBeforeSendUserMessage,
+        onBeforeSendFileMessage,
+        onBeforeSendVoiceMessage,
+        onBeforeSendMultipleFilesMessage,
+        onBeforeDownloadFileMessage,
+        isMultipleFilesMessageEnabled,
+        filterEmojiCategoryIds,
+        nicknamesMap,
+    ]);
+    return null;
+};
+var ThreadProvider = function (props) {
+    var _a, _b;
+    var children = props.children;
+    return (React__default.default.createElement(InternalThreadProvider, _tslib.__assign({}, props),
+        React__default.default.createElement(ThreadManager, _tslib.__assign({ key: (_b = (_a = props.message) === null || _a === void 0 ? void 0 : _a.messageId) !== null && _b !== void 0 ? _b : 'thread' }, props)),
+        React__default.default.createElement(UserProfileContext.UserProfileProvider, _tslib.__assign({}, props), children)));
+};
+var useThreadContext = function () {
+    var _a = useThread(), state = _a.state, actions = _a.actions;
+    return _tslib.__assign(_tslib.__assign({}, state), actions);
+};
+var useThreadStore = function () {
+    return SendbirdContext.useStore(ThreadContext, function (state) { return state; }, initialState());
+};
+
+exports.InternalThreadProvider = InternalThreadProvider;
+exports.ThreadContext = ThreadContext;
+exports.ThreadManager = ThreadManager;
+exports.ThreadProvider = ThreadProvider;
+exports.useThread = useThread;
+exports.useThreadContext = useThreadContext;
+//# sourceMappingURL=bundle-CYSJJmTZ.js.map