Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
13.8 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

import {Limits} from '@app/features/app/utils/UserLimits';
import editingStyles from '@app/features/channel/components/EditingMessageInput.module.css';
import {MessageCharacterCounter} from '@app/features/channel/components/MessageCharacterCounter';
import wrapperStyles from '@app/features/channel/components/textarea/InputWrapper.module.css';
import {TextareaButton} from '@app/features/channel/components/textarea/TextareaButton';
import styles from '@app/features/channel/components/textarea/TextareaInput.module.css';
import type {Channel} from '@app/features/channel/models/Channel';
import type {FlatEmoji} from '@app/features/emoji/types/EmojiTypes';
import {ExpressionPickerSheet} from '@app/features/expressions/components/modals/ExpressionPickerSheet';
import {ExpressionPickerPopout} from '@app/features/expressions/components/popouts/ExpressionPickerPopout';
import GuildVerification, {VerificationFailureReason} from '@app/features/guild/state/GuildVerification';
import {
	CANNOT_SEND_MESSAGES_IN_CHANNEL_DESCRIPTOR,
	EDIT_MESSAGE_DESCRIPTOR,
	EMOJIS_DESCRIPTOR,
} from '@app/features/i18n/utils/CommonMessageDescriptors';
import {LexicalRichInput, type LexicalRichInputHandle} from '@app/features/lexical/composer/LexicalRichInput';
import {useMarkdownKeybinds} from '@app/features/messaging/hooks/useMarkdownKeybinds';
import type {Message} from '@app/features/messaging/models/MessagingMessage';
import MessageEdit from '@app/features/messaging/state/MessageEdit';
import {applyMarkdownSegments} from '@app/features/messaging/utils/MarkdownToSegmentUtils';
import type {MentionSegment} from '@app/features/messaging/utils/TextareaSegmentManager';
import {TextareaSegmentManager} from '@app/features/messaging/utils/TextareaSegmentManager';
import {resolveTypedEmojiShortcodes} from '@app/features/messaging/utils/TypedEmojiShortcodeUtils';
import {ComponentBus} from '@app/features/platform/utils/ComponentBus';
import * as PopoutCommands from '@app/features/ui/commands/PopoutCommands';
import FocusRing from '@app/features/ui/focus_ring/FocusRing';
import {openPopout} from '@app/features/ui/popover/PopoverPopout';
import KeyboardMode from '@app/features/ui/state/KeyboardMode';
import MobileLayout from '@app/features/ui/state/MobileLayout';
import {MAX_MESSAGE_LENGTH_PREMIUM} from '@fluxer/constants/src/LimitConstants';
import {Trans, useLingui} from '@lingui/react/macro';
import {SmileyIcon} from '@phosphor-icons/react';
import {clsx} from 'clsx';
import {observer} from 'mobx-react-lite';
import type React from 'react';
import {useCallback, useEffect, useMemo, useRef, useState} from 'react';

interface EditingFocusRequest {
	requestedChannelId: string | null;
	enterKeyboardMode: boolean | null;
	channelId: string;
	messageId: string;
	editingDisabled: boolean;
	composer: LexicalRichInputHandle | null;
}

function focusEditingInput(request: EditingFocusRequest): boolean | null {
	if (
		request.requestedChannelId != null &&
		request.requestedChannelId !== '' &&
		request.requestedChannelId !== request.channelId
	) {
		return null;
	}
	if (request.editingDisabled) {
		return false;
	}
	if (!MessageEdit.isEditing(request.channelId, request.messageId)) {
		return false;
	}
	if (request.enterKeyboardMode === true) {
		KeyboardMode.enterKeyboardMode(true);
	} else {
		KeyboardMode.exitKeyboardMode();
	}
	if (request.composer != null) {
		request.composer.focus();
	}
	return true;
}

