upstream-rocketchat/apps/meteor/client/lib/parseMessageTextToAstMarkdown.ts

import type { IMessage, ITranslatedMessage, MessageAttachment } from '@rocket.chat/core-typings';
import {
	isFileAttachment,
	isE2EEMessage,
	isQuoteAttachment,
	isTranslatedAttachment,
	isTranslatedMessage,
	isEncryptedMessageAttachment,
} from '@rocket.chat/core-typings';
import type { Options, Root } from '@rocket.chat/message-parser';
import { parse } from '@rocket.chat/message-parser';

import { getMarkdownParserLimit } from './getMarkdownParserLimit';
import { toPlainTextRoot } from './toPlainTextRoot';
import type { AutoTranslateOptions } from '../views/room/MessageList/hooks/useAutoTranslate';
import { isParsedMessage } from '../views/room/MessageList/lib/isParsedMessage';

type WithRequiredProperty<Type, Key extends keyof Type> = Omit<Type, Key> & {
	[Property in Key]-?: Type[Property];
};

export type MessageWithMdEnforced<TMessage extends IMessage & Partial<ITranslatedMessage> = IMessage & Partial<ITranslatedMessage>> =
	WithRequiredProperty<TMessage, 'md'> & {
		/** The exact source text `md` was parsed from (translation-aware), so its `fallback` offsets can be sliced. */
		mdSource?: string;
	};
/**
 * Removes null values for known properties values.
 * Adds a property `md` to the message with the parsed message if is not provided.
 * if has `attachments` property, but attachment is missing `md` property, it will be added.
 * if translation is enabled and message contains `translations` property, it will be replaced by the parsed message.
 * @param message The message to be parsed.
 * @param parseOptions The options to be used in the parser.
 * @param autoTranslateOptions The auto translate options to be used in the parser.
 * @returns message normalized.
 */
export const parseMessageTextToAstMarkdown = <
	TMessage extends IMessage & Partial<ITranslatedMessage> = IMessage & Partial<ITranslatedMessage>,
>(
	message: TMessage,
	parseOptions: Options,
	autoTranslateOptions: AutoTranslateOptions,
): MessageWithMdEnforced => {
	const msg = removePossibleNullMessageValues(message);
	const { showAutoTranslate, autoTranslateLanguage } = autoTranslateOptions;
	const translations = autoTranslateLanguage && isTranslatedMessage(msg) && msg.translations;
	const translated = showAutoTranslate(message);

	const text = (translated && translations && translations[autoTranslateLanguage]) || msg.msg;

	return {
		...msg,
		md: isE2EEMessage(message) || translated ? textToMessageToken(text, parseOptions) : (msg.md ?? textToMessageToken(text, parseOptions)),
		// `text` is the exact string `md` was parsed from (translation/E2EE-aware, and equal to
		// `msg.msg` otherwise), so block `fallback` offsets slice against the right source.
		mdSource: text,
		...(msg.attachments && {
			attachments: parseMessageAttachments(msg.attachments, parseOptions, { autoTranslateLanguage, translated }),
		}),
	};
};

export const parseMessageAttachment = <T extends MessageAttachment>(
	attachment: T,
	parseOptions: Options,
	autoTranslateOptions: { autoTranslateLanguage?: string; translated: boolean },
): T => {
	const { translated, autoTranslateLanguage } = autoTranslateOptions;
	if (!attachment.text && !attachment.description) {
		return attachment;
	}

	if (isQuoteAttachment(attachment) && attachment.attachments) {
		attachment.attachments = parseMessageAttachments(attachment.attachments, parseOptions, autoTranslateOptions);
	}

	const text =
		(isTranslatedAttachment(attachment) && autoTranslateLanguage && attachment?.translations?.[autoTranslateLanguage]) ||
		attachment.text ||
		attachment.description ||
		'';

	if (isFileAttachment(attachment) && attachment.description) {
		attachment.descriptionMd =
			translated || isEncryptedMessageAttachment(attachment)
				? textToMessageToken(text, parseOptions)
				: (attachment.descriptionMd ?? textToMessageToken(text, parseOptions));
	}

	return {
		...attachment,
		md: translated ? textToMessageToken(text, parseOptions) : (attachment.md ?? textToMessageToken(text, parseOptions)),
	};
};

export const parseMessageAttachments = <T extends MessageAttachment>(
	attachments: T[],
	parseOptions: Options,
	autoTranslateOptions: { autoTranslateLanguage?: string; translated: boolean },
): T[] => attachments.map((attachment) => parseMessageAttachment(attachment, parseOptions, autoTranslateOptions));

const isNotNullOrUndefined = (value: unknown): boolean => value !== null && value !== undefined;

// In a previous version of the app, some values were being set to null.
// This is a workaround to remove those null values.
// A migration script should be created to remove this code.
export const removePossibleNullMessageValues = <TMessage extends IMessage = IMessage>({
	editedBy,
	editedAt,
	emoji,
	avatar,
	alias,
	customFields,
	groupable,
	attachments,
	reactions,
	...message
}: any): TMessage => ({
	...message,
	...(isNotNullOrUndefined(editedBy) && { editedBy }),
	...(isNotNullOrUndefined(editedAt) && { editedAt }),
	...(isNotNullOrUndefined(emoji) && { emoji }),
	...(isNotNullOrUndefined(avatar) && { avatar }),
	...(isNotNullOrUndefined(alias) && { alias }),
	...(isNotNullOrUndefined(customFields) && { customFields }),
	...(isNotNullOrUndefined(groupable) && { groupable }),
	...(isNotNullOrUndefined(attachments) && { attachments }),
	...(isNotNullOrUndefined(reactions) && { reactions }),
});

const textToMessageToken = (textOrRoot: string | Root, parseOptions: Options): Root => {
	if (!textOrRoot) {
		return [];
	}

	if (isParsedMessage(textOrRoot)) {
		return textOrRoot;
	}

	const parsedMessage = textOrRoot.length > getMarkdownParserLimit() ? toPlainTextRoot(textOrRoot) : parse(textOrRoot, parseOptions);

	const parsedMessageCleaned = parsedMessage[0].type !== 'LINE_BREAK' ? parsedMessage : (parsedMessage.slice(1) as Root);

	return parsedMessageCleaned;
};