@sendbird/uikit-react 3.16.4 → 3.16.5-rc

package/cjs/chunks/{bundle-DG95QOGk.js → bundle-4RgKenY-.js}

@@ -1,21 +1,21 @@
 'use strict';
 
-var _tslib = require('./bundle-vBdLEZEf.js');
+var _tslib = require('./bundle-CtsLqGOu.js');
 var React = require('react');
-var useSendMultipleFilesMessage = require('./bundle-De6LiJt1.js');
-var UserProfileContext = require('./bundle-CWiKzeWc.js');
-var SendbirdContext = require('./bundle-BxPxvWob.js');
+var useSendMultipleFilesMessage = require('./bundle-BAXdFQTR.js');
+var UserProfileContext = require('./bundle-MsXzdgey.js');
+var SendbirdContext = require('./bundle-CIkAYyzL.js');
 var SendbirdChat = require('@sendbird/chat');
-var pubSub_topics = require('./bundle-B5_pX04O.js');
+var pubSub_topics = require('./bundle-DTB_lnXL.js');
 var groupChannel = require('@sendbird/chat/groupChannel');
-var uuid = require('./bundle-D6VHAQ1n.js');
-var compareIds = require('./bundle-4yaT_mvl.js');
+var uuid = require('./bundle-4d-4ii3H.js');
+var compareIds = require('./bundle-2jNINFtN.js');
 var Thread_context_types = require('../Thread/context/types.js');
-var useSendbird = require('./bundle-BJ0hFNf4.js');
-var useDeepCompareEffect = require('./bundle-GuUb5Uk5.js');
+var useSendbird = require('./bundle-BD4O00Pv.js');
+var useDeepCompareEffect = require('./bundle-3UJtNtO-.js');
 var message = require('@sendbird/chat/message');
-require('./bundle-B0aJPqBG.js');
-var consts = require('./bundle-D0IQ27as.js');
+require('./bundle-vG8MHa_f.js');
+var consts = require('./bundle-CAfcCqbs.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -85,7 +85,13 @@ function useSendUserMessageCallback(_a, _b) {
                 });
             });
         }
-    }, [isMentionEnabled, currentChannel]);
+    }, [
+        isMentionEnabled,
+        currentChannel,
+        onBeforeSendUserMessage,
+        sendMessageStart,
+        sendMessageFailure,
+    ]);
     return sendMessage;
 }
 
@@ -137,7 +143,12 @@ function useSendFileMessageCallback(_a, _b) {
                 });
             }
         });
-    }, [currentChannel]);
+    }, [
+        currentChannel,
+        onBeforeSendFileMessage,
+        sendMessageStart,
+        sendMessageFailure,
+    ]);
 }
 
 var useSendVoiceMessageCallback = function (_a, _b) {
@@ -189,6 +200,8 @@ var useSendVoiceMessageCallback = function (_a, _b) {
     }, [
         currentChannel,
         onBeforeSendVoiceMessage,
+        sendMessageStart,
+        sendMessageFailure,
     ]);
     return sendMessage;
 };
@@ -298,7 +311,12 @@ function useResendMessageCallback(_a, _b) {
             failedMessage.sendingStatus = message.SendingStatus.FAILED;
             sendMessageFailure(failedMessage);
         }
-    }, [currentChannel]);
+    }, [
+        currentChannel,
+        resendMessageStart,
+        sendMessageSuccess,
+        sendMessageFailure,
+    ]);
 }
 
 function useUpdateMessageCallback(_a, _b) {
@@ -338,7 +356,11 @@ function useUpdateMessageCallback(_a, _b) {
                 publishingModules: [pubSub_topics.PublishingModuleType.THREAD],
             });
         });
-    }, [currentChannel, isMentionEnabled]);
+    }, [
+        currentChannel,
+        isMentionEnabled,
+        onMessageUpdated,
+    ]);
 }
 
 function useDeleteMessageCallback(_a, _b) {
@@ -370,7 +392,11 @@ function useDeleteMessageCallback(_a, _b) {
                 reject(err);
             });
         });
