@sendbird/uikit-react 3.15.13 → 3.15.14

package/chunks/{bundle-DImSV9VW.js → bundle-HspRRkmy.js}

@@ -1,6 +1,6 @@
-import { c as __spreadArray } from './bundle-C7jYHvwG.js';
+import { a as __spreadArray } from './bundle-B8Grfnrx.js';
 import React__default, { forwardRef } from 'react';
-import { g as getStringSet } from './bundle-pOZPN8hk.js';
+import { g as getStringSet } from './bundle-Y2KBbxRr.js';
 
 var Typography = {
     H_1: 'H_1',
@@ -83,4 +83,4 @@ var LabelColors = Colors;
 var LabelStringSet = getStringSet('en');
 
 export { Label as L, LabelTypography as a, LabelColors as b, LabelStringSet as c, changeColorToClassName as d };
-//# sourceMappingURL=bundle-DImSV9VW.js.map
+//# sourceMappingURL=bundle-HspRRkmy.js.map

package/chunks/bundle-HspRRkmy.js.map

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

package/chunks/bundle-I25ah_Bv.js

@@ -0,0 +1,257 @@
+import { _ as __assign, b as __awaiter, c as __generator } from './bundle-B8Grfnrx.js';
+import { S as SendbirdContext, s as shimExports } from './bundle-C4OmfIXk.js';
+import { useContext, useMemo } from 'react';
+import SendbirdChat, { SendbirdProduct, SendbirdPlatform, DeviceOsPlatform } from '@sendbird/chat';
+import { GroupChannelModule } from '@sendbird/chat/groupChannel';
+import { OpenChannelModule } from '@sendbird/chat/openChannel';
+
+var updateAppInfoStore = function (state, payload) {
+    return __assign(__assign({}, state), { stores: __assign(__assign({}, state.stores), { appInfoStore: __assign(__assign({}, state.stores.appInfoStore), payload) }) });
+};
+var updateSdkStore = function (state, payload) {
+    return __assign(__assign({}, state), { stores: __assign(__assign({}, state.stores), { sdkStore: __assign(__assign({}, state.stores.sdkStore), payload) }) });
+};
+var updateUserStore = function (state, payload) {
+    return __assign(__assign({}, state), { stores: __assign(__assign({}, state.stores), { userStore: __assign(__assign({}, state.stores.userStore), payload) }) });
+};
+function initSDK(_a) {
+    var appId = _a.appId, customApiHost = _a.customApiHost, customWebSocketHost = _a.customWebSocketHost, _b = _a.sdkInitParams, sdkInitParams = _b === void 0 ? {} : _b;
+    var params = Object.assign(sdkInitParams, {
+        appId: appId,
+        modules: [new GroupChannelModule(), new OpenChannelModule()],
+        // newInstance: isNewApp,
+        localCacheEnabled: true,
+    });
+    if (customApiHost)
+        params.customApiHost = customApiHost;
+    if (customWebSocketHost)
+        params.customWebSocketHost = customWebSocketHost;
+    return SendbirdChat.init(params);
+}
+var APP_VERSION_STRING = '3.15.14';
+/**
+ * Sets up the Sendbird SDK after initialization.
+ * Configures necessary settings, adds extensions, sets the platform, and configures the session handler if provided.
+ */
+function setupSDK(sdk, params) {
+    var _a, _b;
+    var logger = params.logger, sessionHandler = params.sessionHandler, isMobile = params.isMobile, customExtensionParams = params.customExtensionParams;
+    (_a = logger.info) === null || _a === void 0 ? void 0 : _a.call(logger, 'SendbirdProvider | useConnect/setupConnection/setVersion', { version: APP_VERSION_STRING });
+    sdk.addExtension('sb_uikit', APP_VERSION_STRING);
+    sdk.addSendbirdExtensions([{ product: SendbirdProduct.UIKIT_CHAT, version: APP_VERSION_STRING, platform: SendbirdPlatform === null || SendbirdPlatform === void 0 ? void 0 : SendbirdPlatform.JS }], { platform: isMobile ? DeviceOsPlatform.MOBILE_WEB : DeviceOsPlatform.WEB }, customExtensionParams);
+    if (sessionHandler) {
+        (_b = logger.info) === null || _b === void 0 ? void 0 : _b.call(logger, 'SendbirdProvider | useConnect/setupConnection/configureSession', sessionHandler);
+        sdk.setSessionHandler(sessionHandler);
+    }
+}
+
+var NO_CONTEXT_ERROR = 'No sendbird state value available. Make sure you are rendering `<SendbirdProvider>` at the top of your app.';
+var useSendbird = function () {
+    var store = useContext(SendbirdContext);
+    if (!store)
+        throw new Error(NO_CONTEXT_ERROR);
+    var state = shimExports.useSyncExternalStore(store.subscribe, store.getState);
+    var actions = useMemo(function () { return ({
+        /* Example: How to set the state basically */
+        // exampleAction: () => {
+        //   store.setState((state): SendbirdState => ({
+        //     ...state,
+        //     example: true,
+        //   })),
+        // },
+        /* AppInfo */
+        initMessageTemplateInfo: function (_a) {
+            var payload = _a.payload;
+            store.setState(function (state) { return (updateAppInfoStore(state, {
+                messageTemplatesInfo: payload,
+                waitingTemplateKeysMap: {},
+            })); });
+        },
+        upsertMessageTemplates: function (_a) {
+            var payload = _a.payload;
+            var appInfoStore = state.stores.appInfoStore;
+            var templatesInfo = appInfoStore.messageTemplatesInfo;
+            if (!templatesInfo)
+                return state; // Not initialized. Ignore.
+            var waitingTemplateKeysMap = __assign({}, appInfoStore.waitingTemplateKeysMap);
+            payload.forEach(function (templatesMapData) {
+                var key = templatesMapData.key, template = templatesMapData.template;
+                templatesInfo.templatesMap[key] = template;
+                delete waitingTemplateKeysMap[key];
+            });
+            store.setState(function (state) { return (updateAppInfoStore(state, {
+                waitingTemplateKeysMap: waitingTemplateKeysMap,
+                messageTemplatesInfo: templatesInfo,
+            })); });
+        },
+        upsertWaitingTemplateKeys: function (_a) {
+            var payload = _a.payload;
+            var appInfoStore = state.stores.appInfoStore;
+            var keys = payload.keys, requestedAt = payload.requestedAt;
+            var waitingTemplateKeysMap = __assign({}, appInfoStore.waitingTemplateKeysMap);
+            keys.forEach(function (key) {
+                var _a, _b;
+                waitingTemplateKeysMap[key] = {
+                    erroredMessageIds: (_b = (_a = waitingTemplateKeysMap[key]) === null || _a === void 0 ? void 0 : _a.erroredMessageIds) !== null && _b !== void 0 ? _b : [],
+                    requestedAt: requestedAt,
+                };
+            });
+            store.setState(function (state) { return (updateAppInfoStore(state, {
+                waitingTemplateKeysMap: waitingTemplateKeysMap,
+            })); });
+        },
+        markErrorWaitingTemplateKeys: function (_a) {
+            var payload = _a.payload;
+            var appInfoStore = state.stores.appInfoStore;
+            var keys = payload.keys, messageId = payload.messageId;
+            var waitingTemplateKeysMap = __assign({}, appInfoStore.waitingTemplateKeysMap);
+            keys.forEach(function (key) {
+                var waitingTemplateKeyData = waitingTemplateKeysMap[key];
+                if (waitingTemplateKeyData && waitingTemplateKeyData.erroredMessageIds.indexOf(messageId) === -1) {
+                    waitingTemplateKeyData.erroredMessageIds.push(messageId);
+                }
+            });
+            store.setState(function (state) { return (updateAppInfoStore(state, {
+                waitingTemplateKeysMap: waitingTemplateKeysMap,
+            })); });
+        },
+        /* SDK */
+        setSdkLoading: function (payload) {
+            store.setState(function (state) { return (updateSdkStore(state, {
+                initialized: false,
+                loading: payload,
+            })); });
+        },
+        sdkError: function () {
+            store.setState(function (state) { return (updateSdkStore(state, {
+                initialized: false,
+                loading: false,
+                error: true,
+            })); });
+        },
+        initSdk: function (payload) {
+            store.setState(function (state) { return (updateSdkStore(state, {
+                sdk: payload,
+                initialized: true,
+                loading: false,
+                error: false,
+            })); });
+        },
+        resetSdk: function () {
+            store.setState(function (state) { return (updateSdkStore(state, {
+                sdk: null,
+                initialized: false,
+                loading: false,
+                error: false,
+            })); });
+        },
+        /* User */
+        initUser: function (payload) {
+            store.setState(function (state) { return (updateUserStore(state, {
+                initialized: true,
+                loading: false,
+                user: payload,
+            })); });
+        },
+        resetUser: function () {
+            store.setState(function (state) { return (updateUserStore(state, {
+                initialized: false,
+                loading: false,
+                user: null,
+            })); });
+        },
+        updateUserInfo: function (payload) {
+            store.setState(function (state) { return (updateUserStore(state, {
+                user: payload,
+            })); });
+        },
+        /* Connection */
+        connect: function (params) { return __awaiter(void 0, void 0, void 0, function () {
+            var logger, userId, appId, accessToken, nickname, profileUrl, isMobile, sdkInitParams, customApiHost, customWebSocketHost, customExtensionParams, eventHandlers, initializeMessageTemplatesInfo, configureSession, initDashboardConfigs, sdk, user, error_1, sendbirdError;
+            var _a, _b, _c, _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        logger = params.logger, userId = params.userId, appId = params.appId, accessToken = params.accessToken, nickname = params.nickname, profileUrl = params.profileUrl, isMobile = params.isMobile, sdkInitParams = params.sdkInitParams, customApiHost = params.customApiHost, customWebSocketHost = params.customWebSocketHost, customExtensionParams = params.customExtensionParams, eventHandlers = params.eventHandlers, initializeMessageTemplatesInfo = params.initializeMessageTemplatesInfo, configureSession = params.configureSession, initDashboardConfigs = params.initDashboardConfigs;
+                        // clean up previous ws connection
+                        return [4 /*yield*/, actions.disconnect({ logger: logger })];
+                    case 1:
+                        // clean up previous ws connection
+                        _f.sent();
+                        sdk = initSDK({
+                            appId: appId,
+                            customApiHost: customApiHost,
+                            customWebSocketHost: customWebSocketHost,
+                            sdkInitParams: sdkInitParams,
+                        });
+                        setupSDK(sdk, {
+                            logger: logger,
+                            isMobile: isMobile,
+                            customExtensionParams: customExtensionParams,
+                            sessionHandler: configureSession ? configureSession(sdk) : undefined,
+                        });
+                        actions.setSdkLoading(true);
+                        _f.label = 2;
+                    case 2:
+                        _f.trys.push([2, 8, , 9]);
+                        return [4 /*yield*/, sdk.connect(userId, accessToken)];
+                    case 3:
+                        user = _f.sent();
+                        actions.initUser(user);
+                        if (!(nickname || profileUrl)) return [3 /*break*/, 5];
+                        return [4 /*yield*/, sdk.updateCurrentUserInfo({
+                                nickname: nickname || user.nickname || '',
+                                profileUrl: profileUrl || user.profileUrl,
+                            })];
+                    case 4:
+                        _f.sent();
+                        _f.label = 5;
+                    case 5: return [4 /*yield*/, (initializeMessageTemplatesInfo === null || initializeMessageTemplatesInfo === void 0 ? void 0 : initializeMessageTemplatesInfo(sdk))];
+                    case 6:
+                        _f.sent();
+                        return [4 /*yield*/, (initDashboardConfigs === null || initDashboardConfigs === void 0 ? void 0 : initDashboardConfigs(sdk))];
+                    case 7:
+                        _f.sent();
+                        actions.initSdk(sdk);
+                        (_b = (_a = eventHandlers === null || eventHandlers === void 0 ? void 0 : eventHandlers.connection) === null || _a === void 0 ? void 0 : _a.onConnected) === null || _b === void 0 ? void 0 : _b.call(_a, user);
+                        return [3 /*break*/, 9];
+                    case 8:
+                        error_1 = _f.sent();
+                        sendbirdError = error_1;
+                        actions.resetSdk();
+                        actions.resetUser();
+                        (_c = logger.error) === null || _c === void 0 ? void 0 : _c.call(logger, 'SendbirdProvider | useSendbird/connect failed', sendbirdError);
+                        (_e = (_d = eventHandlers === null || eventHandlers === void 0 ? void 0 : eventHandlers.connection) === null || _d === void 0 ? void 0 : _d.onFailed) === null || _e === void 0 ? void 0 : _e.call(_d, sendbirdError);
+                        return [3 /*break*/, 9];
+                    case 9: return [2 /*return*/];
+                }
+            });
+        }); },
+        disconnect: function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+            var sdk;
+            var _c;
+            var logger = _b.logger;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        actions.setSdkLoading(true);
+                        sdk = state.stores.sdkStore.sdk;
+                        if (!(sdk === null || sdk === void 0 ? void 0 : sdk.disconnectWebSocket)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, sdk.disconnectWebSocket()];
+                    case 1:
+                        _d.sent();
+                        _d.label = 2;
+                    case 2:
+                        actions.resetSdk();
+                        actions.resetUser();
+                        (_c = logger.info) === null || _c === void 0 ? void 0 : _c.call(logger, 'SendbirdProvider | useSendbird/disconnect completed');
+                        return [2 /*return*/];
+                }
+            });
+        }); },
+    }); }, [store, state.stores.appInfoStore]);
+    return { state: state, actions: actions };
+};
+
+export { useSendbird as u };
+//# sourceMappingURL=bundle-I25ah_Bv.js.map

