@sendbird/uikit-react 3.16.4 → 3.16.5

package/chunks/{bundle-CsFWohR-.js → bundle-BmmYVojl.js}

@@ -1,6 +1,6 @@
-import { _ as __assign } from './bundle-j5GfJ6DZ.js';
+import { _ as __assign } from './bundle-BhO_47tq.js';
 import { useState, useRef, useCallback } from 'react';
-import { u as useMediaQueryContext } from './bundle-DvCKSiBl.js';
+import { u as useMediaQueryContext } from './bundle-Cnd8WtuT.js';
 
 var DEFAULT_DURATION = 300;
 function preventDefault(e) {
@@ -74,4 +74,4 @@ function useLongPress(_a, _b) {
 }
 
 export { useLongPress as u };
-//# sourceMappingURL=bundle-CsFWohR-.js.map
+//# sourceMappingURL=bundle-BmmYVojl.js.map

package/chunks/bundle-BmmYVojl.js.map

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

package/chunks/{bundle-XVRccHb6.js → bundle-Bpv9h3RC.js}

@@ -1,4 +1,4 @@
-import { d as VOICE_RECORDER_AUDIO_SAMPLE_RATE } from './bundle-C6g3HNED.js';
+import { d as VOICE_RECORDER_AUDIO_SAMPLE_RATE } from './bundle-DRW_U8j_.js';
 import { WavHeader as ut, Mp3Encoder as ht } from '../lame.all.js';
 
 // Thanks to https://codesandbox.io/s/media-recorder-api-downsampling-16k-mp3-encode-using-lame-js-forked-n1pblw
@@ -126,4 +126,4 @@ function bufferToWav(abuffer, len) {
 }
 
 export { downsampleToWav, encodeMp3 };
-//# sourceMappingURL=bundle-XVRccHb6.js.map
+//# sourceMappingURL=bundle-Bpv9h3RC.js.map

package/chunks/{bundle-XVRccHb6.js.map → bundle-Bpv9h3RC.js.map}

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

package/chunks/{bundle-CVHnjFdr.js → bundle-BswaeYtG.js}

@@ -1,27 +1,27 @@
-import { a as __spreadArray } from './bundle-j5GfJ6DZ.js';
+import { a as __spreadArray } from './bundle-BhO_47tq.js';
 import React__default, { useContext, useState, useEffect, useRef, useCallback } from 'react';
 import Button, { ButtonTypes, ButtonSizes } from '../ui/Button.js';
-import { C as ContextMenu, b as MenuItems, O as OperatorMenuItem, h as MuteMenuItem, c as MenuItem } from './bundle-BB95aNhx.js';
+import { C as ContextMenu, b as MenuItems, O as OperatorMenuItem, h as MuteMenuItem, c as MenuItem } from './bundle-tuPIvxSD.js';
 import Icon, { IconTypes, IconColors } from '../ui/Icon.js';
 import IconButton from '../ui/IconButton.js';
-import { L as Label, a as LabelTypography, b as LabelColors } from './bundle-ZBp236Ey.js';
+import { L as Label, a as LabelTypography, b as LabelColors } from './bundle-n5q9Ogw_.js';
 import { Participant } from '@sendbird/chat';
-import { L as LocalizationContext } from './bundle-BSUtC3cw.js';
-import { u as useUserProfileContext } from './bundle-S7XE7Lfi.js';
+import { L as LocalizationContext } from './bundle-BAWmpP4y.js';
+import { u as useUserProfileContext } from './bundle-duRL9-6e.js';
 import '../ui/AccordionGroup.js';
-import { A as Avatar } from './bundle-2OseAMr7.js';
+import { A as Avatar } from './bundle-ETV1WSDx.js';
 import 'react-dom';
-import './bundle-DvCKSiBl.js';
-import './bundle-BC1GKYVu.js';
+import './bundle-Cnd8WtuT.js';
+import './bundle-CyGbnOGu.js';
 import '@sendbird/chat/groupChannel';
 import '@sendbird/chat/openChannel';
 import MutedAvatarOverlay from '../ui/MutedAvatarOverlay.js';
 import UserProfile from '../ui/UserProfile.js';
 import { useOpenChannelSettingsContext } from '../OpenChannelSettings/context.js';
-import { M as Modal } from './bundle-B4W1Qw_4.js';
+import { M as Modal } from './bundle-BMOCpLY3.js';
 import { UserListItem as UserListItem$1 } from '../ui/UserListItem.js';
-import { n as noop } from './bundle-idC_wVZi.js';
-import { u as useSendbird } from './bundle-DloqDvm2.js';
+import { n as noop } from './bundle-EjjTUVbY.js';
+import { u as useSendbird } from './bundle-CD7j0-97.js';
 
 function ParticipantsModal(_a) {
     var _b, _c, _d;
@@ -209,4 +209,4 @@ function ParticipantList(_a) {
 }
 
 export { ParticipantList as P, UserListItem as U };
-//# sourceMappingURL=bundle-CVHnjFdr.js.map
+//# sourceMappingURL=bundle-BswaeYtG.js.map

package/chunks/bundle-BswaeYtG.js.map

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

package/chunks/{bundle-Bj2tVPd1.js → bundle-BxPAVosc.js}

@@ -46,4 +46,4 @@ function useElementObserver(selector, targetElement) {
 }
 
 export { useElementObserver as u };
-//# sourceMappingURL=bundle-Bj2tVPd1.js.map
+//# sourceMappingURL=bundle-BxPAVosc.js.map

package/chunks/bundle-BxPAVosc.js.map

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

package/chunks/{bundle-DwbhjuJz.js → bundle-C0hoq9It.js}

@@ -11,4 +11,4 @@ function compareIds(a, b) {
 }
 
 export { compareIds as c };
-//# sourceMappingURL=bundle-DwbhjuJz.js.map
+//# sourceMappingURL=bundle-C0hoq9It.js.map

package/chunks/bundle-C0hoq9It.js.map

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

package/chunks/{bundle-EMEHizdG.js → bundle-C3Ncm83d.js}

@@ -1,10 +1,10 @@
-import { a as __spreadArray, _ as __assign } from './bundle-j5GfJ6DZ.js';
+import { a as __spreadArray, _ as __assign } from './bundle-BhO_47tq.js';
 import { GroupChannelListOrder } from '@sendbird/chat/groupChannel';
 import { OutgoingMessageStates, getOutgoingMessageState } from '../utils/message/getOutgoingMessageState.js';
-import { a as isSafari } from './bundle-Bzoj1u3h.js';
-import { K } from './bundle-Cj_4CfJM.js';
-import { r as requiredArgs, t as toDate } from './bundle-RVsnVYbw.js';
-import { M as MESSAGE_TEMPLATE_KEY } from './bundle-C6g3HNED.js';
+import { a as isSafari } from './bundle-w4kEKXn8.js';
+import { K } from './bundle-DBZGSeCJ.js';
+import { r as requiredArgs, t as toDate } from './bundle-H_u6X-f3.js';
+import { M as MESSAGE_TEMPLATE_KEY } from './bundle-DRW_U8j_.js';
 
 /**
  * @name startOfSecond
@@ -829,4 +829,4 @@ var isDefaultChannelName = function (channel) {
 };
 
 export { filterChannelListParams as $, isGif as A, copyToClipboard as B, convertWordToStringObj as C, isTemplateMessage as D, isAudio as E, isVoiceMessageMimeType as F, isSentStatus as G, arrayEqual as H, getMimeTypesUIKitAccepts as I, isImageMessage as J, isImageFileInfo as K, isAudioMessage as L, getHTMLTextDirection as M, isOGMessage as N, uiContainerType as O, isFormMessage as P, isAdminMessage as Q, isValidTemplateMessageType as R, StringObjType as S, isThreadMessage as T, UIKitMessageTypes as U, getEmojiListAll as V, getEmojiUrl as W, isReactedBy as X, getEmojiTooltipString as Y, getEmojiMapAll as Z, isTextMessage as _, isDefaultChannelName as a, getChannelsWithUpsertedChannel as a0, isChannelJustCreated as a1, filterMessageListParams as a2, isReadMessage as b, isFileMessage as c, isMultipleFilesMessage as d, isEditedMessage as e, getSenderName as f, getSuggestedReplies as g, isSupportedFileView as h, isVoiceMessage as i, isVideo as j, isImage as k, isSendableMessage as l, isUserMessage as m, getUIKitMessageType as n, getUIKitMessageTypes as o, getUIKitFileType as p, isThumbnailMessage as q, isSentMessage as r, isVideoMessage as s, truncateString as t, isGifMessage as u, getEmojiListByCategoryIds as v, isPendingMessage as w, isFailedMessage as x, getClassName as y, getUIKitFileTypes as z };
-//# sourceMappingURL=bundle-EMEHizdG.js.map
+//# sourceMappingURL=bundle-C3Ncm83d.js.map

package/chunks/{bundle-EMEHizdG.js.map → bundle-C3Ncm83d.js.map}

@@ -1 +1 @@
-{"version":3,"file":"bundle-EMEHizdG.js","sources":["../../node_modules/date-fns/esm/startOfSecond/index.js","../../node_modules/date-fns/esm/isSameSecond/index.js"],"sourcesContent":["import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name startOfSecond\n * @category Second Helpers\n * @summary Return the start of a second for the given date.\n *\n * @description\n * Return the start of a second for the given date.\n * The result will be in the local timezone.\n *\n * @param {Date|Number} date - the original date\n * @returns {Date} the start of a second\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // The start of a second for 1 December 2014 22:15:45.400:\n * const result = startOfSecond(new Date(2014, 11, 1, 22, 15, 45, 400))\n * //=> Mon Dec 01 2014 22:15:45.000\n */\nexport default function startOfSecond(dirtyDate) {\n  requiredArgs(1, arguments);\n  var date = toDate(dirtyDate);\n  date.setMilliseconds(0);\n  return date;\n}","import startOfSecond from \"../startOfSecond/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name isSameSecond\n * @category Second Helpers\n * @summary Are the given dates in the same second (and hour and day)?\n *\n * @description\n * Are the given dates in the same second (and hour and day)?\n *\n * @param {Date|Number} dateLeft - the first date to check\n * @param {Date|Number} dateRight - the second date to check\n * @returns {Boolean} the dates are in the same second (and hour and day)\n * @throws {TypeError} 2 arguments required\n *\n * @example\n * // Are 4 September 2014 06:30:15.000 and 4 September 2014 06:30.15.500 in the same second?\n * const result = isSameSecond(\n *   new Date(2014, 8, 4, 6, 30, 15),\n *   new Date(2014, 8, 4, 6, 30, 15, 500)\n * )\n * //=> true\n *\n * @example\n * // Are 4 September 2014 06:00:15.000 and 4 September 2014 06:01.15.000 in the same second?\n * const result = isSameSecond(\n *   new Date(2014, 8, 4, 6, 0, 15),\n *   new Date(2014, 8, 4, 6, 1, 15)\n * )\n * //=> false\n *\n * @example\n * // Are 4 September 2014 06:00:15.000 and 5 September 2014 06:00.15.000 in the same second?\n * const result = isSameSecond(\n *   new Date(2014, 8, 4, 6, 0, 15),\n *   new Date(2014, 8, 5, 6, 0, 15)\n * )\n * //=> false\n */\nexport default function isSameSecond(dirtyDateLeft, dirtyDateRight) {\n  requiredArgs(2, arguments);\n  var dateLeftStartOfSecond = startOfSecond(dirtyDateLeft);\n  var dateRightStartOfSecond = startOfSecond(dirtyDateRight);\n  return dateLeftStartOfSecond.getTime() === dateRightStartOfSecond.getTime();\n}"],"names":[],"mappings":";;;;;;;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAAS,aAAa,CAAC,SAAS,EAAE;AACjD,EAAE,YAAY,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;AAC7B,EAAE,IAAI,IAAI,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;AAC/B,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;AAC1B,EAAE,OAAO,IAAI,CAAC;AACd;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAAS,YAAY,CAAC,aAAa,EAAE,cAAc,EAAE;AACpE,EAAE,YAAY,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;AAC7B,EAAE,IAAI,qBAAqB,GAAG,aAAa,CAAC,aAAa,CAAC,CAAC;AAC3D,EAAE,IAAI,sBAAsB,GAAG,aAAa,CAAC,cAAc,CAAC,CAAC;AAC7D,EAAE,OAAO,qBAAqB,CAAC,OAAO,EAAE,KAAK,sBAAsB,CAAC,OAAO,EAAE,CAAC;AAC9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","x_google_ignoreList":[0,1]}
+{"version":3,"file":"bundle-C3Ncm83d.js","sources":["../../node_modules/date-fns/esm/startOfSecond/index.js","../../node_modules/date-fns/esm/isSameSecond/index.js"],"sourcesContent":["import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name startOfSecond\n * @category Second Helpers\n * @summary Return the start of a second for the given date.\n *\n * @description\n * Return the start of a second for the given date.\n * The result will be in the local timezone.\n *\n * @param {Date|Number} date - the original date\n * @returns {Date} the start of a second\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // The start of a second for 1 December 2014 22:15:45.400:\n * const result = startOfSecond(new Date(2014, 11, 1, 22, 15, 45, 400))\n * //=> Mon Dec 01 2014 22:15:45.000\n */\nexport default function startOfSecond(dirtyDate) {\n  requiredArgs(1, arguments);\n  var date = toDate(dirtyDate);\n  date.setMilliseconds(0);\n  return date;\n}","import startOfSecond from \"../startOfSecond/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name isSameSecond\n * @category Second Helpers\n * @summary Are the given dates in the same second (and hour and day)?\n *\n * @description\n * Are the given dates in the same second (and hour and day)?\n *\n * @param {Date|Number} dateLeft - the first date to check\n * @param {Date|Number} dateRight - the second date to check\n * @returns {Boolean} the dates are in the same second (and hour and day)\n * @throws {TypeError} 2 arguments required\n *\n * @example\n * // Are 4 September 2014 06:30:15.000 and 4 September 2014 06:30.15.500 in the same second?\n * const result = isSameSecond(\n *   new Date(2014, 8, 4, 6, 30, 15),\n *   new Date(2014, 8, 4, 6, 30, 15, 500)\n * )\n * //=> true\n *\n * @example\n * // Are 4 September 2014 06:00:15.000 and 4 September 2014 06:01.15.000 in the same second?\n * const result = isSameSecond(\n *   new Date(2014, 8, 4, 6, 0, 15),\n *   new Date(2014, 8, 4, 6, 1, 15)\n * )\n * //=> false\n *\n * @example\n * // Are 4 September 2014 06:00:15.000 and 5 September 2014 06:00.15.000 in the same second?\n * const result = isSameSecond(\n *   new Date(2014, 8, 4, 6, 0, 15),\n *   new Date(2014, 8, 5, 6, 0, 15)\n * )\n * //=> false\n */\nexport default function isSameSecond(dirtyDateLeft, dirtyDateRight) {\n  requiredArgs(2, arguments);\n  var dateLeftStartOfSecond = startOfSecond(dirtyDateLeft);\n  var dateRightStartOfSecond = startOfSecond(dirtyDateRight);\n  return dateLeftStartOfSecond.getTime() === dateRightStartOfSecond.getTime();\n}"],"names":[],"mappings":";;;;;;;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAAS,aAAa,CAAC,SAAS,EAAE;AACjD,EAAE,YAAY,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;AAC7B,EAAE,IAAI,IAAI,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;AAC/B,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;AAC1B,EAAE,OAAO,IAAI,CAAC;AACd;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAAS,YAAY,CAAC,aAAa,EAAE,cAAc,EAAE;AACpE,EAAE,YAAY,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;AAC7B,EAAE,IAAI,qBAAqB,GAAG,aAAa,CAAC,aAAa,CAAC,CAAC;AAC3D,EAAE,IAAI,sBAAsB,GAAG,aAAa,CAAC,cAAc,CAAC,CAAC;AAC7D,EAAE,OAAO,qBAAqB,CAAC,OAAO,EAAE,KAAK,sBAAsB,CAAC,OAAO,EAAE,CAAC;AAC9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","x_google_ignoreList":[0,1]}