-    }, [currentChannel]);
+    }, [
+        currentChannel,
+        onMessageDeletedByReqId,
+        onMessageDeleted,
+    ]);
 }
 
 function getThreadMessageListParams(params) {
@@ -408,7 +434,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 = React.useCallback(function (callback) { return _tslib.__awaiter(void 0, void 0, void 0, function () {
         var params, _a, threadedMessages_2, parentMessage, error_2;
         return _tslib.__generator(this, function (_b) {
@@ -436,7 +470,15 @@ var useThreadFetchers = function (_a) {
                 case 4: return [2 /*return*/];
             }
         });
-    }); }, [threadListState, oldestMessageTimeStamp, isReactionEnabled, staleParentMessage]);
+    }); }, [
+        threadListState,
+        oldestMessageTimeStamp,
+        isReactionEnabled,
+        staleParentMessage,
+        getPrevMessagesStart,
+        getPrevMessagesSuccess,
+        getPrevMessagesFailure,
+    ]);
     var loadNext = React.useCallback(function (callback) { return _tslib.__awaiter(void 0, void 0, void 0, function () {
         var params, _a, threadedMessages_3, parentMessage, error_3;
         return _tslib.__generator(this, function (_b) {
@@ -464,7 +506,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,
@@ -481,33 +531,33 @@ var useThread = function () {
     if (!store)
         throw new Error('useThread must be used within a ThreadProvider');
     // SendbirdStateContext config
-    var _c = useSendbird.useSendbird().state, stores = _c.stores, config = _c.config;
+    var config = useSendbird.useSendbird().state.config;
     var logger = config.logger, pubSub = config.pubSub;
     var isMentionEnabled = config.groupChannel.enableMention;
     var isReactionEnabled = config.groupChannel.enableReactions;
     var state = SendbirdContext.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: React.useCallback(function (message) { return store.setState(function (state) {
             return _tslib.__assign(_tslib.__assign({}, state), { localThreadMessages: _tslib.__spreadArray(_tslib.__spreadArray([], state.localThreadMessages, true), [
                     message,
                 ], false) });
-        }); },
-        sendMessageSuccess: function (message) { return store.setState(function (state) {
+        }); }, [store]),
+        sendMessageSuccess: React.useCallback(function (message) { return store.setState(function (state) {
             return _tslib.__assign(_tslib.__assign({}, state), { allThreadMessages: _tslib.__spreadArray(_tslib.__spreadArray([], state.allThreadMessages.filter(function (m) { return (!useSendMultipleFilesMessage.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 (!useSendMultipleFilesMessage.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: React.useCallback(function (message) { return store.setState(function (state) {
             return _tslib.__assign(_tslib.__assign({}, state), { localThreadMessages: state.localThreadMessages.map(function (m) { return (useSendMultipleFilesMessage.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: React.useCallback(function (message) { return store.setState(function (state) {
             return _tslib.__assign(_tslib.__assign({}, state), { localThreadMessages: state.localThreadMessages.map(function (m) { return (useSendMultipleFilesMessage.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 = {
@@ -555,28 +605,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 _tslib.__assign(_tslib.__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 _tslib.__assign(_tslib.__assign({}, state), { parentMessage: null, parentMessageState: Thread_context_types.ParentMessageStateTypes.NIL, allThreadMessages: [] });
-            }
-            return _tslib.__assign(_tslib.__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 _tslib.__assign(_tslib.__assign({}, state), { localThreadMessages: state.localThreadMessages.filter(function (m) { return (!useSendMultipleFilesMessage.compareIds(m.reqId, reqId)); }) });
-        }); },
+        onMessageUpdated: React.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 _tslib.__assign(_tslib.__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: React.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 _tslib.__assign(_tslib.__assign({}, state), { parentMessage: null, parentMessageState: Thread_context_types.ParentMessageStateTypes.NIL, allThreadMessages: [] });
+                }
+                return _tslib.__assign(_tslib.__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: React.useCallback(function (reqId) {
+            store.setState(function (state) {
+                return _tslib.__assign(_tslib.__assign({}, state), { localThreadMessages: state.localThreadMessages.filter(function (m) { return (!useSendMultipleFilesMessage.compareIds(m.reqId, reqId)); }) });
+            });
+        }, [store]),
     };
     var modifyMessageActions = {
         updateMessage: useUpdateMessageCallback({
@@ -591,40 +647,40 @@ var useThread = function () {
         }, { logger: logger }),
     };
     var threadFetcherStatusActions = {
-        initializeThreadListStart: function () { return store.setState(function (state) {
+        initializeThreadListStart: React.useCallback(function () { return store.setState(function (state) {
             return _tslib.__assign(_tslib.__assign({}, state), { threadListState: Thread_context_types.ThreadListStateTypes.LOADING, allThreadMessages: [] });
-        }); },
-        initializeThreadListSuccess: function (parentMessage, anchorMessage, threadedMessages) { return store.setState(function (state) {
+        }); }, [store]),
+        initializeThreadListSuccess: React.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 _tslib.__assign(_tslib.__assign({}, state), { threadListState: Thread_context_types.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: React.useCallback(function () { return store.setState(function (state) {
             return _tslib.__assign(_tslib.__assign({}, state), { threadListState: Thread_context_types.ThreadListStateTypes.LOADING, allThreadMessages: [] });
-        }); },
-        getPrevMessagesStart: function () { return store.setState(function (state) {
+        }); }, [store]),
+        getPrevMessagesStart: React.useCallback(function () { return store.setState(function (state) {
             return _tslib.__assign({}, state);
-        }); },
-        getPrevMessagesSuccess: function (threadedMessages) { return store.setState(function (state) {
+        }); }, [store]),
+        getPrevMessagesSuccess: React.useCallback(function (threadedMessages) { return store.setState(function (state) {
             return _tslib.__assign(_tslib.__assign({}, state), { hasMorePrev: threadedMessages.length === PREV_THREADS_FETCH_SIZE, allThreadMessages: _tslib.__spreadArray(_tslib.__spreadArray([], threadedMessages, true), state.allThreadMessages, true) });
-        }); },
-        getPrevMessagesFailure: function () { return store.setState(function (state) {
+        }); }, [store]),
+        getPrevMessagesFailure: React.useCallback(function () { return store.setState(function (state) {
             return _tslib.__assign(_tslib.__assign({}, state), { hasMorePrev: false });
-        }); },
-        getNextMessagesStart: function () { return store.setState(function (state) {
+        }); }, [store]),
+        getNextMessagesStart: React.useCallback(function () { return store.setState(function (state) {
             return _tslib.__assign({}, state);
-        }); },
-        getNextMessagesSuccess: function (threadedMessages) { return store.setState(function (state) {
+        }); }, [store]),
+        getNextMessagesSuccess: React.useCallback(function (threadedMessages) { return store.setState(function (state) {
             return _tslib.__assign(_tslib.__assign({}, state), { hasMoreNext: threadedMessages.length === NEXT_THREADS_FETCH_SIZE, allThreadMessages: _tslib.__spreadArray(_tslib.__spreadArray([], state.allThreadMessages, true), threadedMessages, true) });
-        }); },
-        getNextMessagesFailure: function () { return store.setState(function (state) {
+        }); }, [store]),
+        getNextMessagesFailure: React.useCallback(function () { return store.setState(function (state) {
             return _tslib.__assign(_tslib.__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,
@@ -642,13 +698,22 @@ var useThread = function () {
         getNextMessagesStart: threadFetcherStatusActions.getNextMessagesStart,
         getNextMessagesSuccess: threadFetcherStatusActions.getNextMessagesSuccess,
         getNextMessagesFailure: threadFetcherStatusActions.getNextMessagesFailure,
-    }), initializeThreadFetcher = _d.initializeThreadFetcher, fetchPrevThreads = _d.fetchPrevThreads, fetchNextThreads = _d.fetchNextThreads;
-    var actions = React.useMemo(function () { return (_tslib.__assign(_tslib.__assign(_tslib.__assign(_tslib.__assign(_tslib.__assign(_tslib.__assign({ setCurrentUserId: function (currentUserId) { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { currentUserId: currentUserId })); }); }, getChannelStart: function () { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { channelState: Thread_context_types.ChannelStateTypes.LOADING, currentChannel: null })); }); }, getChannelSuccess: function (groupChannel) { return store.setState(function (state) {
+    }), initializeThreadFetcher = _c.initializeThreadFetcher, fetchPrevThreads = _c.fetchPrevThreads, fetchNextThreads = _c.fetchNextThreads;
+    var simpleActions = {
+        setCurrentUserId: React.useCallback(function (currentUserId) { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { currentUserId: currentUserId })); }); }, [store]),
+        getChannelStart: React.useCallback(function () { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { channelState: Thread_context_types.ChannelStateTypes.LOADING, currentChannel: null })); }); }, [store]),
+        getChannelSuccess: React.useCallback(function (groupChannel) { return store.setState(function (state) {
             var _a, _b;
             return (_tslib.__assign(_tslib.__assign({}, state), { channelState: Thread_context_types.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 (_tslib.__assign(_tslib.__assign({}, state), { channelState: Thread_context_types.ChannelStateTypes.INVALID, currentChannel: null })); }); }, getParentMessageStart: function () { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { parentMessageState: Thread_context_types.ParentMessageStateTypes.LOADING, parentMessage: null })); }); }, getParentMessageSuccess: function (parentMessage) { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { parentMessageState: Thread_context_types.ParentMessageStateTypes.INITIALIZED, parentMessage: parentMessage })); }); }, getParentMessageFailure: function () { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { parentMessageState: Thread_context_types.ParentMessageStateTypes.INVALID, parentMessage: null })); }); }, setEmojiContainer: function (emojiContainer) { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { emojiContainer: emojiContainer })); }); }, onMessageReceived: function (channel, message) { return store.setState(function (state) {
+        }); }, [store]),
+        getChannelFailure: React.useCallback(function () { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { channelState: Thread_context_types.ChannelStateTypes.INVALID, currentChannel: null })); }); }, [store]),
+        getParentMessageStart: React.useCallback(function () { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { parentMessageState: Thread_context_types.ParentMessageStateTypes.LOADING, parentMessage: null })); }); }, [store]),
+        getParentMessageSuccess: React.useCallback(function (parentMessage) { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { parentMessageState: Thread_context_types.ParentMessageStateTypes.INITIALIZED, parentMessage: parentMessage })); }); }, [store]),
+        getParentMessageFailure: React.useCallback(function () { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { parentMessageState: Thread_context_types.ParentMessageStateTypes.INVALID, parentMessage: null })); }); }, [store]),
+        setEmojiContainer: React.useCallback(function (emojiContainer) { return store.setState(function (state) { return (_tslib.__assign(_tslib.__assign({}, state), { emojiContainer: emojiContainer })); }); }, [store]),
+        onMessageReceived: React.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
@@ -661,7 +726,8 @@ var useThread = function () {
                     : _tslib.__spreadArray(_tslib.__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: React.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);
@@ -674,41 +740,51 @@ var useThread = function () {
                     }
                     return m;
                 }) });
-        }); }, onUserMuted: function (channel, user) { return store.setState(function (state) {
+        }); }, [store]),
+        onUserMuted: React.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 _tslib.__assign(_tslib.__assign({}, state), { isMuted: true });
-        }); }, onUserUnmuted: function (channel, user) { return store.setState(function (state) {
+        }); }, [store]),
+        onUserUnmuted: React.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 _tslib.__assign(_tslib.__assign({}, state), { isMuted: false });
-        }); }, onUserBanned: function () { return store.setState(function (state) {
+        }); }, [store]),
+        onUserBanned: React.useCallback(function () { return store.setState(function (state) {
             return _tslib.__assign(_tslib.__assign({}, state), { channelState: Thread_context_types.ChannelStateTypes.NIL, threadListState: Thread_context_types.ThreadListStateTypes.NIL, parentMessageState: Thread_context_types.ParentMessageStateTypes.NIL, currentChannel: null, parentMessage: null, allThreadMessages: [], hasMorePrev: false, hasMoreNext: false });
-        }); }, onUserUnbanned: function () { return store.setState(function (state) {
+        }); }, [store]),
+        onUserUnbanned: React.useCallback(function () { return store.setState(function (state) {
             return _tslib.__assign({}, state);
-        }); }, onUserLeft: function () { return store.setState(function (state) {
+        }); }, [store]),
+        onUserLeft: React.useCallback(function () { return store.setState(function (state) {
             return _tslib.__assign(_tslib.__assign({}, state), { channelState: Thread_context_types.ChannelStateTypes.NIL, threadListState: Thread_context_types.ThreadListStateTypes.NIL, parentMessageState: Thread_context_types.ParentMessageStateTypes.NIL, currentChannel: null, parentMessage: null, allThreadMessages: [], hasMorePrev: false, hasMoreNext: false });
-        }); }, onChannelFrozen: function () { return store.setState(function (state) {
+        }); }, [store]),
+        onChannelFrozen: React.useCallback(function () { return store.setState(function (state) {
             return _tslib.__assign(_tslib.__assign({}, state), { isChannelFrozen: true });
-        }); }, onChannelUnfrozen: function () { return store.setState(function (state) {
+        }); }, [store]),
+        onChannelUnfrozen: React.useCallback(function () { return store.setState(function (state) {
             return _tslib.__assign(_tslib.__assign({}, state), { isChannelFrozen: false });
-        }); }, onOperatorUpdated: function (channel) { return store.setState(function (state) {
+        }); }, [store]),
+        onOperatorUpdated: React.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 _tslib.__assign(_tslib.__assign({}, state), { currentChannel: channel });
             }
             return state;
