@sendbird/uikit-react 3.15.13 → 3.15.14-rc

package/chunks/bundle-DCVn-5-M.js

@@ -0,0 +1,209 @@
+import { a as __spreadArray, b as __awaiter, c as __generator, _ as __assign } from './bundle-Cj5_JUGB.js';
+import { u as useStore, c as createStore, s as shimExports } from './bundle-m1et25Jg.js';
+import React__default, { useEffect, createContext, useState, useCallback, useRef, useContext, useMemo } from 'react';
+import { GroupChannelHandler } from '@sendbird/chat/groupChannel';
+import { u as uuidv4 } from './bundle-D9R7Jiqe.js';
+import { c as compareIds } from './bundle-IJCJg91y.js';
+import { c as classnames } from './bundle-BY9oUVFG.js';
+import { U as UserProfileProvider } from './bundle-Bkbt9_K2.js';
+import { u as useSendbird } from './bundle-CDp-g5XU.js';
+
+function useSetChannel(_a) {
+    var _this = this;
+    var channelUrl = _a.channelUrl, sdk = _a.sdk, logger = _a.logger, initialized = _a.initialized, _b = _a.dependencies, dependencies = _b === void 0 ? [] : _b;
+    var _c = useChannelSettings().actions, setChannel = _c.setChannel, setInvalid = _c.setInvalid, setLoading = _c.setLoading;
+    useEffect(function () {
+        var controller = new AbortController();
+        var signal = controller.signal;
+        var fetchChannel = function () { return __awaiter(_this, void 0, void 0, function () {
+            var groupChannel, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, 3, 4]);
+                        if (!channelUrl) {
+                            logger.warning('ChannelSettings: channel url is required');
+                            setLoading(false);
+                            return [2 /*return*/];
+                        }
+                        if (!initialized || !sdk) {
+                            logger.warning('ChannelSettings: SDK is not initialized');
+                            setLoading(false);
+                            return [2 /*return*/];
+                        }
+                        if (!sdk.groupChannel) {
+                            logger.warning('ChannelSettings: GroupChannelModule is not specified in the SDK');
+                            setLoading(false);
+                            return [2 /*return*/];
+                        }
+                        setLoading(true);
+                        return [4 /*yield*/, sdk.groupChannel.getChannel(channelUrl)];
+                    case 1:
+                        groupChannel = _a.sent();
+                        if (!signal.aborted) {
+                            logger.info('ChannelSettings | useSetChannel: fetched group channel', groupChannel);
+                            setChannel(groupChannel);
+                        }
+                        return [3 /*break*/, 4];
+                    case 2:
+                        error_1 = _a.sent();
+                        if (!signal.aborted) {
+                            logger.error('ChannelSettings | useSetChannel: failed fetching channel', error_1);
+                            setInvalid(true);
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        if (!signal.aborted) {
+                            setLoading(false);
+                        }
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); };
+        fetchChannel();
+        return function () { return controller.abort(); }; // Cleanup with AbortController
+    }, __spreadArray([channelUrl, initialized, sdk], dependencies, true));
+}
+
+var useChannelHandler = function (_a) {
+    var sdk = _a.sdk, channelUrl = _a.channelUrl, logger = _a.logger, forceUpdateUI = _a.forceUpdateUI, _b = _a.dependencies, dependencies = _b === void 0 ? [] : _b;
+    useEffect(function () {
+        if (!sdk || !sdk.groupChannel) {
+            logger.warning('ChannelSettings: SDK or GroupChannelModule is not available');
+            return;
+        }
+        var newChannelHandlerId = uuidv4();
+        var channelHandler = new GroupChannelHandler({
+            onUserLeft: function (channel, user) {
+                if (compareIds(channel === null || channel === void 0 ? void 0 : channel.url, channelUrl)) {
+                    logger.info('ChannelSettings: onUserLeft', { channel: channel, user: user });
+                    forceUpdateUI();
+                }
+            },
+            onUserBanned: function (channel, user) {
+                if (compareIds(channel === null || channel === void 0 ? void 0 : channel.url, channelUrl) && channel.isGroupChannel()) {
+                    logger.info('ChannelSettings: onUserBanned', { channel: channel, user: user });
+                    forceUpdateUI();
+                }
+            },
+        });
+        sdk.groupChannel.addGroupChannelHandler(newChannelHandlerId, channelHandler);
+        return function () {
+            if (sdk.groupChannel && newChannelHandlerId) {
+                logger.info('ChannelSettings: Removing message receiver handler', newChannelHandlerId);
+                sdk.groupChannel.removeGroupChannelHandler(newChannelHandlerId);
+            }
+        };
+    }, __spreadArray([sdk, channelUrl, logger], dependencies, true));
+    return null;
+};
+
+var ChannelSettingsContext = createContext(null);
+var initialState = {
+    // Props
+    channelUrl: '',
+    onCloseClick: undefined,
+    onLeaveChannel: undefined,
+    onChannelModified: undefined,
+    onBeforeUpdateChannel: undefined,
+    renderUserListItem: undefined,
+    queries: {},
+    overrideInviteUser: undefined,
+    // Managed states
+    channel: null,
+    loading: false,
+    invalidChannel: false,
+    forceUpdateUI: function () { },
+    setChannelUpdateId: function () { },
+};
+/**
+ * @returns {ReturnType<typeof createStore<ChannelSettingsState>>}
+ */
+var useChannelSettingsStore = function () {
+    return useStore(ChannelSettingsContext, function (state) { return state; }, initialState);
+};
+var ChannelSettingsManager = function (_a) {
+    var _b;
+    var channelUrl = _a.channelUrl, onCloseClick = _a.onCloseClick, onLeaveChannel = _a.onLeaveChannel, onChannelModified = _a.onChannelModified, overrideInviteUser = _a.overrideInviteUser, onBeforeUpdateChannel = _a.onBeforeUpdateChannel, queries = _a.queries, renderUserListItem = _a.renderUserListItem;
+    var state = useSendbird().state;
+    var config = state.config, stores = state.stores;
+    var updateState = useChannelSettingsStore().updateState;
+    var logger = config.logger;
+    var _c = (_b = stores === null || stores === void 0 ? void 0 : stores.sdkStore) !== null && _b !== void 0 ? _b : {}, sdk = _c.sdk, initialized = _c.initialized;
+    var _d = useState(function () { return uuidv4(); }), channelUpdateId = _d[0], setChannelUpdateId = _d[1];
+    var forceUpdateUI = useCallback(function () { return setChannelUpdateId(uuidv4()); }, []);
+    var dependencies = [channelUpdateId];
+    useSetChannel({
+        channelUrl: channelUrl,
+        sdk: sdk,
+        logger: logger,
+        initialized: initialized,
+        dependencies: dependencies,
+    });
+    useChannelHandler({
+        sdk: sdk,
+        channelUrl: channelUrl,
+        logger: logger,
+        forceUpdateUI: forceUpdateUI,
+        dependencies: dependencies,
+    });
+    useEffect(function () {
+        updateState({
+            channelUrl: channelUrl,
+            onCloseClick: onCloseClick,
+            onLeaveChannel: onLeaveChannel,
+            onChannelModified: onChannelModified,
+            onBeforeUpdateChannel: onBeforeUpdateChannel,
+            renderUserListItem: renderUserListItem,
+            queries: queries,
+            overrideInviteUser: overrideInviteUser,
+            forceUpdateUI: forceUpdateUI,
+            setChannelUpdateId: setChannelUpdateId,
+        });
+    }, [
+        channelUrl,
+        onCloseClick,
+        onLeaveChannel,
+        onChannelModified,
+        onBeforeUpdateChannel,
+        renderUserListItem,
+        queries,
+        overrideInviteUser,
+        forceUpdateUI,
+    ]);
+    return null;
+};
+var createChannelSettingsStore = function () { return createStore(initialState); };
+var InternalChannelSettingsProvider = function (_a) {
+    var children = _a.children;
+    var storeRef = useRef(createChannelSettingsStore());
+    return (React__default.createElement(ChannelSettingsContext.Provider, { value: storeRef.current }, children));
+};
+var ChannelSettingsProvider = function (props) {
+    var children = props.children, className = props.className;
+    return (React__default.createElement(InternalChannelSettingsProvider, null,
+        React__default.createElement(ChannelSettingsManager, __assign({}, props)),
+        React__default.createElement(UserProfileProvider, __assign({}, props),
+            React__default.createElement("div", { className: classnames('sendbird-channel-settings', className) }, children))));
+};
+var useChannelSettingsContext = function () {
+    var _a = useChannelSettings(), state = _a.state, actions = _a.actions;
+    return __assign(__assign({}, state), actions);
+};
+
+var useChannelSettings = function () {
+    var store = useContext(ChannelSettingsContext);
+    if (!store)
+        throw new Error('useChannelSettings must be used within a ChannelSettingsProvider');
+    var state = shimExports.useSyncExternalStore(store.subscribe, store.getState);
+    var actions = useMemo(function () { return ({
+        setChannel: function (channel) { return store.setState(function (state) { return (__assign(__assign({}, state), { channel: channel })); }); },
+        setLoading: function (loading) { return store.setState(function (state) { return (__assign(__assign({}, state), { loading: loading })); }); },
+        setInvalid: function (invalid) { return store.setState(function (state) { return (__assign(__assign({}, state), { invalidChannel: invalid })); }); },
+    }); }, [store]);
+    return { state: state, actions: actions };
+};
+
+export { ChannelSettingsProvider as C, useChannelSettings as a, useChannelSettingsContext as u };
+//# sourceMappingURL=bundle-DCVn-5-M.js.map

