snapshot of https://github.com/RocketChat/Rocket.Chat.git (develop, 2026-09-16; blobs > 131072B omitted)

apps/meteor/client/lib/ChatMessages.ts

@@ -0,0 +1,191 @@
+import type { DeepWritable, IMessage, IRoom, IUser } from '@rocket.chat/core-typings';
+import { isVideoConfMessage } from '@rocket.chat/core-typings';
+import type { IActionManager } from '@rocket.chat/ui-contexts';
+
+import { CurrentEditingMessage } from './CurrentEditingMessage';
+import { UserAction } from './UserAction';
+import type { ChatAPI, ComposerAPI, DataAPI } from './chats/ChatAPI';
+import { createDataAPI } from './chats/data';
+import { processMessageEditing } from './chats/flows/processMessageEditing';
+import { processMessageUploads } from './chats/flows/processMessageUploads';
+import { processSetReaction } from './chats/flows/processSetReaction';
+import { processSlashCommand } from './chats/flows/processSlashCommand';
+import { processTooLongMessage } from './chats/flows/processTooLongMessage';
+import { replyBroadcast } from './chats/flows/replyBroadcast';
+import { requestMessageDeletion } from './chats/flows/requestMessageDeletion';
+import { sendMessage } from './chats/flows/sendMessage';
+import { uploadFiles } from './chats/flows/uploadFiles';
+import { ReadStateManager } from './chats/readStateManager';
+import { setHighlightMessage } from '../views/room/MessageList/providers/messageHighlightSubscription';
+
+export class ChatMessages implements ChatAPI {
+	public uid: string | undefined;
+
+	public tmid?: IMessage['_id'];
+
+	public composer: ComposerAPI | undefined;
+
+	public setComposerAPI = (composer?: ComposerAPI): void => {
+		this.composer?.release();
+		this.composer = composer;
+	};
+
+	public data: DataAPI;
+
+	public currentEditingMessage: CurrentEditingMessage;
+
+	public readStateManager: ReadStateManager;
+
+	public ActionManager: any;
+
+	public emojiPicker: {
+		open(el: Element, cb: (emoji: string) => void): void;
+		close(): void;
+	};
+
+	public action: {
+		start(action: 'typing'): Promise<void> | void;
+		stop(action: 'typing' | 'recording' | 'uploading' | 'playing'): Promise<void> | void;
+		performContinuously(action: 'recording' | 'uploading' | 'playing'): Promise<void> | void;
+	};
+
+	public messageEditing: ChatAPI['messageEditing'] = {
+		toPreviousMessage: async () => {
+			if (!this.composer) {
+				return;
+			}
+
+			const mid = this.currentEditingMessage.getMID();
+
+			if (!mid) {
+				let lastMessage = await this.data.findPreviousOwnMessage();
+
+				// Videoconf messages should not be edited
+				if (lastMessage && isVideoConfMessage(lastMessage)) {
+					lastMessage = await this.data.findPreviousOwnMessage(lastMessage);
+				}
+
+				if (lastMessage) {
+					await this.data.saveDraft(undefined, this.composer.text);
+					await this.messageEditing.editMessage(lastMessage);
+				}
+
+				return;
+			}
+
+			const currentMessage = await this.data.findMessageByID(mid);
+			let previousMessage = currentMessage ? await this.data.findPreviousOwnMessage(currentMessage) : undefined;
+
+			// Videoconf messages should not be edited
+			if (previousMessage && isVideoConfMessage(previousMessage)) {
+				previousMessage = await this.data.findPreviousOwnMessage(previousMessage);
+			}
+
+			if (previousMessage) {
+				await this.messageEditing.editMessage(previousMessage);
+				return;
+			}
+
+			await this.currentEditingMessage.cancel();
+			await this.currentEditingMessage.stop();
+		},
+		toNextMessage: async () => {
+			const mid = this.currentEditingMessage.getMID();
+
+			if (!this.composer || !mid) {
+				return;
+			}
+
+			const currentMessage = await this.data.findMessageByID(mid);
+			let nextMessage = currentMessage ? await this.data.findNextOwnMessage(currentMessage) : undefined;
+
+			// Videoconf messages should not be edited
+			if (nextMessage && isVideoConfMessage(nextMessage)) {
+				nextMessage = await this.data.findNextOwnMessage(nextMessage);
+			}
+
+			if (nextMessage) {
+				await this.messageEditing.editMessage(nextMessage, { cursorAtStart: true });
+				return;
+			}
+
+			await this.currentEditingMessage.cancel();
+			await this.currentEditingMessage.stop();
+		},
+		editMessage: async (message: IMessage, { cursorAtStart = false }: { cursorAtStart?: boolean } = {}) => {
+			this.composer?.uploads.clear();
+			const text = (await this.data.getDraft(message._id)) || message.attachments?.[0]?.description || message.msg;
+
+			await this.currentEditingMessage.stop();
+
+			if (!this.composer || !(await this.data.canUpdateMessage(message))) {
+				return;
+			}
+
+			this.currentEditingMessage.setMID(message._id);
+			setHighlightMessage(message._id);
+			this.composer.setEditingMode(true);
+
+			this.composer.setText(text);
+			cursorAtStart && this.composer.setCursorToStart();
+			!cursorAtStart && this.composer.setCursorToEnd();
+			this.composer.focus();
+		},
+	};
+
+	public flows: DeepWritable<ChatAPI['flows']>;
+
+	public constructor(params: { rid: IRoom['_id']; tmid?: IMessage['_id']; uid: IUser['_id'] | undefined; actionManager: IActionManager }) {
+		const { rid, tmid } = params;
+		this.tmid = tmid;
+		this.uid = params.uid;
+		this.data = createDataAPI({ rid, tmid });
+		this.ActionManager = params.actionManager;
+		this.currentEditingMessage = new CurrentEditingMessage(this);
+
+		const unimplemented = () => {
+			throw new Error('Flow is not implemented');
+		};
+
+		this.readStateManager = new ReadStateManager(rid);
+
+		this.emojiPicker = {
+			open: unimplemented,
+			close: unimplemented,
+		};
+
+		this.action = {
+			start: async (action: 'typing') => {
+				UserAction.start(params.rid, `user-${action}`, { tmid: params.tmid });
+			},
+			performContinuously: async (action: 'recording' | 'uploading' | 'playing') => {
+				UserAction.performContinuously(params.rid, `user-${action}`, { tmid: params.tmid });
+			},
+			stop: async (action: 'typing' | 'recording' | 'uploading' | 'playing') => {
+				UserAction.stop(params.rid, `user-${action}`, { tmid: params.tmid });
+			},
+		};
+
+		this.flows = {
+			uploadFiles: uploadFiles.bind(null, this),
+			sendMessage: sendMessage.bind(this, this),
+			processSlashCommand: processSlashCommand.bind(null, this),
+			processTooLongMessage: processTooLongMessage.bind(null, this),
+			processMessageEditing: processMessageEditing.bind(null, this),
+			processMessageUploads: processMessageUploads.bind(null, this),
+			processSetReaction: processSetReaction.bind(null, this),
+			requestMessageDeletion: requestMessageDeletion.bind(this, this),
+			replyBroadcast: replyBroadcast.bind(null, this),
+		};
+	}
+
+	public async release() {
+		if (this.currentEditingMessage.getMID()) {
+			if (!this.tmid) {
+				await this.currentEditingMessage.cancel();
+				await this.currentEditingMessage.stop();
+			}
+			this.composer?.clear();
+		}
+	}
+}