-        }); }, onTypingStatusUpdated: function (channel, typingMembers) { return store.setState(function (state) {
+        }); }, [store]),
+        onTypingStatusUpdated: React.useCallback(function (channel, typingMembers) { return store.setState(function (state) {
             var _a;
             if (!useSendMultipleFilesMessage.compareIds(channel.url, (_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url)) {
                 return state;
             }
             return _tslib.__assign(_tslib.__assign({}, state), { typingMembers: typingMembers });
-        }); }, onFileInfoUpdated: function (_a) {
+        }); }, [store]),
+        onFileInfoUpdated: React.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;
@@ -730,14 +806,19 @@ var useThread = function () {
                 }
                 return _tslib.__assign(_tslib.__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 = React.useMemo(function () { return (_tslib.__assign(_tslib.__assign(_tslib.__assign(_tslib.__assign(_tslib.__assign(_tslib.__assign(_tslib.__assign(_tslib.__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 };
 };
@@ -1133,4 +1214,4 @@ exports.ThreadManager = ThreadManager;
 exports.ThreadProvider = ThreadProvider;
 exports.useThread = useThread;
 exports.useThreadContext = useThreadContext;
-//# sourceMappingURL=bundle-DG95QOGk.js.map
+//# sourceMappingURL=bundle-4RgKenY-.js.map

package/{chunks/bundle-CNmV5PTy.js.map → cjs/chunks/bundle-4RgKenY-.js.map}

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

package/cjs/chunks/{bundle-D6VHAQ1n.js → bundle-4d-4ii3H.js}

@@ -12,4 +12,4 @@ var uuidv4 = function () { return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace
 }); };
 
 exports.uuidv4 = uuidv4;
-//# sourceMappingURL=bundle-D6VHAQ1n.js.map
+//# sourceMappingURL=bundle-4d-4ii3H.js.map

package/cjs/chunks/bundle-4d-4ii3H.js.map

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

package/cjs/chunks/{bundle-DsiRw0Lz.js → bundle-5Eff_f26.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var _const = require('./bundle-BRUWTERD.js');
+var _const = require('./bundle-ZhQt4fn_.js');
 
 function getComponentKeyFromMessage(message) {
     if ('sendingStatus' in message) {
@@ -61,4 +61,4 @@ exports.isDisabledBecauseMessageForm = isDisabledBecauseMessageForm;
 exports.isDisabledBecauseMuted = isDisabledBecauseMuted;
 exports.isDisabledBecauseSuggestedReplies = isDisabledBecauseSuggestedReplies;
 exports.isFormVersionCompatible = isFormVersionCompatible;
-//# sourceMappingURL=bundle-DsiRw0Lz.js.map
+//# sourceMappingURL=bundle-5Eff_f26.js.map

package/cjs/chunks/bundle-5Eff_f26.js.map

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

package/cjs/chunks/{bundle-DdVHDt_b.js → bundle-7dpwimfm.js}

@@ -5,10 +5,10 @@ var ui_PlaybackTime = require('../ui/PlaybackTime.js');
 var ui_ProgressBar = require('../ui/ProgressBar.js');
 var ui_TextButton = require('../ui/TextButton.js');
 var ui_Icon = require('../ui/Icon.js');
-var ui_Label = require('./bundle-FVF7cK_5.js');
-var LocalizationContext = require('./bundle-B0aJPqBG.js');
-var consts = require('./bundle-D0IQ27as.js');
-var utils = require('./bundle-BotUaB2k.js');
+var ui_Label = require('./bundle-ChBnEQFY.js');
+var LocalizationContext = require('./bundle-vG8MHa_f.js');
+var consts = require('./bundle-CAfcCqbs.js');
+var utils = require('./bundle-URE0d1K6.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -101,4 +101,4 @@ var VoiceMessageInput = function (_a) {
 
 exports.VoiceMessageInput = VoiceMessageInput;
 exports.VoiceMessageInputStatus = VoiceMessageInputStatus;
-//# sourceMappingURL=bundle-DdVHDt_b.js.map
+//# sourceMappingURL=bundle-7dpwimfm.js.map

package/cjs/chunks/{bundle-DdVHDt_b.js.map → bundle-7dpwimfm.js.map}

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

package/cjs/chunks/{bundle-BZds40K8.js → bundle-B2xreZua.js}

@@ -1,15 +1,15 @@
 'use strict';
 
 var React = require('react');
-var utils = require('./bundle-BotUaB2k.js');
-var ui_ContextMenu = require('./bundle-hA8wTtuU.js');
-var _tslib = require('./bundle-vBdLEZEf.js');
+var utils = require('./bundle-URE0d1K6.js');
+var ui_ContextMenu = require('./bundle-DBVeTytU.js');
+var _tslib = require('./bundle-CtsLqGOu.js');
 var ui_IconButton = require('../ui/IconButton.js');
 var ui_Icon = require('../ui/Icon.js');
-var index = require('./bundle-DNeYPS8V.js');
-var LocalizationContext = require('./bundle-B0aJPqBG.js');
+var index = require('./bundle-DXUzHTvV.js');
+var LocalizationContext = require('./bundle-vG8MHa_f.js');
 var SendbirdChat = require('@sendbird/chat');
-var useSendbird = require('./bundle-BJ0hFNf4.js');
+var useSendbird = require('./bundle-BD4O00Pv.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -216,4 +216,4 @@ var MessageMenu = function (_a) {
 };
 
 exports.MessageMenu = MessageMenu;
-//# sourceMappingURL=bundle-BZds40K8.js.map
+//# sourceMappingURL=bundle-B2xreZua.js.map

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

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

package/cjs/chunks/{bundle-ByHilW6t.js → bundle-B3Rdhix2.js}

@@ -1,8 +1,8 @@
 'use strict';
 
-var index$1 = require('./bundle-Bq9ZezMR.js');
-var index = require('./bundle-8Ix_bYQH.js');
-var index$2 = require('./bundle-CFoJcGT-.js');
+var index$1 = require('./bundle-DZahLWKR.js');
+var index = require('./bundle-C2k-Mktk.js');
+var index$2 = require('./bundle-BDTKZAMh.js');
 
 /**
  * @name isToday
@@ -167,4 +167,4 @@ function isYesterday(dirtyDate) {
 exports.isThisYear = isThisYear;
 exports.isToday = isToday;
 exports.isYesterday = isYesterday;
-//# sourceMappingURL=bundle-ByHilW6t.js.map
+//# sourceMappingURL=bundle-B3Rdhix2.js.map

package/cjs/chunks/{bundle-ByHilW6t.js.map → bundle-B3Rdhix2.js.map}

@@ -1 +1 @@
-{"version":3,"file":"bundle-ByHilW6t.js","sources":["../../../node_modules/date-fns/esm/isToday/index.js","../../../node_modules/date-fns/esm/isSameYear/index.js","../../../node_modules/date-fns/esm/isThisYear/index.js","../../../node_modules/date-fns/esm/addDays/index.js","../../../node_modules/date-fns/esm/subDays/index.js","../../../node_modules/date-fns/esm/isYesterday/index.js"],"sourcesContent":["import isSameDay from \"../isSameDay/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name isToday\n * @category Day Helpers\n * @summary Is the given date today?\n * @pure false\n *\n * @description\n * Is the given date today?\n *\n * > ⚠️ Please note that this function is not present in the FP submodule as\n * > it uses `Date.now()` internally hence impure and can't be safely curried.\n *\n * @param {Date|Number} date - the date to check\n * @returns {Boolean} the date is today\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // If today is 6 October 2014, is 6 October 14:00:00 today?\n * const result = isToday(new Date(2014, 9, 6, 14, 0))\n * //=> true\n */\nexport default function isToday(dirtyDate) {\n  requiredArgs(1, arguments);\n  return isSameDay(dirtyDate, Date.now());\n}","import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name isSameYear\n * @category Year Helpers\n * @summary Are the given dates in the same year?\n *\n * @description\n * Are the given dates in the same year?\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 year\n * @throws {TypeError} 2 arguments required\n *\n * @example\n * // Are 2 September 2014 and 25 September 2014 in the same year?\n * const result = isSameYear(new Date(2014, 8, 2), new Date(2014, 8, 25))\n * //=> true\n */\nexport default function isSameYear(dirtyDateLeft, dirtyDateRight) {\n  requiredArgs(2, arguments);\n  var dateLeft = toDate(dirtyDateLeft);\n  var dateRight = toDate(dirtyDateRight);\n  return dateLeft.getFullYear() === dateRight.getFullYear();\n}","import isSameYear from \"../isSameYear/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name isThisYear\n * @category Year Helpers\n * @summary Is the given date in the same year as the current date?\n * @pure false\n *\n * @description\n * Is the given date in the same year as the current date?\n *\n * > ⚠️ Please note that this function is not present in the FP submodule as\n * > it uses `Date.now()` internally hence impure and can't be safely curried.\n *\n * @param {Date|Number} date - the date to check\n * @returns {Boolean} the date is in this year\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // If today is 25 September 2014, is 2 July 2014 in this year?\n * const result = isThisYear(new Date(2014, 6, 2))\n * //=> true\n */\nexport default function isThisYear(dirtyDate) {\n  requiredArgs(1, arguments);\n  return isSameYear(dirtyDate, Date.now());\n}","import toInteger from \"../_lib/toInteger/index.js\";\nimport toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name addDays\n * @category Day Helpers\n * @summary Add the specified number of days to the given date.\n *\n * @description\n * Add the specified number of days to the given date.\n *\n * @param {Date|Number} date - the date to be changed\n * @param {Number} amount - the amount of days to be added. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.\n * @returns {Date} - the new date with the days added\n * @throws {TypeError} - 2 arguments required\n *\n * @example\n * // Add 10 days to 1 September 2014:\n * const result = addDays(new Date(2014, 8, 1), 10)\n * //=> Thu Sep 11 2014 00:00:00\n */\nexport default function addDays(dirtyDate, dirtyAmount) {\n  requiredArgs(2, arguments);\n  var date = toDate(dirtyDate);\n  var amount = toInteger(dirtyAmount);\n  if (isNaN(amount)) {\n    return new Date(NaN);\n  }\n  if (!amount) {\n    // If 0 days, no-op to avoid changing times in the hour before end of DST\n    return date;\n  }\n  date.setDate(date.getDate() + amount);\n  return date;\n}","import addDays from \"../addDays/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\nimport toInteger from \"../_lib/toInteger/index.js\";\n/**\n * @name subDays\n * @category Day Helpers\n * @summary Subtract the specified number of days from the given date.\n *\n * @description\n * Subtract the specified number of days from the given date.\n *\n * @param {Date|Number} date - the date to be changed\n * @param {Number} amount - the amount of days to be subtracted. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.\n * @returns {Date} the new date with the days subtracted\n * @throws {TypeError} 2 arguments required\n *\n * @example\n * // Subtract 10 days from 1 September 2014:\n * const result = subDays(new Date(2014, 8, 1), 10)\n * //=> Fri Aug 22 2014 00:00:00\n */\nexport default function subDays(dirtyDate, dirtyAmount) {\n  requiredArgs(2, arguments);\n  var amount = toInteger(dirtyAmount);\n  return addDays(dirtyDate, -amount);\n}","import isSameDay from \"../isSameDay/index.js\";\nimport subDays from \"../subDays/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name isYesterday\n * @category Day Helpers\n * @summary Is the given date yesterday?\n * @pure false\n *\n * @description\n * Is the given date yesterday?\n *\n * > ⚠️ Please note that this function is not present in the FP submodule as\n * > it uses `Date.now()` internally hence impure and can't be safely curried.\n *\n * @param {Date|Number} date - the date to check\n * @returns {Boolean} the date is yesterday\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // If today is 6 October 2014, is 5 October 14:00:00 yesterday?\n * const result = isYesterday(new Date(2014, 9, 5, 14, 0))\n * //=> true\n */\nexport default function isYesterday(dirtyDate) {\n  requiredArgs(1, arguments);\n  return isSameDay(dirtyDate, subDays(Date.now(), 1));\n}"],"names":["requiredArgs","isSameDay","toDate","toInteger"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5]}
+{"version":3,"file":"bundle-B3Rdhix2.js","sources":["../../../node_modules/date-fns/esm/isToday/index.js","../../../node_modules/date-fns/esm/isSameYear/index.js","../../../node_modules/date-fns/esm/isThisYear/index.js","../../../node_modules/date-fns/esm/addDays/index.js","../../../node_modules/date-fns/esm/subDays/index.js","../../../node_modules/date-fns/esm/isYesterday/index.js"],"sourcesContent":["import isSameDay from \"../isSameDay/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name isToday\n * @category Day Helpers\n * @summary Is the given date today?\n * @pure false\n *\n * @description\n * Is the given date today?\n *\n * > ⚠️ Please note that this function is not present in the FP submodule as\n * > it uses `Date.now()` internally hence impure and can't be safely curried.\n *\n * @param {Date|Number} date - the date to check\n * @returns {Boolean} the date is today\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // If today is 6 October 2014, is 6 October 14:00:00 today?\n * const result = isToday(new Date(2014, 9, 6, 14, 0))\n * //=> true\n */\nexport default function isToday(dirtyDate) {\n  requiredArgs(1, arguments);\n  return isSameDay(dirtyDate, Date.now());\n}","import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name isSameYear\n * @category Year Helpers\n * @summary Are the given dates in the same year?\n *\n * @description\n * Are the given dates in the same year?\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 year\n * @throws {TypeError} 2 arguments required\n *\n * @example\n * // Are 2 September 2014 and 25 September 2014 in the same year?\n * const result = isSameYear(new Date(2014, 8, 2), new Date(2014, 8, 25))\n * //=> true\n */\nexport default function isSameYear(dirtyDateLeft, dirtyDateRight) {\n  requiredArgs(2, arguments);\n  var dateLeft = toDate(dirtyDateLeft);\n  var dateRight = toDate(dirtyDateRight);\n  return dateLeft.getFullYear() === dateRight.getFullYear();\n}","import isSameYear from \"../isSameYear/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name isThisYear\n * @category Year Helpers\n * @summary Is the given date in the same year as the current date?\n * @pure false\n *\n * @description\n * Is the given date in the same year as the current date?\n *\n * > ⚠️ Please note that this function is not present in the FP submodule as\n * > it uses `Date.now()` internally hence impure and can't be safely curried.\n *\n * @param {Date|Number} date - the date to check\n * @returns {Boolean} the date is in this year\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // If today is 25 September 2014, is 2 July 2014 in this year?\n * const result = isThisYear(new Date(2014, 6, 2))\n * //=> true\n */\nexport default function isThisYear(dirtyDate) {\n  requiredArgs(1, arguments);\n  return isSameYear(dirtyDate, Date.now());\n}","import toInteger from \"../_lib/toInteger/index.js\";\nimport toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name addDays\n * @category Day Helpers\n * @summary Add the specified number of days to the given date.\n *\n * @description\n * Add the specified number of days to the given date.\n *\n * @param {Date|Number} date - the date to be changed\n * @param {Number} amount - the amount of days to be added. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.\n * @returns {Date} - the new date with the days added\n * @throws {TypeError} - 2 arguments required\n *\n * @example\n * // Add 10 days to 1 September 2014:\n * const result = addDays(new Date(2014, 8, 1), 10)\n * //=> Thu Sep 11 2014 00:00:00\n */\nexport default function addDays(dirtyDate, dirtyAmount) {\n  requiredArgs(2, arguments);\n  var date = toDate(dirtyDate);\n  var amount = toInteger(dirtyAmount);\n  if (isNaN(amount)) {\n    return new Date(NaN);\n  }\n  if (!amount) {\n    // If 0 days, no-op to avoid changing times in the hour before end of DST\n    return date;\n  }\n  date.setDate(date.getDate() + amount);\n  return date;\n}","import addDays from \"../addDays/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\nimport toInteger from \"../_lib/toInteger/index.js\";\n/**\n * @name subDays\n * @category Day Helpers\n * @summary Subtract the specified number of days from the given date.\n *\n * @description\n * Subtract the specified number of days from the given date.\n *\n * @param {Date|Number} date - the date to be changed\n * @param {Number} amount - the amount of days to be subtracted. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.\n * @returns {Date} the new date with the days subtracted\n * @throws {TypeError} 2 arguments required\n *\n * @example\n * // Subtract 10 days from 1 September 2014:\n * const result = subDays(new Date(2014, 8, 1), 10)\n * //=> Fri Aug 22 2014 00:00:00\n */\nexport default function subDays(dirtyDate, dirtyAmount) {\n  requiredArgs(2, arguments);\n  var amount = toInteger(dirtyAmount);\n  return addDays(dirtyDate, -amount);\n}","import isSameDay from \"../isSameDay/index.js\";\nimport subDays from \"../subDays/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name isYesterday\n * @category Day Helpers\n * @summary Is the given date yesterday?\n * @pure false\n *\n * @description\n * Is the given date yesterday?\n *\n * > ⚠️ Please note that this function is not present in the FP submodule as\n * > it uses `Date.now()` internally hence impure and can't be safely curried.\n *\n * @param {Date|Number} date - the date to check\n * @returns {Boolean} the date is yesterday\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // If today is 6 October 2014, is 5 October 14:00:00 yesterday?\n * const result = isYesterday(new Date(2014, 9, 5, 14, 0))\n * //=> true\n */\nexport default function isYesterday(dirtyDate) {\n  requiredArgs(1, arguments);\n  return isSameDay(dirtyDate, subDays(Date.now(), 1));\n}"],"names":["requiredArgs","isSameDay","toDate","toInteger"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5]}