stream-chat-react 11.20.0 → 12.0.0-rc.1

package/dist/components/MessageInput/hooks/useMessageInputText.js

@@ -1,25 +1,25 @@
 import { useCallback, useEffect, useRef } from 'react';
 import { logChatPromiseExecution } from 'stream-chat';
 import { useChannelStateContext } from '../../../context/ChannelStateContext';
-export var useMessageInputText = function (props, state, dispatch, findAndEnqueueURLsToEnrich) {
-    var channel = useChannelStateContext('useMessageInputText').channel;
-    var additionalTextareaProps = props.additionalTextareaProps, focus = props.focus, parent = props.parent, _a = props.publishTypingEvent, publishTypingEvent = _a === void 0 ? true : _a;
-    var text = state.text;
-    var textareaRef = useRef();
+export const useMessageInputText = (props, state, dispatch, findAndEnqueueURLsToEnrich) => {
+    const { channel } = useChannelStateContext('useMessageInputText');
+    const { additionalTextareaProps, focus, parent, publishTypingEvent = true } = props;
+    const { text } = state;
+    const textareaRef = useRef();
     // Focus
-    useEffect(function () {
+    useEffect(() => {
         if (focus && textareaRef.current) {
             textareaRef.current.focus();
         }
     }, [focus]);
     // Text + cursor position
-    var newCursorPosition = useRef();
-    var insertText = useCallback(function (textToInsert) {
-        var maxLength = (additionalTextareaProps || {}).maxLength;
+    const newCursorPosition = useRef();
+    const insertText = useCallback((textToInsert) => {
+        const { maxLength } = additionalTextareaProps || {};
         if (!textareaRef.current) {
             return dispatch({
-                getNewText: function (text) {
-                    var updatedText = text + textToInsert;
+                getNewText: (text) => {
+                    const updatedText = text + textToInsert;
                     if (maxLength && updatedText.length > maxLength) {
                         return updatedText.slice(0, maxLength);
                     }
@@ -28,11 +28,11 @@ export var useMessageInputText = function (props, state, dispatch, findAndEnqueu
                 type: 'setText',
             });
         }
-        var _a = textareaRef.current, selectionEnd = _a.selectionEnd, selectionStart = _a.selectionStart;
+        const { selectionEnd, selectionStart } = textareaRef.current;
         newCursorPosition.current = selectionStart + textToInsert.length;
         dispatch({
-            getNewText: function (prevText) {
-                var updatedText = prevText.slice(0, selectionStart) + textToInsert + prevText.slice(selectionEnd);
+            getNewText: (prevText) => {
+                const updatedText = prevText.slice(0, selectionStart) + textToInsert + prevText.slice(selectionEnd);
                 if (maxLength && updatedText.length > maxLength) {
                     return updatedText.slice(0, maxLength);
                 }
@@ -43,34 +43,34 @@ export var useMessageInputText = function (props, state, dispatch, findAndEnqueu
     }, 
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [additionalTextareaProps, newCursorPosition, textareaRef]);
-    useEffect(function () {
-        var textareaElement = textareaRef.current;
+    useEffect(() => {
+        const textareaElement = textareaRef.current;
         if (textareaElement && newCursorPosition.current !== undefined) {
             textareaElement.selectionStart = newCursorPosition.current;
             textareaElement.selectionEnd = newCursorPosition.current;
             newCursorPosition.current = undefined;
         }
     }, [text, newCursorPosition]);
-    var handleChange = useCallback(function (event) {
+    const handleChange = useCallback((event) => {
         event.preventDefault();
         if (!event || !event.target) {
             return;
         }
-        var newText = event.target.value;
+        const newText = event.target.value;
         dispatch({
-            getNewText: function () { return newText; },
+            getNewText: () => newText,
             type: 'setText',
         });
-        findAndEnqueueURLsToEnrich === null || findAndEnqueueURLsToEnrich === void 0 ? void 0 : findAndEnqueueURLsToEnrich(newText);
+        findAndEnqueueURLsToEnrich?.(newText);
         if (publishTypingEvent && newText && channel) {
-            logChatPromiseExecution(channel.keystroke(parent === null || parent === void 0 ? void 0 : parent.id), 'start typing event');
+            logChatPromiseExecution(channel.keystroke(parent?.id), 'start typing event');
         }
     }, 
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [channel, findAndEnqueueURLsToEnrich, parent, publishTypingEvent]);
     return {
-        handleChange: handleChange,
-        insertText: insertText,
-        textareaRef: textareaRef,
+        handleChange,
+        insertText,
+        textareaRef,
     };
 };

package/dist/components/MessageInput/hooks/usePasteHandler.d.ts

@@ -3,4 +3,3 @@ import type { EnrichURLsController } from './useLinkPreviews';
 export declare const usePasteHandler: (uploadNewFiles: (files: FileList | FileLike[] | File[]) => void, insertText: (textToInsert: string) => void, isUploadEnabled: boolean, findAndEnqueueURLsToEnrich?: EnrichURLsController['findAndEnqueueURLsToEnrich']) => {
     onPaste: (clipboardEvent: React.ClipboardEvent<HTMLTextAreaElement>) => void;
 };
-//# sourceMappingURL=usePasteHandler.d.ts.map

package/dist/components/MessageInput/hooks/usePasteHandler.js

@@ -1,58 +1,43 @@
-import { __awaiter, __generator } from "tslib";
 import { useCallback } from 'react';
-import { dataTransferItemsHaveFiles, dataTransferItemsToFiles, } from '../../ReactFileUtilities';
+import { 
+// dataTransferItemsHaveFiles,
+dataTransferItemsToFiles, } from '../../ReactFileUtilities';
 import { SetLinkPreviewMode } from '../types';
-export var usePasteHandler = function (uploadNewFiles, insertText, isUploadEnabled, findAndEnqueueURLsToEnrich) {
-    var onPaste = useCallback(function (clipboardEvent) {
-        if (!isUploadEnabled)
-            return;
-        (function (event) { return __awaiter(void 0, void 0, void 0, function () {
-            var items, plainTextPromise, _loop_1, i, state_1, fileLikes, pastedText;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        items = event.clipboardData.items;
-                        if (!dataTransferItemsHaveFiles(Array.from(items)))
-                            return [2 /*return*/];
-                        event.preventDefault();
-                        plainTextPromise = undefined;
-                        _loop_1 = function (i) {
-                            var item = items[i];
-                            if (item.kind === 'string' && item.type === 'text/plain') {
-                                plainTextPromise = new Promise(function (resolve) {
-                                    item.getAsString(function (string) {
-                                        resolve(string);
-                                    });
-                                });
-                                return "break";
-                            }
-                        };
-                        for (i = 0; i < items.length; i++) {
-                            state_1 = _loop_1(i);
-                            if (state_1 === "break")
-                                break;
-                        }
-                        return [4 /*yield*/, dataTransferItemsToFiles(Array.from(items))];
-                    case 1:
-                        fileLikes = _a.sent();
-                        if (fileLikes.length) {
-                            uploadNewFiles(fileLikes);
-                            return [2 /*return*/];
-                        }
-                        if (!plainTextPromise) return [3 /*break*/, 3];
-                        return [4 /*yield*/, plainTextPromise];
-                    case 2:
-                        pastedText = _a.sent();
-                        insertText(pastedText);
-                        findAndEnqueueURLsToEnrich === null || findAndEnqueueURLsToEnrich === void 0 ? void 0 : findAndEnqueueURLsToEnrich(pastedText, SetLinkPreviewMode.UPSERT);
-                        findAndEnqueueURLsToEnrich === null || findAndEnqueueURLsToEnrich === void 0 ? void 0 : findAndEnqueueURLsToEnrich.flush();
-                        _a.label = 3;
-                    case 3: return [2 /*return*/];
+export const usePasteHandler = (uploadNewFiles, insertText, isUploadEnabled, findAndEnqueueURLsToEnrich) => {
+    const onPaste = useCallback((clipboardEvent) => {
+        (async (event) => {
+            const { items } = event.clipboardData;
+            event.preventDefault();
+            // Get a promise for the plain text in case no files are
+            // found. This needs to be done here because chrome cleans
+            // up the DataTransferItems after resolving of a promise.
+            let plainTextPromise = undefined;
+            for (let i = 0; i < items.length; i++) {
+                const item = items[i];
+                if (item.kind === 'string' && item.type === 'text/plain') {
+                    plainTextPromise = new Promise((resolve) => {
+                        item.getAsString((string) => {
+                            resolve(string);
+                        });
+                    });
+                    break;
                 }
-            });
-        }); })(clipboardEvent);
+            }
+            const fileLikes = await dataTransferItemsToFiles(Array.from(items));
+            if (fileLikes.length && isUploadEnabled) {
+                uploadNewFiles(fileLikes);
+                return;
+            }
+            // fallback to regular text paste
+            if (plainTextPromise) {
+                const pastedText = await plainTextPromise;
+                insertText(pastedText);
+                findAndEnqueueURLsToEnrich?.(pastedText, SetLinkPreviewMode.UPSERT);
+                findAndEnqueueURLsToEnrich?.flush();
+            }
+        })(clipboardEvent);
     }, 
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [insertText, uploadNewFiles]);
-    return { onPaste: onPaste };
+    return { onPaste };
 };

package/dist/components/MessageInput/hooks/useSubmitHandler.d.ts

@@ -3,7 +3,6 @@ import type { MessageInputReducerAction, MessageInputState } from './useMessageI
 import type { MessageInputProps } from '../MessageInput';
 import type { CustomTrigger, DefaultStreamChatGenerics, SendMessageOptions } from '../../../types/types';
 import type { EnrichURLsController } from './useLinkPreviews';
-export declare const useSubmitHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics, V extends CustomTrigger = CustomTrigger>(props: MessageInputProps<StreamChatGenerics, V>, state: MessageInputState<StreamChatGenerics>, dispatch: import("react").Dispatch<MessageInputReducerAction<StreamChatGenerics>>, numberOfUploads: number, enrichURLsController: EnrichURLsController) => {
-    handleSubmit: (event?: React.BaseSyntheticEvent, customMessageData?: Partial<Message<StreamChatGenerics>> | undefined, options?: SendMessageOptions) => Promise<void>;
+export declare const useSubmitHandler: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics, V extends CustomTrigger = CustomTrigger>(props: MessageInputProps<StreamChatGenerics, V>, state: MessageInputState<StreamChatGenerics>, dispatch: React.Dispatch<MessageInputReducerAction<StreamChatGenerics>>, numberOfUploads: number, enrichURLsController: EnrichURLsController) => {
+    handleSubmit: (event?: React.BaseSyntheticEvent, customMessageData?: Partial<Message<StreamChatGenerics>>, options?: SendMessageOptions) => Promise<void>;
 };
-//# sourceMappingURL=useSubmitHandler.d.ts.map

package/dist/components/MessageInput/hooks/useSubmitHandler.js

@@ -1,191 +1,172 @@
-import { __assign, __awaiter, __generator, __rest, __spreadArray } from "tslib";
 import { useEffect, useRef } from 'react';
 import { useChannelActionContext } from '../../../context/ChannelActionContext';
 import { useChannelStateContext } from '../../../context/ChannelStateContext';
 import { useTranslationContext } from '../../../context/TranslationContext';
 import { LinkPreviewState } from '../types';
-var getAttachmentTypeFromMime = function (mime) {
+const getAttachmentTypeFromMime = (mime) => {
     if (mime.includes('video/'))
         return 'video';
     if (mime.includes('audio/'))
         return 'audio';
     return 'file';
 };
-export var useSubmitHandler = function (props, state, dispatch, numberOfUploads, enrichURLsController) {
-    var clearEditingState = props.clearEditingState, message = props.message, overrideSubmitHandler = props.overrideSubmitHandler, parent = props.parent, publishTypingEvent = props.publishTypingEvent;
-    var attachments = state.attachments, fileOrder = state.fileOrder, fileUploads = state.fileUploads, imageOrder = state.imageOrder, imageUploads = state.imageUploads, linkPreviews = state.linkPreviews, mentioned_users = state.mentioned_users, text = state.text;
-    var cancelURLEnrichment = enrichURLsController.cancelURLEnrichment, findAndEnqueueURLsToEnrich = enrichURLsController.findAndEnqueueURLsToEnrich;
-    var channel = useChannelStateContext('useSubmitHandler').channel;
-    var _a = useChannelActionContext('useSubmitHandler'), addNotification = _a.addNotification, editMessage = _a.editMessage, sendMessage = _a.sendMessage;
-    var t = useTranslationContext('useSubmitHandler').t;
-    var textReference = useRef({ hasChanged: false, initialText: text });
-    useEffect(function () {
+export const useSubmitHandler = (props, state, dispatch, numberOfUploads, enrichURLsController) => {
+    const { clearEditingState, message, overrideSubmitHandler, parent, publishTypingEvent } = props;
+    const { attachments, fileOrder, fileUploads, imageOrder, imageUploads, linkPreviews, mentioned_users, text, } = state;
+    const { cancelURLEnrichment, findAndEnqueueURLsToEnrich } = enrichURLsController;
+    const { channel } = useChannelStateContext('useSubmitHandler');
+    const { addNotification, editMessage, sendMessage } = useChannelActionContext('useSubmitHandler');
+    const { t } = useTranslationContext('useSubmitHandler');
+    const textReference = useRef({ hasChanged: false, initialText: text });
+    useEffect(() => {
         if (!textReference.current.initialText.length) {
             textReference.current.initialText = text;
             return;
         }
         textReference.current.hasChanged = text !== textReference.current.initialText;
     }, [text]);
-    var getAttachmentsFromUploads = function () {
-        var imageAttachments = imageOrder
-            .map(function (id) { return imageUploads[id]; })
-            .filter(function (upload) { return upload.state !== 'failed'; })
-            .filter(function (_a, _, self) {
-            var id = _a.id, url = _a.url;
-            return self.every(function (upload) { return upload.id === id || upload.url !== url; });
-        })
-            .filter(function (upload) {
+    const getAttachmentsFromUploads = () => {
+        const imageAttachments = imageOrder
+            .map((id) => imageUploads[id])
+            .filter((upload) => upload.state !== 'failed')
+            .filter(({ id, url }, _, self) => self.every((upload) => upload.id === id || upload.url !== url))
+            .filter((upload) => {
             // keep the OG attachments in case the text has not changed as the BE
             // won't re-enrich the message when only attachments have changed
             if (!textReference.current.hasChanged)
                 return true;
             return !upload.og_scrape_url;
         })
-            .map(function (_a) {
-            var name = _a.file.name, url = _a.url, rest = __rest(_a, ["file", "url"]);
-            return ({
-                author_name: rest.author_name,
-                fallback: name,
-                image_url: url,
-                og_scrape_url: rest.og_scrape_url,
-                text: rest.text,
-                title: rest.title,
-                title_link: rest.title_link,
-                type: 'image',
-            });
-        });
-        var fileAttachments = fileOrder
-            .map(function (id) { return fileUploads[id]; })
-            .filter(function (upload) { return upload.state !== 'failed'; })
-            .map(function (upload) { return ({
+            .map(({ file: { name }, url, ...rest }) => ({
+            author_name: rest.author_name,
+            fallback: name,
+            image_url: url,
+            og_scrape_url: rest.og_scrape_url,
+            text: rest.text,
+            title: rest.title,
+            title_link: rest.title_link,
+            type: 'image',
+        }));
+        const fileAttachments = fileOrder
+            .map((id) => fileUploads[id])
+            .filter((upload) => upload.state !== 'failed')
+            .map((upload) => ({
             asset_url: upload.url,
             file_size: upload.file.size,
             mime_type: upload.file.type,
             thumb_url: upload.thumb_url,
             title: upload.file.name,
             type: getAttachmentTypeFromMime(upload.file.type || ''),
-        }); });
-        var otherAttachments = attachments
-            .filter(function (att) { var _a; return ((_a = att.localMetadata) === null || _a === void 0 ? void 0 : _a.uploadState) !== 'failed'; })
-            .map(function (localAttachment) {
-            var _ = localAttachment.localMetadata, attachment = __rest(localAttachment, ["localMetadata"]);
+        }));
+        const otherAttachments = attachments
+            .filter((att) => att.localMetadata?.uploadState !== 'failed')
+            .map((localAttachment) => {
+            const { localMetadata: _, ...attachment } = localAttachment;
             return attachment;
         });
-        return __spreadArray(__spreadArray(__spreadArray([], otherAttachments, true), imageAttachments, true), fileAttachments, true);
+        return [...otherAttachments, ...imageAttachments, ...fileAttachments];
     };
-    var handleSubmit = function (event, customMessageData, options) { return __awaiter(void 0, void 0, void 0, function () {
-        var trimmedMessage, isEmptyMessage, someAttachmentsUploading, attachmentsFromUploads, attachmentsFromLinkPreviews, someLinkPreviewsLoading, someLinkPreviewsDismissed, newAttachments, actualMentionedUsers, updatedMessage, linkPreviewsEnabled, skip_enrich_url, sendOptions, err_1, err_2;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    event === null || event === void 0 ? void 0 : event.preventDefault();
-                    trimmedMessage = text.trim();
-                    isEmptyMessage = trimmedMessage === '' ||
-                        trimmedMessage === '>' ||
-                        trimmedMessage === '``````' ||
-                        trimmedMessage === '``' ||
-                        trimmedMessage === '**' ||
-                        trimmedMessage === '____' ||
-                        trimmedMessage === '__' ||
-                        trimmedMessage === '****';
-                    if (isEmptyMessage && numberOfUploads === 0 && attachments.length === 0)
-                        return [2 /*return*/];
-                    someAttachmentsUploading = Object.values(imageUploads).some(function (upload) { return upload.state === 'uploading'; }) ||
-                        Object.values(fileUploads).some(function (upload) { return upload.state === 'uploading'; }) ||
-                        attachments.some(function (att) { var _a; return ((_a = att.localMetadata) === null || _a === void 0 ? void 0 : _a.uploadState) === 'uploading'; });
-                    if (someAttachmentsUploading) {
-                        return [2 /*return*/, addNotification(t('Wait until all attachments have uploaded'), 'error')];
-                    }
-                    attachmentsFromUploads = getAttachmentsFromUploads();
-                    attachmentsFromLinkPreviews = [];
-                    if (findAndEnqueueURLsToEnrich) {
-                        // filter out all the attachments scraped before the message was edited - only if the scr
-                        attachmentsFromUploads = attachmentsFromUploads.filter(function (attachment) { return !attachment.og_scrape_url; });
-                        // prevent showing link preview in MessageInput after the message has been sent
-                        cancelURLEnrichment();
-                        someLinkPreviewsLoading = Array.from(linkPreviews.values()).some(function (linkPreview) {
-                            return [LinkPreviewState.QUEUED, LinkPreviewState.LOADING].includes(linkPreview.state);
-                        });
-                        someLinkPreviewsDismissed = Array.from(linkPreviews.values()).some(function (linkPreview) { return linkPreview.state === LinkPreviewState.DISMISSED; });
-                        if (!someLinkPreviewsLoading) {
-                            attachmentsFromLinkPreviews = Array.from(linkPreviews.values())
-                                .filter(function (linkPreview) {
-                                return linkPreview.state === LinkPreviewState.LOADED &&
-                                    !attachmentsFromUploads.find(function (attFromUpload) { return attFromUpload.og_scrape_url === linkPreview.og_scrape_url; });
-                            })
-                                // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                                .map(function (_a) {
-                                var linkPreviewState = _a.state, ogAttachment = __rest(_a, ["state"]);
-                                return ogAttachment;
-                            });
-                        }
-                    }
-                    newAttachments = __spreadArray(__spreadArray([], attachmentsFromUploads, true), attachmentsFromLinkPreviews, true);
-                    actualMentionedUsers = Array.from(new Set(mentioned_users.filter(function (_a) {
-                        var id = _a.id, name = _a.name;
-                        return text.includes("@".concat(id)) || text.includes("@".concat(name));
-                    })));
-                    updatedMessage = {
-                        attachments: newAttachments,
-                        mentioned_users: actualMentionedUsers,
-                        text: text,
-                    };
-                    linkPreviewsEnabled = !!findAndEnqueueURLsToEnrich;
-                    skip_enrich_url = linkPreviewsEnabled &&
-                        ((!someLinkPreviewsLoading && attachmentsFromLinkPreviews.length > 0) ||
-                            someLinkPreviewsDismissed);
-                    sendOptions = linkPreviewsEnabled || options
-                        ? Object.assign(linkPreviewsEnabled ? { skip_enrich_url: skip_enrich_url } : {}, options !== null && options !== void 0 ? options : {})
-                        : undefined;
-                    if (!(message && message.type !== 'error')) return [3 /*break*/, 5];
-                    delete message.i18n;
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, editMessage(__assign(__assign(__assign({}, message), updatedMessage), customMessageData), sendOptions)];
-                case 2:
-                    _a.sent();
-                    clearEditingState === null || clearEditingState === void 0 ? void 0 : clearEditingState();
-                    dispatch({ type: 'clear' });
-                    return [3 /*break*/, 4];
-                case 3:
-                    err_1 = _a.sent();
-                    addNotification(t('Edit message request failed'), 'error');
-                    return [3 /*break*/, 4];
-                case 4: return [3 /*break*/, 13];
-                case 5:
-                    _a.trys.push([5, 12, , 13]);
-                    dispatch({ type: 'clear' });
-                    if (!overrideSubmitHandler) return [3 /*break*/, 7];
-                    return [4 /*yield*/, overrideSubmitHandler(__assign(__assign({}, updatedMessage), { parent: parent }), channel.cid, customMessageData, sendOptions)];
-                case 6:
-                    _a.sent();
-                    return [3 /*break*/, 9];
-                case 7: return [4 /*yield*/, sendMessage(__assign(__assign({}, updatedMessage), { parent: parent }), customMessageData, sendOptions)];
-                case 8:
-                    _a.sent();
-                    _a.label = 9;
-                case 9:
-                    if (!publishTypingEvent) return [3 /*break*/, 11];
-                    return [4 /*yield*/, channel.stopTyping()];
-                case 10:
-                    _a.sent();
-                    _a.label = 11;
-                case 11: return [3 /*break*/, 13];
-                case 12:
-                    err_2 = _a.sent();
-                    dispatch({
-                        getNewText: function () { return text; },
-                        type: 'setText',
-                    });
-                    actualMentionedUsers === null || actualMentionedUsers === void 0 ? void 0 : actualMentionedUsers.forEach(function (user) {
-                        dispatch({ type: 'addMentionedUser', user: user });
-                    });
-                    addNotification(t('Send message request failed'), 'error');
-                    return [3 /*break*/, 13];
-                case 13: return [2 /*return*/];
+    const handleSubmit = async (event, customMessageData, options) => {
+        event?.preventDefault();
+        const trimmedMessage = text.trim();
+        const isEmptyMessage = trimmedMessage === '' ||
+            trimmedMessage === '>' ||
+            trimmedMessage === '``````' ||
+            trimmedMessage === '``' ||
+            trimmedMessage === '**' ||
+            trimmedMessage === '____' ||
+            trimmedMessage === '__' ||
+            trimmedMessage === '****';
+        if (isEmptyMessage && numberOfUploads === 0 && attachments.length === 0)
+            return;
+        // the channel component handles the actual sending of the message
+        const someAttachmentsUploading = Object.values(imageUploads).some((upload) => upload.state === 'uploading') ||
+            Object.values(fileUploads).some((upload) => upload.state === 'uploading') ||
+            attachments.some((att) => att.localMetadata?.uploadState === 'uploading');
+        if (someAttachmentsUploading) {
+            return addNotification(t('Wait until all attachments have uploaded'), 'error');
+        }
+        let attachmentsFromUploads = getAttachmentsFromUploads();
+        let attachmentsFromLinkPreviews = [];
+        let someLinkPreviewsLoading;
+        let someLinkPreviewsDismissed;
+        if (findAndEnqueueURLsToEnrich) {
+            // filter out all the attachments scraped before the message was edited - only if the scr
+            attachmentsFromUploads = attachmentsFromUploads.filter((attachment) => !attachment.og_scrape_url);
+            // prevent showing link preview in MessageInput after the message has been sent
+            cancelURLEnrichment();
+            someLinkPreviewsLoading = Array.from(linkPreviews.values()).some((linkPreview) => [LinkPreviewState.QUEUED, LinkPreviewState.LOADING].includes(linkPreview.state));
+            someLinkPreviewsDismissed = Array.from(linkPreviews.values()).some((linkPreview) => linkPreview.state === LinkPreviewState.DISMISSED);
+            if (!someLinkPreviewsLoading) {
+                attachmentsFromLinkPreviews = Array.from(linkPreviews.values())
+                    .filter((linkPreview) => linkPreview.state === LinkPreviewState.LOADED &&
+                    !attachmentsFromUploads.find((attFromUpload) => attFromUpload.og_scrape_url === linkPreview.og_scrape_url))
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                    .map(({ state: linkPreviewState, ...ogAttachment }) => ogAttachment);
             }
-        });
-    }); };
-    return { handleSubmit: handleSubmit };
+        }
+        const newAttachments = [...attachmentsFromUploads, ...attachmentsFromLinkPreviews];
+        // Instead of checking if a user is still mentioned every time the text changes,
+        // just filter out non-mentioned users before submit, which is cheaper
+        // and allows users to easily undo any accidental deletion
+        const actualMentionedUsers = Array.from(new Set(mentioned_users.filter(({ id, name }) => text.includes(`@${id}`) || text.includes(`@${name}`))));
+        const updatedMessage = {
+            attachments: newAttachments,
+            mentioned_users: actualMentionedUsers,
+            text,
+        };
+        // scraped attachments are added only if all enrich queries has completed. Otherwise, the scraping has to be done server-side.
+        const linkPreviewsEnabled = !!findAndEnqueueURLsToEnrich;
+        const skip_enrich_url = linkPreviewsEnabled &&
+            ((!someLinkPreviewsLoading && attachmentsFromLinkPreviews.length > 0) ||
+                someLinkPreviewsDismissed);
+        const sendOptions = linkPreviewsEnabled || options
+            ? Object.assign(linkPreviewsEnabled ? { skip_enrich_url } : {}, options ?? {})
+            : undefined;
+        if (message && message.type !== 'error') {
+            delete message.i18n;
+            try {
+                await editMessage({
+                    ...message,
+                    ...updatedMessage,
+                    ...customMessageData,
+                }, sendOptions);
+                clearEditingState?.();
+                dispatch({ type: 'clear' });
+            }
+            catch (err) {
+                addNotification(t('Edit message request failed'), 'error');
+            }
+        }
+        else {
+            try {
+                dispatch({ type: 'clear' });
+                if (overrideSubmitHandler) {
+                    await overrideSubmitHandler({
+                        ...updatedMessage,
+                        parent,
+                    }, channel.cid, customMessageData, sendOptions);
+                }
+                else {
+                    await sendMessage({
+                        ...updatedMessage,
+                        parent,
+                    }, customMessageData, sendOptions);
+                }
+                if (publishTypingEvent)
+                    await channel.stopTyping();
+            }
+            catch (err) {
+                dispatch({
+                    getNewText: () => text,
+                    type: 'setText',
+                });
+                actualMentionedUsers?.forEach((user) => {
+                    dispatch({ type: 'addMentionedUser', user });
+                });
+                addNotification(t('Send message request failed'), 'error');
+            }
+        }
+    };
+    return { handleSubmit };
 };

package/dist/components/MessageInput/hooks/useTimeElapsed.d.ts

@@ -7,4 +7,3 @@ export declare const useTimeElapsed: ({ startOnMount }?: UseTimeElapsedParams) =
     stopCounter: () => void;
 };
 export {};
-//# sourceMappingURL=useTimeElapsed.d.ts.map

package/dist/components/MessageInput/hooks/useTimeElapsed.js

@@ -1,30 +1,29 @@
 import { useCallback, useEffect, useRef, useState } from 'react';
 // todo: provide start timestamp
-export var useTimeElapsed = function (_a) {
-    var _b = _a === void 0 ? {} : _a, startOnMount = _b.startOnMount;
-    var _c = useState(0), secondsElapsed = _c[0], setSecondsElapsed = _c[1];
-    var updateInterval = useRef();
-    var startCounter = useCallback(function () {
-        updateInterval.current = setInterval(function () {
-            setSecondsElapsed(function (prev) { return prev + 1; });
+export const useTimeElapsed = ({ startOnMount } = {}) => {
+    const [secondsElapsed, setSecondsElapsed] = useState(0);
+    const updateInterval = useRef();
+    const startCounter = useCallback(() => {
+        updateInterval.current = setInterval(() => {
+            setSecondsElapsed((prev) => prev + 1);
         }, 1000);
     }, []);
-    var stopCounter = useCallback(function () {
+    const stopCounter = useCallback(() => {
         clearInterval(updateInterval.current);
     }, []);
-    useEffect(function () {
+    useEffect(() => {
         if (!startOnMount)
             return;
-        updateInterval.current = setInterval(function () {
-            setSecondsElapsed(function (prev) { return prev + 1; });
+        updateInterval.current = setInterval(() => {
+            setSecondsElapsed((prev) => prev + 1);
         }, 1000);
-        return function () {
+        return () => {
             stopCounter();
         };
     }, [startOnMount, stopCounter]);
     return {
-        secondsElapsed: secondsElapsed,
-        startCounter: startCounter,
-        stopCounter: stopCounter,
+        secondsElapsed,
+        startCounter,
+        stopCounter,
     };
 };

package/dist/components/MessageInput/hooks/useTimer.d.ts

@@ -1,4 +1,3 @@
 export declare const useTimer: ({ startFrom }: {
     startFrom: number;
 }) => number | undefined;
-//# sourceMappingURL=useTimer.d.ts.map

package/dist/components/MessageInput/hooks/useTimer.js

@@ -1,20 +1,19 @@
 import { useEffect, useState } from 'react';
-export var useTimer = function (_a) {
-    var startFrom = _a.startFrom;
-    var _b = useState(), secondsLeft = _b[0], setSecondsLeft = _b[1];
-    useEffect(function () {
-        var countdownTimeout;
+export const useTimer = ({ startFrom }) => {
+    const [secondsLeft, setSecondsLeft] = useState();
+    useEffect(() => {
+        let countdownTimeout;
         if (typeof secondsLeft === 'number' && secondsLeft > 0) {
-            countdownTimeout = setTimeout(function () {
+            countdownTimeout = setTimeout(() => {
                 setSecondsLeft(secondsLeft - 1);
             }, 1000);
         }
-        return function () {
+        return () => {
             clearTimeout(countdownTimeout);
         };
     }, [secondsLeft]);
-    useEffect(function () {
-        setSecondsLeft(startFrom !== null && startFrom !== void 0 ? startFrom : 0);
+    useEffect(() => {
+        setSecondsLeft(startFrom ?? 0);
     }, [startFrom]);
     return secondsLeft;
 };