@sendbird/uikit-react 3.10.1 → 3.10.2-alpha.0

package/cjs/chunks/{bundle-r8Z3GYqh.js → bundle-gW6qz9z9.js}

@@ -14,26 +14,27 @@ exports.CHANNEL_TYPE = void 0;
 var CreateChannelContext = React.createContext(undefined);
 var CreateChannelProvider = function (props) {
     var _a;
-    var children = props.children, onCreateChannel = props.onCreateChannel, onBeforeCreateChannel = props.onBeforeCreateChannel, overrideInviteUser = props.overrideInviteUser, userListQuery = props.userListQuery;
+    var children = props.children, onCreateChannelClick = props.onCreateChannelClick, onBeforeCreateChannel = props.onBeforeCreateChannel, onChannelCreated = props.onChannelCreated, userListQuery = props.userListQuery, onCreateChannel = props.onCreateChannel, overrideInviteUser = props.overrideInviteUser;
     var store = useSendbirdStateContext.useSendbirdStateContext();
-    var userListQuery_ = (_a = store === null || store === void 0 ? void 0 : store.config) === null || _a === void 0 ? void 0 : _a.userListQuery;
-    var createChannel = sendbirdSelectors.getCreateGroupChannel(store);
+    var _userListQuery = userListQuery !== null && userListQuery !== void 0 ? userListQuery : (_a = store === null || store === void 0 ? void 0 : store.config) === null || _a === void 0 ? void 0 : _a.userListQuery;
     var _b = React.useState(0), step = _b[0], setStep = _b[1];
     var _c = React.useState(exports.CHANNEL_TYPE.GROUP), type = _c[0], setType = _c[1];
     return (React.createElement(CreateChannelContext.Provider, { value: {
+            createChannel: sendbirdSelectors.getCreateGroupChannel(store),
+            onCreateChannelClick: onCreateChannelClick,
             onBeforeCreateChannel: onBeforeCreateChannel,
-            createChannel: createChannel,
-            onCreateChannel: onCreateChannel,
-            overrideInviteUser: overrideInviteUser,
-            userListQuery: userListQuery || userListQuery_,
+            onChannelCreated: onChannelCreated,
+            userListQuery: _userListQuery,
             step: step,
             setStep: setStep,
             type: type,
             setType: setType,
+            onCreateChannel: onCreateChannel,
+            overrideInviteUser: overrideInviteUser,
         } }, children));
 };
 var useCreateChannelContext = function () { return (React.useContext(CreateChannelContext)); };
 
 exports.CreateChannelProvider = CreateChannelProvider;
 exports.useCreateChannelContext = useCreateChannelContext;
-//# sourceMappingURL=bundle-r8Z3GYqh.js.map
+//# sourceMappingURL=bundle-gW6qz9z9.js.map

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

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

package/cjs/chunks/{bundle-9iE0HY96.js → bundle-haAptps1.js}

@@ -1,7 +1,6 @@
 'use strict';
 
-var _tslib = require('./bundle-bXLZZTmP.js');
-var index = require('./bundle-p6kWiWDv.js');
+var _tslib = require('./bundle-DhtZdKsr.js');
 
 var USER_MENTION_PREFIX = '@';
 