package/chunks/{bundle-CNmV5PTy.js → bundle-C5K0S7d0.js}

@@ -1,19 +1,19 @@
-import { _ as __assign, b as __awaiter, c as __generator, a as __spreadArray } from './bundle-j5GfJ6DZ.js';
+import { _ as __assign, b as __awaiter, c as __generator, a as __spreadArray } from './bundle-BhO_47tq.js';
 import React__default, { useCallback, useContext, useMemo, useEffect, useRef } from 'react';
-import { s as scrollIntoLast, u as useSendMultipleFilesMessage, c as compareIds, g as getParentMessageFrom, a as getNicknamesMapFromMembers } from './bundle-CBj0OtHa.js';
-import { U as UserProfileProvider } from './bundle-S7XE7Lfi.js';
-import { s as shimExports, u as useStore, c as createStore } from './bundle-BC1GKYVu.js';
+import { s as scrollIntoLast, c as compareIds, u as useSendMultipleFilesMessage, g as getParentMessageFrom, a as getNicknamesMapFromMembers } from './bundle-BiSGw4Sz.js';
+import { U as UserProfileProvider } from './bundle-duRL9-6e.js';
+import { s as shimExports, u as useStore, c as createStore } from './bundle-CyGbnOGu.js';
 import { ChannelType } from '@sendbird/chat';