package/chunks/bundle-DCVn-5-M.js.map

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

package/chunks/bundle-DFLinAbj.js

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

package/chunks/bundle-DFLinAbj.js.map

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

package/chunks/{bundle-BI2YMBw_.js → bundle-DG6u-bEo.js}

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

package/chunks/bundle-DG6u-bEo.js.map

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

package/chunks/{bundle-C1U8wE49.js → bundle-DGW9ZhNd.js}

@@ -1,4 +1,4 @@
-import { U as UIKIT_COMPATIBLE_FORM_VERSION } from './bundle-Dpdq7qeD.js';
+import { U as UIKIT_COMPATIBLE_FORM_VERSION } from './bundle-C-JPnBnR.js';
 
 function getComponentKeyFromMessage(message) {
     if ('sendingStatus' in message) {
@@ -52,4 +52,4 @@ var isDisabledBecauseMessageForm = function (allMessages, enableFormTypeMessage)
 };
 
 export { isDisabledBecauseMuted as a, isContextMenuClosed as b, isDisabledBecauseSuggestedReplies as c, isDisabledBecauseMessageForm as d, getMessageTopOffset as e, isFormVersionCompatible as f, getComponentKeyFromMessage as g, isDisabledBecauseFrozen as i };
-//# sourceMappingURL=bundle-C1U8wE49.js.map
+//# sourceMappingURL=bundle-DGW9ZhNd.js.map

package/chunks/bundle-DGW9ZhNd.js.map

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

package/chunks/{bundle-BiPxcZtH.js → bundle-DMhVPx55.js}

@@ -15,4 +15,4 @@ function useKeyDown(ref, keyDownCallbackMap) {
 }
 
 export { useKeyDown as u };
-//# sourceMappingURL=bundle-BiPxcZtH.js.map
+//# sourceMappingURL=bundle-DMhVPx55.js.map

package/chunks/bundle-DMhVPx55.js.map

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

package/chunks/{bundle-2kzSicIw.js → bundle-DTsnEKas.js}

@@ -1,5 +1,5 @@
-import { a as __awaiter, b as __generator } from './bundle-C7jYHvwG.js';
-import { p as pxToNumber } from './bundle-BR3O1lZq.js';
+import { b as __awaiter, c as __generator } from './bundle-Cj5_JUGB.js';
+import { p as pxToNumber } from './bundle-RBoKRbHz.js';
 
 var compressImage = function (_a) {
     var imageFile = _a.imageFile, compressionRate = _a.compressionRate, resizingWidth = _a.resizingWidth, resizingHeight = _a.resizingHeight, outputFormat = _a.outputFormat;
@@ -118,4 +118,4 @@ var compressImages = function (_a) { return __awaiter(void 0, [_a], void 0, func
 }); };
 
 export { compressImages as c };
-//# sourceMappingURL=bundle-2kzSicIw.js.map
+//# sourceMappingURL=bundle-DTsnEKas.js.map

package/chunks/{bundle-2kzSicIw.js.map → bundle-DTsnEKas.js.map}

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