package/chunks/{bundle-DCX2mqfp.js.map → bundle-I25ah_Bv.js.map}

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

package/chunks/{bundle-CDvvzlad.js → bundle-L60pJMdf.js}

@@ -1,16 +1,17 @@
 import React__default from 'react';
-import { useSendbirdStateContext } from '../useSendbirdStateContext.js';
 import { TypingIndicator } from '../GroupChannel/components/TypingIndicator.js';
-import { T as TypingIndicatorType } from './bundle-BP1CB0js.js';
+import { T as TypingIndicatorType } from './bundle-DZJe3dCn.js';
 import ConnectionStatus from '../ui/ConnectionStatus.js';
 import PlaceHolder, { PlaceHolderTypes } from '../ui/PlaceHolder.js';
-import { d as deleteNullish } from './bundle-DUTyBaXr.js';
+import { d as deleteNullish } from './bundle-CDcu1I4f.js';
+import { u as useSendbird } from './bundle-I25ah_Bv.js';
 
 var GroupChannelUIView = function (props) {
     var _a, _b, _c, _d;
     var isLoading = props.isLoading, isInvalid = props.isInvalid, channelUrl = props.channelUrl;
     var _e = deleteNullish(props), renderChannelHeader = _e.renderChannelHeader, renderMessageList = _e.renderMessageList, renderMessageInput = _e.renderMessageInput, renderTypingIndicator = _e.renderTypingIndicator, renderPlaceholderLoader = _e.renderPlaceholderLoader, renderPlaceholderInvalid = _e.renderPlaceholderInvalid;
-    var _f = useSendbirdStateContext(), stores = _f.stores, config = _f.config;
+    var state = useSendbird().state;
+    var stores = state.stores, config = state.config;
     var sdkError = (_a = stores === null || stores === void 0 ? void 0 : stores.sdkStore) === null || _a === void 0 ? void 0 : _a.error;
     var logger = config.logger, isOnline = config.isOnline;
     // Note: This is not a loading status of the message list.
@@ -42,4 +43,4 @@ var GroupChannelUIView = function (props) {
 };
 
 export { GroupChannelUIView as G };
-//# sourceMappingURL=bundle-CDvvzlad.js.map
+//# sourceMappingURL=bundle-L60pJMdf.js.map

package/chunks/bundle-L60pJMdf.js.map

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

package/chunks/bundle-LnGQMQVt.js

@@ -0,0 +1,65 @@
+import { a as __spreadArray } from './bundle-B8Grfnrx.js';
+import React__default, { useContext, useState, useEffect } from 'react';
+import { createPortal } from 'react-dom';
+import { c as classnames, n as noop } from './bundle-CDcu1I4f.js';
+import { L as LocalizationContext } from './bundle-l_QLKq1Y.js';
+import { u as useMediaQueryContext } from './bundle-yKqHFFfz.js';
+import IconButton from '../ui/IconButton.js';
+import Button, { ButtonTypes } from '../ui/Button.js';
+import Icon, { IconTypes, IconColors } from '../ui/Icon.js';
+import { L as Label, a as LabelTypography, b as LabelColors } from './bundle-HspRRkmy.js';
+import { u as uuidv4 } from './bundle-CTkGIdt8.js';
+import { u as useSendbird } from './bundle-I25ah_Bv.js';
+
+// simple component to be used as modal root
+var MODAL_ROOT = 'sendbird-modal-root';
+var ModalRoot = function () { return (React__default.createElement("div", { id: MODAL_ROOT, className: MODAL_ROOT })); };
+
+var ModalHeader = function (_a) {
+    var titleText = _a.titleText, onCloseClick = _a.onCloseClick;
+    return (React__default.createElement("div", { className: "sendbird-modal__header" },
+        React__default.createElement(Label, { type: LabelTypography.H_1, color: LabelColors.ONBACKGROUND_1 }, titleText),
+        React__default.createElement("div", { className: "sendbird-modal__close" },
+            React__default.createElement(IconButton, { width: "32px", height: "32px", onClick: onCloseClick },
+                React__default.createElement(Icon, { type: IconTypes.CLOSE, fillColor: IconColors.DEFAULT, width: "24px", height: "24px" })))));
+};
+var ModalBody = function (_a) {
+    var children = _a.children;
+    return (React__default.createElement("div", { className: "sendbird-modal__body" },
+        React__default.createElement(Label, { type: LabelTypography.SUBTITLE_1, color: LabelColors.ONBACKGROUND_2 }, children)));
+};
+var ModalFooter = function (_a) {
+    var submitText = _a.submitText, _b = _a.disabled, disabled = _b === void 0 ? false : _b, _c = _a.hideCancelButton, hideCancelButton = _c === void 0 ? false : _c, _d = _a.type, type = _d === void 0 ? ButtonTypes.DANGER : _d, onSubmit = _a.onSubmit, onCancel = _a.onCancel;
+    var stringSet = useContext(LocalizationContext).stringSet;
+    return (React__default.createElement("div", { className: "sendbird-modal__footer" },
+        !hideCancelButton && (React__default.createElement(Button, { type: ButtonTypes.SECONDARY, onClick: onCancel },
+            React__default.createElement(Label, { type: LabelTypography.BUTTON_1, color: LabelColors.ONBACKGROUND_1 }, stringSet.BUTTON__CANCEL))),
+        React__default.createElement(Button, { type: type, disabled: disabled, onClick: onSubmit }, submitText)));
+};
+function Modal(props) {
+    var _a;
+    var _b = props.children, children = _b === void 0 ? null : _b, _c = props.className, className = _c === void 0 ? '' : _c, _d = props.contentClassName, contentClassName = _d === void 0 ? '' : _d, _e = props.isCloseOnClickOutside, isCloseOnClickOutside = _e === void 0 ? false : _e, _f = props.isFullScreenOnMobile, isFullScreenOnMobile = _f === void 0 ? false : _f, titleText = props.titleText, submitText = props.submitText, _g = props.disabled, disabled = _g === void 0 ? false : _g, _h = props.hideFooter, hideFooter = _h === void 0 ? false : _h, _j = props.type, type = _j === void 0 ? ButtonTypes.DANGER : _j, renderHeader = props.renderHeader, _k = props.onSubmit, onSubmit = _k === void 0 ? noop : _k, onClose = props.onClose, onCancel = props.onCancel, customFooter = props.customFooter;
+    var handleClose = (_a = onClose !== null && onClose !== void 0 ? onClose : onCancel) !== null && _a !== void 0 ? _a : noop;
+    var eventHandlers = useSendbird().state.eventHandlers;
+    var id = useState(function () { return "sbu-modal-".concat(uuidv4()); })[0];
+    useEffect(function () {
+        var _a, _b;
+        return (_b = (_a = eventHandlers === null || eventHandlers === void 0 ? void 0 : eventHandlers.modal) === null || _a === void 0 ? void 0 : _a.onMounted) === null || _b === void 0 ? void 0 : _b.call(_a, { close: handleClose, id: id });
+    }, []);
+    var isMobile = useMediaQueryContext().isMobile;
+    return createPortal(React__default.createElement("div", { className: classnames('sendbird-modal', className, isFullScreenOnMobile && isMobile && 'sendbird-modal--full-mobile') },
+        React__default.createElement("div", { className: classnames.apply(void 0, __spreadArray(['sendbird-modal__content'], (Array.isArray(contentClassName) ? contentClassName : [contentClassName]), false)) },
+            (renderHeader === null || renderHeader === void 0 ? void 0 : renderHeader()) || React__default.createElement(ModalHeader, { titleText: titleText !== null && titleText !== void 0 ? titleText : '', onCloseClick: handleClose }),
+            React__default.createElement(ModalBody, null, children),
+            !hideFooter
+                && (customFooter !== null && customFooter !== void 0 ? customFooter : (React__default.createElement(ModalFooter, { disabled: disabled, onCancel: handleClose, onSubmit: onSubmit, submitText: submitText !== null && submitText !== void 0 ? submitText : '', type: type })))),
+        React__default.createElement("div", { className: classnames('sendbird-modal__backdrop', isCloseOnClickOutside && 'sendbird-modal__backdrop--clickoutside'), onClick: function (e) {
+                e === null || e === void 0 ? void 0 : e.stopPropagation();
+                if (isCloseOnClickOutside) {
+                    handleClose();
+                }
+            } })), document.getElementById(MODAL_ROOT));
+}
+
+export { Modal as M, MODAL_ROOT as a, ModalRoot as b, ModalFooter as c, ModalHeader as d, ModalBody as e };
+//# sourceMappingURL=bundle-LnGQMQVt.js.map

package/chunks/bundle-LnGQMQVt.js.map

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

package/chunks/{bundle-DkviGBGz.js → bundle-Ob7Cw3V-.js}

@@ -37,5 +37,5 @@ var CACHED_MESSAGE_TEMPLATES_TOKEN_KEY = 'sendbird_message_templates_token_key';
 var CACHED_MESSAGE_TEMPLATES_KEY = 'sendbird_message_templates_key';
 var MESSAGE_TEMPLATE_KEY = 'message_template';
 
-export { BROWSER_SUPPORT_MIME_TYPE_LIST as B, CACHED_MESSAGE_TEMPLATES_TOKEN_KEY as C, DELIVERY_RECEIPT as D, META_ARRAY_VOICE_DURATION_KEY as M, ONE_MiB as O, SCROLL_BUFFER as S, VOICE_PLAYER_AUDIO_ID as V, VOICE_MESSAGE_MIME_TYPE as a, VOICE_RECORDER_AUDIO_SAMPLE_RATE as b, SCROLL_BOTTOM_DELAY_FOR_FETCH as c, SCROLL_BOTTOM_DELAY_FOR_SEND as d, VOICE_MESSAGE_FILE_NAME as e, META_ARRAY_MESSAGE_TYPE_KEY as f, META_ARRAY_MESSAGE_TYPE_VALUE__VOICE as g, MESSAGE_TEMPLATE_KEY as h, VOICE_RECORDER_CLICK_BUFFER_TIME as i, VOICE_RECORDER_DEFAULT_MIN as j, VOICE_MESSAGE_FILE_NAME__XM4A as k, VOICE_MESSAGE_MIME_TYPE__XM4A as l, VOICE_PLAYER_ROOT_ID as m, SLIDER_BUTTON_ICON_SIDE_LENGTH as n, VOICE_RECORDER_AUDIO_BIT_RATE as o, CACHED_MESSAGE_TEMPLATES_KEY as p, DEFAULT_MULTIPLE_FILES_MESSAGE_LIMIT as q, DEFAULT_UPLOAD_SIZE_LIMIT as r, VOICE_RECORDER_DEFAULT_MAX as s };
-//# sourceMappingURL=bundle-DkviGBGz.js.map
+export { BROWSER_SUPPORT_MIME_TYPE_LIST as B, CACHED_MESSAGE_TEMPLATES_TOKEN_KEY as C, DELIVERY_RECEIPT as D, MESSAGE_TEMPLATE_KEY as M, ONE_MiB as O, SCROLL_BUFFER as S, VOICE_RECORDER_AUDIO_BIT_RATE as V, VOICE_MESSAGE_FILE_NAME as a, VOICE_MESSAGE_MIME_TYPE as b, VOICE_PLAYER_AUDIO_ID as c, VOICE_RECORDER_AUDIO_SAMPLE_RATE as d, SCROLL_BOTTOM_DELAY_FOR_SEND as e, SCROLL_BOTTOM_DELAY_FOR_FETCH as f, VOICE_RECORDER_CLICK_BUFFER_TIME as g, VOICE_RECORDER_DEFAULT_MIN as h, META_ARRAY_VOICE_DURATION_KEY as i, META_ARRAY_MESSAGE_TYPE_KEY as j, META_ARRAY_MESSAGE_TYPE_VALUE__VOICE as k, VOICE_MESSAGE_FILE_NAME__XM4A as l, VOICE_MESSAGE_MIME_TYPE__XM4A as m, VOICE_PLAYER_ROOT_ID as n, SLIDER_BUTTON_ICON_SIDE_LENGTH as o, CACHED_MESSAGE_TEMPLATES_KEY as p, DEFAULT_MULTIPLE_FILES_MESSAGE_LIMIT as q, DEFAULT_UPLOAD_SIZE_LIMIT as r, VOICE_RECORDER_DEFAULT_MAX as s };
+//# sourceMappingURL=bundle-Ob7Cw3V-.js.map

package/chunks/bundle-Ob7Cw3V-.js.map

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

package/chunks/{bundle-C6-Ix-Lk.js → bundle-QCH8CZT8.js}

@@ -1,15 +1,16 @@
-import { e as __extends, _ as __assign, c as __spreadArray } from './bundle-C7jYHvwG.js';
+import { e as __extends, _ as __assign, a as __spreadArray } from './bundle-B8Grfnrx.js';
 import React__default, { useState, useRef, useCallback, useEffect, createContext, useContext } from 'react';
 import { createPortal } from 'react-dom';
-import { c as classnames } from './bundle-DUTyBaXr.js';
+import { c as classnames } from './bundle-CDcu1I4f.js';
 import { Role } from '@sendbird/chat';
 import { OpenChannel } from '@sendbird/chat/openChannel';
 import SortByRow from '../ui/SortByRow.js';
-import '../withSendbird.js';
 import '../ui/IconButton.js';
-import './bundle-DYeeW5nS.js';
-import './bundle-CIN9yQRB.js';
-import { L as Label, a as LabelTypography, b as LabelColors } from './bundle-DImSV9VW.js';
+import './bundle-CgLhYjm5.js';
+import './bundle-l_QLKq1Y.js';
+import { L as Label, a as LabelTypography, b as LabelColors } from './bundle-HspRRkmy.js';
+import './bundle-C4OmfIXk.js';
+import '@sendbird/chat/groupChannel';
 
 var APP_LAYOUT_ROOT = 'sendbird-app__layout';
 
@@ -324,4 +325,4 @@ function ContextMenu(_a) {
 }
 
 export { APP_LAYOUT_ROOT as A, BottomSheetMenuItem as B, ContextMenu as C, EMOJI_MENU_ROOT_ID as E, MessageMenuProvider as M, OperatorMenuItem as O, MenuItem$1 as a, MenuItems as b, MenuItem as c, MENU_ROOT_ID as d, MENU_OBSERVING_CLASS_NAME as e, EmojiListItems as f, getObservingId as g, MuteMenuItem as h, EmojiReactionListRoot as i, MenuRoot as j, useMessageMenuContext as u };
-//# sourceMappingURL=bundle-C6-Ix-Lk.js.map
+//# sourceMappingURL=bundle-QCH8CZT8.js.map

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

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

package/chunks/bundle-WJtiC3BL.js

@@ -0,0 +1,12 @@
+import { _ as __assign } from './bundle-B8Grfnrx.js';
+import React__default from 'react';
+import { S as SuggestedMentionListView } from './bundle-CF8V-ET_.js';
+import { u as useThread } from './bundle-CVS5Kfg_.js';
+
+var SuggestedMentionList = function (props) {
+    var currentChannel = useThread().state.currentChannel;
+    return (React__default.createElement(SuggestedMentionListView, __assign({}, props, { currentChannel: currentChannel })));
+};
+
+export { SuggestedMentionList as S };
+//# sourceMappingURL=bundle-WJtiC3BL.js.map

package/chunks/bundle-WJtiC3BL.js.map

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

package/chunks/{bundle-Cq6wCLlD.js → bundle-WsWZ-SJW.js}

@@ -1,7 +1,17 @@
 import { ConnectionHandler } from '@sendbird/chat';
-import { useState, useEffect, useLayoutEffect, useMemo } from 'react';
-import { u as uuidv4 } from './bundle-4W3uBGU3.js';
-import { a as __awaiter, b as __generator } from './bundle-C7jYHvwG.js';
+import { useLayoutEffect, useState, useEffect, useMemo } from 'react';
+import { u as uuidv4 } from './bundle-CTkGIdt8.js';
+import { b as __awaiter, c as __generator } from './bundle-B8Grfnrx.js';
+
+// this hook accepts a callback to run component is unmounted
+function useUnmount(callback, deps) {
+    if (deps === void 0) { deps = []; }
+    useLayoutEffect(function () {
+        return function () {
+            callback();
+        };
+    }, deps);
+}
 
 function useOnlineStatus(sdk, logger) {
     var _a, _b;
@@ -148,16 +158,6 @@ function schedulerFactory(_a) {
     };
 }
 
-// this hook accepts a callback to run component is unmounted
-function useUnmount(callback, deps) {
-    if (deps === void 0) { deps = []; }
-    useLayoutEffect(function () {
-        return function () {
-            callback();
-        };
-    }, deps);
-}
-
 function useMarkAsDeliveredScheduler(_a, _b) {
     var _this = this;
     var isConnected = _a.isConnected;
@@ -176,7 +176,7 @@ function useMarkAsDeliveredScheduler(_a, _b) {
                         return [3 /*break*/, 3];
                     case 2:
                         error_1 = _a.sent();
-                        logger.warning('Channel: Mark as delivered failed', { channel: channel, error: error_1 });
+                        logger === null || logger === void 0 ? void 0 : logger.warning('Channel: Mark as delivered failed', { channel: channel, error: error_1 });
                         return [3 /*break*/, 3];
                     case 3: return [2 /*return*/];
                 }
@@ -194,4 +194,4 @@ function useMarkAsDeliveredScheduler(_a, _b) {
 }
 
 export { useMarkAsDeliveredScheduler as a, useUnmount as b, schedulerFactory as s, useOnlineStatus as u };
-//# sourceMappingURL=bundle-Cq6wCLlD.js.map
+//# sourceMappingURL=bundle-WsWZ-SJW.js.map

package/chunks/{bundle-Cq6wCLlD.js.map → bundle-WsWZ-SJW.js.map}

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

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

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

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

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

package/chunks/{bundle-BI2YMBw_.js → bundle-YbXrJewH.js}

@@ -1,15 +1,69 @@
 import { useCallback, useEffect } from 'react';
 import { ReplyType } from '@sendbird/chat/message';
-import { s as scrollIntoLast, d as scrollToRenderedMessage } from './bundle-Deel9XzY.js';
-import { R as RESET_MESSAGES, M as MESSAGE_LIST_PARAMS_CHANGED, F as FETCH_INITIAL_MESSAGES_START, a as FETCH_INITIAL_MESSAGES_SUCCESS, b as FETCH_INITIAL_MESSAGES_FAILURE } from './bundle-BWM5xqIs.js';
-import './bundle-Dpdq7qeD.js';
-import { c as SCROLL_BOTTOM_DELAY_FOR_FETCH } from './bundle-DkviGBGz.js';
+import { s as scrollIntoLast, d as scrollToRenderedMessage } from './bundle-D_tSqvX6.js';
+import './bundle-BciLDE6M.js';
+import { f as SCROLL_BOTTOM_DELAY_FOR_FETCH } from './bundle-Ob7Cw3V-.js';
 
 // For legacy
 // These are not used for collections(GroupChannel)
 var PREV_RESULT_SIZE = 30;
 var NEXT_RESULT_SIZE = 15;
 
+var RESET_MESSAGES = 'RESET_MESSAGES';
+var FETCH_INITIAL_MESSAGES_START = 'FETCH_INITIAL_MESSAGES_START';
+var FETCH_INITIAL_MESSAGES_SUCCESS = 'FETCH_INITIAL_MESSAGES_SUCCESS';
+var FETCH_INITIAL_MESSAGES_FAILURE = 'FETCH_INITIAL_MESSAGES_FAILURE';
+var FETCH_PREV_MESSAGES_SUCCESS = 'FETCH_PREV_MESSAGES_SUCCESS';
+var FETCH_PREV_MESSAGES_FAILURE = 'FETCH_PREV_MESSAGES_FAILURE';
+var FETCH_NEXT_MESSAGES_SUCCESS = 'FETCH_NEXT_MESSAGES_SUCCESS';
+var FETCH_NEXT_MESSAGES_FAILURE = 'FETCH_NEXT_MESSAGES_FAILURE';
+var SEND_MESSAGE_START = 'SEND_MESSAGE_START';
+var SEND_MESSAGE_SUCCESS = 'SEND_MESSAGE_SUCCESS';
+var SEND_MESSAGE_FAILURE = 'SEND_MESSAGE_FAILURE';
+var RESEND_MESSAGE_START = 'RESEND_MESSAGE_START';
+var ON_MESSAGE_RECEIVED = 'ON_MESSAGE_RECEIVED';
+var ON_MESSAGE_UPDATED = 'ON_MESSAGE_UPDATED';
+var ON_MESSAGE_THREAD_INFO_UPDATED = 'ON_MESSAGE_THREAD_INFO_UPDATED';
+var ON_MESSAGE_DELETED = 'ON_MESSAGE_DELETED';
+var ON_MESSAGE_DELETED_BY_REQ_ID = 'ON_MESSAGE_DELETED_BY_REQ_ID';
+var SET_CURRENT_CHANNEL = 'SET_CURRENT_CHANNEL';
+var SET_CHANNEL_INVALID = 'SET_CHANNEL_INVALID';
+var MARK_AS_READ = 'MARK_AS_READ';
+var ON_REACTION_UPDATED = 'ON_REACTION_UPDATED';
+var SET_EMOJI_CONTAINER = 'SET_EMOJI_CONTAINER';
+var MESSAGE_LIST_PARAMS_CHANGED = 'MESSAGE_LIST_PARAMS_CHANGED';
+var ON_FILE_INFO_UPLOADED = 'ON_FILE_INFO_UPLOADED';
+var ON_TYPING_STATUS_UPDATED = 'ON_TYPING_STATUS_UPDATED';
+
+var channelActions = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  FETCH_INITIAL_MESSAGES_FAILURE: FETCH_INITIAL_MESSAGES_FAILURE,
+  FETCH_INITIAL_MESSAGES_START: FETCH_INITIAL_MESSAGES_START,
+  FETCH_INITIAL_MESSAGES_SUCCESS: FETCH_INITIAL_MESSAGES_SUCCESS,
+  FETCH_NEXT_MESSAGES_FAILURE: FETCH_NEXT_MESSAGES_FAILURE,
+  FETCH_NEXT_MESSAGES_SUCCESS: FETCH_NEXT_MESSAGES_SUCCESS,
+  FETCH_PREV_MESSAGES_FAILURE: FETCH_PREV_MESSAGES_FAILURE,
+  FETCH_PREV_MESSAGES_SUCCESS: FETCH_PREV_MESSAGES_SUCCESS,
+  MARK_AS_READ: MARK_AS_READ,
+  MESSAGE_LIST_PARAMS_CHANGED: MESSAGE_LIST_PARAMS_CHANGED,
+  ON_FILE_INFO_UPLOADED: ON_FILE_INFO_UPLOADED,
+  ON_MESSAGE_DELETED: ON_MESSAGE_DELETED,
+  ON_MESSAGE_DELETED_BY_REQ_ID: ON_MESSAGE_DELETED_BY_REQ_ID,
+  ON_MESSAGE_RECEIVED: ON_MESSAGE_RECEIVED,
+  ON_MESSAGE_THREAD_INFO_UPDATED: ON_MESSAGE_THREAD_INFO_UPDATED,
+  ON_MESSAGE_UPDATED: ON_MESSAGE_UPDATED,
+  ON_REACTION_UPDATED: ON_REACTION_UPDATED,
+  ON_TYPING_STATUS_UPDATED: ON_TYPING_STATUS_UPDATED,
+  RESEND_MESSAGE_START: RESEND_MESSAGE_START,
+  RESET_MESSAGES: RESET_MESSAGES,
+  SEND_MESSAGE_FAILURE: SEND_MESSAGE_FAILURE,
+  SEND_MESSAGE_START: SEND_MESSAGE_START,
+  SEND_MESSAGE_SUCCESS: SEND_MESSAGE_SUCCESS,
+  SET_CHANNEL_INVALID: SET_CHANNEL_INVALID,
+  SET_CURRENT_CHANNEL: SET_CURRENT_CHANNEL,
+  SET_EMOJI_CONTAINER: SET_EMOJI_CONTAINER
+});
+
 function useInitialMessagesFetch(_a, _b) {
     var currentGroupChannel = _a.currentGroupChannel, initialTimeStamp = _a.initialTimeStamp, userFilledMessageListQuery = _a.userFilledMessageListQuery, replyType = _a.replyType, setIsScrolled = _a.setIsScrolled;
     var logger = _b.logger, scrollRef = _b.scrollRef, messagesDispatcher = _b.messagesDispatcher;
@@ -99,5 +153,5 @@ function useInitialMessagesFetch(_a, _b) {
     return fetchMessages;
 }
 
-export { NEXT_RESULT_SIZE as N, PREV_RESULT_SIZE as P, useInitialMessagesFetch as u };
-//# sourceMappingURL=bundle-BI2YMBw_.js.map
+export { FETCH_INITIAL_MESSAGES_START as F, MARK_AS_READ as M, NEXT_RESULT_SIZE as N, ON_MESSAGE_RECEIVED as O, PREV_RESULT_SIZE as P, RESET_MESSAGES as R, SEND_MESSAGE_START as S, FETCH_INITIAL_MESSAGES_SUCCESS as a, FETCH_PREV_MESSAGES_SUCCESS as b, FETCH_NEXT_MESSAGES_SUCCESS as c, FETCH_INITIAL_MESSAGES_FAILURE as d, FETCH_PREV_MESSAGES_FAILURE as e, FETCH_NEXT_MESSAGES_FAILURE as f, SEND_MESSAGE_SUCCESS as g, SEND_MESSAGE_FAILURE as h, SET_CURRENT_CHANNEL as i, SET_CHANNEL_INVALID as j, ON_MESSAGE_UPDATED as k, ON_MESSAGE_THREAD_INFO_UPDATED as l, RESEND_MESSAGE_START as m, ON_MESSAGE_DELETED as n, ON_MESSAGE_DELETED_BY_REQ_ID as o, SET_EMOJI_CONTAINER as p, ON_REACTION_UPDATED as q, MESSAGE_LIST_PARAMS_CHANGED as r, ON_FILE_INFO_UPLOADED as s, ON_TYPING_STATUS_UPDATED as t, useInitialMessagesFetch as u, channelActions as v };
+//# sourceMappingURL=bundle-YbXrJewH.js.map

package/chunks/bundle-YbXrJewH.js.map

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