-import { p as pubSubTopics, b as PublishingModuleType, a as shouldPubSubPublishToThread, P as PUBSUB_TOPICS } from './bundle-u2dy86rx.js';
+import { p as pubSubTopics, b as PublishingModuleType, a as shouldPubSubPublishToThread, P as PUBSUB_TOPICS } from './bundle-xej6L5ic.js';
 import { GroupChannelHandler } from '@sendbird/chat/groupChannel';
-import { u as uuidv4 } from './bundle-B7LMd75S.js';
-import { c as compareIds$1 } from './bundle-DwbhjuJz.js';
-import { ThreadListStateTypes, ChannelStateTypes, ParentMessageStateTypes } from '../Thread/context/types.js';
-import { u as useSendbird } from './bundle-DloqDvm2.js';
-import { u as useDeepCompareEffect } from './bundle-CxpAk_cb.js';
+import { u as uuidv4 } from './bundle-CVeRlzCV.js';
+import { c as compareIds$1 } from './bundle-C0hoq9It.js';
+import { ThreadListStateTypes, ParentMessageStateTypes, ChannelStateTypes } from '../Thread/context/types.js';
+import { u as useSendbird } from './bundle-CD7j0-97.js';
+import { u as useDeepCompareEffect } from './bundle-ziHom22G.js';
 import { SendingStatus, MessageMetaArray, MessageType } from '@sendbird/chat/message';
