@sendbird/uikit-react 3.10.1 → 3.11.0

package/cjs/chunks/{bundle-rgxTgHrK.js → bundle-_apVcG-_.js}

@@ -1,11 +1,12 @@
 'use strict';
 
 var React = require('react');
-var _tslib = require('./bundle-bXLZZTmP.js');
-var consts = require('./bundle-JbxviE94.js');
+var _tslib = require('./bundle-RVs527mS.js');
+var consts = require('./bundle-SggLEV_z.js');
 var useSendbirdStateContext = require('../useSendbirdStateContext.js');
 
 var INITIALIZE_AUDIO_UNIT = 'INITIALIZE_AUDIO_UNIT';
+var RESET_AUDIO_UNIT = 'RESET_AUDIO_UNIT';
 var SET_CURRENT_PLAYER = 'SET_CURRENT_PLAYER';
 var ON_VOICE_PLAYER_PLAY = 'ON_VOICE_PLAYER_PLAY';
 var ON_VOICE_PLAYER_PAUSE = 'ON_VOICE_PLAYER_PAUSE';
@@ -31,44 +32,43 @@ var voicePlayerInitialState = {
 };
 
 function voicePlayerReducer(state, action) {
-    var _a, _b, _c, _d;
-    var _e, _f, _g, _h;
+    var _a, _b, _c, _d, _e;
+    var _f, _g, _h, _j;
     switch (action.type) {
         case INITIALIZE_AUDIO_UNIT: {
             var groupKey = action.payload.groupKey;
-            var audioUnit = (((_e = state.audioStorage) === null || _e === void 0 ? void 0 : _e[groupKey]) ? state.audioStorage[groupKey] : AudioUnitDefaultValue());
+            var audioUnit = (((_f = state.audioStorage) === null || _f === void 0 ? void 0 : _f[groupKey]) ? state.audioStorage[groupKey] : AudioUnitDefaultValue());
             audioUnit.playingStatus = VOICE_PLAYER_STATUS.PREPARING;
             return _tslib.__assign(_tslib.__assign({}, state), { audioStorage: _tslib.__assign(_tslib.__assign({}, state.audioStorage), (_a = {}, _a[groupKey] = audioUnit, _a)) });
         }
+        case RESET_AUDIO_UNIT: {
+            var groupKey = action.payload.groupKey;
+            return _tslib.__assign(_tslib.__assign({}, state), { audioStorage: _tslib.__assign(_tslib.__assign({}, state.audioStorage), (_b = {}, _b[groupKey] = AudioUnitDefaultValue(), _b)) });
+        }
         case SET_CURRENT_PLAYER: {
-            var _j = action.payload, audioPlayer = _j.audioPlayer, groupKey = _j.groupKey;
+            var _k = action.payload, audioPlayer = _k.audioPlayer, groupKey = _k.groupKey;
             return _tslib.__assign(_tslib.__assign({}, state), { currentPlayer: audioPlayer, currentGroupKey: groupKey });
         }
         case ON_VOICE_PLAYER_PLAY: {
-            var _k = action.payload, groupKey = _k.groupKey, audioFile = _k.audioFile;
-            var audioUnit = (((_f = state.audioStorage) === null || _f === void 0 ? void 0 : _f[groupKey]) ? state.audioStorage[groupKey] : AudioUnitDefaultValue());
+            var _l = action.payload, groupKey = _l.groupKey, audioFile = _l.audioFile;
+            var audioUnit = (((_g = state.audioStorage) === null || _g === void 0 ? void 0 : _g[groupKey]) ? state.audioStorage[groupKey] : AudioUnitDefaultValue());
             audioUnit.audioFile = audioFile;
             audioUnit.playingStatus = VOICE_PLAYER_STATUS.PLAYING;
-            return _tslib.__assign(_tslib.__assign({}, state), { audioStorage: _tslib.__assign(_tslib.__assign({}, state.audioStorage), (_b = {}, _b[groupKey] = audioUnit, _b)) });
+            return _tslib.__assign(_tslib.__assign({}, state), { audioStorage: _tslib.__assign(_tslib.__assign({}, state.audioStorage), (_c = {}, _c[groupKey] = audioUnit, _c)) });
         }
         case ON_VOICE_PLAYER_PAUSE: {
-            var groupKey = action.payload.groupKey;
-            var audioUnit = (((_g = state.audioStorage) === null || _g === void 0 ? void 0 : _g[groupKey]) ? state.audioStorage[groupKey] : AudioUnitDefaultValue());
+            var _m = action.payload, groupKey = _m.groupKey, duration = _m.duration, currentTime = _m.currentTime;
+            var audioUnit = (((_h = state.audioStorage) === null || _h === void 0 ? void 0 : _h[groupKey]) ? state.audioStorage[groupKey] : AudioUnitDefaultValue());
             audioUnit.playingStatus = VOICE_PLAYER_STATUS.PAUSED;
-            var _l = state.currentPlayer, currentTime = _l.currentTime, duration = _l.duration;
-            if (audioUnit.playbackTime === audioUnit.duration) {
+            if (duration === currentTime) {
                 audioUnit.playbackTime = 0;
             }
-            else if (currentTime > 0 && duration > 0) {
-                audioUnit.playbackTime = currentTime;
-                audioUnit.duration = duration;
-            }
-            return _tslib.__assign(_tslib.__assign({}, state), { audioStorage: _tslib.__assign(_tslib.__assign({}, state.audioStorage), (_c = {}, _c[groupKey] = audioUnit, _c)) });
+            return _tslib.__assign(_tslib.__assign({}, state), { audioStorage: _tslib.__assign(_tslib.__assign({}, state.audioStorage), (_d = {}, _d[groupKey] = audioUnit, _d)) });
         }
         case ON_CURRENT_TIME_UPDATE: {
             var groupKey = action.payload.groupKey;
-            var _m = state.currentPlayer, currentTime = _m.currentTime, duration = _m.duration;
-            var audioUnit = (((_h = state.audioStorage) === null || _h === void 0 ? void 0 : _h[groupKey]) ? state.audioStorage[groupKey] : AudioUnitDefaultValue());
+            var _o = state.currentPlayer, currentTime = _o.currentTime, duration = _o.duration;
+            var audioUnit = (((_j = state.audioStorage) === null || _j === void 0 ? void 0 : _j[groupKey]) ? state.audioStorage[groupKey] : AudioUnitDefaultValue());
             // sometimes the final time update is fired AFTER the pause event when audio is finished
             if (audioUnit.playbackTime === audioUnit.duration && audioUnit.playingStatus === VOICE_PLAYER_STATUS.PAUSED) {
                 audioUnit.playbackTime = 0;
@@ -77,7 +77,7 @@ function voicePlayerReducer(state, action) {
                 audioUnit.playbackTime = currentTime;
                 audioUnit.duration = duration;
             }
-            return _tslib.__assign(_tslib.__assign({}, state), { audioStorage: _tslib.__assign(_tslib.__assign({}, state.audioStorage), (_d = {}, _d[groupKey] = audioUnit, _d)) });
+            return _tslib.__assign(_tslib.__assign({}, state), { audioStorage: _tslib.__assign(_tslib.__assign({}, state.audioStorage), (_e = {}, _e[groupKey] = audioUnit, _e)) });
         }
         default:
             return state;
@@ -132,7 +132,7 @@ var VoicePlayerProvider = function (_a) {
             voicePlayerRoot.removeChild(voicePlayerAudioElement);
         }
         logger.info('VoicePlayer: Start getting audio file.');
-        new Promise(function (resolve) {
+        new Promise(function (resolve, reject) {
             var _a;
             voicePlayerDispatcher({
                 type: INITIALIZE_AUDIO_UNIT,
@@ -161,8 +161,10 @@ var VoicePlayerProvider = function (_a) {
                 });
                 resolve(audioFile);
                 logger.info('VoicePlayer: Get the audioFile from URL.');
-            });
-        }).then(function (audioFile) {
+            })
+                .catch(reject);
+        })
+            .then(function (audioFile) {
             var _a;
             var voicePlayerRoot = document.getElementById(consts.VOICE_PLAYER_ROOT_ID);
             logger.info('VoicePlayer: Succeeded getting audio file.', { audioFile: audioFile });
@@ -183,7 +185,7 @@ var VoicePlayerProvider = function (_a) {
                 logger.info('VoicePlayer: OnPause event is called from audioPlayer', { groupKey: groupKey, audioPlayer: audioPlayer });
                 voicePlayerDispatcher({
                     type: ON_VOICE_PLAYER_PAUSE,
-                    payload: { groupKey: groupKey },
+                    payload: { groupKey: groupKey, duration: audioPlayer.duration, currentTime: audioPlayer.currentTime },
                 });
             };
             audioPlayer.ontimeupdate = function () {
@@ -192,6 +194,13 @@ var VoicePlayerProvider = function (_a) {
                     payload: { groupKey: groupKey },
                 });
             };
+            audioPlayer.onerror = function (error) {
+                logger.error('VoicePlayer: Failed to load the audioFile on the audio player.', error);
+                voicePlayerDispatcher({
+                    type: RESET_AUDIO_UNIT,
+                    payload: { groupKey: groupKey },
+                });
+            };
             audioPlayer.dataset.sbGroupId = groupKey;
             // clean up the previous audio player
             try {
@@ -201,10 +210,6 @@ var VoicePlayerProvider = function (_a) {
                     var thisGroupKey = (_a = element.dataset) === null || _a === void 0 ? void 0 : _a.sbGroupKey;
                     if (thisGroupKey !== groupKey) {
                         (_b = element === null || element === void 0 ? void 0 : element.pause) === null || _b === void 0 ? void 0 : _b.call(element);
-                        voicePlayerDispatcher({
-                            type: ON_VOICE_PLAYER_PAUSE,
-                            payload: { groupKey: groupKey },
-                        });
                         voicePlayerRoot.removeChild(element);
                         logger.info('VoicePlayer: Removed other player.', { element: element });
                     }
@@ -219,6 +224,13 @@ var VoicePlayerProvider = function (_a) {
                 });
                 logger.info('VoicePlayer: Succeeded playing audio player.', { groupKey: groupKey, audioPlayer: audioPlayer });
             }
+        })
+            .catch(function (error) {
+            logger.warning('VoicePlayer: Failed loading audio file with URL.', error);
+            voicePlayerDispatcher({
+                type: RESET_AUDIO_UNIT,
+                payload: { groupKey: groupKey },
+            });
         });
     };
     return (React.createElement(Context.Provider, { value: {
@@ -237,4 +249,4 @@ exports.AudioUnitDefaultValue = AudioUnitDefaultValue;
 exports.VOICE_PLAYER_STATUS = VOICE_PLAYER_STATUS;
 exports.VoicePlayerProvider = VoicePlayerProvider;
 exports.useVoicePlayerContext = useVoicePlayerContext;
-//# sourceMappingURL=bundle-rgxTgHrK.js.map
+//# sourceMappingURL=bundle-_apVcG-_.js.map

package/cjs/chunks/bundle-_apVcG-_.js.map

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

package/cjs/chunks/{bundle-XaLiuh0L.js → bundle-a1nOrOrG.js}

@@ -1,8 +1,6 @@
 'use strict';
 
-var _tslib = require('./bundle-bXLZZTmP.js');
-var index$1 = require('./bundle-6ZegaDWX.js');
-var index = require('./bundle-p6kWiWDv.js');
+var _tslib = require('./bundle-RVs527mS.js');
 var message = require('@sendbird/chat/message');
 
 var scrollToRenderedMessage = function (scrollRef, initialTimeStamp, setIsScrolled) {
@@ -101,28 +99,6 @@ var mergeAndSortMessages = function (oldMessages, newMessages) {
     var unique = getUniqueListByMessageId(mergedMessages);
     return sortByCreatedAt(unique);
 };
-var getMessageCreatedAt = function (message) { return index$1.format(message.createdAt, 'p'); };
-var isSameGroup = function (message, comparingMessage, currentChannel) {
-    var _a, _b;
-    if (!(message
-        && comparingMessage
-        && message.messageType
-        && message.messageType !== 'admin'
-        && comparingMessage.messageType
-        && (comparingMessage === null || comparingMessage === void 0 ? void 0 : comparingMessage.messageType) !== 'admin'
-        && 'sender' in message
-        && 'sender' in comparingMessage
-        && message.createdAt
-        && comparingMessage.createdAt
-        && message.sender.userId
-        && comparingMessage.sender.userId)) {
-        return false;
-    }
-    return ((message === null || message === void 0 ? void 0 : message.sendingStatus) === (comparingMessage === null || comparingMessage === void 0 ? void 0 : comparingMessage.sendingStatus)
-        && ((_a = message === null || message === void 0 ? void 0 : message.sender) === null || _a === void 0 ? void 0 : _a.userId) === ((_b = comparingMessage === null || comparingMessage === void 0 ? void 0 : comparingMessage.sender) === null || _b === void 0 ? void 0 : _b.userId)
-        && getMessageCreatedAt(message) === getMessageCreatedAt(comparingMessage)
-        && index.isReadMessage(currentChannel, message) === index.isReadMessage(currentChannel, comparingMessage));
-};
 var passUnsuccessfullMessages = function (allMessages, newMessage) {
     if ('sendingStatus' in newMessage
         && (newMessage.sendingStatus === message.SendingStatus.SUCCEEDED || newMessage.sendingStatus === message.SendingStatus.PENDING)) {
@@ -150,10 +126,8 @@ exports.getNicknamesMapFromMembers = getNicknamesMapFromMembers;
 exports.isAboutSame = isAboutSame;
 exports.isDisabledBecauseFrozen = isDisabledBecauseFrozen;
 exports.isDisabledBecauseMuted = isDisabledBecauseMuted;
-exports.isOperator = isOperator;
-exports.isSameGroup = isSameGroup;
 exports.mergeAndSortMessages = mergeAndSortMessages;
 exports.passUnsuccessfullMessages = passUnsuccessfullMessages;
 exports.scrollIntoLast = scrollIntoLast;
 exports.scrollToRenderedMessage = scrollToRenderedMessage;
-//# sourceMappingURL=bundle-XaLiuh0L.js.map
+//# sourceMappingURL=bundle-a1nOrOrG.js.map

package/{chunks/bundle-Gkl7Q1IK.js.map → cjs/chunks/bundle-a1nOrOrG.js.map}

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

package/cjs/chunks/{bundle-v02q7K8T.js → bundle-aAOHT0Qv.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var _tslib = require('./bundle-bXLZZTmP.js');
-var pxToNumber = require('./bundle--d5w7FVF.js');
+var _tslib = require('./bundle-RVs527mS.js');
+var pxToNumber = require('./bundle-wU4qxzey.js');
 
 var compressImage = function (_a) {
     var imageFile = _a.imageFile, compressionRate = _a.compressionRate, resizingWidth = _a.resizingWidth, resizingHeight = _a.resizingHeight;
@@ -114,4 +114,4 @@ var compressImages = function (_a) {
 };
 
 exports.compressImages = compressImages;
-//# sourceMappingURL=bundle-v02q7K8T.js.map
+//# sourceMappingURL=bundle-aAOHT0Qv.js.map

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

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

package/cjs/chunks/{bundle-hXzxY0NJ.js → bundle-dLwo2XPj.js}

@@ -3,4 +3,4 @@
 var TEXT_MESSAGE_BODY_CLASSNAME = 'sendbird-text-message-item-body';
 
 exports.TEXT_MESSAGE_BODY_CLASSNAME = TEXT_MESSAGE_BODY_CLASSNAME;
-//# sourceMappingURL=bundle-hXzxY0NJ.js.map
+//# sourceMappingURL=bundle-dLwo2XPj.js.map

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

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

package/cjs/chunks/{bundle--MJd6Gw1.js → bundle-duGLRUrw.js}

@@ -81,4 +81,4 @@ exports.SET_CHANNEL_INVALID = SET_CHANNEL_INVALID;
 exports.SET_CURRENT_CHANNEL = SET_CURRENT_CHANNEL;
 exports.SET_EMOJI_CONTAINER = SET_EMOJI_CONTAINER;
 exports.channelActions = channelActions;
-//# sourceMappingURL=bundle--MJd6Gw1.js.map
+//# sourceMappingURL=bundle-duGLRUrw.js.map

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

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

package/cjs/chunks/{bundle-p6kWiWDv.js → bundle-fnv2bNo-.js}

@@ -1,9 +1,9 @@
 'use strict';
 
-var _tslib = require('./bundle-bXLZZTmP.js');
+var _tslib = require('./bundle-RVs527mS.js');
 var groupChannel = require('@sendbird/chat/groupChannel');
 var utils_message_getOutgoingMessageState = require('../utils/message/getOutgoingMessageState.js');
-var index = require('./bundle-65IwoStx.js');
+var index = require('./bundle--RWWGoZo.js');
 
 // https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Complete_list_of_MIME_types
 var SUPPORTED_MIMES = {
@@ -255,6 +255,9 @@ function getSuggestedReplies(message) {
     }
 }
 var URL_REG = /^((http|https):\/\/)?([a-z\d-]+\.)+[a-z]{2,}(\:[0-9]{1,5})?(\/[-a-zA-Z\d%_.~+&=]*)*(\?[;&a-zA-Z\d%_.~+=-]*)?(#\S*)?$/;
+/** @deprecated
+ * URL detection in a message text will be handled in utils/tokens/tokenize.ts
+ */
 var isUrl = function (text) { return URL_REG.test(text); };
 var truncateString = function (fullStr, strLen) {
     if (!strLen)
@@ -561,12 +564,17 @@ var filterChannelListParams = function (params, channel, currentUserId) {
     }
     return true;
 };
-// This is required when channel is displayed on channel list by filter
-var getChannelsWithUpsertedChannel = function (_channels, channel, order) {
+var sortChannelList = function (channels, order) {
     var compareFunc = index.K(order)
         .with(groupChannel.GroupChannelListOrder.CHANNEL_NAME_ALPHABETICAL, function () { return (function (a, b) { return a.name.localeCompare(b.name); }); })
         .with(groupChannel.GroupChannelListOrder.CHRONOLOGICAL, function () { return (function (a, b) { return b.createdAt - a.createdAt; }); })
         .otherwise(function () { return (function (a, b) { var _a, _b, _c, _d; return ((_b = (_a = b.lastMessage) === null || _a === void 0 ? void 0 : _a.createdAt) !== null && _b !== void 0 ? _b : Number.MIN_SAFE_INTEGER) - ((_d = (_c = a.lastMessage) === null || _c === void 0 ? void 0 : _c.createdAt) !== null && _d !== void 0 ? _d : Number.MIN_SAFE_INTEGER); }); });
+    return channels.sort(compareFunc);
+};
+/**
+ * Upserts given channel to the channel list and then returns the sorted channel list.
+ */
+var getChannelsWithUpsertedChannel = function (_channels, channel, order) {
     var channels = _tslib.__spreadArray([], _channels, true);
     var findingIndex = channels.findIndex(function (ch) { return ch.url === channel.url; });
     if (findingIndex !== -1) {
@@ -575,7 +583,7 @@ var getChannelsWithUpsertedChannel = function (_channels, channel, order) {
     else {
         channels.push(channel);
     }
-    return channels.sort(compareFunc);
+    return sortChannelList(channels, order);
 };
 exports.StringObjType = void 0;
 (function (StringObjType) {
@@ -691,11 +699,10 @@ exports.isTextMessage = isTextMessage;
 exports.isTextuallyNull = isTextuallyNull;
 exports.isThreadMessage = isThreadMessage;
 exports.isThumbnailMessage = isThumbnailMessage;
-exports.isUrl = isUrl;
 exports.isUserMessage = isUserMessage;
 exports.isVideo = isVideo;
 exports.isVideoMessage = isVideoMessage;
 exports.isVoiceMessage = isVoiceMessage;
 exports.isVoiceMessageMimeType = isVoiceMessageMimeType;
 exports.truncateString = truncateString;
-//# sourceMappingURL=bundle-p6kWiWDv.js.map
+//# sourceMappingURL=bundle-fnv2bNo-.js.map

package/cjs/chunks/{bundle-p6kWiWDv.js.map → bundle-fnv2bNo-.js.map}

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

package/cjs/chunks/bundle-fvz26Ije.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var React = require('react');
+var LocalizationContext = require('./bundle-WLD9KKbn.js');
+var ui_Label = require('./bundle-JaD2Ao-u.js');
+var ui_Icon = require('../ui/Icon.js');
+var index = require('./bundle-7sO7MuTY.js');
+
+var UnreadCount = function (_a) {
+    var _b = _a.className, className = _b === void 0 ? '' : _b, _c = _a.count, count = _c === void 0 ? 0 : _c, _d = _a.time, time = _d === void 0 ? '' : _d, onClick = _a.onClick, lastReadAt = _a.lastReadAt;
+    var _e = React.useContext(LocalizationContext.LocalizationContext), stringSet = _e.stringSet, dateLocale = _e.dateLocale;
+    var unreadSince = React.useMemo(function () {
+        var _a, _b;
+        // TODO: Remove this on v4
+        if (stringSet.CHANNEL__MESSAGE_LIST__NOTIFICATION__ON !== 'on') {
+            var timeArray = ((_b = (_a = time === null || time === void 0 ? void 0 : time.toString) === null || _a === void 0 ? void 0 : _a.call(time)) === null || _b === void 0 ? void 0 : _b.split(' ')) || [];
+            timeArray === null || timeArray === void 0 ? void 0 : timeArray.splice(-2, 0, stringSet.CHANNEL__MESSAGE_LIST__NOTIFICATION__ON);
+            return timeArray.join(' ');
+        }
+        else if (lastReadAt) {
+            return index.format(lastReadAt, stringSet.DATE_FORMAT__MESSAGE_LIST__NOTIFICATION__UNREAD_SINCE, { locale: dateLocale });
+        }
+    }, [time, lastReadAt]);
+    return (React.createElement("div", { className: "sendbird-notification".concat(count < 1 ? '--hide' : '', " ").concat(className), onClick: onClick },
+        React.createElement(ui_Label.Label, { className: "sendbird-notification__text", color: ui_Label.LabelColors.ONCONTENT_1, type: ui_Label.LabelTypography.CAPTION_2 }, "".concat(count, " "),
+            stringSet.CHANNEL__MESSAGE_LIST__NOTIFICATION__NEW_MESSAGE, " ".concat(unreadSince)),
+        React.createElement(ui_Icon.default, { width: "24px", height: "24px", type: ui_Icon.IconTypes.CHEVRON_DOWN, fillColor: ui_Icon.IconColors.CONTENT })));
+};
+
+exports.UnreadCount = UnreadCount;
+//# sourceMappingURL=bundle-fvz26Ije.js.map

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

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

package/cjs/chunks/bundle-g2rKMwnQ.js

@@ -0,0 +1,123 @@
+'use strict';
+
+var React = require('react');
+var ChannelList_components_ChannelPreview = require('./bundle-plE_NeWt.js');
+var ChannelList_components_ChannelPreviewAction = require('./bundle-9fFxVdSK.js');
+var ChannelList_context = require('./bundle-9ZxGYXTj.js');
+var useSendbirdStateContext = require('../useSendbirdStateContext.js');
+var index = require('./bundle-Mq0jUvZk.js');
+var EditUserProfile = require('../EditUserProfile.js');
+var ui_PlaceHolder = require('../ui/PlaceHolder.js');
+var index$1 = require('./bundle-_TBSquwd.js');
+var ChannelList_components_AddChannel = require('./bundle-5cpSg7Yt.js');
+
+var GroupChannelListUIView = function (_a) {
+    var renderHeader = _a.renderHeader, renderPlaceHolderError = _a.renderPlaceHolderError, renderPlaceHolderLoading = _a.renderPlaceHolderLoading, renderPlaceHolderEmptyList = _a.renderPlaceHolderEmptyList, onChangeTheme = _a.onChangeTheme, onUserProfileUpdated = _a.onUserProfileUpdated, allowProfileEdit = _a.allowProfileEdit, channels = _a.channels, onLoadMore = _a.onLoadMore, initialized = _a.initialized, renderChannel = _a.renderChannel, renderAddChannel = _a.renderAddChannel;
+    var _b = React.useState(false), showProfileEdit = _b[0], setShowProfileEdit = _b[1];
+    var stores = useSendbirdStateContext.useSendbirdStateContext().stores;
+    var renderer = {
+        addChannel: renderAddChannel,
+        channel: renderChannel,
+        placeholder: {
+            loading: function () {
+                if (initialized)
+                    return null;
+                if (renderPlaceHolderLoading)
+                    return renderPlaceHolderLoading();
+                return React.createElement(ui_PlaceHolder.default, { type: ui_PlaceHolder.PlaceHolderTypes.LOADING });
+            },
+            empty: function () {
+                if (!initialized)
+                    return null;
+                if (renderPlaceHolderEmptyList)
+                    return renderPlaceHolderEmptyList();
+                return React.createElement(ui_PlaceHolder.default, { type: ui_PlaceHolder.PlaceHolderTypes.NO_CHANNELS });
+            },
+            error: function () {
+                if (!initialized || !stores.sdkStore.error)
+                    return null;
+                if (renderPlaceHolderError)
+                    return renderPlaceHolderError();
+                return React.createElement(ui_PlaceHolder.default, { type: ui_PlaceHolder.PlaceHolderTypes.WRONG });
+            },
+        },
+    };
+    return (React.createElement(React.Fragment, null,
+        React.createElement("div", { className: "sendbird-channel-list__header" }, (renderHeader === null || renderHeader === void 0 ? void 0 : renderHeader()) || (React.createElement(index.GroupChannelListHeader, { onEdit: function () { return allowProfileEdit && setShowProfileEdit(true); }, allowProfileEdit: allowProfileEdit, renderIconButton: function () { return renderer.addChannel(); } }))),
+        showProfileEdit && (React.createElement(EditUserProfile, { onThemeChange: onChangeTheme, onCancel: function () { return setShowProfileEdit(false); }, onEditProfile: function (user) {
+                setShowProfileEdit(false);
+                onUserProfileUpdated(user);
+            } })),
+        React.createElement(ChannelListComponent, { data: channels, renderItem: renderer.channel, onLoadMore: onLoadMore, placeholderLoading: renderer.placeholder.loading(), placeholderEmpty: renderer.placeholder.empty(), placeholderError: renderer.placeholder.error() })));
+};
+/**
+ * To do: Implement windowing
+ * Implement windowing if you are dealing with large number of messages/channels
+ * https://github.com/bvaughn/react-window -> recommendation
+ * We hesitate to bring one more dependency to our library,
+ * we are planning to implement it inside the library
+ * */
+var ChannelListComponent = function (props) {
+    var data = props.data, renderItem = props.renderItem, onLoadMore = props.onLoadMore, placeholderLoading = props.placeholderLoading, placeholderError = props.placeholderError, placeholderEmpty = props.placeholderEmpty;
+    var onScroll = index$1.useOnScrollPositionChangeDetector({
+        onReachedBottom: function () { return onLoadMore(); },
+    });
+    return (React.createElement("div", { className: 'sendbird-channel-list__body', onScroll: onScroll },
+        placeholderError,
+        React.createElement("div", null, data.map(function (item, index) { return renderItem({ item: item, index: index }); })),
+        placeholderLoading,
+        data.length === 0 && placeholderEmpty));
+};
+
+var ChannelListUI = function (props) {
+    var renderHeader = props.renderHeader, renderChannelPreview = props.renderChannelPreview, renderPlaceHolderError = props.renderPlaceHolderError, renderPlaceHolderLoading = props.renderPlaceHolderLoading, renderPlaceHolderEmptyList = props.renderPlaceHolderEmptyList;
+    var _a = ChannelList_context.useChannelListContext(), onThemeChange = _a.onThemeChange, allowProfileEdit = _a.allowProfileEdit, allChannels = _a.allChannels, currentChannel = _a.currentChannel, channelListDispatcher = _a.channelListDispatcher, typingChannels = _a.typingChannels, initialized = _a.initialized, fetchChannelList = _a.fetchChannelList, onProfileEditSuccess = _a.onProfileEditSuccess;
+    var _b = useSendbirdStateContext.useSendbirdStateContext(), stores = _b.stores, config = _b.config;
+    var logger = config.logger, _c = config.isOnline, isOnline = _c === void 0 ? false : _c;
+    var sdk = stores.sdkStore.sdk;
+    var renderListItem = function (props) {
+        var channel = props.item, index = props.index;
+        var onLeaveChannel = function (channel, cb) {
+            logger.info('ChannelList: Leaving channel', channel);
+            channel
+                .leave()
+                .then(function (res) {
+                logger.info('ChannelList: Leaving channel success', res);
+                if (cb && typeof cb === 'function')
+                    cb(channel, null);
+                channelListDispatcher({
+                    type: ChannelList_context.LEAVE_CHANNEL_SUCCESS,
+                    payload: channel.url,
+                });
+            })
+                .catch(function (err) {
+                logger.error('ChannelList: Leaving channel failed', err);
+                if (cb && typeof cb === 'function')
+                    cb(channel, err);
+            });
+        };
+        var onClickChannel = function () {
+            if (!isOnline && !(sdk === null || sdk === void 0 ? void 0 : sdk.isCacheEnabled)) {
+                logger.warning('ChannelList: Inactivated clicking channel item during offline.');
+                return;
+            }
+            logger.info('ChannelList: Clicked on channel:', channel);
+            channelListDispatcher({
+                type: ChannelList_context.SET_CURRENT_CHANNEL,
+                payload: channel,
+            });
+        };
+        if (renderChannelPreview) {
+            return (React.createElement("div", { key: channel === null || channel === void 0 ? void 0 : channel.url, onClick: onClickChannel }, renderChannelPreview({ channel: channel, onLeaveChannel: onLeaveChannel })));
+        }
+        return (React.createElement(ChannelList_components_ChannelPreview.ChannelPreview, { key: channel === null || channel === void 0 ? void 0 : channel.url, tabIndex: index, onClick: onClickChannel, channel: channel, onLeaveChannel: function () { return onLeaveChannel(channel, null); }, isActive: (channel === null || channel === void 0 ? void 0 : channel.url) === (currentChannel === null || currentChannel === void 0 ? void 0 : currentChannel.url), isTyping: typingChannels === null || typingChannels === void 0 ? void 0 : typingChannels.some(function (_a) {
+                var url = _a.url;
+                return url === (channel === null || channel === void 0 ? void 0 : channel.url);
+            }), renderChannelAction: function () { return (React.createElement(ChannelList_components_ChannelPreviewAction.ChannelPreviewAction, { channel: channel, disabled: !isOnline, onLeaveChannel: function () { return onLeaveChannel(channel, null); } })); } }));
+    };
+    return (React.createElement(GroupChannelListUIView, { renderHeader: renderHeader, renderChannel: renderListItem, renderPlaceHolderError: renderPlaceHolderError, renderPlaceHolderLoading: renderPlaceHolderLoading, renderPlaceHolderEmptyList: renderPlaceHolderEmptyList, onChangeTheme: onThemeChange, allowProfileEdit: allowProfileEdit, onUserProfileUpdated: onProfileEditSuccess, channels: allChannels, onLoadMore: fetchChannelList, initialized: initialized, renderAddChannel: function () { return React.createElement(ChannelList_components_AddChannel.AddChannel, null); } }));
+};
+
+exports.ChannelListUI = ChannelListUI;
+exports.GroupChannelListUIView = GroupChannelListUIView;
+//# sourceMappingURL=bundle-g2rKMwnQ.js.map

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

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

package/cjs/chunks/bundle-guyZxs5x.js

@@ -0,0 +1,91 @@
+'use strict';
+
+var React = require('react');
+var uikitTools = require('@sendbird/uikit-tools');
+
+/**
+ * Note: `leading` has higher priority rather than `trailing`
+ * */
+function useThrottleCallback(callback, delay, options) {
+    if (options === void 0) { options = {
+        leading: true,
+        trailing: false,
+    }; }
+    var timer = React.useRef(null);
+    var trailingArgs = React.useRef(null);
+    React.useEffect(function () {
+        return function () {
+            if (timer.current)
+                clearTimeout(timer.current);
+        };
+    }, []);
+    return uikitTools.usePreservedCallback(function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (timer.current) {
+            trailingArgs.current = args;
+            return;
+        }
+        if (options.leading) {
+            callback.apply(void 0, args);
+        }
+        else {
+            trailingArgs.current = args;
+        }
+        var invoke = function () {
+            if (options.trailing && trailingArgs.current) {
+                callback.apply(void 0, trailingArgs.current);
+                trailingArgs.current = null;
+                timer.current = setTimeout(invoke, delay);
+            }
+            else {
+                timer.current = null;
+            }
+        };
+        timer.current = setTimeout(invoke, delay);
+    });
+}
+/**
+ * Note: `leading` has higher priority rather than `trailing`
+ * */
+function throttle(callback, delay, options) {
+    if (options === void 0) { options = {
+        leading: true,
+        trailing: false,
+    }; }
+    var timer = null;
+    var trailingArgs = null;
+    return (function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (timer) {
+            trailingArgs = args;
+            return;
+        }
+        if (options.leading) {
+            callback.apply(void 0, args);
+        }
+        else {
+            trailingArgs = args;
+        }
+        var invoke = function () {
+            if (options.trailing && trailingArgs) {
+                callback.apply(void 0, trailingArgs);
+                trailingArgs = null;
+                timer = setTimeout(invoke, delay);
+            }
+            else {
+                timer = null;
+            }
+        };
+        timer = setTimeout(invoke, delay);
+    });
+}
+
+exports.throttle = throttle;
+exports.useThrottleCallback = useThrottleCallback;
+//# sourceMappingURL=bundle-guyZxs5x.js.map

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

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