@@ -54,21 +53,38 @@ function identifyMentions(_a) {
     return results;
 }
 function identifyUrlsAndStrings(token) {
+    var URL_REG = /(?:https?:\/\/|www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.(xn--)?[a-z0-9-]{2,20}\b([-a-zA-Z0-9@:%_+[\],.~#?&/=]*[-a-zA-Z0-9@:%_+~#?&/=])*/g;
     var results = token.map(function (token) {
         if (token.type !== TOKEN_TYPES.undetermined) {
             return token;
         }
         var _a = token.value, value = _a === void 0 ? '' : _a;
-        var parts = value.split(' ');
-        var tokens = parts.map(function (part) {
-            if (index.isUrl(part)) {
-                return { value: part, type: TOKEN_TYPES.url };
-            }
-            else {
-                return { value: part, type: TOKEN_TYPES.string };
-            }
+        var matches = Array.from(value.matchAll(URL_REG));
+        var founds = matches.map(function (value) {
+            var _a;
+            var text = value[0];
+            var start = (_a = value.index) !== null && _a !== void 0 ? _a : 0;
+            var end = start + text.length;
+            return { text: text, start: start, end: end };
         });
-        return tokens;
+        var items = [{ value: value, type: TOKEN_TYPES.string }];
+        var cursor = 0;
+        founds.forEach(function (_a) {
+            var text = _a.text, start = _a.start, end = _a.end;
+            var restText = items.pop().value;
+            var head = restText.slice(0, start - cursor);
+            var mid = text;
+            var tail = restText.slice(end - cursor);
+            items.push({ value: head, type: TOKEN_TYPES.string }, { value: mid, type: TOKEN_TYPES.url });
+            if (tail.length > 0)
+                items.push({ value: tail, type: TOKEN_TYPES.string });
+            cursor = end;
+        });
+        // Remove the first empty string
+        if (items[0].value === '' && items[0].type === TOKEN_TYPES.string) {
+            items.shift();
+        }
+        return items;
     }).flat();
     return results;
 }
@@ -76,7 +92,7 @@ function combineNearbyStrings(tokens) {
     var results = tokens.reduce(function (acc, token) {
         var lastToken = acc[acc.length - 1];
         if ((lastToken === null || lastToken === void 0 ? void 0 : lastToken.type) === TOKEN_TYPES.string && token.type === TOKEN_TYPES.string) {
-            lastToken.value = "".concat(lastToken.value, " ").concat(token.value);
+            lastToken.value = "".concat(lastToken.value).concat(token.value);
             return acc;
         }
         return _tslib.__spreadArray(_tslib.__spreadArray([], acc, true), [token], false);
@@ -134,4 +150,4 @@ exports.TOKEN_TYPES = TOKEN_TYPES;
 exports.USER_MENTION_PREFIX = USER_MENTION_PREFIX;
 exports.getWhiteSpacePreservedText = getWhiteSpacePreservedText;
 exports.tokenizeMessage = tokenizeMessage;
-//# sourceMappingURL=bundle-9iE0HY96.js.map
+//# sourceMappingURL=bundle-haAptps1.js.map

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

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

package/cjs/chunks/{bundle-vphYV1gz.js → bundle-iY19D_aw.js}

@@ -32,4 +32,4 @@ var generateDefaultAvatar = function (channel) {
 exports.generateDefaultAvatar = generateDefaultAvatar;
 exports.getChannelAvatarSource = getChannelAvatarSource;
 exports.getOpenChannelAvatar = getOpenChannelAvatar;
-//# sourceMappingURL=bundle-vphYV1gz.js.map
+//# sourceMappingURL=bundle-iY19D_aw.js.map

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

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

package/cjs/chunks/bundle-jYLCAuUn.js

@@ -0,0 +1,123 @@
+'use strict';
+
+var React = require('react');
+var ChannelList_components_ChannelPreview = require('./bundle-Y86Tvf8p.js');
+var ChannelList_components_ChannelPreviewAction = require('./bundle-1tu4OFP8.js');
+var ChannelList_context = require('./bundle-zGSEOOdl.js');
+var useSendbirdStateContext = require('../useSendbirdStateContext.js');
+var index = require('./bundle-fUWIw3RI.js');
+var EditUserProfile = require('../EditUserProfile.js');
+var ui_PlaceHolder = require('../ui/PlaceHolder.js');
+var index$1 = require('./bundle-zHDXCFIb.js');
+var ChannelList_components_AddChannel = require('./bundle-rcw3KtAu.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-jYLCAuUn.js.map

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

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

package/cjs/chunks/bundle-jcgWT1ad.js

@@ -0,0 +1,40 @@
+'use strict';
+
+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';
+};
+
+exports.getComponentKeyFromMessage = getComponentKeyFromMessage;
+exports.getMessageTopOffset = getMessageTopOffset;
+exports.isContextMenuClosed = isContextMenuClosed;
+exports.isDisabledBecauseFrozen = isDisabledBecauseFrozen;
+exports.isDisabledBecauseMuted = isDisabledBecauseMuted;
+//# sourceMappingURL=bundle-jcgWT1ad.js.map

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

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

package/cjs/chunks/{bundle-Dax6YIIr.js → bundle-nYBtJl9e.js}

@@ -3,4 +3,4 @@
 var MENTION_USER_LABEL_CLASSNAME = 'sendbird-mention-user-label';
 
 exports.MENTION_USER_LABEL_CLASSNAME = MENTION_USER_LABEL_CLASSNAME;
-//# sourceMappingURL=bundle-Dax6YIIr.js.map
+//# sourceMappingURL=bundle-nYBtJl9e.js.map

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

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

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

@@ -1,9 +1,9 @@
 'use strict';
 
-var _tslib = require('./bundle-bXLZZTmP.js');
+var _tslib = require('./bundle-DhtZdKsr.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-xM2DAzE6.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-nox41MG6.js.map

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

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

package/cjs/chunks/{bundle-mnbFX6XC.js → bundle-pp7tp7GG.js}

@@ -1,24 +1,22 @@
 'use strict';
 
 var React = require('react');
-var index = require('./bundle-6ZegaDWX.js');
-var UserProfileContext = require('./bundle-7AS0Rcch.js');
-var _tslib = require('./bundle-bXLZZTmP.js');
-var compareIds = require('./bundle-UaSM_xZY.js');
-var pubSub_topics = require('./bundle-135pRm7i.js');
+var UserProfileContext = require('./bundle-TPy0gj60.js');
+var _tslib = require('./bundle-DhtZdKsr.js');
+var compareIds = require('./bundle-NZvAE9FS.js');
+var pubSub_topics = require('./bundle-77qvrXp8.js');
 var SendbirdChat = require('@sendbird/chat');
 var openChannel = require('@sendbird/chat/openChannel');
-var uuid = require('./bundle-INJtS58R.js');
-var compressImages = require('./bundle-v02q7K8T.js');
+var uuid = require('./bundle-TB_UEIPg.js');
+var compressImages = require('./bundle-PSEoX-EH.js');
 var useSendbirdStateContext = require('../useSendbirdStateContext.js');
 var hooks_useModal = require('../hooks/useModal.js');
-var LocalizationContext = require('./bundle-qtXdbPNE.js');
-var consts = require('./bundle-JbxviE94.js');
-var ui_Modal = require('./bundle-Oc2T5_VP.js');
-require('./bundle-7J3nX_hP.js');
+var LocalizationContext = require('./bundle-6SzyBwQ5.js');
+var consts = require('./bundle-UAspU0bH.js');
+var ui_Modal = require('./bundle-6L4HCLmb.js');
+require('./bundle-VxcYXhwp.js');
 var ui_Button = require('../ui/Button.js');
 
-var getMessageCreatedAt = function (message) { return index.format(message.createdAt, 'p'); };
 var shouldFetchMore = function (messageLength, maxMessages) {
     if (typeof maxMessages !== 'number') {
         return true;
@@ -48,33 +46,6 @@ var scrollIntoLast = function (initialTry, scrollRef) {
         }, 500 * currentTry);
     }
 };
-var isSameGroup = function (message, comparingMessage) {
-    var _a, _b, _c, _d;
-    if (!(message
-        && comparingMessage
-        && (message === null || message === void 0 ? void 0 : message.messageType)
-        && message.messageType !== 'admin'
-        && (comparingMessage === null || comparingMessage === void 0 ? void 0 : comparingMessage.messageType)
-        && comparingMessage.messageType !== 'admin'
-        && (message === null || message === void 0 ? void 0 : message.sender)
-        && (comparingMessage === null || comparingMessage === void 0 ? void 0 : comparingMessage.sender)
-        && (message === null || message === void 0 ? void 0 : message.createdAt)
-        && (comparingMessage === null || comparingMessage === void 0 ? void 0 : comparingMessage.createdAt)
-        && ((_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))) {
-        return false;
-    }
-    // to fix typecasting
-    var message_ = message;
-    var comparingMessage_ = comparingMessage;
-    return ((message_ === null || message_ === void 0 ? void 0 : message_.sendingStatus) === (comparingMessage_ === null || comparingMessage_ === void 0 ? void 0 : comparingMessage_.sendingStatus)
-        && ((_c = message_ === null || message_ === void 0 ? void 0 : message_.sender) === null || _c === void 0 ? void 0 : _c.userId) === ((_d = comparingMessage_ === null || comparingMessage_ === void 0 ? void 0 : comparingMessage_.sender) === null || _d === void 0 ? void 0 : _d.userId)
-        && (getMessageCreatedAt(message) === getMessageCreatedAt(comparingMessage)));
-};
-var compareMessagesForGrouping = function (prevMessage, currMessage, nextMessage) { return ([
-    isSameGroup(prevMessage, currMessage),
-    isSameGroup(currMessage, nextMessage),
-]); };
 var kFormatter = function (num) {
     if (Math.abs(num) > 999999) {
         return "".concat((Math.abs(num) / 1000000).toFixed(1), "M");
@@ -1393,7 +1364,6 @@ var OpenChannelProvider = function (props) {
 var useOpenChannelContext = function () { return React.useContext(OpenChannelContext); };
 
 exports.OpenChannelProvider = OpenChannelProvider;
-exports.compareMessagesForGrouping = compareMessagesForGrouping;
 exports.kFormatter = kFormatter;
 exports.useOpenChannelContext = useOpenChannelContext;
-//# sourceMappingURL=bundle-mnbFX6XC.js.map
+//# sourceMappingURL=bundle-pp7tp7GG.js.map

package/cjs/chunks/{bundle-mnbFX6XC.js.map → bundle-pp7tp7GG.js.map}

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

package/cjs/chunks/bundle-qRiLsSwC.js

@@ -0,0 +1,153 @@
+'use strict';
+
+var React = require('react');
+var ui_Icon = require('../ui/Icon.js');
+var message = require('@sendbird/chat/message');
+var ui_ImageRenderer = require('../ui/ImageRenderer.js');
+var index = require('./bundle-nox41MG6.js');
+var ui_FileViewer = require('./bundle-NPzNlnHJ.js');
+var index$1 = require('./bundle-xM2DAzE6.js');
+var _tslib = require('./bundle-DhtZdKsr.js');
+
+function ImageGrid(_a) {
+    var _b;
+    var children = _a.children, className = _a.className, message = _a.message, isReactionEnabled = _a.isReactionEnabled;
+    return (React.createElement("div", { className: 'sendbird-image-grid-wrap' },
+        React.createElement("div", { className: index.getClassName([
+                className,
+                'sendbird-image-grid',
+                (isReactionEnabled && ((_b = message === null || message === void 0 ? void 0 : message.reactions) === null || _b === void 0 ? void 0 : _b.length) > 0) ? 'reactions' : '',
+            ]) }, children)));
+}
+
+var GRID_WIDTH_CHAT_WEB = 400;
+var GRID_SIDE_PADDING = 8;
+var GRID_GAP = 4;
+var TIMESTAMP_WIDTH_AND_ITS_SIDE_MARGIN = 54;
+var PROFILE_IMAGE_WIDTH = 40;
+var CHAT_MOBILE_SIDE_PADDING = 48;
+var THREAD_PARENT_WIDTH = 320;
+var THREAD_PARENT_SIDE_PADDING = 28;
+var THREAD_PARENT_GRID_MARGIN_LEFT = 12;
+var THREAD_CHILD_WIDTH = 200;
+var THREAD_CHILD_SIDE_PADDING = 8;
+var THREAD_CHILD_MOBILE_SIDE_PADDING = 32;
+var THREAD_CHILD_MOBILE_TIMESTAMP_WIDTH_AND_ITS_SIDE_MARGIN = 60;
+var MULTIPLE_FILES_IMAGE_SIDE_LENGTH = {
+    CHAT_WEB: "calc(".concat(GRID_WIDTH_CHAT_WEB / 2, "px - ").concat((GRID_SIDE_PADDING + GRID_GAP) / 2, "px)"),
+    CHAT_MOBILE: "calc(50vw - ".concat((CHAT_MOBILE_SIDE_PADDING + PROFILE_IMAGE_WIDTH + TIMESTAMP_WIDTH_AND_ITS_SIDE_MARGIN + GRID_SIDE_PADDING + GRID_GAP) / 2, "px)"),
+    THREAD_PARENT_WEB: "calc(".concat((THREAD_PARENT_WIDTH - (THREAD_PARENT_SIDE_PADDING + PROFILE_IMAGE_WIDTH + THREAD_PARENT_GRID_MARGIN_LEFT + GRID_GAP)) / 2, "px)"),
+    THREAD_PARENT_MOBILE: "calc(50vw - ".concat((THREAD_PARENT_SIDE_PADDING + PROFILE_IMAGE_WIDTH + THREAD_PARENT_GRID_MARGIN_LEFT + GRID_GAP) / 2, "px)"),
+    THREAD_CHILD_WEB: "calc(".concat((THREAD_CHILD_WIDTH - THREAD_CHILD_SIDE_PADDING - GRID_GAP) / 2, "px)"),
+    THREAD_CHILD_MOBILE: "calc(50vw - ".concat((THREAD_CHILD_MOBILE_SIDE_PADDING + PROFILE_IMAGE_WIDTH + THREAD_CHILD_MOBILE_TIMESTAMP_WIDTH_AND_ITS_SIDE_MARGIN + GRID_SIDE_PADDING + GRID_GAP) / 2, "px)"),
+};
+var MULTIPLE_FILES_IMAGE_BORDER_RADIUS = {
+    CHAT_WEB: '6px',
+    CHAT_MOBILE: '6px',
+    THREAD_PARENT_WEB: '6px',
+    THREAD_PARENT_MOBILE: '6px',
+    THREAD_CHILD_WEB: '6px',
+    THREAD_CHILD_MOBILE: '6px',
+};
+var MULTIPLE_FILES_IMAGE_THUMBNAIL_SIDE_LENGTH = '34px';
+
+var ThreadMessageKind = {
+    PARENT: 'parent',
+    CHILD: 'child',
+};
+function MultipleFilesMessageItemBody(_a) {
+    var className = _a.className, message$1 = _a.message, _b = _a.isReactionEnabled, isReactionEnabled = _b === void 0 ? false : _b, threadMessageKindKey = _a.threadMessageKindKey, _c = _a.statefulFileInfoList, statefulFileInfoList = _c === void 0 ? [] : _c;
+    var _d = React.useState(-1), currentFileViewerIndex = _d[0], setCurrentFileViewerIndex = _d[1];
+    function onClose() {
+        setCurrentFileViewerIndex(-1);
+    }
+    function onClickLeft() {
+        setCurrentFileViewerIndex(currentFileViewerIndex === 0 ? statefulFileInfoList.length - 1 : currentFileViewerIndex - 1);
+    }
+    function onClickRight() {
+        setCurrentFileViewerIndex(currentFileViewerIndex === statefulFileInfoList.length - 1 ? 0 : currentFileViewerIndex + 1);
+    }
+    return (threadMessageKindKey && (React.createElement(React.Fragment, null,
+        currentFileViewerIndex > -1 && (React.createElement(ui_FileViewer.FileViewer, { message: message$1, statefulFileInfoList: statefulFileInfoList, currentIndex: currentFileViewerIndex, onClickLeft: onClickLeft, onClickRight: onClickRight, onClose: onClose })),
+        React.createElement(ImageGrid, { className: className, message: message$1, isReactionEnabled: isReactionEnabled }, statefulFileInfoList.map(function (fileInfo, index$1) {
+            var _a, _b, _c;
+            return (React.createElement("div", { className: "sendbird-multiple-files-image-renderer-wrapper", onClick: message$1.sendingStatus === message.SendingStatus.SUCCEEDED ? function () { return setCurrentFileViewerIndex(index$1); } : undefined, key: "sendbird-multiple-files-image-renderer-".concat(index$1, "-").concat(fileInfo.url) },
+                React.createElement(ui_ImageRenderer.default, { url: (_c = (_b = (_a = fileInfo.thumbnails) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.url) !== null && _c !== void 0 ? _c : fileInfo.url, fixedSize: false, width: MULTIPLE_FILES_IMAGE_SIDE_LENGTH[threadMessageKindKey], maxSideLength: MULTIPLE_FILES_IMAGE_SIDE_LENGTH.CHAT_WEB, height: MULTIPLE_FILES_IMAGE_SIDE_LENGTH[threadMessageKindKey], borderRadius: ui_ImageRenderer.getBorderRadiusForMultipleImageRenderer(MULTIPLE_FILES_IMAGE_BORDER_RADIUS[threadMessageKindKey], index$1, statefulFileInfoList.length), shadeOnHover: true, isUploaded: !!fileInfo.isUploaded, placeHolder: function (_a) {
+                        var style = _a.style;
+                        if (index.isGif(fileInfo.mimeType))
+                            return React.createElement(ImagePlaceholder.GIF, { style: style });
+                        return React.createElement(ImagePlaceholder.Default, { style: style });
+                    }, defaultComponent: React.createElement(ImagePlaceholder.LoadError, null) })));
+        })))));
+}
+var ImagePlaceholder = {
+    Default: function (_a) {
+        var style = _a.style;
+        return (React.createElement("div", { className: "sendbird-multiple-files-image-renderer__thumbnail__placeholder", style: style },
+            React.createElement(ui_Icon.default, { type: ui_Icon.IconTypes.PHOTO, fillColor: ui_Icon.IconColors.ON_BACKGROUND_2, width: MULTIPLE_FILES_IMAGE_THUMBNAIL_SIDE_LENGTH, height: MULTIPLE_FILES_IMAGE_THUMBNAIL_SIDE_LENGTH })));
+    },
+    GIF: function (_a) {
+        var style = _a.style;
+        return (React.createElement("div", { className: "sendbird-multiple-files-image-renderer__thumbnail__placeholder", style: style },
+            React.createElement("div", { className: "sendbird-multiple-files-image-renderer__thumbnail__placeholder__icon" },
+                React.createElement(ui_Icon.default, { type: ui_Icon.IconTypes.GIF, fillColor: ui_Icon.IconColors.THUMBNAIL_ICON, width: MULTIPLE_FILES_IMAGE_THUMBNAIL_SIDE_LENGTH, height: MULTIPLE_FILES_IMAGE_THUMBNAIL_SIDE_LENGTH }))));
+    },
+    LoadError: function () { return (React.createElement("div", { className: "sendbird-multiple-files-image-renderer__thumbnail__placeholder" },
+        React.createElement(ui_Icon.default, { type: ui_Icon.IconTypes.THUMBNAIL_NONE, fillColor: ui_Icon.IconColors.ON_BACKGROUND_2, width: MULTIPLE_FILES_IMAGE_THUMBNAIL_SIDE_LENGTH, height: MULTIPLE_FILES_IMAGE_THUMBNAIL_SIDE_LENGTH }))); },
+};
+
+function useThreadMessageKindKeySelector(_a) {
+    var threadMessageKind = _a.threadMessageKind, isMobile = _a.isMobile;
+    var threadMessageKindKey = React.useMemo(function () {
+        return index$1.K(threadMessageKind)
+            .with(ThreadMessageKind.PARENT, function () { return (isMobile
+            ? 'THREAD_PARENT_MOBILE'
+            : 'THREAD_PARENT_WEB'); })
+            .with(ThreadMessageKind.CHILD, function () { return (isMobile
+            ? 'THREAD_CHILD_MOBILE'
+            : 'THREAD_CHILD_WEB'); })
+            .otherwise(function () { return (isMobile
+            ? 'CHAT_MOBILE'
+            : 'CHAT_WEB'); });
+    }, [isMobile, threadMessageKind]);
+    return threadMessageKindKey;
+}
+
+// SendingStatus.SCHEDULED is currently not covered in UIKit
+//  So we can ignore for now, but for future, it is better to explicitly use PENDING, FAILED, or CANCELED.
+var useFileInfoListWithUploaded = function (message$1) {
+    var blobHandler = React.useRef(new Map());
+    var getObjectURL = function (index, blob) {
+        if (!blobHandler.current.has(index) && blob)
+            blobHandler.current.set(index, URL.createObjectURL(blob));
+        return blobHandler.current.get(index);
+    };
+    var revokeURLs = function () {
+        if (blobHandler.current.size > 0) {
+            blobHandler.current.forEach(function (url) { return URL.revokeObjectURL(url); });
+            blobHandler.current.clear();
+        }
+    };
+    React.useEffect(function () {
+        return function () { return revokeURLs(); };
+    }, []);
+    if (!message$1 || !message$1.isMultipleFilesMessage || !message$1.isMultipleFilesMessage()) {
+        return [];
+    }
+    else if (message$1.sendingStatus === message.SendingStatus.SUCCEEDED) {
+        revokeURLs();
+        return message$1.fileInfoList.map(function (it) { return (_tslib.__assign(_tslib.__assign({}, it), { url: it.url, isUploaded: true })); });
+    }
+    else {
+        return message$1.messageParams.fileInfoList.map(function (it, index) {
+            var _a, _b;
+            return (_tslib.__assign(_tslib.__assign({}, it), { url: (_b = (_a = getObjectURL(index)) !== null && _a !== void 0 ? _a : it.fileUrl) !== null && _b !== void 0 ? _b : (it.file instanceof Blob ? getObjectURL(index, it.file) : undefined), isUploaded: !it.file && typeof it.fileUrl === 'string' && it.fileUrl.length > 0 }));
+        });
+    }
+};
+
+exports.MultipleFilesMessageItemBody = MultipleFilesMessageItemBody;
+exports.ThreadMessageKind = ThreadMessageKind;
+exports.useFileInfoListWithUploaded = useFileInfoListWithUploaded;
+exports.useThreadMessageKindKeySelector = useThreadMessageKindKeySelector;
+//# sourceMappingURL=bundle-qRiLsSwC.js.map

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

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