-import './bundle-BSUtC3cw.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-C6g3HNED.js';
+import './bundle-BAWmpP4y.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-DRW_U8j_.js';
 
 var PREV_THREADS_FETCH_SIZE = 30;
 var NEXT_THREADS_FETCH_SIZE = 30;
@@ -79,7 +79,13 @@ function useSendUserMessageCallback(_a, _b) {
                 });
             });
         }
-    }, [isMentionEnabled, currentChannel]);
+    }, [
+        isMentionEnabled,
+        currentChannel,
+        onBeforeSendUserMessage,
+        sendMessageStart,
+        sendMessageFailure,
+    ]);
     return sendMessage;
 }
 
@@ -131,7 +137,12 @@ function useSendFileMessageCallback(_a, _b) {
                 });
             }
         });
-    }, [currentChannel]);
+    }, [
+        currentChannel,
+        onBeforeSendFileMessage,
+        sendMessageStart,
+        sendMessageFailure,
+    ]);
 }
 
 var useSendVoiceMessageCallback = function (_a, _b) {
@@ -183,6 +194,8 @@ var useSendVoiceMessageCallback = function (_a, _b) {
     }, [
         currentChannel,
         onBeforeSendVoiceMessage,
+        sendMessageStart,
+        sendMessageFailure,
     ]);
     return sendMessage;
 };
@@ -292,7 +305,12 @@ function useResendMessageCallback(_a, _b) {
             failedMessage.sendingStatus = SendingStatus.FAILED;
             sendMessageFailure(failedMessage);
         }
-    }, [currentChannel]);
+    }, [
+        currentChannel,
+        resendMessageStart,
+        sendMessageSuccess,
+        sendMessageFailure,
+    ]);
 }
 
 function useUpdateMessageCallback(_a, _b) {
@@ -332,7 +350,11 @@ function useUpdateMessageCallback(_a, _b) {
                 publishingModules: [PublishingModuleType.THREAD],
             });
         });
-    }, [currentChannel, isMentionEnabled]);
+    }, [
+        currentChannel,
+        isMentionEnabled,
+        onMessageUpdated,
+    ]);
 }
 
 function useDeleteMessageCallback(_a, _b) {
@@ -364,7 +386,11 @@ function useDeleteMessageCallback(_a, _b) {
                 reject(err);
             });
         });
-    }, [currentChannel]);
+    }, [
+        currentChannel,
+        onMessageDeletedByReqId,
+        onMessageDeleted,
+    ]);
 }
 
 function getThreadMessageListParams(params) {
@@ -402,7 +428,15 @@ var useThreadFetchers = function (_a) {
                 case 4: return [2 /*return*/];
             }
         });
