@sendbird/uikit-react 3.17.11 → 3.18.0

package/chunks/{bundle-D4as5hKh.js → bundle-DzB_38co.js}

@@ -2,11 +2,11 @@ import React__default, { useState, useMemo } from 'react';
 import { PlaybackTime } from '../ui/PlaybackTime.js';
 import { ProgressBar } from '../ui/ProgressBar.js';
 import TextButton from '../ui/TextButton.js';
-import Icon, { IconTypes, IconColors } from '../ui/Icon.js';
-import { b as LabelColors, L as Label, a as LabelTypography } from './bundle-CE8XZeIa.js';
-import { u as useLocalization } from './bundle-CD6CGxYu.js';
-import { g as VOICE_RECORDER_DEFAULT_MIN, h as VOICE_RECORDER_CLICK_BUFFER_TIME } from './bundle-D67XuNKa.js';
-import { c as classnames } from './bundle-CQJQkdjB.js';
+import Icon, { IconColors, IconTypes } from '../ui/Icon.js';
+import { a as LabelColors, L as Label, c as LabelTypography } from './bundle-Cdplrrlw.js';
+import { u as useLocalization } from './bundle-Cdqsdoa8.js';
+import { s as VOICE_RECORDER_DEFAULT_MIN, q as VOICE_RECORDER_CLICK_BUFFER_TIME } from './bundle-JhKiWlXT.js';
+import { c as classnames } from './bundle-DX6fRIJl.js';
 
 /* eslint-disable no-redeclare */
 var VoiceMessageInputStatus = {
@@ -93,5 +93,5 @@ var VoiceMessageInput = function (_a) {
                 React__default.createElement(Icon, { width: "19px", height: "19px", type: IconTypes.SEND, fillColor: isSendButtonDisabled ? IconColors.ON_BACKGROUND_4 : IconColors.CONTENT }))))));
 };
 
-export { VoiceMessageInputStatus as V, VoiceMessageInput as a };
-//# sourceMappingURL=bundle-D4as5hKh.js.map
+export { VoiceMessageInput as V, VoiceMessageInputStatus as a };
+//# sourceMappingURL=bundle-DzB_38co.js.map

package/chunks/{bundle-BS4kt0WK.js.map → bundle-DzB_38co.js.map}

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

package/chunks/{bundle-C9eESsTb.js → bundle-EKFQIahk.js}

@@ -1,4 +1,4 @@
-import { c as __spreadArray } from './bundle-CUFNseKN.js';
+import { e as __spreadArray } from './bundle-Bpofr334.js';
 
 var USER_MENTION_PREFIX = '@';
 
@@ -236,5 +236,5 @@ function getWhiteSpacePreservedText(text) {
     return result;
 }
 
-export { TOKEN_TYPES as T, USER_MENTION_PREFIX as U, tokenizeMarkdown as a, getWhiteSpacePreservedText as b, getChannelPreviewMessage as g, tokenizeMessage as t };
-//# sourceMappingURL=bundle-C9eESsTb.js.map
+export { TOKEN_TYPES as T, USER_MENTION_PREFIX as U, getWhiteSpacePreservedText as a, tokenizeMessage as b, getChannelPreviewMessage as g, tokenizeMarkdown as t };
+//# sourceMappingURL=bundle-EKFQIahk.js.map

package/chunks/{bundle-C9eESsTb.js.map → bundle-EKFQIahk.js.map}

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

package/chunks/bundle-ExNQo0Ly.js