export const EditingMessageInput = observer(
	({
		channel,
		message,
		onCancel,
		onSubmit,
	}: {
		channel: Channel;
		message: Message;
		onCancel: () => void;
		onSubmit: (actualContent?: string) => void;
	}) => {
		const {i18n} = useLingui();
		const maxMessageLength = Limits.getMaxMessageLength();
		const premiumMaxLength = Limits.getStockValue('max_message_length', MAX_MESSAGE_LENGTH_PREMIUM);
		const [initial] = useState(() => {
			let wire = MessageEdit.getEditingContent(channel.id, message.id);
			if (wire == null) {
				wire = MessageEdit.getDraftContent(message.id);
			}
			if (wire == null) {
				wire = message.content;
			}
			const segments = new TextareaSegmentManager();
			const display = applyMarkdownSegments(wire, channel.guildId, segments);
			return {display, segments: segments.getSegmentsCopy(), wire};
		});
		const [actualContent, setActualContent] = useState(initial.wire);
		const resolvedContent = useMemo(
			() => resolveTypedEmojiShortcodes({content: actualContent, channel, i18n}),
			[actualContent, channel, i18n],
		);
		const composerRef = useRef<LexicalRichInputHandle | null>(null);
		const containerRef = useRef<HTMLDivElement>(null);
		const editableRef = useRef<HTMLElement | null>(null);
		const expressionPickerTriggerRef = useRef<HTMLButtonElement>(null);
		const [expressionPickerOpen, setExpressionPickerOpen] = useState(false);
		const [isFocused, setIsFocused] = useState(false);
		const hasFocusedInitiallyRef = useRef(false);
		const mobileLayout = MobileLayout;
		useMarkdownKeybinds(isFocused, {preserveEditableFocusActions: false});
		const editingDisabled =
			channel.guildId != null &&
			GuildVerification.getFailureReason(channel.guildId) === VerificationFailureReason.TIMED_OUT;
		let placeholderText = '';
		if (editingDisabled) {
			placeholderText = i18n._(CANNOT_SEND_MESSAGES_IN_CHANNEL_DESCRIPTOR);
		}
		useEffect(() => {
			const container = containerRef.current;
			if (container == null) {
				editableRef.current = null;
				return;
			}
			const editable = container.querySelector<HTMLElement>('[data-channel-textarea]');
			if (editable == null) {
				editableRef.current = null;
				return;
			}
			editableRef.current = editable;
		}, []);
		const handleChange = useCallback(
			(_display: string, _segments: Array<MentionSegment>, wire: string) => {
				setActualContent(wire);
				MessageEdit.setEditingContent(channel.id, message.id, wire);
			},
			[channel.id, message.id],
		);
		const handleEmojiSelect = useCallback((emoji: FlatEmoji) => {
			const composer = composerRef.current;
			if (composer != null) {
				composer.insertEmoji(emoji);
			}
		}, []);
		const handleSubmit = useCallback(() => {
			if (editingDisabled || resolvedContent.length > maxMessageLength) {
				return;
			}
			onSubmit(resolvedContent);
		}, [editingDisabled, maxMessageLength, onSubmit, resolvedContent]);
		const handleKeyDown = useCallback(
			(event: React.KeyboardEvent<HTMLElement>) => {
				if (event.defaultPrevented) {
					return;
				}
				if (event.key === 'Escape' && !event.shiftKey && !event.defaultPrevented && !event.nativeEvent.isComposing) {
					event.preventDefault();
					event.stopPropagation();
					onCancel();
				}
			},
			[actualContent, onCancel],
		);
		useEffect(() => {
			if (editingDisabled || hasFocusedInitiallyRef.current) {
				return;
			}
			hasFocusedInitiallyRef.current = true;
			requestAnimationFrame(() => {
				const composer = composerRef.current;
				if (composer != null) {
					composer.focus();
				}
			});
		}, [editingDisabled]);
		useEffect(() => {
			if (!editingDisabled) {
				return;
			}
			const container = containerRef.current;
			const active = document.activeElement;
			if (container != null && active instanceof HTMLElement && container.contains(active)) {
				active.blur();
			}
			PopoutCommands.close(`editing-expression-picker-${channel.id}`);
			setExpressionPickerOpen(false);
		}, [channel.id, editingDisabled]);
		useEffect(() => {
			const unsubscribe = ComponentBus.subscribe('FOCUS_TEXTAREA', (payload?: unknown) => {
				const data = payload as {channelId?: string; enterKeyboardMode?: boolean} | undefined;
				let requestedChannelId: string | null = null;
				let enterKeyboardMode: boolean | null = null;
				if (data != null) {
					if (data.channelId != null) {
						requestedChannelId = data.channelId;
					}
					if (data.enterKeyboardMode != null) {
						enterKeyboardMode = data.enterKeyboardMode;
					}
				}
				return focusEditingInput({
					requestedChannelId,
					enterKeyboardMode,
					channelId: channel.id,
					messageId: message.id,
					editingDisabled,
					composer: composerRef.current,
				});
			});
			return unsubscribe;
		}, [channel.id, editingDisabled, message.id]);
		const handleExpressionPickerToggle = useCallback(() => {
			if (editingDisabled) {
				return;
			}
			const triggerElement = expressionPickerTriggerRef.current;
			if (triggerElement == null) {
				return;
			}
			const popoutKey = `editing-expression-picker-${channel.id}`;
			if (expressionPickerOpen) {
				PopoutCommands.close(popoutKey);
				setExpressionPickerOpen(false);
				return;
			}
			openPopout(
				triggerElement,
				{
					render: ({onClose}) => (
						<ExpressionPickerPopout
							channelId={channel.id}
							onEmojiSelect={handleEmojiSelect}
							onClose={onClose}
							visibleTabs={['emojis']}
							data-flx="channel.editing-message-input.handle-expression-picker-toggle.expression-picker-popout"
						/>
					),
					position: 'top-end',
					animationType: 'none',
					offsetCrossAxis: 16,
					onOpen: () => setExpressionPickerOpen(true),
					onClose: () => setExpressionPickerOpen(false),
					returnFocusRef: editableRef,
				},
				popoutKey,
			);
		}, [channel.id, editingDisabled, expressionPickerOpen, handleEmojiSelect]);
		useEffect(() => {
			const unsubscribe = ComponentBus.subscribe('EDITING_EXPRESSION_PICKER_TAB_TOGGLE', (payload?: unknown) => {
				const data = payload as {channelId?: string; messageId?: string; tab?: string} | undefined;
				if (data == null || data.channelId !== channel.id || data.messageId !== message.id || data.tab !== 'emojis') {
					return;
				}
				handleExpressionPickerToggle();
			});
			return unsubscribe;
		}, [channel.id, handleExpressionPickerToggle, message.id]);
		let expressionPickerButtonRef: React.Ref<HTMLButtonElement> | undefined;
		if (!mobileLayout.enabled) {
			expressionPickerButtonRef = expressionPickerTriggerRef;
		}
		let handleExpressionPickerButtonClick = handleExpressionPickerToggle;
		if (mobileLayout.enabled) {
			handleExpressionPickerButtonClick = () => setExpressionPickerOpen(true);
		}
		let displayContentLength = resolvedContent.length;
		if (editingDisabled) {
			displayContentLength = 0;
		}
		return (
			<>
				<FocusRing within={true} offset={-2} data-flx="channel.editing-message-input.focus-ring">
					<div
						ref={containerRef}
						className={styles.textareaContainer}
						data-flx="channel.editing-message-input.textarea-container"
					>
						<div
							className={clsx(styles.mainWrapperEditing, editingDisabled && wrapperStyles.disabled)}
							data-flx="channel.editing-message-input.main-wrapper-editing"
						>
							<div className={styles.contentAreaEditing} data-flx="channel.editing-message-input.content-area-editing">
								<LexicalRichInput
									initialValue={initial.display}
									initialSegments={initial.segments}
									placeholder={placeholderText}
									disabled={editingDisabled}
									channel={channel}
									markdown={true}
									singleLine={!mobileLayout.enabled}
									size="chat"
									maxWireLength={maxMessageLength}
									className={editingStyles.editor}
									autocompleteAnchor={containerRef.current}
									ariaLabel={i18n._(EDIT_MESSAGE_DESCRIPTOR)}
									richInputRef={composerRef}
									onChange={handleChange}
									onSubmit={handleSubmit}
									onKeyDown={handleKeyDown}
									onFocus={() => setIsFocused(true)}
									onBlur={() => setIsFocused(false)}
									i18n={i18n}
									data-flx="channel.editing-message-input.lexical-rich-input.submit"
								/>
							</div>
							<div
								className={styles.buttonContainerEditing}
								data-flx="channel.editing-message-input.button-container-editing"
							>
								<TextareaButton
									ref={expressionPickerButtonRef}
									icon={SmileyIcon}
									iconProps={{weight: 'fill'}}
									label={i18n._(EMOJIS_DESCRIPTOR)}
									isSelected={expressionPickerOpen}
									compact={true}
									disabled={editingDisabled}
									data-expression-picker-tab="emojis"
									onClick={handleExpressionPickerButtonClick}
									data-flx="channel.editing-message-input.textarea-button.set-expression-picker-open"
								/>
							</div>
						</div>
						<MessageCharacterCounter
							currentLength={displayContentLength}
							maxLength={maxMessageLength}
							canUpgrade={maxMessageLength < premiumMaxLength}
							premiumMaxLength={premiumMaxLength}
							data-flx="channel.editing-message-input.message-character-counter"
						/>
					</div>
				</FocusRing>
				<div className={editingStyles.footer} data-flx="channel.editing-message-input.footer">
					<div data-flx="channel.editing-message-input.hints">
						<Trans>
							Escape to{' '}
							<FocusRing offset={-2} data-flx="channel.editing-message-input.focus-ring--2">
								<button
									type="button"
									className={editingStyles.footerLink}
									onClick={onCancel}
									key="cancel"
									data-flx="channel.editing-message-input.button.cancel"
								>
									cancel
								</button>
							</FocusRing>
						</Trans>
						<div
							aria-hidden={true}
							className={editingStyles.separator}
							data-flx="channel.editing-message-input.separator"
						/>
						<Trans>
							Enter to{' '}
							<FocusRing offset={-2} enabled={!editingDisabled} data-flx="channel.editing-message-input.focus-ring--3">
								<button
									type="button"
									className={editingStyles.footerLink}
									onClick={handleSubmit}
									disabled={editingDisabled}
									key="save"
									data-flx="channel.editing-message-input.button.submit"
								>
									save
								</button>
							</FocusRing>
						</Trans>
					</div>
				</div>
				{mobileLayout.enabled && !editingDisabled && (
					<ExpressionPickerSheet
						isOpen={expressionPickerOpen}
						onClose={() => setExpressionPickerOpen(false)}
						channelId={channel.id}
						onEmojiSelect={handleEmojiSelect}
						visibleTabs={['emojis']}
						data-flx="channel.editing-message-input.expression-picker-sheet"
					/>
				)}
			</>
		);
	},
);