@sendbird/uikit-react 3.15.13 → 3.15.14-rc

package/chunks/{bundle-CcHvUx-a.js → bundle-DloA6aeM.js}

@@ -1,15 +1,16 @@
-import { a as __awaiter, b as __generator, d as __rest, _ as __assign } from './bundle-C7jYHvwG.js';
+import { b as __awaiter, c as __generator, d as __rest, _ as __assign } from './bundle-Cj5_JUGB.js';
 import React__default, { useState, useRef, useCallback, createContext, useContext } from 'react';
 import { Role } from '@sendbird/chat';
 import { OpenChannel } from '@sendbird/chat/openChannel';
-import { useSendbirdStateContext } from '../useSendbirdStateContext.js';
-import '../withSendbird.js';
-import { a as MenuItem, b as MenuItems } from './bundle-C6-Ix-Lk.js';
+import { u as useSendbird } from './bundle-CDp-g5XU.js';
+import { a as MenuItem, b as MenuItems } from './bundle-B-hLTjcZ.js';
 import 'react-dom';
 import IconButton from '../ui/IconButton.js';
-import './bundle-DYeeW5nS.js';
-import { u as useLocalization } from './bundle-CIN9yQRB.js';
-import { c as classnames } from './bundle-DUTyBaXr.js';
+import './bundle-DbJ8lyIW.js';
+import { u as useLocalization } from './bundle-BdjfIRue.js';
+import './bundle-m1et25Jg.js';
+import '@sendbird/chat/groupChannel';
+import { c as classnames } from './bundle-BY9oUVFG.js';
 import Icon, { IconTypes, IconColors } from '../ui/Icon.js';
 
 // Utility function to handle processing state and promise execution