@@ -0,0 +1,160 @@
+import { e as __spreadArray } from './bundle-Bpofr334.js';
+import { useState, useRef, useCallback, useEffect, useMemo } from 'react';
+import { G as isImage } from './bundle-BZSLsKkw.js';
+import { u as uuidv4 } from './bundle-LLA95Pqf.js';
+import { b as validateFileTypes, v as validateFileCount, a as validateFileSizes } from './bundle-B5xkbY4c.js';
+
+var buildPendingFile = function (file) {
+    var fileIsImage = isImage(file.type);
+    return {
+        id: uuidv4(),
+        file: file,
+        previewUrl: fileIsImage ? URL.createObjectURL(file) : undefined,
+        isImage: fileIsImage,
+    };
+};
+/**
+ * Holds files staged for the message composer before send. Producers (file
+ * picker, drag-and-drop, clipboard paste) all call addFiles. The owning
+ * wrapper drains pendingFiles on submit and calls clear().
+ */
+var usePendingFiles = function (_a) {
+    var uikitUploadSizeLimit = _a.uikitUploadSizeLimit, uikitMultipleFilesMessageLimit = _a.uikitMultipleFilesMessageLimit, acceptableMimeTypes = _a.acceptableMimeTypes, openModal = _a.openModal, stringSet = _a.stringSet, logger = _a.logger;
+    var _b = useState([]), pendingFiles = _b[0], setPendingFiles = _b[1];
+    var pendingFilesRef = useRef(pendingFiles);
+    pendingFilesRef.current = pendingFiles;
+    var revokeUrl = useCallback(function (entry) {
+        if (entry.previewUrl)
+            URL.revokeObjectURL(entry.previewUrl);
+    }, []);
+    var addFiles = useCallback(function (files) {
+        if (files.length === 0)
+            return;
+        if (!validateFileTypes({
+            files: files,
+            acceptableMimeTypes: acceptableMimeTypes,
+            openModal: openModal,
+            stringSet: stringSet,
+            logger: logger,
+            logTag: 'usePendingFiles',
+        }))
+            return;
+        var totalCount = pendingFilesRef.current.length + files.length;
+        if (!validateFileCount({
+            totalCount: totalCount,
+            uikitMultipleFilesMessageLimit: uikitMultipleFilesMessageLimit,
+            openModal: openModal,
+            stringSet: stringSet,
+            logger: logger,
+            logTag: 'usePendingFiles',
+        }))
+            return;
+        if (!validateFileSizes({
+            files: files,
+            uikitUploadSizeLimit: uikitUploadSizeLimit,
+            openModal: openModal,
+            stringSet: stringSet,
+            logger: logger,
+            logTag: 'usePendingFiles',
+        }))
+            return;
+        setPendingFiles(function (current) { return __spreadArray(__spreadArray([], current, true), files.map(buildPendingFile), true); });
+    }, [uikitUploadSizeLimit, uikitMultipleFilesMessageLimit, acceptableMimeTypes, openModal, stringSet, logger]);
+    var removeFile = useCallback(function (id) {
+        setPendingFiles(function (current) {
+            var target = current.find(function (entry) { return entry.id === id; });
+            if (target)
+                revokeUrl(target);
+            return current.filter(function (entry) { return entry.id !== id; });
+        });
+    }, [revokeUrl]);
+    var clear = useCallback(function () {
+        pendingFilesRef.current.forEach(revokeUrl);
+        setPendingFiles([]);
+    }, [revokeUrl]);
+    useEffect(function () {
+        return function () {
+            pendingFilesRef.current.forEach(function (entry) {
+                if (entry.previewUrl)
+                    URL.revokeObjectURL(entry.previewUrl);
+            });
+        };
+    }, []);
+    var hasPendingFiles = useMemo(function () { return pendingFiles.length > 0; }, [pendingFiles]);
+    return {
+        pendingFiles: pendingFiles,
+        addFiles: addFiles,
+        removeFile: removeFile,
+        clear: clear,
+        hasPendingFiles: hasPendingFiles,
+    };
+};
+
+var dragHasFiles = function (event) {
+    var _a, _b;
+    // dataTransfer.types is the only reliable cross-browser signal during dragover;
+    // dataTransfer.files is empty until drop in most browsers.
+    return Array.from((_b = (_a = event.dataTransfer) === null || _a === void 0 ? void 0 : _a.types) !== null && _b !== void 0 ? _b : []).includes('Files');
+};
+/**
+ * Window-level drag-and-drop for file uploads. While enabled, the entire
+ * viewport accepts file drops — the caller does not need to render a visual
+ * affordance.
+ *
+ * When disabled, no listeners are attached, so the browser's default drop
+ * behavior (open the file) is preserved.
+ *
+ * When multiple instances are mounted concurrently (e.g. main channel composer
+ * + thread composer on desktop), each one passes a `shouldAccept` predicate so
+ * exactly one consumes any given drop based on its position in the DOM.
+ */
+var useDragAndDrop = function (_a) {
+    var onAddFiles = _a.onAddFiles, _b = _a.disabled, disabled = _b === void 0 ? false : _b, shouldAccept = _a.shouldAccept;
+    // Latch callbacks in refs so listener registration only churns on disabled
+    // flips. Otherwise inline shouldAccept / onAddFiles passed from a caller
+    // would change identity each render and tear the listeners down + up,
+    // risking missed drag events in between.
+    var onAddFilesRef = useRef(onAddFiles);
+    var shouldAcceptRef = useRef(shouldAccept);
+    useEffect(function () {
+        onAddFilesRef.current = onAddFiles;
+        shouldAcceptRef.current = shouldAccept;
+    });
+    useEffect(function () {
+        if (disabled)
+            return undefined;
+        var onDragOver = function (event) {
+            if (!dragHasFiles(event))
+                return;
+            var shouldAcceptFn = shouldAcceptRef.current;
+            if (shouldAcceptFn && !shouldAcceptFn(event))
+                return;
+            // Required to mark the document as a valid drop target and suppress
+            // the browser's default "open file" behavior on drop.
+            event.preventDefault();
+            if (event.dataTransfer)
+                event.dataTransfer.dropEffect = 'copy';
+        };
+        var onDrop = function (event) {
+            var _a, _b;
+            if (!dragHasFiles(event))
+                return;
+            var shouldAcceptFn = shouldAcceptRef.current;
+            if (shouldAcceptFn && !shouldAcceptFn(event))
+                return;
+            event.preventDefault();
+            var files = Array.from((_b = (_a = event.dataTransfer) === null || _a === void 0 ? void 0 : _a.files) !== null && _b !== void 0 ? _b : []);
+            if (files.length > 0)
+                onAddFilesRef.current(files);
+        };
+        window.addEventListener('dragover', onDragOver);
+        window.addEventListener('drop', onDrop);
+        return function () {
+            window.removeEventListener('dragover', onDragOver);
+            window.removeEventListener('drop', onDrop);
+        };
+    }, [disabled]);
+};
+
+export { usePendingFiles as a, useDragAndDrop as u };
+//# sourceMappingURL=bundle-ExNQo0Ly.js.map

