Skip to content

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

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

import {EMAIL_HTML_LAYOUTS} from '@pkgs/email/src/email_html/EmailHtmlLayouts.generated';

export type EmailTextDirection = 'ltr' | 'rtl';

const RTL_LANGUAGES = new Set(['ar', 'he']);
const LOCAL_HOSTNAMES = new Set(['localhost', '127.0.0.1', '[::1]']);
const SLOT_PATTERN = /%%([a-z0-9_]+)%%/g;
const BLOCK_PATTERN = /%%\?([a-z0-9_]+)%%([\s\S]*?)%%\/\1%%/g;
const LANG_PATTERN = /^[a-zA-Z]{2,3}(?:-[a-zA-Z0-9]{2,8})*$/;
const CHANNEL_MENTION_PATTERN = /(?<![\w/&#])#[a-z][a-z0-9-]*/g;
const LEFT_TO_RIGHT_ISOLATE = '\u2066';
const FIRST_STRONG_ISOLATE = '\u2068';
const POP_DIRECTIONAL_ISOLATE = '\u2069';
const INERT_LITERALS: ReadonlyArray<readonly [string, string]> = [
	['<', '\uE000'],
	['>', '\uE001'],
	['[', '\uE002'],
	[']', '\uE003'],
	['\\', '\uE004'],
];
const INERT_PATTERN = /[<>[\]\\]/g;
const LITERAL_PATTERN = /[\uE000-\uE004]/g;
const TO_INERT = new Map(INERT_LITERALS);
const TO_LITERAL = new Map(INERT_LITERALS.map(([literal, inert]) => [inert, literal]));
const TO_MARKDOWN_LITERAL = new Map(INERT_LITERALS.map(([literal, inert]) => [inert, `\\${literal}`]));
const HTML_ESCAPES: Record<string, string> = {
	'&': '&amp;',
	'<': '&lt;',
	'>': '&gt;',
	'"': '&quot;',
	"'": '&#39;',
};

export function getEmailTextDirection(locale: string): EmailTextDirection {
	return RTL_LANGUAGES.has(locale.split('-')[0].toLowerCase()) ? 'rtl' : 'ltr';
}

export function escapeHtml(value: string): string {
	return value.replace(/[&<>"']/g, (character) => HTML_ESCAPES[character]);
}

export function inertEmailValue(value: string): string {
	return value.replace(INERT_PATTERN, (character) => TO_INERT.get(character) ?? character);
}

export function restoreEmailLiterals(value: string): string {
	return value.replace(LITERAL_PATTERN, (character) => TO_LITERAL.get(character) ?? character);
}

export function isolateEmailValue(value: string): string {
	return `${FIRST_STRONG_ISOLATE}${value}${POP_DIRECTIONAL_ISOLATE}`;
}

function bidiIsolatesToHtml(value: string): string {
	const open: Array<boolean> = [];
	let out = '';
	for (const character of value) {
		if (character === FIRST_STRONG_ISOLATE) {
			open.push(true);
			out += '<bdi>';
		} else if (character === LEFT_TO_RIGHT_ISOLATE) {
			open.push(false);
			out += '<span dir="ltr">';
		} else if (character === POP_DIRECTIONAL_ISOLATE) {
			const isBdi = open.pop();
			if (isBdi === true) out += '</bdi>';
			else if (isBdi === false) out += '</span>';
		} else {
			out += character;
		}
	}
	return open.reduceRight((closing, isBdi) => closing + (isBdi ? '</bdi>' : '</span>'), out);
}

function escapeText(value: string): string {
	return bidiIsolatesToHtml(escapeHtml(restoreEmailLiterals(value)));
}

function hasUnsafeUrlCharacters(value: string): boolean {
	for (const character of value) {
		const code = character.codePointAt(0) ?? 0;
		if (code <= 0x20 || code === 0x7f || /\s/u.test(character)) {
			return true;
		}
	}
	return false;
}

export function validateEmailUrl(value: string, ownHttpOrigins: ReadonlySet<string> = new Set()): string {
	if (hasUnsafeUrlCharacters(value)) {
		throw new Error('Email link contains whitespace or control characters');
	}
	let url: URL;
	try {
		url = new URL(value);
	} catch {
		throw new Error('Email link is not an absolute URL');
	}
	if (url.username || url.password) {
		throw new Error('Email link must not contain credentials');
	}
	const isAllowedHttp =
		url.protocol === 'http:' && (LOCAL_HOSTNAMES.has(url.hostname) || ownHttpOrigins.has(url.origin));
	if (url.protocol !== 'https:' && !isAllowedHttp) {
		throw new Error(`Email link must use https: ${url.protocol}`);
	}
	return value;
}

function isolateChannelMentions(value: string): string {
	return value.replace(
		CHANNEL_MENTION_PATTERN,
		(mention) => `${LEFT_TO_RIGHT_ISOLATE}${mention}${POP_DIRECTIONAL_ISOLATE}`,
	);
}

type Slots = Readonly<Record<string, string | null | undefined>>;

interface InlineLink {
	anchor: string;
	url: string | null;
}

type InlinePart = string | InlineLink;

const INLINE_PATTERN = /<(mail|settings|dsa|arn|labs)>([^<]*)<\/\1>|\[([^\]\n]+)\]\(([^)\s]+)\)/g;
const CITED_LINK_HOSTS = ['digital-strategy.ec.europa.eu', 'www.arn.se'];

export function emailLinkHosts(baseUrls: ReadonlyArray<string>): ReadonlySet<string> {
	const hosts = new Set(CITED_LINK_HOSTS);
	for (const base of baseUrls) {
		if (URL.canParse(base)) {
			hosts.add(new URL(base).host);
		}
	}
	return hosts;
}
const EMAIL_PATTERN = /^[^\s@<>()]+@[^\s@<>()]+\.[^\s@<>()]+$/;

function inlineParts(
	text: string,
	slots: Slots,
	checkUrl: ((url: string) => string) | null,
	linkHosts: ReadonlySet<string> | null = null,
): Array<InlinePart> {
	const parts: Array<InlinePart> = [];
	let last = 0;
	for (const match of text.matchAll(INLINE_PATTERN)) {
		const index = match.index ?? 0;
		parts.push(text.slice(last, index));
		last = index + match[0].length;
		if (match[1]) {
			const [, tag, anchor] = match;
			if (tag === 'mail') {
				if (!EMAIL_PATTERN.test(anchor) && checkUrl) {
					throw new Error(`Email link tag holds no address: ${anchor}`);
				}
				parts.push({anchor, url: `mailto:${anchor}`});
				continue;
			}
			const url = slots[`${tag}_url`];
			if (!url && checkUrl) {
				throw new Error(`Email link tag <${tag}> has no ${tag}_url slot`);
			}
			parts.push({anchor, url: url && checkUrl ? checkUrl(url) : (url ?? null)});
			continue;
		}
		const [whole, , , anchor, url] = match;
		if (linkHosts && !(URL.canParse(url) && linkHosts.has(new URL(url).host))) {
			parts.push(whole);
			continue;
		}
		try {
			parts.push({anchor, url: checkUrl ? checkUrl(url) : url});
		} catch {
			parts.push(whole);
		}
	}
	parts.push(text.slice(last));
	return parts.filter((part) => part !== '');
}

function inlineHtml(
	text: string,
	slots: Slots,
	direction: EmailTextDirection,
	ownHttpOrigins: ReadonlySet<string>,
	linkHosts: ReadonlySet<string>,
) {
	return inlineParts(text, slots, (url) => validateEmailUrl(url, ownHttpOrigins), linkHosts)
		.map((part) => {
			if (typeof part === 'string') {
				return escapeText(direction === 'rtl' ? isolateChannelMentions(part) : part);
			}
			const href = part.url ?? '';
			const dir = href.startsWith('mailto:') ? ' dir="ltr"' : '';
			return `<a href="${escapeHtml(href)}" class="x-link"${dir} style="color:#4641d9">${escapeText(part.anchor)}</a>`;
		})
		.join('');
}

function paragraphs(value: string): Array<string> {
	return value
		.split(/\r?\n/)
		.map((line) => line.trim())
		.filter(Boolean);
}

function encodeSlot(
	name: string,
	value: string,
	slots: Slots,
	direction: EmailTextDirection,
	ownHttpOrigins: ReadonlySet<string>,
	linkHosts: ReadonlySet<string>,
): string {
	if (name === 'lang') {
		if (!LANG_PATTERN.test(value)) {
			throw new Error(`Invalid email language tag: ${value}`);
		}
		return value;
	}
	if (name.endsWith('_url')) {
		return escapeHtml(validateEmailUrl(value, ownHttpOrigins));
	}
	if (name === 'subject' || name === 'preheader' || name === 'heading' || name === 'code' || name.endsWith('_label')) {
		const literal = restoreEmailLiterals(value);
		return escapeHtml(direction === 'rtl' ? isolateChannelMentions(literal) : literal);
	}
	if (name.endsWith('_list')) {
		return paragraphs(value)
			.map((item) => `<li style="margin:0 0 6px">${inlineHtml(item, slots, direction, ownHttpOrigins, linkHosts)}</li>`)
			.join('');
	}
	if (/^(fact_\d+|sum_\d+|sum_total)_value$/.test(name)) {
		const lines = paragraphs(value).map((line) =>
			inlineHtml(direction === 'rtl' ? isolateEmailValue(line) : line, slots, direction, ownHttpOrigins, linkHosts),
		);
		return lines.length === 1 ? lines[0] : lines.map((line) => `<div>${line}</div>`).join('');
	}
	const blocks = paragraphs(value);
	if (blocks.length <= 1) {
		return inlineHtml(blocks[0] ?? '', slots, direction, ownHttpOrigins, linkHosts);
	}
	return blocks
		.map(
			(block, index) =>
				`<p style="margin:${index === 0 ? 0 : '12px 0 0'}">${inlineHtml(block, slots, direction, ownHttpOrigins, linkHosts)}</p>`,
		)
		.join('');
}

export function renderEmailHtml(
	direction: EmailTextDirection,
	slots: Slots,
	ownHttpOrigins: ReadonlySet<string> = new Set(),
	linkHosts: ReadonlySet<string> = new Set(CITED_LINK_HOSTS),
): string {
	let html: string = EMAIL_HTML_LAYOUTS.message[direction];
	for (let previous = ''; previous !== html; ) {
		previous = html;
		html = html.replace(BLOCK_PATTERN, (_match, name: string, inner: string) => (slots[name] ? inner : ''));
	}
	return html.replace(SLOT_PATTERN, (_match, name: string) => {
		const value = slots[name];
		if (typeof value !== 'string') {
			throw new Error(`Missing email layout slot ${name}`);
		}
		return encodeSlot(name, value, slots, direction, ownHttpOrigins, linkHosts);
	});
}

export type EmailTextLinks = 'plain' | 'markdown';

export function stripInlineMarkup(text: string): string {
	return inlineParts(text, {}, null)
		.map((part) => (typeof part === 'string' ? part : part.anchor))
		.join('');
}

const FACT_COUNT = 7;
const SUMMARY_COUNT = 7;
const SUMMARY_TOTAL_AFTER = 5;
const SECTION_COUNT = 4;

function textInline(text: string, slots: Slots, links: EmailTextLinks): {line: string; urls: Array<string>} {
	const urls: Array<string> = [];
	const line = inlineParts(text, slots, null)
		.map((part) => {
			if (typeof part === 'string') {
				return part;
			}
			if (!part.url || part.url.startsWith('mailto:')) {
				return part.anchor;
			}
			if (links === 'markdown') {
				return `[${part.anchor}](${part.url})`;
			}
			urls.push(part.url);
			return part.anchor;
		})
		.join('');
	return {line, urls};
}

function textParagraphs(value: string | null | undefined, slots: Slots, links: EmailTextLinks): string | null {
	if (!value) {
		return null;
	}
	return paragraphs(value)
		.map((block) => {
			const {line, urls} = textInline(block, slots, links);
			return [line, ...urls].join('\n');
		})
		.join('\n\n');
}

function textList(value: string | null | undefined, slots: Slots, links: EmailTextLinks): string | null {
	if (!value) {
		return null;
	}
	return paragraphs(value)
		.map((item) => {
			const {line, urls} = textInline(item, slots, links);
			return [`- ${line}`, ...urls.map((url) => `  ${url}`)].join('\n');
		})
		.join('\n');
}

function textLink(label: string | null | undefined, url: string | null | undefined, links: EmailTextLinks) {
	if (!label || !url) {
		return null;
	}
	return links === 'markdown' ? `[${label}](${url})` : `${label}\n${url}`;
}

function textBlock(...lines: Array<string | null | undefined>): string {
	return lines.filter((line): line is string => Boolean(line)).join('\n');
}

export function renderEmailText(slots: Slots, links: EmailTextLinks = 'plain'): string {
	const facts: Array<string> = [];
	for (let n = 1; n <= FACT_COUNT; n++) {
		const label = slots[`fact_${n}_label`];
		const value = slots[`fact_${n}_value`] ?? slots[`fact_${n}_link`];
		if (!label || !value) {
			continue;
		}
		const url = slots[`fact_${n}_link_url`];
		if (slots[`fact_${n}_link`] && url) {
			facts.push(links === 'markdown' ? `${label}: [${value}](${url})` : `${label}: ${value}\n${url}`);
			continue;
		}
		const {line, urls} = textInline(paragraphs(value).join('\n'), slots, links);
		facts.push([`${label}: ${line}`, ...urls].join('\n'));
	}
	const summary: Array<string> = [];
	const summaryLine = (label: string | null | undefined, value: string | null | undefined) => {
		if (label && value) {
			summary.push(`${label}: ${paragraphs(value).join(' ')}`);
		}
	};
	for (let n = 1; n <= SUMMARY_COUNT; n++) {
		summaryLine(slots[`sum_${n}_label`], slots[`sum_${n}_value`]);
		if (n === SUMMARY_TOTAL_AFTER) {
			summaryLine(slots.sum_total_label, slots.sum_total_value);
			if (slots.sum_total_label && slots.sum_tax) {
				summary.push(slots.sum_tax);
			}
		}
	}
	const sections: Array<string> = [];
	for (let n = 1; n <= SECTION_COUNT; n++) {
		const title = slots[`section_${n}_title`];
		if (!title) {
			continue;
		}
		const blocks = [
			textParagraphs(slots[`section_${n}_body`], slots, links),
			textList(slots[`section_${n}_list`], slots, links),
			textParagraphs(slots[`section_${n}_note`], slots, links),
			textLink(slots[`section_${n}_link`], slots[`section_${n}_link_url`], links),
		].filter(Boolean);
		sections.push(`${title}\n${blocks.join('\n\n')}`);
	}
	const footer = textBlock(textParagraphs(slots.footer_reason, slots, links), slots.legal_address);
	const text = [
		slots.heading,
		textParagraphs(slots.intro, slots, links),
		slots.code,
		facts.join('\n'),
		summary.join('\n'),
		textList(slots.points_list, slots, links),
		textParagraphs(slots.lead, slots, links),
		textParagraphs(slots.box, slots, links),
		textLink(slots.cta, slots.cta_url, links),
		textParagraphs(slots.expiry, slots, links),
		textParagraphs(slots.text_1, slots, links),
		textParagraphs(slots.text_2, slots, links),
		...sections,
		textParagraphs(slots.note, slots, links),
		textLink(slots.end_link, slots.end_link_url, links),
		slots.signoff,
		footer,
	]
		.filter((block): block is string => Boolean(block))
		.join('\n\n');
	if (links === 'markdown') {
		return text.replace(LITERAL_PATTERN, (character) => TO_MARKDOWN_LITERAL.get(character) ?? character);
	}
	return restoreEmailLiterals(text);
}