@@ -158,7 +159,7 @@ var useToggleBan = function (_a) {
 var UserListItemMenuContext = createContext(undefined);
 var UserListItemMenuProvider = function (_a) {
     var children = _a.children, values = __rest(_a, ["children"]);
-    var config = useSendbirdStateContext().config;
+    var config = useSendbird().state.config;
     var currentUserId = config.userId;
     var channel = values.channel, user = values.user;
     var isCurrentUser = user.userId === currentUserId;
@@ -247,7 +248,7 @@ var UserListItemMenu = function (props) {
     var _c = useState(false), isMenuVisible = _c[0], setMenuVisibility = _c[1];
     var containerRef = useRef(null);
     var triggerRef = useRef(null);
-    var config = useSendbirdStateContext().config;
+    var config = useSendbird().state.config;
     var currentUserId = config.userId;
     var toggleMenu = function () {
         setMenuVisibility(function (prev) { return !prev; });
@@ -275,4 +276,4 @@ var UserListItemMenu = function (props) {
 };
 
 export { UserListItemMenu as U, UserListItemMenuProvider as a, useUserListItemMenuContext as u };
-//# sourceMappingURL=bundle-CcHvUx-a.js.map
+//# sourceMappingURL=bundle-DloA6aeM.js.map

package/chunks/{bundle-CcHvUx-a.js.map → bundle-DloA6aeM.js.map}

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

package/chunks/{bundle-P-vXuw8U.js → bundle-DqDF0kxo.js}

@@ -1,4 +1,4 @@
 var TEXT_MESSAGE_BODY_CLASSNAME = 'sendbird-text-message-item-body';
 
 export { TEXT_MESSAGE_BODY_CLASSNAME as T };
-//# sourceMappingURL=bundle-P-vXuw8U.js.map
+//# sourceMappingURL=bundle-DqDF0kxo.js.map

package/chunks/bundle-DqDF0kxo.js.map

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

package/chunks/{bundle-k6zcGkBp.js → bundle-Dw8813nX.js}

@@ -1,10 +1,10 @@
 import React__default from 'react';
-import { K } from './bundle-DYeeW5nS.js';
-import { T as TOKEN_TYPES, a as tokenizeMarkdown, U as USER_MENTION_PREFIX, b as getWhiteSpacePreservedText } from './bundle-_-FiwcfQ.js';
+import { K } from './bundle-CClknHGO.js';
+import { T as TOKEN_TYPES, a as tokenizeMarkdown, U as USER_MENTION_PREFIX, b as getWhiteSpacePreservedText } from './bundle-BJw1wPlD.js';
 import { useMessageContext } from '../Message/context.js';
 import MentionLabel from '../ui/MentionLabel.js';
 import LinkLabel from '../ui/LinkLabel.js';
-import { a as LabelTypography, b as LabelColors } from './bundle-DImSV9VW.js';
+import { a as LabelTypography, b as LabelColors } from './bundle-CyiL7cM0.js';
 
 // this function is used to generate a unique key for token in message
 // it changes with updated time and index
@@ -66,4 +66,4 @@ function TextFragment(_a) {
 }
 
 export { TextFragment as T };
-//# sourceMappingURL=bundle-k6zcGkBp.js.map
+//# sourceMappingURL=bundle-Dw8813nX.js.map

package/chunks/bundle-Dw8813nX.js.map

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

package/chunks/{bundle-BP1CB0js.js → bundle-DwSHHkPT.js}

@@ -5,4 +5,4 @@ var TypingIndicatorType;
 })(TypingIndicatorType || (TypingIndicatorType = {}));
 
 export { TypingIndicatorType as T };
-//# sourceMappingURL=bundle-BP1CB0js.js.map
+//# sourceMappingURL=bundle-DwSHHkPT.js.map

package/chunks/bundle-DwSHHkPT.js.map

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

package/chunks/{bundle-pOZPN8hk.js → bundle-DxxvrMQI.js}

@@ -247,4 +247,4 @@ var getStringSet = function (lang) {
 };
 
 export { getStringSet as g };
-//# sourceMappingURL=bundle-pOZPN8hk.js.map
+//# sourceMappingURL=bundle-DxxvrMQI.js.map

package/chunks/{bundle-pOZPN8hk.js.map → bundle-DxxvrMQI.js.map}

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

package/chunks/{bundle-C9dF4QVS.js → bundle-DyUM-cLB.js}

@@ -15,4 +15,4 @@ var NodeNames = {
 };
 
 export { MessageInputKeys as M, NodeTypes as N, NodeNames as a };
-//# sourceMappingURL=bundle-C9dF4QVS.js.map
+//# sourceMappingURL=bundle-DyUM-cLB.js.map

package/chunks/bundle-DyUM-cLB.js.map

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

package/chunks/{bundle-BP1DBRft.js → bundle-HWQAzYJv.js}

@@ -1,9 +1,9 @@
 import { useCallback } from 'react';
-import { p as pubSubTopics, s as shouldPubSubPublishToChannel, a as shouldPubSubPublishToThread } from './bundle-MkyS3j4-.js';
-import { s as scrollIntoLast$1 } from './bundle-Deel9XzY.js';
+import { p as pubSubTopics, s as shouldPubSubPublishToChannel, a as shouldPubSubPublishToThread } from './bundle-CdizyEdk.js';
+import { s as scrollIntoLast$1 } from './bundle-B_2pLVhC.js';
 import '../utils/message/getOutgoingMessageState.js';
-import './bundle-CIN9yQRB.js';
-import { d as SCROLL_BOTTOM_DELAY_FOR_SEND } from './bundle-DkviGBGz.js';
+import './bundle-BdjfIRue.js';
+import { e as SCROLL_BOTTOM_DELAY_FOR_SEND } from './bundle-BznbvczW.js';
 
 var getNicknamesMapFromMembers = function (members) {
     if (members === void 0) { members = []; }
@@ -168,4 +168,4 @@ var useSendMultipleFilesMessage = function (_a, _b) {
 };
 
 export { getNicknamesMapFromMembers as a, compareIds as c, getParentMessageFrom as g, isAboutSame as i, scrollIntoLast as s, useSendMultipleFilesMessage as u };
-//# sourceMappingURL=bundle-BP1DBRft.js.map
+//# sourceMappingURL=bundle-HWQAzYJv.js.map

package/chunks/{bundle-BP1DBRft.js.map → bundle-HWQAzYJv.js.map}

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

package/chunks/{bundle-DLlgZtQy.js → bundle-I8q8yCrt.js}

@@ -1,7 +1,7 @@
 import React__default, { useCallback, useEffect, useContext, useReducer } from 'react';
-import { p as pubSubTopics } from './bundle-MkyS3j4-.js';
-import { useSendbirdStateContext } from '../useSendbirdStateContext.js';
-import { _ as __assign, c as __spreadArray } from './bundle-C7jYHvwG.js';
+import { p as pubSubTopics } from './bundle-CdizyEdk.js';
+import { _ as __assign, a as __spreadArray } from './bundle-Cj5_JUGB.js';
+import { u as useSendbird } from './bundle-CDp-g5XU.js';
 
 var OpenChannelListFetchingStatus;
 (function (OpenChannelListFetchingStatus) {
@@ -262,7 +262,7 @@ var OpenChannelListProvider = function (_a) {
     var _b, _c;
     var className = _a.className, children = _a.children, queries = _a.queries, onChannelSelected = _a.onChannelSelected;
     // props
-    var _d = useSendbirdStateContext(), stores = _d.stores, config = _d.config;
+    var _d = useSendbird().state, stores = _d.stores, config = _d.config;
     var logger = config.logger, pubSub = config.pubSub;
     var sdk = ((_b = stores === null || stores === void 0 ? void 0 : stores.sdkStore) === null || _b === void 0 ? void 0 : _b.sdk) || null;
     var sdkInitialized = ((_c = stores === null || stores === void 0 ? void 0 : stores.sdkStore) === null || _c === void 0 ? void 0 : _c.initialized) || false;
@@ -332,4 +332,4 @@ var OpenChannelListProvider$1 = {
 };
 
 export { OpenChannelListProvider as O, OpenChannelListFetchingStatus as a, OpenChannelListActionTypes$1 as b, OpenChannelListProvider$1 as c, useOpenChannelListContext as u };
-//# sourceMappingURL=bundle-DLlgZtQy.js.map
+//# sourceMappingURL=bundle-I8q8yCrt.js.map

package/{cjs/chunks/bundle-DUanoG7J.js.map → chunks/bundle-I8q8yCrt.js.map}

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

package/chunks/{bundle-CzdrQ_Yq.js → bundle-IJCJg91y.js}

@@ -11,4 +11,4 @@ function compareIds(a, b) {
 }
 
 export { compareIds as c };
-//# sourceMappingURL=bundle-CzdrQ_Yq.js.map
+//# sourceMappingURL=bundle-IJCJg91y.js.map

package/chunks/bundle-IJCJg91y.js.map

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

package/chunks/bundle-JsdOq6pg.js

@@ -0,0 +1,260 @@
+import { _ as __assign, a as __spreadArray } from './bundle-Cj5_JUGB.js';
+import { u as useStore, c as createStore, s as shimExports } from './bundle-m1et25Jg.js';
+import React__default, { useEffect, useCallback, useState, createContext, useRef, useMemo, useContext } from 'react';
+import { u as useSendbird } from './bundle-CDp-g5XU.js';
+
+function useSetChannel(_a, _b) {
+    var channelUrl = _a.channelUrl, sdkInit = _a.sdkInit;
+    var sdk = _b.sdk, logger = _b.logger;
+    var _c = useMessageSearch().actions, setCurrentChannel = _c.setCurrentChannel, setChannelInvalid = _c.setChannelInvalid;
+    useEffect(function () {
+        if (channelUrl && sdkInit && (sdk === null || sdk === void 0 ? void 0 : sdk.groupChannel)) {
+            sdk.groupChannel.getChannel(channelUrl)
+                .then(function (groupChannel) {
+                logger.info('MessageSearch | useSetChannel group channel', groupChannel);
+                setCurrentChannel(groupChannel);
+            })
+                .catch(function () {
+                setChannelInvalid();
+            });
+        }
+    }, [channelUrl, sdkInit]);
+}
+
+var MessageSearchOrder;
+(function (MessageSearchOrder) {
+    MessageSearchOrder["SCORE"] = "score";
+    MessageSearchOrder["TIMESTAMP"] = "ts";
+})(MessageSearchOrder || (MessageSearchOrder = {}));
+function useGetSearchedMessages(_a, _b) {
+    var currentChannel = _a.currentChannel, channelUrl = _a.channelUrl, requestString = _a.requestString, messageSearchQuery = _a.messageSearchQuery, onResultLoaded = _a.onResultLoaded;
+    var sdk = _b.sdk, logger = _b.logger;
+    var _c = useMessageSearch(), retryCount = _c.state.retryCount, _d = _c.actions, startMessageSearch = _d.startMessageSearch, getSearchedMessages = _d.getSearchedMessages, setQueryInvalid = _d.setQueryInvalid, startGettingSearchedMessages = _d.startGettingSearchedMessages;
+    var handleSearchError = useCallback(function (error) {
+        logger.warning('MessageSearch | useGetSearchedMessages: failed getting search messages.', error);
+        setQueryInvalid();
+        if (onResultLoaded && typeof onResultLoaded === 'function') {
+            onResultLoaded(undefined, error);
+        }
+    }, [logger, setQueryInvalid, onResultLoaded]);
+    useEffect(function () {
+        startMessageSearch();
+        if (sdk && channelUrl && sdk.createMessageSearchQuery && currentChannel && requestString) {
+            currentChannel.refresh()
+                .then(function (channel) {
+                var inputSearchMessageQueryObject = __assign({ order: MessageSearchOrder.TIMESTAMP, channelUrl: channelUrl, messageTimestampFrom: channel.invitedAt, keyword: requestString }, messageSearchQuery);
+                var createdQuery = sdk.createMessageSearchQuery(inputSearchMessageQueryObject);
+                startGettingSearchedMessages(createdQuery);
+                createdQuery.next().then(function (messages) {
+                    logger.info('MessageSearch | useGetSearchedMessages: succeeded getting messages', messages);
+                    getSearchedMessages(messages, createdQuery);
+                    if (onResultLoaded && typeof onResultLoaded === 'function') {
+                        onResultLoaded(messages, undefined);
+                    }
+                }).catch(handleSearchError);
+            })
+                .catch(function (error) {
+                logger.warning('MessageSearch | useGetSearchedMessages: failed getting channel.', error);
+                handleSearchError(error);
+            });
+        }
+        else if (!requestString) {
+            logger.info('MessageSearch | useGetSearchedMessages: search string is empty');
+        }
+    }, [channelUrl, messageSearchQuery, requestString, currentChannel, retryCount]);
+}
+
+function useScrollCallback(_a, _b) {
+    var onResultLoaded = _a.onResultLoaded;
+    var logger = _b.logger;
+    var _c = useMessageSearch(), _d = _c.state, currentMessageSearchQuery = _d.currentMessageSearchQuery, hasMoreResult = _d.hasMoreResult, getNextSearchedMessages = _c.actions.getNextSearchedMessages;
+    return useCallback(function (cb) {
+        if (!hasMoreResult) {
+            logger.warning('MessageSearch | useScrollCallback: no more searched results', hasMoreResult);
+        }
+        if (currentMessageSearchQuery && currentMessageSearchQuery.hasNext) {
+            currentMessageSearchQuery
+                .next()
+                .then(function (messages) {
+                logger.info('MessageSearch | useScrollCallback: succeeded getting searched messages', messages);
+                getNextSearchedMessages(messages);
+                cb(messages, null);
+                if (onResultLoaded && typeof onResultLoaded === 'function') {
+                    onResultLoaded(messages, null);
+                }
+            })
+                .catch(function (error) {
+                logger.warning('MessageSearch | useScrollCallback: failed getting searched messages', error);
+                cb(null, error);
+                if (onResultLoaded && typeof onResultLoaded === 'function') {
+                    onResultLoaded(null, error);
+                }
+            });
+        }
+        else {
+            logger.warning('MessageSearch | useScrollCallback: no currentMessageSearchQuery');
+        }
+    }, [currentMessageSearchQuery, hasMoreResult]);
+}
+
+var DEBOUNCING_TIME = 500;
+function useSearchStringEffect(_a) {
+    var searchString = _a.searchString;
+    var _b = useState(''), requestString = _b[0], setRequestString = _b[1];
+    var _c = useState(null), debouncingTimer = _c[0], setDebouncingTimer = _c[1];
+    var resetSearchString = useMessageSearch().actions.resetSearchString;
+    var handleSearchStringChange = useCallback(function () {
+        if (searchString) {
+            setRequestString(searchString);
+        }
+        else {
+            setRequestString('');
+            resetSearchString();
+        }
+    }, [searchString, resetSearchString]);
+    useEffect(function () {
+        if (debouncingTimer) {
+            clearTimeout(debouncingTimer);
+        }
+        var timer = setTimeout(handleSearchStringChange, DEBOUNCING_TIME);
+        setDebouncingTimer(timer);
+        return function () {
+            if (timer) {
+                clearTimeout(timer);
+            }
+        };
+    }, [searchString, handleSearchStringChange]);
+    return requestString;
+}
+
+var initialState = {
+    channelUrl: '',
+    allMessages: [],
+    loading: false,
+    isInvalid: false,
+    initialized: false,
+    currentChannel: null,
+    currentMessageSearchQuery: null,
+    messageSearchQuery: null,
+    hasMoreResult: false,
+    retryCount: 0,
+    selectedMessageId: null,
+    searchString: '',
+    requestString: '',
+    /**
+     * messageSearchDispatcher is no longer used.
+     * Please use useMessageSearch() to get the store and update the state.
+     */
+    // messageSearchDispatcher: null,
+};
+var MessageSearchContext = createContext(null);
+var MessageSearchManager = function (_a) {
+    var _b, _c;
+    var channelUrl = _a.channelUrl, searchString = _a.searchString, messageSearchQuery = _a.messageSearchQuery, onResultLoaded = _a.onResultLoaded, onResultClick = _a.onResultClick;
+    var _d = useMessageSearchStore(), state = _d.state, updateState = _d.updateState;
+    var _e = useSendbird().state, config = _e.config, stores = _e.stores;
+    var sdk = (_b = stores === null || stores === void 0 ? void 0 : stores.sdkStore) === null || _b === void 0 ? void 0 : _b.sdk;
+    var sdkInit = (_c = stores === null || stores === void 0 ? void 0 : stores.sdkStore) === null || _c === void 0 ? void 0 : _c.initialized;
+    var logger = config.logger;
+    var scrollRef = useRef(null);
+    useSetChannel({ channelUrl: channelUrl, sdkInit: sdkInit }, { sdk: sdk, logger: logger });
+    var _searchString = useMemo(function () {
+        var _a;
+        return (_a = searchString !== null && searchString !== void 0 ? searchString : messageSearchQuery === null || messageSearchQuery === void 0 ? void 0 : messageSearchQuery.keyword) !== null && _a !== void 0 ? _a : '';
+    }, [searchString, messageSearchQuery === null || messageSearchQuery === void 0 ? void 0 : messageSearchQuery.keyword]);
+    var requestString = useSearchStringEffect({ searchString: _searchString });
+    useGetSearchedMessages({
+        currentChannel: state.currentChannel,
+        channelUrl: channelUrl,
+        requestString: requestString,
+        messageSearchQuery: messageSearchQuery,
+        onResultLoaded: onResultLoaded,
+    }, { sdk: sdk, logger: logger });
+    var onScroll = useScrollCallback({ onResultLoaded: onResultLoaded }, { logger: logger });
+    var handleOnScroll = useCallback(function (e) {
+        var scrollElement = e.target;
+        var scrollTop = scrollElement.scrollTop, scrollHeight = scrollElement.scrollHeight, clientHeight = scrollElement.clientHeight;
+        if (!state.hasMoreResult) {
+            return;
+        }
+        if (scrollTop + clientHeight >= scrollHeight) {
+            onScroll(function () {
+                // after load more searched messages
+            });
+        }
+    }, [state.hasMoreResult, onScroll]);
+    useEffect(function () {
+        updateState({
+            channelUrl: channelUrl,
+            searchString: _searchString,
+            messageSearchQuery: messageSearchQuery,
+            onResultClick: onResultClick,
+            onScroll: onScroll,
+            handleOnScroll: handleOnScroll,
+            scrollRef: scrollRef,
+            requestString: requestString,
+        });
+    }, [channelUrl, searchString, messageSearchQuery, onResultClick, updateState, requestString]);
+    return null;
+};
+var createMessageSearchStore = function () { return createStore(initialState); };
+var InternalMessageSearchProvider = function (_a) {
+    var children = _a.children;
+    var storeRef = useRef(createMessageSearchStore());
+    return (React__default.createElement(MessageSearchContext.Provider, { value: storeRef.current }, children));
+};
+var MessageSearchProvider = function (_a) {
+    var children = _a.children, channelUrl = _a.channelUrl, searchString = _a.searchString, messageSearchQuery = _a.messageSearchQuery, onResultLoaded = _a.onResultLoaded, onResultClick = _a.onResultClick;
+    return (React__default.createElement(InternalMessageSearchProvider, null,
+        React__default.createElement(MessageSearchManager, { channelUrl: channelUrl, searchString: searchString, messageSearchQuery: messageSearchQuery, onResultLoaded: onResultLoaded, onResultClick: onResultClick }),
+        children));
+};
+// Keep this function for backward compatibility.
+var useMessageSearchContext = function () {
+    var _a = useMessageSearch(), state = _a.state, actions = _a.actions;
+    return __assign(__assign({}, state), actions);
+};
+/**
+ * A specialized hook for MessageSearch state management
+ * @returns {ReturnType<typeof createStore<MessageSearchState>>}
+ */
+var useMessageSearchStore = function () {
+    return useStore(MessageSearchContext, function (state) { return state; }, initialState);
+};
+
+var useMessageSearch = function () {
+    var store = useContext(MessageSearchContext);
+    if (!store)
+        throw new Error('useMessageSearch must be used within a MessageSearchProvider');
+    var state = shimExports.useSyncExternalStore(store.subscribe, store.getState);
+    var actions = useMemo(function () { return ({
+        setCurrentChannel: function (channel) { return store.setState(function (state) { return (__assign(__assign({}, state), { currentChannel: channel, initialized: true })); }); },
+        setChannelInvalid: function () { return store.setState(function (state) { return (__assign(__assign({}, state), { currentChannel: null, initialized: false })); }); },
+        getSearchedMessages: function (messages, createdQuery) {
+            store.setState(function (state) {
+                var _a;
+                if (createdQuery && createdQuery.channelUrl === ((_a = state.currentMessageSearchQuery) === null || _a === void 0 ? void 0 : _a.channelUrl)
+                    && createdQuery.key === state.currentMessageSearchQuery.key) {
+                    return __assign(__assign({}, state), { loading: false, isInvalid: false, allMessages: messages, hasMoreResult: state.currentMessageSearchQuery.hasNext });
+                }
+                return state;
+            });
+        },
+        setQueryInvalid: function () { return store.setState(function (state) { return (__assign(__assign({}, state), { isInvalid: true })); }); },
+        startMessageSearch: function () { return store.setState(function (state) { return (__assign(__assign({}, state), { isInvalid: false, loading: false })); }); },
+        startGettingSearchedMessages: function (query) { return store.setState(function (state) { return (__assign(__assign({}, state), { loading: true, currentMessageSearchQuery: query })); }); },
+        getNextSearchedMessages: function (messages) { return store.setState(function (state) {
+            var _a;
+            return (__assign(__assign({}, state), { allMessages: __spreadArray(__spreadArray([], state.allMessages, true), messages, true), hasMoreResult: ((_a = state.currentMessageSearchQuery) === null || _a === void 0 ? void 0 : _a.hasNext) || false }));
+        }); },
+        resetSearchString: function () { return store.setState(function (state) { return (__assign(__assign({}, state), { allMessages: [] })); }); },
+        setSelectedMessageId: function (messageId) { return store.setState(function (state) { return (__assign(__assign({}, state), { selectedMessageId: messageId })); }); },
+        handleRetryToConnect: function () { return store.setState(function (state) { return (__assign(__assign({}, state), { retryCount: state.retryCount + 1 })); }); },
+        // Looks exactly same as handleRetryToConnect but keep just for backward compatibility
+        setRetryCount: function () { return store.setState(function (state) { return (__assign(__assign({}, state), { retryCount: state.retryCount + 1 })); }); },
+    }); }, [store]);
+    return { state: state, actions: actions };
+};
+
+export { MessageSearchContext as M, MessageSearchProvider as a, useMessageSearchContext as b, MessageSearchManager as c, useMessageSearch as u };
+//# sourceMappingURL=bundle-JsdOq6pg.js.map

package/chunks/bundle-JsdOq6pg.js.map

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

package/{cjs/chunks/bundle-DE5YH8Q-.js → chunks/bundle-KQc1NYs1.js}

@@ -1,13 +1,3 @@
-'use strict';
-
-var _tslib = require('./bundle-D1slQ3hS.js');
-var React = require('react');
-var stringSet = require('./bundle-DzEGN4bG.js');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
-
-var React__default = /*#__PURE__*/_interopDefaultCompat(React);
-
 var formatDistanceLocale = {
   lessThanXSeconds: {
     one: 'less than a second',
@@ -486,25 +476,5 @@ var locale = {
   }
 };
 
-var LocalizationContextDefault = {
-    stringSet: stringSet.getStringSet('en'),
-    dateLocale: locale,
-};
-var LocalizationContext = React__default.default.createContext(LocalizationContextDefault);
-var LocalizationProvider = function (props) {
-    var children = props.children;
-    return React__default.default.createElement(LocalizationContext.Provider, { value: _tslib.__assign(_tslib.__assign({}, LocalizationContextDefault), props) }, children);
-};
-var useLocalization = function () {
-    var context = React__default.default.useContext(LocalizationContext);
-    if (!context) {
-        throw new Error('`useLocalization` hook must be used within `SendbirdProvider` that includes `LocalizationProvider`.');
-    }
-    return context;
-};
-
-exports.LocalizationContext = LocalizationContext;
-exports.LocalizationProvider = LocalizationProvider;
-exports.locale = locale;
-exports.useLocalization = useLocalization;
-//# sourceMappingURL=bundle-DE5YH8Q-.js.map
+export { locale as l };
+//# sourceMappingURL=bundle-KQc1NYs1.js.map