package/chunks/{bundle-C9pDO7b_.js.map → bundle-ExNQo0Ly.js.map}

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

package/chunks/{bundle-BrZWYj5G.js → bundle-F_R9C4cW.js}

@@ -12,4 +12,4 @@ var pxToNumber = function (px) {
 };
 
 export { pxToNumber as p };
-//# sourceMappingURL=bundle-BrZWYj5G.js.map
+//# sourceMappingURL=bundle-F_R9C4cW.js.map

package/chunks/bundle-F_R9C4cW.js.map

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

package/chunks/{bundle-BdqzVlr4.js → bundle-FnWZX8on.js}

@@ -1,7 +1,7 @@
-import { S as SCROLL_BUFFER } from './bundle-D67XuNKa.js';
-import { a as isAboutSame } from './bundle-DNZm2aCn.js';
+import { h as SCROLL_BUFFER } from './bundle-JhKiWlXT.js';
+import { i as isAboutSame } from './bundle-ChLik1Zs.js';
 import { usePreservedCallback } from '@sendbird/uikit-tools';
-import { u as useThrottleCallback } from './bundle-C7rLZX4P.js';
+import { u as useThrottleCallback } from './bundle-Cd8fnvI_.js';
 
 var BUFFER_DELAY = 100;
 function useOnScrollPositionChangeDetector(params) {
@@ -27,4 +27,4 @@ function useOnScrollPositionChangeDetector(params) {
 }
 
 export { useOnScrollPositionChangeDetector as u };
-//# sourceMappingURL=bundle-BdqzVlr4.js.map
+//# sourceMappingURL=bundle-FnWZX8on.js.map

package/chunks/bundle-FnWZX8on.js.map

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

package/chunks/{bundle-u7ZSOSmF.js → bundle-Gpc6ZS8v.js}

@@ -1,19 +1,19 @@
-import { _ as __assign, a as __awaiter, b as __generator, c as __spreadArray } from './bundle-CUFNseKN.js';
+import { _ as __assign, a as __awaiter, c as __generator, e as __spreadArray } from './bundle-Bpofr334.js';
 import React__default, { useCallback, useContext, useMemo, useEffect, useRef } from 'react';
-import { s as scrollIntoLast, c as compareIds, u as useSendMultipleFilesMessage, g as getParentMessageFrom, a as getNicknamesMapFromMembers } from './bundle-C9pDO7b_.js';
-import { U as UserProfileProvider } from './bundle-CH1SOYd0.js';
-import { d as commonjsGlobal, s as shimExports, u as useStore, c as createStore } from './bundle-DOHzCh7a.js';
+import { s as scrollIntoLast, c as compareIds, u as useSendMultipleFilesMessage, g as getNicknamesMapFromMembers, a as getParentMessageFrom } from './bundle-XzHJwv9S.js';
+import { U as UserProfileProvider } from './bundle-B5LKcMN_.js';
+import { c as commonjsGlobal, s as shimExports, b as createStore, d as useStore } from './bundle-B56O1y8C.js';
 import { ChannelType } from '@sendbird/chat';
-import { p as pubSubTopics, b as PublishingModuleType, a as shouldPubSubPublishToThread, P as PUBSUB_TOPICS } from './bundle-B5yOEM4l.js';
+import { p as pubSubTopics, a as PublishingModuleType, b as shouldPubSubPublishToThread, P as PUBSUB_TOPICS } from './bundle-YDriVB8K.js';
 import { GroupChannelHandler } from '@sendbird/chat/groupChannel';
-import { u as uuidv4 } from './bundle-D1MmNbfE.js';
-import { c as compareIds$1 } from './bundle-DCbF_EZ6.js';
+import { u as uuidv4 } from './bundle-LLA95Pqf.js';
+import { c as compareIds$1 } from './bundle-DpOgiF9r.js';
 import { ThreadListStateTypes, ParentMessageStateTypes, ChannelStateTypes } from '../Thread/context/types.js';
-import { u as useSendbird } from './bundle-CeLEEyFJ.js';
-import { u as useDeepCompareEffect } from './bundle-LKiKEQMD.js';
+import { u as useSendbird } from './bundle-4clodtJA.js';
+import { u as useDeepCompareEffect } from './bundle-BsY2Dawk.js';
 import { SendingStatus, MessageMetaArray, MessageType } from '@sendbird/chat/message';
-import './bundle-CD6CGxYu.js';
-import { e as SCROLL_BOTTOM_DELAY_FOR_SEND, a as VOICE_MESSAGE_FILE_NAME, b as VOICE_MESSAGE_MIME_TYPE, i as META_ARRAY_VOICE_DURATION_KEY, j as META_ARRAY_MESSAGE_TYPE_KEY, k as META_ARRAY_MESSAGE_TYPE_VALUE__VOICE } from './bundle-D67XuNKa.js';
+import './bundle-Cdqsdoa8.js';
+import { g as SCROLL_BOTTOM_DELAY_FOR_SEND, f as META_ARRAY_VOICE_DURATION_KEY, e as META_ARRAY_MESSAGE_TYPE_VALUE__VOICE, d as META_ARRAY_MESSAGE_TYPE_KEY, k as VOICE_MESSAGE_MIME_TYPE, V as VOICE_MESSAGE_FILE_NAME } from './bundle-JhKiWlXT.js';
 
 var PREV_THREADS_FETCH_SIZE = 30;
 var NEXT_THREADS_FETCH_SIZE = 30;
@@ -319,11 +319,14 @@ function useUpdateMessageCallback(_a, _b) {
     // TODO: add type
     return useCallback(function (props) {
         var _a;
-        var messageId = props.messageId, message = props.message, mentionedUsers = props.mentionedUsers, mentionTemplate = props.mentionTemplate;
+        var messageId = props.messageId, message = props.message, mentionedUsers = props.mentionedUsers, mentionedUserIds = props.mentionedUserIds, mentionTemplate = props.mentionTemplate;
         var createParamsDefault = function () {
             var params = {};
             params.message = message;
-            if (isMentionEnabled && mentionedUsers && (mentionedUsers === null || mentionedUsers === void 0 ? void 0 : mentionedUsers.length) > 0) {
+            if (isMentionEnabled && mentionedUserIds) {
+                params.mentionedUserIds = mentionedUserIds;
+            }
+            else if (isMentionEnabled && mentionedUsers) {
                 params.mentionedUsers = mentionedUsers;
             }
             if (isMentionEnabled && mentionTemplate) {
@@ -5974,7 +5977,7 @@ lodash.exports;
 	      bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);
 
 	      if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {
-	        bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);
+	        bitmask &= -4;
 	      }
 	      var newData = [
 	        func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,
@@ -6077,7 +6080,7 @@ lodash.exports;
 	      }
 	      var length = partials ? partials.length : 0;
 	      if (!length) {
-	        bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);
+	        bitmask &= -97;
 	        partials = holders = undefined$1;
 	      }
 	      ary = ary === undefined$1 ? ary : nativeMax(toInteger(ary), 0);
@@ -6110,7 +6113,7 @@ lodash.exports;
 	        : nativeMax(newData[9] - length, 0);
 
 	      if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {
-	        bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);
+	        bitmask &= -25;
 	      }
 	      if (!bitmask || bitmask == WRAP_BIND_FLAG) {
 	        var result = createBind(func, bitmask, thisArg);
@@ -17967,15 +17970,37 @@ var useThread = function () {
             }
             return __assign(__assign({}, state), { isMuted: false });
         }); }, [store]),
