@sendbird/uikit-react 3.14.3-rc.1 → 3.14.4

package/chunks/{bundle-D_MTREEI.js.map → bundle-BmTGlIgs.js.map}

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

package/chunks/{bundle-D_o_gdug.js → bundle-BtY8jyVv.js}

@@ -1,29 +1,29 @@
-/**
- * Dashboard UIKitConfig's replyType is consisted of all lowercases,
- * we need to convert it into uppercase ones(or vice versa)
- * when we pass the value to internal components
- *  - 'thread' <-> 'THREAD'
- *  - 'quote_reply' <-> 'QUOTE_REPLY'
- */
-function getCaseResolvedReplyType(replyType) {
-    return {
-        lowerCase: replyType.toLowerCase(),
-        upperCase: replyType.toUpperCase(),
-    };
-}
-/**
- * Dashboard UIKitConfig's threadReplySelectType is consisted of all lowercase letters,
- * we need to convert it into uppercase ones(or vice versa)
- * when we pass the value to internal components
- *  - 'thread' <-> 'THREAD'
- *  - 'parent' <-> 'PARENT'
- */
-function getCaseResolvedThreadReplySelectType(threadReplySelectType) {
-    return {
-        lowerCase: threadReplySelectType.toLowerCase(),
-        upperCase: threadReplySelectType.toUpperCase(),
-    };
+/**
+ * Dashboard UIKitConfig's replyType is consisted of all lowercases,
+ * we need to convert it into uppercase ones(or vice versa)
+ * when we pass the value to internal components
+ *  - 'thread' <-> 'THREAD'
+ *  - 'quote_reply' <-> 'QUOTE_REPLY'
+ */
+function getCaseResolvedReplyType(replyType) {
+    return {
+        lowerCase: replyType.toLowerCase(),
+        upperCase: replyType.toUpperCase(),
+    };
+}
+/**
+ * Dashboard UIKitConfig's threadReplySelectType is consisted of all lowercase letters,
+ * we need to convert it into uppercase ones(or vice versa)
+ * when we pass the value to internal components
+ *  - 'thread' <-> 'THREAD'
+ *  - 'parent' <-> 'PARENT'
+ */
+function getCaseResolvedThreadReplySelectType(threadReplySelectType) {
+    return {
+        lowerCase: threadReplySelectType.toLowerCase(),
+        upperCase: threadReplySelectType.toUpperCase(),
+    };
 }
 
 export { getCaseResolvedThreadReplySelectType as a, getCaseResolvedReplyType as g };
-//# sourceMappingURL=bundle-D_o_gdug.js.map
+//# sourceMappingURL=bundle-BtY8jyVv.js.map

package/chunks/{bundle-D_o_gdug.js.map → bundle-BtY8jyVv.js.map}

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

package/chunks/{bundle-HHlRp7vF.js → bundle-BvG71y_P.js}

@@ -1,34 +1,34 @@
-function getComponentKeyFromMessage(message) {
-    if ('sendingStatus' in message) {
-        if (message.sendingStatus === 'succeeded')
-            return String(message.messageId);
-        return message.reqId;
-    }
-    return String(message.messageId);
-}
-function isContextMenuClosed() {
-    var _a, _b;
-    return (((_a = document.getElementById('sendbird-dropdown-portal')) === null || _a === void 0 ? void 0 : _a.childElementCount) === 0
-        && ((_b = document.getElementById('sendbird-emoji-list-portal')) === null || _b === void 0 ? void 0 : _b.childElementCount) === 0);
-}
-function getMessageTopOffset(messageCreatedAt) {
-    var _a;
-    var element = (_a = document.querySelectorAll("[data-sb-created-at=\"".concat(messageCreatedAt, "\"]"))) === null || _a === void 0 ? void 0 : _a[0];
-    if (element instanceof HTMLElement) {
-        return element.offsetTop;
-    }
-    return null;
-}
-var isDisabledBecauseFrozen = function (groupChannel) {
-    if (!groupChannel)
-        return false;
-    return groupChannel.isFrozen && groupChannel.myRole !== 'operator';
-};
-var isDisabledBecauseMuted = function (groupChannel) {
-    if (!groupChannel)
-        return false;
-    return groupChannel.myMutedState === 'muted';
+function getComponentKeyFromMessage(message) {
+    if ('sendingStatus' in message) {
+        if (message.sendingStatus === 'succeeded')
+            return String(message.messageId);
+        return message.reqId;
+    }
+    return String(message.messageId);
+}
+function isContextMenuClosed() {
+    var _a, _b;
+    return (((_a = document.getElementById('sendbird-dropdown-portal')) === null || _a === void 0 ? void 0 : _a.childElementCount) === 0
+        && ((_b = document.getElementById('sendbird-emoji-list-portal')) === null || _b === void 0 ? void 0 : _b.childElementCount) === 0);
+}
+function getMessageTopOffset(messageCreatedAt) {
+    var _a;
+    var element = (_a = document.querySelectorAll("[data-sb-created-at=\"".concat(messageCreatedAt, "\"]"))) === null || _a === void 0 ? void 0 : _a[0];
+    if (element instanceof HTMLElement) {
+        return element.offsetTop;
+    }
+    return null;
+}
+var isDisabledBecauseFrozen = function (groupChannel) {
+    if (!groupChannel)
+        return false;
+    return groupChannel.isFrozen && groupChannel.myRole !== 'operator';
+};
+var isDisabledBecauseMuted = function (groupChannel) {
+    if (!groupChannel)
+        return false;
+    return groupChannel.myMutedState === 'muted';
 };
 
 export { isDisabledBecauseMuted as a, isContextMenuClosed as b, getMessageTopOffset as c, getComponentKeyFromMessage as g, isDisabledBecauseFrozen as i };
-//# sourceMappingURL=bundle-HHlRp7vF.js.map
+//# sourceMappingURL=bundle-BvG71y_P.js.map

package/chunks/bundle-BvG71y_P.js.map

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

package/chunks/{bundle-BADg8JRM.js → bundle-BvaqGh4L.js}

@@ -1,8 +1,8 @@
-var USER_ACTIONS = {
-    INIT_USER: 'INIT_USER',
-    RESET_USER: 'RESET_USER',
-    UPDATE_USER_INFO: 'UPDATE_USER_INFO',
+var USER_ACTIONS = {
+    INIT_USER: 'INIT_USER',
+    RESET_USER: 'RESET_USER',
+    UPDATE_USER_INFO: 'UPDATE_USER_INFO',
 };
 
 export { USER_ACTIONS as U };
-//# sourceMappingURL=bundle-BADg8JRM.js.map
+//# sourceMappingURL=bundle-BvaqGh4L.js.map

package/chunks/bundle-BvaqGh4L.js.map

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

package/chunks/{bundle-DW4HEvvh.js → bundle-Bx5vhTbU.js}

@@ -1,16 +1,16 @@
 import React__default from 'react';
-import { g as getStringSet } from './bundle-CwG4pj5M.js';
-import { d as defaultLocale } from './bundle-DD0CjCiu.js';
+import { g as getStringSet } from './bundle-C8im5l9B.js';
+import { d as defaultLocale } from './bundle-C1ds4cil.js';
 
-var LocalizationContext = React__default.createContext({
-    stringSet: getStringSet('en'),
-    dateLocale: defaultLocale,
-});
-var LocalizationProvider = function (props) {
-    var children = props.children;
-    return (React__default.createElement(LocalizationContext.Provider, { value: props }, children));
-};
+var LocalizationContext = React__default.createContext({
+    stringSet: getStringSet('en'),
+    dateLocale: defaultLocale,
+});
+var LocalizationProvider = function (props) {
+    var children = props.children;
+    return (React__default.createElement(LocalizationContext.Provider, { value: props }, children));
+};
 var useLocalization = function () { return React__default.useContext(LocalizationContext); };
 
 export { LocalizationContext as L, LocalizationProvider as a, useLocalization as u };
-//# sourceMappingURL=bundle-DW4HEvvh.js.map
+//# sourceMappingURL=bundle-Bx5vhTbU.js.map

package/chunks/bundle-Bx5vhTbU.js.map

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

package/chunks/{bundle-Du8hBYjM.js → bundle-Byig85JJ.js}

@@ -1,197 +1,197 @@
 import { ConnectionHandler } from '@sendbird/chat';
 import { useState, useEffect, useLayoutEffect, useMemo } from 'react';
-import { u as uuidv4 } from './bundle-D7HxTsM2.js';
-import { a as __awaiter, b as __generator } from './bundle-Dd7yWAzk.js';
+import { u as uuidv4 } from './bundle-BJ46V6XQ.js';
+import { a as __awaiter, b as __generator } from './bundle-7oF7KbGv.js';
 
-function useOnlineStatus(sdk, logger) {
-    var _a, _b;
-    var _c = useState(
-    // window is undefined in SSR env
-    typeof window !== 'undefined'
-        ? ((_b = (_a = window === null || window === void 0 ? void 0 : window.navigator) === null || _a === void 0 ? void 0 : _a.onLine) !== null && _b !== void 0 ? _b : true)
-        : true), isOnline = _c[0], setIsOnline = _c[1];
-    useEffect(function () {
-        var uniqueHandlerId = uuidv4();
-        try {
-            logger.warning('sdk changed', uniqueHandlerId);
-            var handler = new ConnectionHandler({
-                onDisconnected: function () {
-                    setIsOnline(false);
-                    logger.warning('onDisconnected', { isOnline: isOnline });
-                },
-                onReconnectStarted: function () {
-                    setIsOnline(false);
-                    logger.warning('onReconnectStarted', { isOnline: isOnline });
-                },
-                onReconnectSucceeded: function () {
-                    setIsOnline(true);
-                    logger.warning('onReconnectSucceeded', { isOnline: isOnline });
-                },
-                onReconnectFailed: function () {
-                    sdk.reconnect();
-                    logger.warning('onReconnectFailed');
-                },
-            });
-            if (sdk === null || sdk === void 0 ? void 0 : sdk.addConnectionHandler) {
-                // workaround -> addConnectionHandler invalidates session handler
-                // provided through configureSession
-                sdk.addConnectionHandler(uniqueHandlerId, handler);
-                logger.info('Added ConnectionHandler', uniqueHandlerId);
-            }
-        }
-        catch (_a) {
-            //
-        }
-        return function () {
-            try {
-                sdk.removeConnectionHandler(uniqueHandlerId);
-                logger.info('Removed ConnectionHandler', uniqueHandlerId);
-            }
-            catch (_a) {
-                //
-            }
-        };
-    }, [sdk]);
-    useEffect(function () {
-        var tryReconnect = function () {
-            try {
-                logger.warning('Try reconnecting SDK');
-                if (sdk.connectionState !== 'OPEN') { // connection is not broken yet
-                    sdk.reconnect();
-                }
-            }
-            catch (_a) {
-                //
-            }
-        };
-        // addEventListener version
-        window.addEventListener('online', tryReconnect);
-        return function () {
-            window.removeEventListener('online', tryReconnect);
-        };
-    }, [sdk]);
-    // add offline-class to body
-    useEffect(function () {
-        var body = document.querySelector('body');
-        if (!isOnline && !(sdk === null || sdk === void 0 ? void 0 : sdk.isCacheEnabled)) {
-            try {
-                body.classList.add('sendbird__offline');
-                logger.info('Added class sendbird__offline to body');
-            }
-            catch (e) {
-                //
-            }
-        }
-        else {
-            try {
-                body.classList.remove('sendbird__offline');
-                logger.info('Removed class sendbird__offline from body');
-            }
-            catch (e) {
-                //
-            }
-        }
-    }, [isOnline, sdk === null || sdk === void 0 ? void 0 : sdk.isCacheEnabled]);
-    return isOnline;
+function useOnlineStatus(sdk, logger) {
+    var _a, _b;
+    var _c = useState(
+    // window is undefined in SSR env
+    typeof window !== 'undefined'
+        ? ((_b = (_a = window === null || window === void 0 ? void 0 : window.navigator) === null || _a === void 0 ? void 0 : _a.onLine) !== null && _b !== void 0 ? _b : true)
+        : true), isOnline = _c[0], setIsOnline = _c[1];
+    useEffect(function () {
+        var uniqueHandlerId = uuidv4();
+        try {
+            logger.warning('sdk changed', uniqueHandlerId);
+            var handler = new ConnectionHandler({
+                onDisconnected: function () {
+                    setIsOnline(false);
+                    logger.warning('onDisconnected', { isOnline: isOnline });
+                },
+                onReconnectStarted: function () {
+                    setIsOnline(false);
+                    logger.warning('onReconnectStarted', { isOnline: isOnline });
+                },
+                onReconnectSucceeded: function () {
+                    setIsOnline(true);
+                    logger.warning('onReconnectSucceeded', { isOnline: isOnline });
+                },
+                onReconnectFailed: function () {
+                    sdk.reconnect();
+                    logger.warning('onReconnectFailed');
+                },
+            });
+            if (sdk === null || sdk === void 0 ? void 0 : sdk.addConnectionHandler) {
+                // workaround -> addConnectionHandler invalidates session handler
+                // provided through configureSession
+                sdk.addConnectionHandler(uniqueHandlerId, handler);
+                logger.info('Added ConnectionHandler', uniqueHandlerId);
+            }
+        }
+        catch (_a) {
+            //
+        }
+        return function () {
+            try {
+                sdk.removeConnectionHandler(uniqueHandlerId);
+                logger.info('Removed ConnectionHandler', uniqueHandlerId);
+            }
+            catch (_a) {
+                //
+            }
+        };
+    }, [sdk]);
+    useEffect(function () {
+        var tryReconnect = function () {
+            try {
+                logger.warning('Try reconnecting SDK');
+                if (sdk.connectionState !== 'OPEN') { // connection is not broken yet
+                    sdk.reconnect();
+                }
+            }
+            catch (_a) {
+                //
+            }
+        };
+        // addEventListener version
+        window.addEventListener('online', tryReconnect);
+        return function () {
+            window.removeEventListener('online', tryReconnect);
+        };
+    }, [sdk]);
+    // add offline-class to body
+    useEffect(function () {
+        var body = document.querySelector('body');
+        if (!isOnline && !(sdk === null || sdk === void 0 ? void 0 : sdk.isCacheEnabled)) {
+            try {
+                body.classList.add('sendbird__offline');
+                logger.info('Added class sendbird__offline to body');
+            }
+            catch (e) {
+                //
+            }
+        }
+        else {
+            try {
+                body.classList.remove('sendbird__offline');
+                logger.info('Removed class sendbird__offline from body');
+            }
+            catch (e) {
+                //
+            }
+        }
+    }, [isOnline, sdk === null || sdk === void 0 ? void 0 : sdk.isCacheEnabled]);
+    return isOnline;
 }
 
-var TIMEOUT = 2000;
-/*
-  * This is a factory function that returns a scheduler.
-  * The scheduler is a queue that calls the callback function on intervals.
-  * If interval is empty, the callback function is called immediately.
-  * If interval is not empty, the callback function is called after the interval.
-*/
-function schedulerFactory(_a) {
-    var logger = _a.logger, timeout = _a.timeout, cb = _a.cb;
-    var queue = [];
-    var interval = null;
-    var push = function (channel) {
-        var channelPresent = queue.find(function (c) { return c.url === channel.url; });
-        if (!channelPresent) {
-            queue.push(channel);
-        }
-        else {
-            logger.info('Channel: Mark as read already in queue', { channel: channel });
-        }
-        // start the interval if it's not already running
-        if (interval) {
-            return;
-        }
-        var item = queue.shift();
-        if (item) {
-            cb(item);
-        }
-        interval = setInterval(function () {
-            if (queue.length === 0 && interval) {
-                clearInterval(interval);
-                interval = null;
-                return;
-            }
-            var item = queue.shift();
-            if (item) {
-                cb(item);
-            }
-        }, (timeout || TIMEOUT));
-    };
-    var clear = function () {
-        queue = [];
-        if (interval) {
-            clearInterval(interval);
-            interval = null;
-        }
-    };
-    return {
-        push: push,
-        clear: clear,
-        getQueue: function () { return queue; },
-    };
+var TIMEOUT = 2000;
+/*
+  * This is a factory function that returns a scheduler.
+  * The scheduler is a queue that calls the callback function on intervals.
+  * If interval is empty, the callback function is called immediately.
+  * If interval is not empty, the callback function is called after the interval.
+*/
+function schedulerFactory(_a) {
+    var logger = _a.logger, timeout = _a.timeout, cb = _a.cb;
+    var queue = [];
+    var interval = null;
+    var push = function (channel) {
+        var channelPresent = queue.find(function (c) { return c.url === channel.url; });
+        if (!channelPresent) {
+            queue.push(channel);
+        }
+        else {
+            logger.info('Channel: Mark as read already in queue', { channel: channel });
+        }
+        // start the interval if it's not already running
+        if (interval) {
+            return;
+        }
+        var item = queue.shift();
+        if (item) {
+            cb(item);
+        }
+        interval = setInterval(function () {
+            if (queue.length === 0 && interval) {
+                clearInterval(interval);
+                interval = null;
+                return;
+            }
+            var item = queue.shift();
+            if (item) {
+                cb(item);
+            }
+        }, (timeout || TIMEOUT));
+    };
+    var clear = function () {
+        queue = [];
+        if (interval) {
+            clearInterval(interval);
+            interval = null;
+        }
+    };
+    return {
+        push: push,
+        clear: clear,
+        getQueue: function () { return queue; },
+    };
 }
 
-// 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);
+// 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;
-    var logger = _b.logger;
-    var markAsDeliveredScheduler = useMemo(function () { return schedulerFactory({
-        logger: logger,
-        cb: function (channel) { return __awaiter(_this, void 0, void 0, function () {
-            var error_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        return [4 /*yield*/, channel.markAsDelivered()];
-                    case 1:
-                        _a.sent();
-                        return [3 /*break*/, 3];
-                    case 2:
-                        error_1 = _a.sent();
-                        logger.warning('Channel: Mark as delivered failed', { channel: channel, error: error_1 });
-                        return [3 /*break*/, 3];
-                    case 3: return [2 /*return*/];
-                }
-            });
-        }); },
-    }); }, []);
-    useEffect(function () {
-        // for simplicity, we clear the queue when the connection is lost
-        if (!isConnected) {
-            markAsDeliveredScheduler.clear();
-        }
-    }, [isConnected]);
-    useUnmount(function () { markAsDeliveredScheduler.clear(); });
-    return markAsDeliveredScheduler;
+function useMarkAsDeliveredScheduler(_a, _b) {
+    var _this = this;
+    var isConnected = _a.isConnected;
+    var logger = _b.logger;
+    var markAsDeliveredScheduler = useMemo(function () { return schedulerFactory({
+        logger: logger,
+        cb: function (channel) { return __awaiter(_this, void 0, void 0, function () {
+            var error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, channel.markAsDelivered()];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_1 = _a.sent();
+                        logger.warning('Channel: Mark as delivered failed', { channel: channel, error: error_1 });
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        }); },
+    }); }, []);
+    useEffect(function () {
+        // for simplicity, we clear the queue when the connection is lost
+        if (!isConnected) {
+            markAsDeliveredScheduler.clear();
+        }
+    }, [isConnected]);
+    useUnmount(function () { markAsDeliveredScheduler.clear(); });
+    return markAsDeliveredScheduler;
 }
 
 export { useMarkAsDeliveredScheduler as a, useUnmount as b, schedulerFactory as s, useOnlineStatus as u };
-//# sourceMappingURL=bundle-Du8hBYjM.js.map
+//# sourceMappingURL=bundle-Byig85JJ.js.map

package/chunks/{bundle-Du8hBYjM.js.map → bundle-Byig85JJ.js.map}

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

package/chunks/bundle-BymWz1lX.js

@@ -0,0 +1,30 @@
+import { _ as __assign } from './bundle-7oF7KbGv.js';
+import React__default from 'react';
+import { IconTypes, IconColors } from '../ui/Icon.js';
+import ChannelAvatar from '../ui/ChannelAvatar.js';
+import { g as getChannelTitle } from './bundle-9MhshueU.js';
+import { u as useMediaQueryContext } from './bundle-Diqj6For.js';
+import { useSendbirdStateContext } from '../useSendbirdStateContext.js';
+import { u as useLocalization } from './bundle-Bx5vhTbU.js';
+import Header from '../ui/Header.js';
+
+var GroupChannelHeaderView = function (_a) {
+    var className = _a.className, currentChannel = _a.currentChannel, showSearchIcon = _a.showSearchIcon, onBackClick = _a.onBackClick, onSearchClick = _a.onSearchClick, onChatHeaderActionClick = _a.onChatHeaderActionClick, 
+    // Header custom props
+    renderLeft = _a.renderLeft, renderMiddle = _a.renderMiddle, renderRight = _a.renderRight;
+    var config = useSendbirdStateContext().config;
+    var userId = config.userId, theme = config.theme;
+    var isMobile = useMediaQueryContext().isMobile;
+    var stringSet = useLocalization().stringSet;
+    var isMuted = (currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.myMutedState) === 'muted';
+    var channelTitle = getChannelTitle(currentChannel, userId, stringSet);
+    return (React__default.createElement(Header, { className: "sendbird-chat-header ".concat(className), renderLeft: renderLeft !== null && renderLeft !== void 0 ? renderLeft : (function () { return (React__default.createElement(React__default.Fragment, null,
+            isMobile && (React__default.createElement(Header.Icon, { className: "sendbird-chat-header__icon_back", onClick: onBackClick, type: IconTypes.ARROW_LEFT, color: IconColors.PRIMARY, width: "24px", height: "24px" })),
+            React__default.createElement(ChannelAvatar, { theme: theme, channel: currentChannel, userId: userId, height: 32, width: 32 }))); }), renderMiddle: renderMiddle !== null && renderMiddle !== void 0 ? renderMiddle : (function () { return (React__default.createElement(Header.Title, { title: channelTitle })); }), renderRight: renderRight !== null && renderRight !== void 0 ? renderRight : (function () { return (React__default.createElement(React__default.Fragment, null,
+            isMuted && (React__default.createElement(Header.Icon, { className: "sendbird-chat-header__right__mute", type: IconTypes.NOTIFICATIONS_OFF_FILLED, color: IconColors.ON_BACKGROUND_2, width: "24px", height: "24px" })),
+            (showSearchIcon && !(currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.isEphemeral)) && (React__default.createElement(Header.IconButton, { className: "sendbird-chat-header__right__search", onClick: onSearchClick, type: IconTypes.SEARCH, color: IconColors.PRIMARY, renderIcon: function (props) { return React__default.createElement(Header.Icon, __assign({}, props, { width: "24px", height: "24px" })); } })),
+            React__default.createElement(Header.IconButton, { className: "sendbird-chat-header__right__info", onClick: onChatHeaderActionClick, type: IconTypes.INFO, color: IconColors.PRIMARY, renderIcon: function (props) { return React__default.createElement(Header.Icon, __assign({}, props, { width: "24px", height: "24px" })); } }))); }) }));
+};
+
+export { GroupChannelHeaderView as G };
+//# sourceMappingURL=bundle-BymWz1lX.js.map

package/chunks/bundle-BymWz1lX.js.map

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