@sendbird/uikit-react 3.15.13 → 3.15.14-rc

package/cjs/chunks/bundle-CPmEIY0J.js.map

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

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

@@ -1,9 +1,9 @@
 'use strict';
 
 var React = require('react');
-var pubSub_topics = require('./bundle-DWfeFlxG.js');
-var useSendbirdStateContext = require('../useSendbirdStateContext.js');
-var _tslib = require('./bundle-D1slQ3hS.js');
+var pubSub_topics = require('./bundle-DB7AA9OZ.js');
+var _tslib = require('./bundle-BPkbLqnu.js');
+var useSendbird = require('./bundle-BgQpYkVd.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -268,7 +268,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.useSendbirdStateContext(), stores = _d.stores, config = _d.config;
+    var _d = useSendbird.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;
@@ -341,4 +341,4 @@ exports.OpenChannelListActionTypes = OpenChannelListActionTypes$1;
 exports.OpenChannelListProvider = OpenChannelListProvider;
 exports.OpenChannelListProvider$1 = OpenChannelListProvider$1;
 exports.useOpenChannelListContext = useOpenChannelListContext;
-//# sourceMappingURL=bundle-DUanoG7J.js.map
+//# sourceMappingURL=bundle-CTa0qp2J.js.map

package/cjs/chunks/bundle-CTa0qp2J.js.map

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

package/cjs/chunks/{bundle-CNvRk1Z6.js → bundle-CVshjFAv.js}

@@ -19,4 +19,4 @@ var NodeNames = {
 exports.MessageInputKeys = MessageInputKeys;
 exports.NodeNames = NodeNames;
 exports.NodeTypes = NodeTypes;
-//# sourceMappingURL=bundle-CNvRk1Z6.js.map
+//# sourceMappingURL=bundle-CVshjFAv.js.map

package/cjs/chunks/bundle-CVshjFAv.js.map

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

package/cjs/chunks/{bundle-DeLEOQNO.js → bundle-C_Lbwszw.js}

@@ -1,11 +1,11 @@
 'use strict';
 
 var React = require('react');
-var pubSub_topics = require('./bundle-DWfeFlxG.js');
-var utils = require('./bundle-nWxq3V_Q.js');
+var pubSub_topics = require('./bundle-DB7AA9OZ.js');
+var utils = require('./bundle-DmbYmCTt.js');
 require('../utils/message/getOutgoingMessageState.js');
-require('./bundle-DE5YH8Q-.js');
-var consts = require('./bundle-BloKh_k7.js');
+require('./bundle-DKTpL0g1.js');
+var consts = require('./bundle-B6qGo4m1.js');
 
 var getNicknamesMapFromMembers = function (members) {
     if (members === void 0) { members = []; }
@@ -175,4 +175,4 @@ exports.getParentMessageFrom = getParentMessageFrom;
 exports.isAboutSame = isAboutSame;
 exports.scrollIntoLast = scrollIntoLast;
 exports.useSendMultipleFilesMessage = useSendMultipleFilesMessage;
-//# sourceMappingURL=bundle-DeLEOQNO.js.map
+//# sourceMappingURL=bundle-C_Lbwszw.js.map

package/cjs/chunks/{bundle-B5-vaN7x.js.map → bundle-C_Lbwszw.js.map}

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

package/cjs/chunks/{bundle-BfjugOIp.js → bundle-CayzfAtS.js}

@@ -1,8 +1,8 @@
 'use strict';
 
-var consts = require('./bundle-BloKh_k7.js');
-var useThrottleCallback = require('./bundle-DuSS5Dmw.js');
-var utils = require('./bundle-nWxq3V_Q.js');
+var consts = require('./bundle-B6qGo4m1.js');
+var useThrottleCallback = require('./bundle-BlmK-5Zz.js');
+var utils = require('./bundle-DmbYmCTt.js');
 var uikitTools = require('@sendbird/uikit-tools');
 
 var DELAY = 100;
@@ -52,4 +52,4 @@ function useHandleOnScrollCallback(_a) {
 }
 
 exports.useHandleOnScrollCallback = useHandleOnScrollCallback;
-//# sourceMappingURL=bundle-BfjugOIp.js.map
+//# sourceMappingURL=bundle-CayzfAtS.js.map

package/cjs/chunks/bundle-CayzfAtS.js.map

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

package/cjs/chunks/bundle-Cbdc9ZJY.js

@@ -0,0 +1,201 @@
+'use strict';
+
+var _tslib = require('./bundle-BPkbLqnu.js');
+var React = require('react');
+var groupChannel = require('@sendbird/chat/groupChannel');
+var uikitTools = require('@sendbird/uikit-tools');
+var UserProfileContext = require('./bundle-CK1N-Lna.js');
+var useMarkAsDeliveredScheduler = require('./bundle-BPPW92E3.js');
+var SendbirdContext = require('./bundle-LSngpiw3.js');
+var utils = require('./bundle-BDIgb36c.js');
+var useSendbird = require('./bundle-BgQpYkVd.js');
+var useDeepCompareEffect = require('./bundle-BxRRC13A.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultCompat(React);
+
+var useGroupChannelList = function () {
+    var store = React.useContext(GroupChannelListContext);
+    if (!store)
+        throw new Error('useGroupChannelList must be used within a GroupChannelListProvider');
+    var setGroupChannels = React.useCallback(function (channels) {
+        store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { groupChannels: channels })); }, true);
+    }, []);
+    var state = SendbirdContext.shimExports.useSyncExternalStore(store.subscribe, store.getState);
+    var actions = React.useMemo(function () { return ({
+        setGroupChannels: setGroupChannels,
+    }); }, [setGroupChannels]);
+    return { state: state, actions: actions };
+};
+
+var GroupChannelListContext = React__default.default.createContext(null);
+var initialState = {
+    className: '',
+    selectedChannelUrl: '',
+    disableAutoSelect: false,
+    allowProfileEdit: false,
+    isTypingIndicatorEnabled: false,
+    isMessageReceiptStatusEnabled: false,
+    onChannelSelect: function () { },
+    onChannelCreated: function () { },
+    onThemeChange: utils.noop,
+    onCreateChannelClick: utils.noop,
+    onBeforeCreateChannel: null,
+    onUserProfileUpdated: utils.noop,
+    typingChannelUrls: [],
+    refreshing: false,
+    initialized: false,
+    groupChannels: [],
+    refresh: null,
+    loadMore: null,
+    scrollRef: { current: null },
+};
+/**
+ * @returns {ReturnType<typeof createStore<GroupChannelListState>>}
+ */
+var useGroupChannelListStore = function () {
+    return SendbirdContext.useStore(GroupChannelListContext, function (state) { return state; }, initialState);
+};
+var GroupChannelListManager = function (_a) {
+    var _b, _c, _d, _e, _f, _g;
+    var _h = _a.className, className = _h === void 0 ? '' : _h, _j = _a.selectedChannelUrl, selectedChannelUrl = _j === void 0 ? '' : _j, _k = _a.disableAutoSelect, disableAutoSelect = _k === void 0 ? false : _k, channelListQueryParams = _a.channelListQueryParams, onThemeChange = _a.onThemeChange, onChannelSelect = _a.onChannelSelect, onChannelCreated = _a.onChannelCreated, onCreateChannelClick = _a.onCreateChannelClick, onBeforeCreateChannel = _a.onBeforeCreateChannel, onUserProfileUpdated = _a.onUserProfileUpdated, props = _tslib.__rest(_a, ["className", "selectedChannelUrl", "disableAutoSelect", "channelListQueryParams", "onThemeChange", "onChannelSelect", "onChannelCreated", "onCreateChannelClick", "onBeforeCreateChannel", "onUserProfileUpdated"]);
+    var sendbirdState = useSendbird.useSendbird().state;
+    var config = sendbirdState.config, stores = sendbirdState.stores;
+    var _l = useGroupChannelList(), state = _l.state, actions = _l.actions;
+    var updateState = useGroupChannelListStore().updateState;
+    var sdkStore = stores.sdkStore;
+    var sdk = sdkStore.sdk;
+    var isConnected = useMarkAsDeliveredScheduler.useOnlineStatus(sdk, config.logger);
+    var scheduler = useMarkAsDeliveredScheduler.useMarkAsDeliveredScheduler({ isConnected: isConnected }, config);
+    var scrollRef = React.useRef(null);
+    var channelListDataSource = uikitTools.useGroupChannelList(sdk, {
+        collectionCreator: getCollectionCreator(sdk, channelListQueryParams),
+        markAsDelivered: function (channels) { return channels.forEach(scheduler.push); },
+        onChannelsDeleted: function (channelUrls) {
+            channelUrls.forEach(function (url) {
+                if (url === selectedChannelUrl)
+                    onChannelSelect(null);
+            });
+        },
+        onChannelsUpdated: function () {
+            actions.setGroupChannels(groupChannels);
+        },
+    });
+    var refreshing = channelListDataSource.refreshing, initialized = channelListDataSource.initialized, groupChannels = channelListDataSource.groupChannels, refresh = channelListDataSource.refresh, loadMore = channelListDataSource.loadMore;
+    // SideEffect: Auto select channel
+    React.useEffect(function () {
+        var _a;
+        if (!disableAutoSelect && stores.sdkStore.initialized && initialized) {
+            if (!selectedChannelUrl)
+                onChannelSelect((_a = groupChannels[0]) !== null && _a !== void 0 ? _a : null);
+        }
+    }, [disableAutoSelect, stores.sdkStore.initialized, initialized, selectedChannelUrl]);
+    // Recreates the GroupChannelCollection when `channelListQueryParams` change
+    React.useEffect(function () {
+        refresh === null || refresh === void 0 ? void 0 : refresh();
+    }, [
+        Object.keys(channelListQueryParams !== null && channelListQueryParams !== void 0 ? channelListQueryParams : {}).sort()
+            .map(function (key) { return "".concat(key, "=").concat(encodeURIComponent(JSON.stringify(channelListQueryParams[key]))); })
+            .join('&'),
+    ]);
+    var typingChannelUrls = state.typingChannelUrls;
+    uikitTools.useGroupChannelHandler(sdk, {
+        onTypingStatusUpdated: function (channel) {
+            var _a;
+            var channelList = typingChannelUrls.filter(function (channelUrl) { return channelUrl !== channel.url; });
+            if (((_a = channel.getTypingUsers()) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+                updateState({
+                    typingChannelUrls: (channelList.concat(channel.url)),
+                });
+            }
+            else {
+                updateState({
+                    typingChannelUrls: (channelList),
+                });
+            }
+        },
+    });
+    var allowProfileEdit = (_c = (_b = props.allowProfileEdit) !== null && _b !== void 0 ? _b : config.allowProfileEdit) !== null && _c !== void 0 ? _c : true;
+    var isTypingIndicatorEnabled = (_e = (_d = props.isTypingIndicatorEnabled) !== null && _d !== void 0 ? _d : config.groupChannelList.enableTypingIndicator) !== null && _e !== void 0 ? _e : false;
+    var isMessageReceiptStatusEnabled = (_g = (_f = props.isMessageReceiptStatusEnabled) !== null && _f !== void 0 ? _f : config.groupChannelList.enableMessageReceiptStatus) !== null && _g !== void 0 ? _g : false;
+    var eventHandlers = React.useMemo(function () { return ({
+        onChannelSelect: onChannelSelect,
+        onChannelCreated: onChannelCreated,
+        onThemeChange: onThemeChange,
+        onCreateChannelClick: onCreateChannelClick,
+        onBeforeCreateChannel: onBeforeCreateChannel,
+        onUserProfileUpdated: onUserProfileUpdated,
+    }); }, [
+        onChannelSelect,
+        onChannelCreated,
+        onThemeChange,
+        onCreateChannelClick,
+        onBeforeCreateChannel,
+        onUserProfileUpdated,
+    ]);
+    var configurations = React.useMemo(function () { return ({
+        className: className,
+        selectedChannelUrl: selectedChannelUrl,
+        disableAutoSelect: disableAutoSelect,
+        allowProfileEdit: allowProfileEdit,
+        isTypingIndicatorEnabled: isTypingIndicatorEnabled,
+        isMessageReceiptStatusEnabled: isMessageReceiptStatusEnabled,
+        typingChannelUrls: typingChannelUrls,
+        refreshing: refreshing,
+        initialized: initialized,
+        refresh: refresh,
+        loadMore: loadMore,
+    }); }, [
+        className,
+        selectedChannelUrl,
+        disableAutoSelect,
+        allowProfileEdit,
+        isTypingIndicatorEnabled,
+        isMessageReceiptStatusEnabled,
+        typingChannelUrls,
+        refreshing,
+        initialized,
+        scrollRef,
+    ]);
+    useDeepCompareEffect.useDeepCompareEffect(function () {
+        updateState(_tslib.__assign(_tslib.__assign(_tslib.__assign({}, eventHandlers), configurations), { groupChannels: groupChannels }));
+    }, [
+        configurations,
+        eventHandlers,
+        groupChannels.map(function (groupChannel) { return groupChannel.serialize(); }),
+    ]);
+    return null;
+};
+var createGroupChannelListStore = function () { return SendbirdContext.createStore(initialState); };
+var InternalGroupChannelListProvider = function (_a) {
+    var children = _a.children;
+    var storeRef = React.useRef(createGroupChannelListStore());
+    return (React__default.default.createElement(GroupChannelListContext.Provider, { value: storeRef.current }, children));
+};
+var GroupChannelListProvider = function (props) {
+    var children = props.children, className = props.className;
+    return (React__default.default.createElement(InternalGroupChannelListProvider, null,
+        React__default.default.createElement(GroupChannelListManager, _tslib.__assign({}, props)),
+        React__default.default.createElement(UserProfileContext.UserProfileProvider, _tslib.__assign({}, props),
+            React__default.default.createElement("div", { className: "sendbird-channel-list ".concat(className) }, children))));
+};
+// Keep this function for backward compatibility.
+var useGroupChannelListContext = function () {
+    var _a = useGroupChannelList(), state = _a.state, actions = _a.actions;
+    return _tslib.__assign(_tslib.__assign({}, state), actions);
+};
+function getCollectionCreator(sdk, channelListQueryParams) {
+    return function (defaultParams) {
+        var params = _tslib.__assign(_tslib.__assign({}, defaultParams), channelListQueryParams);
+        return sdk.groupChannel.createGroupChannelCollection(_tslib.__assign(_tslib.__assign({}, params), { filter: new groupChannel.GroupChannelFilter(params) }));
+    };
+}
+
+exports.GroupChannelListContext = GroupChannelListContext;
+exports.GroupChannelListManager = GroupChannelListManager;
+exports.GroupChannelListProvider = GroupChannelListProvider;
+exports.useGroupChannelList = useGroupChannelList;
+exports.useGroupChannelListContext = useGroupChannelListContext;
+exports.useGroupChannelListStore = useGroupChannelListStore;
+//# sourceMappingURL=bundle-Cbdc9ZJY.js.map

package/cjs/chunks/bundle-Cbdc9ZJY.js.map

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

package/cjs/chunks/{bundle-BSfpBazH.js → bundle-CcGys-84.js}

@@ -1,8 +1,8 @@
 'use strict';
 
-var _tslib = require('./bundle-D1slQ3hS.js');
+var _tslib = require('./bundle-BPkbLqnu.js');
 var React = require('react');
-var MediaQueryContext = require('./bundle-B5aEwfu1.js');
+var MediaQueryContext = require('./bundle-D0lw9Bpa.js');
 
 var DEFAULT_DURATION = 300;
 function preventDefault(e) {
@@ -76,4 +76,4 @@ function useLongPress(_a, _b) {
 }
 
 exports.useLongPress = useLongPress;
-//# sourceMappingURL=bundle-BSfpBazH.js.map
+//# sourceMappingURL=bundle-CcGys-84.js.map

package/cjs/chunks/bundle-CcGys-84.js.map

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

package/cjs/chunks/{bundle-BAF8GaDh.js → bundle-Cgx64DbJ.js}

@@ -10,4 +10,4 @@ var isMobileIOS = function (userAgent) {
 
 exports.isMobileIOS = isMobileIOS;
 exports.isSafari = isSafari;
-//# sourceMappingURL=bundle-BAF8GaDh.js.map
+//# sourceMappingURL=bundle-Cgx64DbJ.js.map

package/cjs/chunks/bundle-Cgx64DbJ.js.map

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

package/cjs/chunks/{bundle-D-kYFL1Z.js → bundle-CkXIqGZB.js}

@@ -17,4 +17,4 @@ function useKeyDown(ref, keyDownCallbackMap) {
 }
 
 exports.useKeyDown = useKeyDown;
-//# sourceMappingURL=bundle-D-kYFL1Z.js.map
+//# sourceMappingURL=bundle-CkXIqGZB.js.map

package/cjs/chunks/bundle-CkXIqGZB.js.map

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

package/cjs/chunks/bundle-CmF5XsRI.js

@@ -0,0 +1,270 @@
+'use strict';
+
+var _tslib = require('./bundle-BPkbLqnu.js');
+var SendbirdContext = require('./bundle-LSngpiw3.js');
+var React = require('react');
+var useSendbird = require('./bundle-BgQpYkVd.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultCompat(React);
+
+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;
+    React.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 = React.useCallback(function (error) {
+        logger.warning('MessageSearch | useGetSearchedMessages: failed getting search messages.', error);
+        setQueryInvalid();
+        if (onResultLoaded && typeof onResultLoaded === 'function') {
+            onResultLoaded(undefined, error);
+        }
+    }, [logger, setQueryInvalid, onResultLoaded]);
+    React.useEffect(function () {
+        startMessageSearch();
+        if (sdk && channelUrl && sdk.createMessageSearchQuery && currentChannel && requestString) {
+            currentChannel.refresh()
+                .then(function (channel) {
+                var inputSearchMessageQueryObject = _tslib.__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 React.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 = React.useState(''), requestString = _b[0], setRequestString = _b[1];
+    var _c = React.useState(null), debouncingTimer = _c[0], setDebouncingTimer = _c[1];
+    var resetSearchString = useMessageSearch().actions.resetSearchString;
+    var handleSearchStringChange = React.useCallback(function () {
+        if (searchString) {
+            setRequestString(searchString);
+        }
+        else {
+            setRequestString('');
+            resetSearchString();
+        }
+    }, [searchString, resetSearchString]);
+    React.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 = React.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.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 = React.useRef(null);
+    useSetChannel({ channelUrl: channelUrl, sdkInit: sdkInit }, { sdk: sdk, logger: logger });
+    var _searchString = React.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 = React.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]);
+    React.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 SendbirdContext.createStore(initialState); };
+var InternalMessageSearchProvider = function (_a) {
+    var children = _a.children;
+    var storeRef = React.useRef(createMessageSearchStore());
+    return (React__default.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.default.createElement(InternalMessageSearchProvider, null,
+        React__default.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 _tslib.__assign(_tslib.__assign({}, state), actions);
+};
+/**
+ * A specialized hook for MessageSearch state management
+ * @returns {ReturnType<typeof createStore<MessageSearchState>>}
+ */
+var useMessageSearchStore = function () {
+    return SendbirdContext.useStore(MessageSearchContext, function (state) { return state; }, initialState);
+};
+
+var useMessageSearch = function () {
+    var store = React.useContext(MessageSearchContext);
+    if (!store)
+        throw new Error('useMessageSearch must be used within a MessageSearchProvider');
+    var state = SendbirdContext.shimExports.useSyncExternalStore(store.subscribe, store.getState);
+    var actions = React.useMemo(function () { return ({
+        setCurrentChannel: function (channel) { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { currentChannel: channel, initialized: true })); }); },
+        setChannelInvalid: function () { return store.setState(function (state) { return (_tslib.__assign(_tslib.__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 _tslib.__assign(_tslib.__assign({}, state), { loading: false, isInvalid: false, allMessages: messages, hasMoreResult: state.currentMessageSearchQuery.hasNext });
+                }
+                return state;
+            });
+        },
+        setQueryInvalid: function () { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { isInvalid: true })); }); },
+        startMessageSearch: function () { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { isInvalid: false, loading: false })); }); },
+        startGettingSearchedMessages: function (query) { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { loading: true, currentMessageSearchQuery: query })); }); },
+        getNextSearchedMessages: function (messages) { return store.setState(function (state) {
+            var _a;
+            return (_tslib.__assign(_tslib.__assign({}, state), { allMessages: _tslib.__spreadArray(_tslib.__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 (_tslib.__assign(_tslib.__assign({}, state), { allMessages: [] })); }); },
+        setSelectedMessageId: function (messageId) { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { selectedMessageId: messageId })); }); },
+        handleRetryToConnect: function () { return store.setState(function (state) { return (_tslib.__assign(_tslib.__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 (_tslib.__assign(_tslib.__assign({}, state), { retryCount: state.retryCount + 1 })); }); },
+    }); }, [store]);
+    return { state: state, actions: actions };
+};
+
+exports.MessageSearchContext = MessageSearchContext;
+exports.MessageSearchManager = MessageSearchManager;
+exports.MessageSearchProvider = MessageSearchProvider;
+exports.useMessageSearch = useMessageSearch;
+exports.useMessageSearchContext = useMessageSearchContext;
+//# sourceMappingURL=bundle-CmF5XsRI.js.map

package/cjs/chunks/bundle-CmF5XsRI.js.map

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

package/cjs/chunks/{bundle-BOCivP7e.js → bundle-CmJi_0Nb.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var consts = require('./bundle-BloKh_k7.js');
+var consts = require('./bundle-B6qGo4m1.js');
 var lame_all = require('../lame.all.js');
 
 // Thanks to https://codesandbox.io/s/media-recorder-api-downsampling-16k-mp3-encode-using-lame-js-forked-n1pblw
@@ -129,4 +129,4 @@ function bufferToWav(abuffer, len) {
 
 exports.downsampleToWav = downsampleToWav;
 exports.encodeMp3 = encodeMp3;
-//# sourceMappingURL=bundle-BOCivP7e.js.map
+//# sourceMappingURL=bundle-CmJi_0Nb.js.map

package/cjs/chunks/bundle-CmJi_0Nb.js.map

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