-        onUserBanned: useCallback(function () { return store.setState(function (state) {
-            return __assign(__assign({}, state), { channelState: ChannelStateTypes.NIL, threadListState: ThreadListStateTypes.NIL, parentMessageState: ParentMessageStateTypes.NIL, currentChannel: null, parentMessage: null, allThreadMessages: [], hasMorePrev: false, hasMoreNext: false });
-        }); }, [store]),
+        onUserBanned: useCallback(function (channel, user) {
+            store.setState(function (state) {
+                var _a;
+                if (((_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url) !== (channel === null || channel === void 0 ? void 0 : channel.url)) {
+                    return state;
+                }
+                // Only reset state when the current user is banned
+                if (state.currentUserId === (user === null || user === void 0 ? void 0 : user.userId)) {
+                    return __assign(__assign({}, state), { channelState: ChannelStateTypes.NIL, threadListState: ThreadListStateTypes.NIL, parentMessageState: ParentMessageStateTypes.NIL, currentChannel: null, parentMessage: null, allThreadMessages: [], hasMorePrev: false, hasMoreNext: false });
+                }
+                // Another user banned: update channel info and nicknames map
+                return __assign(__assign({}, state), { currentChannel: channel, nicknamesMap: getNicknamesMapFromMembers(channel === null || channel === void 0 ? void 0 : channel.members) });
+            });
+        }, [store]),
         onUserUnbanned: useCallback(function () { return store.setState(function (state) {
             return __assign({}, state);
         }); }, [store]),
-        onUserLeft: useCallback(function () { return store.setState(function (state) {
-            return __assign(__assign({}, state), { channelState: ChannelStateTypes.NIL, threadListState: ThreadListStateTypes.NIL, parentMessageState: ParentMessageStateTypes.NIL, currentChannel: null, parentMessage: null, allThreadMessages: [], hasMorePrev: false, hasMoreNext: false });
-        }); }, [store]),
+        onUserLeft: useCallback(function (channel, user) {
+            store.setState(function (state) {
+                var _a;
+                if (((_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url) !== (channel === null || channel === void 0 ? void 0 : channel.url)) {
+                    return state;
+                }
+                // Only reset state when the current user has left
+                if (state.currentUserId === (user === null || user === void 0 ? void 0 : user.userId)) {
+                    return __assign(__assign({}, state), { channelState: ChannelStateTypes.NIL, threadListState: ThreadListStateTypes.NIL, parentMessageState: ParentMessageStateTypes.NIL, currentChannel: null, parentMessage: null, allThreadMessages: [], hasMorePrev: false, hasMoreNext: false });
+                }
+                // Another user left: update channel info and nicknames map
+                return __assign(__assign({}, state), { currentChannel: channel, nicknamesMap: getNicknamesMapFromMembers(channel === null || channel === void 0 ? void 0 : channel.members) });
+            });
+        }, [store]),
         onChannelFrozen: useCallback(function () { return store.setState(function (state) {
             return __assign(__assign({}, state), { isChannelFrozen: true });
         }); }, [store]),
@@ -18224,7 +18249,7 @@ function useHandleChannelEvents(_a, _b) {
                 },
                 onUserBanned: function (channel, user) {
                     logger.info('Thread | useHandleChannelEvents: onUserBanned', { channel: channel, user: user });
-                    onUserBanned();
+                    onUserBanned(channel, user);
                 },
                 onUserUnbanned: function (channel, user) {
                     logger.info('Thread | useHandleChannelEvents: onUserUnbanned', { channel: channel, user: user });
@@ -18232,7 +18257,7 @@ function useHandleChannelEvents(_a, _b) {
                 },
                 onUserLeft: function (channel, user) {
                     logger.info('Thread | useHandleChannelEvents: onUserLeft', { channel: channel, user: user });
-                    onUserLeft();
+                    onUserLeft(channel, user);
                 },
                 // channel status change
                 onChannelFrozen: function (channel) {
@@ -18365,7 +18390,7 @@ var ThreadManager = function (props) {
         sdkInit: sdkInit,
         currentChannel: currentChannel,
         parentMessage: parentMessage,
-    }, { logger: logger, pubSub: pubSub });
+    }, { pubSub: pubSub });
     useEffect(function () {
         if (stores.sdkStore.initialized && config.isOnline) {
             initializeThreadFetcher();
@@ -18421,4 +18446,4 @@ var useThreadStore = function () {
 };
 
 export { InternalThreadProvider as I, ThreadContext as T, ThreadManager as a, ThreadProvider as b, useThreadContext as c, useThread as u };
-//# sourceMappingURL=bundle-u7ZSOSmF.js.map
+//# sourceMappingURL=bundle-Gpc6ZS8v.js.map