-    }); }, [stores.sdkStore.initialized, staleParentMessage, anchorMessage, isReactionEnabled]);
+    }); }, [
+        stores.sdkStore.initialized,
+        staleParentMessage,
+        anchorMessage,
+        isReactionEnabled,
+        initializeThreadListStart,
+        initializeThreadListSuccess,
+        initializeThreadListFailure,
+    ]);
     var loadPrevious = useCallback(function (callback) { return __awaiter(void 0, void 0, void 0, function () {
         var params, _a, threadedMessages_2, parentMessage, error_2;
         return __generator(this, function (_b) {
@@ -430,7 +464,15 @@ var useThreadFetchers = function (_a) {
                 case 4: return [2 /*return*/];
             }
         });
-    }); }, [threadListState, oldestMessageTimeStamp, isReactionEnabled, staleParentMessage]);
+    }); }, [
+        threadListState,
+        oldestMessageTimeStamp,
+        isReactionEnabled,
+        staleParentMessage,
+        getPrevMessagesStart,
+        getPrevMessagesSuccess,
+        getPrevMessagesFailure,
+    ]);
     var loadNext = useCallback(function (callback) { return __awaiter(void 0, void 0, void 0, function () {
         var params, _a, threadedMessages_3, parentMessage, error_3;
         return __generator(this, function (_b) {
@@ -458,7 +500,15 @@ var useThreadFetchers = function (_a) {
                 case 4: return [2 /*return*/];
             }
         });
-    }); }, [threadListState, latestMessageTimeStamp, isReactionEnabled, staleParentMessage]);
+    }); }, [
+        threadListState,
+        latestMessageTimeStamp,
+        isReactionEnabled,
+        staleParentMessage,
+        getNextMessagesStart,
+        getNextMessagesSuccess,
+        getNextMessagesFailure,
+    ]);
     return {
         initializeThreadFetcher: initialize,
         fetchPrevThreads: loadPrevious,
@@ -475,33 +525,33 @@ var useThread = function () {
     if (!store)
         throw new Error('useThread must be used within a ThreadProvider');
     // SendbirdStateContext config
-    var _c = useSendbird().state, stores = _c.stores, config = _c.config;
+    var config = useSendbird().state.config;
     var logger = config.logger, pubSub = config.pubSub;
     var isMentionEnabled = config.groupChannel.enableMention;
     var isReactionEnabled = config.groupChannel.enableReactions;
     var state = shimExports.useSyncExternalStore(store.subscribe, store.getState);
     var message = state.message, parentMessage = state.parentMessage, currentChannel = state.currentChannel, threadListState = state.threadListState, allThreadMessages = state.allThreadMessages, onBeforeSendUserMessage = state.onBeforeSendUserMessage, onBeforeSendFileMessage = state.onBeforeSendFileMessage, onBeforeSendVoiceMessage = state.onBeforeSendVoiceMessage, onBeforeSendMultipleFilesMessage = state.onBeforeSendMultipleFilesMessage;
     var sendMessageStatusActions = {
-        sendMessageStart: function (message) { return store.setState(function (state) {
+        sendMessageStart: useCallback(function (message) { return store.setState(function (state) {
             return __assign(__assign({}, state), { localThreadMessages: __spreadArray(__spreadArray([], state.localThreadMessages, true), [
                     message,
                 ], false) });
-        }); },
-        sendMessageSuccess: function (message) { return store.setState(function (state) {
+        }); }, [store]),
+        sendMessageSuccess: useCallback(function (message) { return store.setState(function (state) {
             return __assign(__assign({}, state), { allThreadMessages: __spreadArray(__spreadArray([], state.allThreadMessages.filter(function (m) { return (!compareIds(m === null || m === void 0 ? void 0 : m.reqId, message === null || message === void 0 ? void 0 : message.reqId)); }), true), [
                     message,
                 ], false), localThreadMessages: state.localThreadMessages.filter(function (m) { return (!compareIds(m === null || m === void 0 ? void 0 : m.reqId, message === null || message === void 0 ? void 0 : message.reqId)); }) });
-        }); },
-        sendMessageFailure: function (message) { return store.setState(function (state) {
+        }); }, [store]),
+        sendMessageFailure: useCallback(function (message) { return store.setState(function (state) {
             return __assign(__assign({}, state), { localThreadMessages: state.localThreadMessages.map(function (m) { return (compareIds(m === null || m === void 0 ? void 0 : m.reqId, message === null || message === void 0 ? void 0 : message.reqId)
                     ? message
                     : m); }) });
-        }); },
-        resendMessageStart: function (message) { return store.setState(function (state) {
+        }); }, [store]),
+        resendMessageStart: useCallback(function (message) { return store.setState(function (state) {
             return __assign(__assign({}, state), { localThreadMessages: state.localThreadMessages.map(function (m) { return (compareIds(m === null || m === void 0 ? void 0 : m.reqId, message === null || message === void 0 ? void 0 : message.reqId)
                     ? message
                     : m); }) });
-        }); },
+        }); }, [store]),
     };
     var toggleReaction = useToggleReactionCallback({ currentChannel: currentChannel }, { logger: logger });
     var sendMessageActions = {
@@ -549,28 +599,34 @@ var useThread = function () {
         }, { logger: logger, pubSub: pubSub }),
     };
     var messageModifiedActions = {
-        onMessageUpdated: function (channel, message) { return store.setState(function (state) {
-            var _a, _b, _c;
-            if (((_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url) !== (channel === null || channel === void 0 ? void 0 : channel.url)) {
-                return state;
-            }
-            return __assign(__assign({}, state), { parentMessage: ((_b = state.parentMessage) === null || _b === void 0 ? void 0 : _b.messageId) === (message === null || message === void 0 ? void 0 : message.messageId)
-                    ? message
-                    : state.parentMessage, allThreadMessages: (_c = state.allThreadMessages) === null || _c === void 0 ? void 0 : _c.map(function (msg) { return (((msg === null || msg === void 0 ? void 0 : msg.messageId) === (message === null || message === void 0 ? void 0 : message.messageId)) ? message : msg); }) });
-        }); },
-        onMessageDeleted: function (channel, messageId) { return store.setState(function (state) {
-            var _a, _b, _c, _d;
-            if (((_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url) !== (channel === null || channel === void 0 ? void 0 : channel.url)) {
-                return state;
-            }
-            if (((_b = state === null || state === void 0 ? void 0 : state.parentMessage) === null || _b === void 0 ? void 0 : _b.messageId) === messageId) {
-                return __assign(__assign({}, state), { parentMessage: null, parentMessageState: ParentMessageStateTypes.NIL, allThreadMessages: [] });
-            }
-            return __assign(__assign({}, state), { allThreadMessages: (_c = state.allThreadMessages) === null || _c === void 0 ? void 0 : _c.filter(function (msg) { return ((msg === null || msg === void 0 ? void 0 : msg.messageId) !== messageId); }), localThreadMessages: (_d = state.localThreadMessages) === null || _d === void 0 ? void 0 : _d.filter(function (msg) { return ((msg === null || msg === void 0 ? void 0 : msg.messageId) !== messageId); }) });
-        }); },
-        onMessageDeletedByReqId: function (reqId) { return store.setState(function (state) {
-            return __assign(__assign({}, state), { localThreadMessages: state.localThreadMessages.filter(function (m) { return (!compareIds(m.reqId, reqId)); }) });
-        }); },
+        onMessageUpdated: useCallback(function (channel, message) {
+            store.setState(function (state) {
+                var _a, _b, _c;
+                if (((_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url) !== (channel === null || channel === void 0 ? void 0 : channel.url)) {
+                    return state;
+                }
+                return __assign(__assign({}, state), { parentMessage: ((_b = state.parentMessage) === null || _b === void 0 ? void 0 : _b.messageId) === (message === null || message === void 0 ? void 0 : message.messageId)
+                        ? message
+                        : state.parentMessage, allThreadMessages: (_c = state.allThreadMessages) === null || _c === void 0 ? void 0 : _c.map(function (msg) { return (((msg === null || msg === void 0 ? void 0 : msg.messageId) === (message === null || message === void 0 ? void 0 : message.messageId)) ? message : msg); }) });
+            });
+        }, [store]),
+        onMessageDeleted: useCallback(function (channel, messageId) {
+            store.setState(function (state) {
+                var _a, _b, _c, _d;
+                if (((_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url) !== (channel === null || channel === void 0 ? void 0 : channel.url)) {
+                    return state;
+                }
+                if (((_b = state === null || state === void 0 ? void 0 : state.parentMessage) === null || _b === void 0 ? void 0 : _b.messageId) === messageId) {
+                    return __assign(__assign({}, state), { parentMessage: null, parentMessageState: ParentMessageStateTypes.NIL, allThreadMessages: [] });
+                }
+                return __assign(__assign({}, state), { allThreadMessages: (_c = state.allThreadMessages) === null || _c === void 0 ? void 0 : _c.filter(function (msg) { return ((msg === null || msg === void 0 ? void 0 : msg.messageId) !== messageId); }), localThreadMessages: (_d = state.localThreadMessages) === null || _d === void 0 ? void 0 : _d.filter(function (msg) { return ((msg === null || msg === void 0 ? void 0 : msg.messageId) !== messageId); }) });
+            });
+        }, [store]),
+        onMessageDeletedByReqId: useCallback(function (reqId) {
+            store.setState(function (state) {
+                return __assign(__assign({}, state), { localThreadMessages: state.localThreadMessages.filter(function (m) { return (!compareIds(m.reqId, reqId)); }) });
+            });
+        }, [store]),
     };
     var modifyMessageActions = {
         updateMessage: useUpdateMessageCallback({
@@ -585,40 +641,40 @@ var useThread = function () {
         }, { logger: logger }),
     };
     var threadFetcherStatusActions = {
-        initializeThreadListStart: function () { return store.setState(function (state) {
+        initializeThreadListStart: useCallback(function () { return store.setState(function (state) {
             return __assign(__assign({}, state), { threadListState: ThreadListStateTypes.LOADING, allThreadMessages: [] });
-        }); },
-        initializeThreadListSuccess: function (parentMessage, anchorMessage, threadedMessages) { return store.setState(function (state) {
+        }); }, [store]),
+        initializeThreadListSuccess: useCallback(function (parentMessage, anchorMessage, threadedMessages) { return store.setState(function (state) {
             var anchorMessageCreatedAt = (!(anchorMessage === null || anchorMessage === void 0 ? void 0 : anchorMessage.messageId)) ? parentMessage === null || parentMessage === void 0 ? void 0 : parentMessage.createdAt : anchorMessage === null || anchorMessage === void 0 ? void 0 : anchorMessage.createdAt;
             var anchorIndex = threadedMessages.findIndex(function (message) { return (message === null || message === void 0 ? void 0 : message.createdAt) > anchorMessageCreatedAt; });
             var prevThreadMessages = anchorIndex > -1 ? threadedMessages.slice(0, anchorIndex) : threadedMessages;
             var anchorThreadMessage = (anchorMessage === null || anchorMessage === void 0 ? void 0 : anchorMessage.messageId) ? [anchorMessage] : [];
             var nextThreadMessages = anchorIndex > -1 ? threadedMessages.slice(anchorIndex) : [];
             return __assign(__assign({}, state), { threadListState: ThreadListStateTypes.INITIALIZED, hasMorePrev: anchorIndex === -1 || anchorIndex === PREV_THREADS_FETCH_SIZE, hasMoreNext: threadedMessages.length - anchorIndex === NEXT_THREADS_FETCH_SIZE, allThreadMessages: [prevThreadMessages, anchorThreadMessage, nextThreadMessages].flat() });
-        }); },
-        initializeThreadListFailure: function () { return store.setState(function (state) {
+        }); }, [store]),
+        initializeThreadListFailure: useCallback(function () { return store.setState(function (state) {
             return __assign(__assign({}, state), { threadListState: ThreadListStateTypes.LOADING, allThreadMessages: [] });
-        }); },
-        getPrevMessagesStart: function () { return store.setState(function (state) {
+        }); }, [store]),
+        getPrevMessagesStart: useCallback(function () { return store.setState(function (state) {
             return __assign({}, state);
-        }); },
-        getPrevMessagesSuccess: function (threadedMessages) { return store.setState(function (state) {
+        }); }, [store]),
+        getPrevMessagesSuccess: useCallback(function (threadedMessages) { return store.setState(function (state) {
             return __assign(__assign({}, state), { hasMorePrev: threadedMessages.length === PREV_THREADS_FETCH_SIZE, allThreadMessages: __spreadArray(__spreadArray([], threadedMessages, true), state.allThreadMessages, true) });
-        }); },
-        getPrevMessagesFailure: function () { return store.setState(function (state) {
+        }); }, [store]),
+        getPrevMessagesFailure: useCallback(function () { return store.setState(function (state) {
             return __assign(__assign({}, state), { hasMorePrev: false });
-        }); },
-        getNextMessagesStart: function () { return store.setState(function (state) {
+        }); }, [store]),
+        getNextMessagesStart: useCallback(function () { return store.setState(function (state) {
             return __assign({}, state);
-        }); },
-        getNextMessagesSuccess: function (threadedMessages) { return store.setState(function (state) {
+        }); }, [store]),
+        getNextMessagesSuccess: useCallback(function (threadedMessages) { return store.setState(function (state) {
             return __assign(__assign({}, state), { hasMoreNext: threadedMessages.length === NEXT_THREADS_FETCH_SIZE, allThreadMessages: __spreadArray(__spreadArray([], state.allThreadMessages, true), threadedMessages, true) });
-        }); },
-        getNextMessagesFailure: function () { return store.setState(function (state) {
+        }); }, [store]),
+        getNextMessagesFailure: useCallback(function () { return store.setState(function (state) {
             return __assign(__assign({}, state), { hasMoreNext: false });
-        }); },
+        }); }, [store]),
     };
-    var _d = useThreadFetchers({
+    var _c = useThreadFetchers({
         parentMessage: parentMessage,
         // anchorMessage should be null when parentMessage doesn't exist
         anchorMessage: (message === null || message === void 0 ? void 0 : message.messageId) !== (parentMessage === null || parentMessage === void 0 ? void 0 : parentMessage.messageId) ? message || undefined : undefined,
@@ -636,13 +692,22 @@ var useThread = function () {
         getNextMessagesStart: threadFetcherStatusActions.getNextMessagesStart,
         getNextMessagesSuccess: threadFetcherStatusActions.getNextMessagesSuccess,
         getNextMessagesFailure: threadFetcherStatusActions.getNextMessagesFailure,
-    }), initializeThreadFetcher = _d.initializeThreadFetcher, fetchPrevThreads = _d.fetchPrevThreads, fetchNextThreads = _d.fetchNextThreads;
-    var actions = useMemo(function () { return (__assign(__assign(__assign(__assign(__assign(__assign({ setCurrentUserId: function (currentUserId) { return store.setState(function (state) { return (__assign(__assign({}, state), { currentUserId: currentUserId })); }); }, getChannelStart: function () { return store.setState(function (state) { return (__assign(__assign({}, state), { channelState: ChannelStateTypes.LOADING, currentChannel: null })); }); }, getChannelSuccess: function (groupChannel) { return store.setState(function (state) {
+    }), initializeThreadFetcher = _c.initializeThreadFetcher, fetchPrevThreads = _c.fetchPrevThreads, fetchNextThreads = _c.fetchNextThreads;
+    var simpleActions = {
+        setCurrentUserId: useCallback(function (currentUserId) { return store.setState(function (state) { return (__assign(__assign({}, state), { currentUserId: currentUserId })); }); }, [store]),
+        getChannelStart: useCallback(function () { return store.setState(function (state) { return (__assign(__assign({}, state), { channelState: ChannelStateTypes.LOADING, currentChannel: null })); }); }, [store]),
+        getChannelSuccess: useCallback(function (groupChannel) { return store.setState(function (state) {
             var _a, _b;
             return (__assign(__assign({}, state), { channelState: ChannelStateTypes.INITIALIZED, currentChannel: groupChannel, 
                 // only support in normal group channel
                 isMuted: ((_b = (_a = groupChannel === null || groupChannel === void 0 ? void 0 : groupChannel.members) === null || _a === void 0 ? void 0 : _a.find(function (member) { return (member === null || member === void 0 ? void 0 : member.userId) === state.currentUserId; })) === null || _b === void 0 ? void 0 : _b.isMuted) || false, isChannelFrozen: (groupChannel === null || groupChannel === void 0 ? void 0 : groupChannel.isFrozen) || false }));
-        }); }, getChannelFailure: function () { return store.setState(function (state) { return (__assign(__assign({}, state), { channelState: ChannelStateTypes.INVALID, currentChannel: null })); }); }, getParentMessageStart: function () { return store.setState(function (state) { return (__assign(__assign({}, state), { parentMessageState: ParentMessageStateTypes.LOADING, parentMessage: null })); }); }, getParentMessageSuccess: function (parentMessage) { return store.setState(function (state) { return (__assign(__assign({}, state), { parentMessageState: ParentMessageStateTypes.INITIALIZED, parentMessage: parentMessage })); }); }, getParentMessageFailure: function () { return store.setState(function (state) { return (__assign(__assign({}, state), { parentMessageState: ParentMessageStateTypes.INVALID, parentMessage: null })); }); }, setEmojiContainer: function (emojiContainer) { return store.setState(function (state) { return (__assign(__assign({}, state), { emojiContainer: emojiContainer })); }); }, onMessageReceived: function (channel, message) { return store.setState(function (state) {
+        }); }, [store]),
+        getChannelFailure: useCallback(function () { return store.setState(function (state) { return (__assign(__assign({}, state), { channelState: ChannelStateTypes.INVALID, currentChannel: null })); }); }, [store]),
+        getParentMessageStart: useCallback(function () { return store.setState(function (state) { return (__assign(__assign({}, state), { parentMessageState: ParentMessageStateTypes.LOADING, parentMessage: null })); }); }, [store]),
+        getParentMessageSuccess: useCallback(function (parentMessage) { return store.setState(function (state) { return (__assign(__assign({}, state), { parentMessageState: ParentMessageStateTypes.INITIALIZED, parentMessage: parentMessage })); }); }, [store]),
+        getParentMessageFailure: useCallback(function () { return store.setState(function (state) { return (__assign(__assign({}, state), { parentMessageState: ParentMessageStateTypes.INVALID, parentMessage: null })); }); }, [store]),
+        setEmojiContainer: useCallback(function (emojiContainer) { return store.setState(function (state) { return (__assign(__assign({}, state), { emojiContainer: emojiContainer })); }); }, [store]),
+        onMessageReceived: useCallback(function (channel, message) { return store.setState(function (state) {
             var _a, _b, _c, _d;
             if (((_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url) !== (channel === null || channel === void 0 ? void 0 : channel.url)
                 || state.hasMoreNext
@@ -655,7 +720,8 @@ var useThread = function () {
                     : __spreadArray(__spreadArray([], state.allThreadMessages.filter(function (m) { return (m === null || m === void 0 ? void 0 : m.reqId) !== (message === null || message === void 0 ? void 0 : message.reqId); }), true), [
                         message,
                     ], false) });
-        }); }, onReactionUpdated: function (reactionEvent) { return store.setState(function (state) {
+        }); }, [store]),
+        onReactionUpdated: useCallback(function (reactionEvent) { return store.setState(function (state) {
             var _a, _b, _c;
             if (((_a = state === null || state === void 0 ? void 0 : state.parentMessage) === null || _a === void 0 ? void 0 : _a.messageId) === (reactionEvent === null || reactionEvent === void 0 ? void 0 : reactionEvent.messageId)) {
                 (_c = (_b = state.parentMessage) === null || _b === void 0 ? void 0 : _b.applyReactionEvent) === null || _c === void 0 ? void 0 : _c.call(_b, reactionEvent);
@@ -668,41 +734,51 @@ var useThread = function () {
                     }
                     return m;
                 }) });
-        }); }, onUserMuted: function (channel, user) { return store.setState(function (state) {
+        }); }, [store]),
+        onUserMuted: useCallback(function (channel, user) { return 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) || state.currentUserId !== (user === null || user === void 0 ? void 0 : user.userId)) {
                 return state;
             }
             return __assign(__assign({}, state), { isMuted: true });
-        }); }, onUserUnmuted: function (channel, user) { return store.setState(function (state) {
+        }); }, [store]),
+        onUserUnmuted: useCallback(function (channel, user) { return 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) || state.currentUserId !== (user === null || user === void 0 ? void 0 : user.userId)) {
                 return state;
             }
             return __assign(__assign({}, state), { isMuted: false });
-        }); }, onUserBanned: function () { return store.setState(function (state) {
+        }); }, [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 });
-        }); }, onUserUnbanned: function () { return store.setState(function (state) {
+        }); }, [store]),
+        onUserUnbanned: useCallback(function () { return store.setState(function (state) {
             return __assign({}, state);
-        }); }, onUserLeft: function () { return store.setState(function (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 });
-        }); }, onChannelFrozen: function () { return store.setState(function (state) {
+        }); }, [store]),
+        onChannelFrozen: useCallback(function () { return store.setState(function (state) {
             return __assign(__assign({}, state), { isChannelFrozen: true });
-        }); }, onChannelUnfrozen: function () { return store.setState(function (state) {
+        }); }, [store]),
+        onChannelUnfrozen: useCallback(function () { return store.setState(function (state) {
             return __assign(__assign({}, state), { isChannelFrozen: false });
-        }); }, onOperatorUpdated: function (channel) { return store.setState(function (state) {
+        }); }, [store]),
+        onOperatorUpdated: useCallback(function (channel) { return store.setState(function (state) {
             var _a;
             if ((channel === null || channel === void 0 ? void 0 : channel.url) === ((_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url)) {
                 return __assign(__assign({}, state), { currentChannel: channel });
             }
             return state;
-        }); }, onTypingStatusUpdated: function (channel, typingMembers) { return store.setState(function (state) {
+        }); }, [store]),
+        onTypingStatusUpdated: useCallback(function (channel, typingMembers) { return store.setState(function (state) {
             var _a;
             if (!compareIds(channel.url, (_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url)) {
                 return state;
             }
             return __assign(__assign({}, state), { typingMembers: typingMembers });
-        }); }, onFileInfoUpdated: function (_a) {
+        }); }, [store]),
+        onFileInfoUpdated: useCallback(function (_a) {
             var channelUrl = _a.channelUrl, requestId = _a.requestId, index = _a.index, uploadableFileInfo = _a.uploadableFileInfo, error = _a.error;
             return store.setState(function (state) {
                 var _a, _b;
@@ -724,14 +800,19 @@ var useThread = function () {
                 }
                 return __assign(__assign({}, state), { localThreadMessages: localThreadMessages });
             });
-        }, toggleReaction: toggleReaction }, sendMessageStatusActions), sendMessageActions), messageModifiedActions), modifyMessageActions), threadFetcherStatusActions), { initializeThreadFetcher: initializeThreadFetcher, fetchPrevThreads: fetchPrevThreads, fetchNextThreads: fetchNextThreads })); }, [
-        store,
-        currentChannel,
-        stores.sdkStore.initialized,
-        parentMessage,
-        threadListState,
-        isReactionEnabled,
-        logger,
+        }, [store]),
+    };
+    var actions = useMemo(function () { return (__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, simpleActions), { toggleReaction: toggleReaction }), sendMessageStatusActions), sendMessageActions), messageModifiedActions), modifyMessageActions), threadFetcherStatusActions), { initializeThreadFetcher: initializeThreadFetcher, fetchPrevThreads: fetchPrevThreads, fetchNextThreads: fetchNextThreads })); }, [
+        simpleActions,
+        toggleReaction,
+        sendMessageStatusActions,
+        sendMessageActions,
+        messageModifiedActions,
+        modifyMessageActions,
+        threadFetcherStatusActions,
+        initializeThreadFetcher,
+        fetchPrevThreads,
+        fetchNextThreads,
     ]);
     return { state: state, actions: actions };
 };
@@ -1122,4 +1203,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-CNmV5PTy.js.map
+//# sourceMappingURL=bundle-C5K0S7d0.js.map

package/{cjs/chunks/bundle-DG95QOGk.js.map → chunks/bundle-C5K0S7d0.js.map}

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