Skip to content

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

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

import {readAttachmentUrlSignature} from '@app/features/messaging/utils/AttachmentCdnUrl';
import {retainImage} from '@app/features/messaging/utils/ImageRetention';
import {LRUCache} from 'lru-cache';

export interface CachedImageSize {
	width: number;
	height: number;
}

interface ImageSubscriber {
	onLoad: () => void;
	onError: (() => void) | undefined;
}

interface ImageCacheEntry {
	src: string;
	loaded: boolean;
	width: number;
	height: number;
	image: HTMLImageElement | null;
	subscribers: Set<ImageSubscriber>;
	failedAttempts: number;
	failedCycles: number;
	retryDelayMs: number;
	failedUntil: number;
	loadTimeoutId: number;
	retryTimeoutId: number;
	retryResume: (() => void) | null;
	retryOnSettle: boolean;
	connectivityListener: (() => void) | null;
}

const MAX_CACHE_ENTRIES = 1000;
const MAX_IMAGE_SOURCE_LENGTH = 16 * 1024;
const MAX_PENDING_IMAGE_CALLBACKS_PER_LOAD = 256;
const IMAGE_LOAD_TIMEOUT_MS = 30_000;
const IMAGE_RETRY_ATTEMPT_LIMIT = 2;
const IMAGE_RETRY_INITIAL_DELAY_MS = 1000;
const IMAGE_RETRY_MAX_DELAY_MS = IMAGE_RETRY_INITIAL_DELAY_MS * 10;
const IMAGE_FAILURE_INITIAL_COOLDOWN_MS = 2000;
const IMAGE_FAILURE_COOLDOWN_MS = 60_000;
const IMAGE_RECOVERY_ATTENTION_WAKE_INTERVAL_MS = 15_000;

interface ImageRecovery {
	readonly src: string;
	readonly waiters: Set<() => void>;
	timeoutId: number;
	cancelLoad: (() => void) | null;
}

const recoveries = new Map<string, ImageRecovery>();
let recoveryWakeListenersInstalled = false;
let lastAttentionWakeAt = Number.NEGATIVE_INFINITY;

const imageCache = new LRUCache<string, ImageCacheEntry>({
	max: MAX_CACHE_ENTRIES,
	disposeAfter: (entry: ImageCacheEntry) => {
		abandonEntry(entry);
	},
});

const imageSourceEncoder = new TextEncoder();

const acceptsImageSource = (src: string | null | undefined): src is string =>
	typeof src === 'string' &&
	src.length > 0 &&
	src.length <= MAX_IMAGE_SOURCE_LENGTH &&
	imageSourceEncoder.encode(src).byteLength <= MAX_IMAGE_SOURCE_LENGTH;

const isLoadedImage = (image: HTMLImageElement | null | undefined): image is HTMLImageElement =>
	image?.complete === true && image.naturalWidth > 0;

const imageHasSource = (image: HTMLImageElement, src: string): boolean => {
	if (image.currentSrc.length > 0) {
		try {
			return image.currentSrc === new URL(src, image.ownerDocument.baseURI).href;
		} catch {
			return image.currentSrc === src;
		}
	}
	if (image.getAttribute('src') === src) return true;
	return image.src === src;
};

const ownsCacheKey = (entry: ImageCacheEntry): boolean => imageCache.peek(entry.src) === entry;

const isCoolingDown = (entry: ImageCacheEntry): boolean => entry.failedUntil > Date.now();

const isLoadInFlight = (entry: ImageCacheEntry): boolean =>
	entry.image != null || entry.retryTimeoutId !== 0 || entry.connectivityListener != null;

const failureCooldownMs = (failedCycles: number): number =>
	Math.min(IMAGE_FAILURE_COOLDOWN_MS, IMAGE_FAILURE_INITIAL_COOLDOWN_MS * 2 ** Math.max(0, failedCycles - 1));

function clearRetryState(entry: ImageCacheEntry): void {
	if (entry.retryTimeoutId !== 0) {
		window.clearTimeout(entry.retryTimeoutId);
		entry.retryTimeoutId = 0;
	}
	entry.retryResume = null;
	if (entry.connectivityListener != null) {
		window.removeEventListener('online', entry.connectivityListener);
		entry.connectivityListener = null;
	}
}

function detachImageLoad(entry: ImageCacheEntry): void {
	if (entry.loadTimeoutId !== 0) {
		window.clearTimeout(entry.loadTimeoutId);
		entry.loadTimeoutId = 0;
	}
	if (entry.image != null) {
		entry.image.onload = null;
		entry.image.onerror = null;
		entry.image = null;
	}
}

function runCallbacks(callbacks: ReadonlyArray<() => void>): void {
	const failures: Array<unknown> = [];
	for (const callback of callbacks) {
		try {
			callback();
		} catch (error) {
			failures.push(error);
		}
	}
	if (failures.length > 0) throw new AggregateError(failures, 'Image load callbacks failed');
}

function notifySubscribers(entry: ImageCacheEntry, loaded: boolean): void {
	const subscribers = [...entry.subscribers];
	entry.subscribers.clear();
	runCallbacks(subscribers.map((subscriber) => (loaded ? subscriber.onLoad : (subscriber.onError ?? (() => {})))));
}

function abandonEntry(entry: ImageCacheEntry): void {
	clearRetryState(entry);
	detachImageLoad(entry);
	notifySubscribers(entry, false);
}

function dropEntry(entry: ImageCacheEntry): void {
	if (ownsCacheKey(entry)) imageCache.delete(entry.src);
	abandonEntry(entry);
}

function failEntry(entry: ImageCacheEntry): void {
	entry.failedAttempts = 0;
	entry.failedCycles += 1;
	entry.retryDelayMs = IMAGE_RETRY_INITIAL_DELAY_MS;
	entry.failedUntil = Date.now() + failureCooldownMs(entry.failedCycles);
	entry.retryOnSettle = false;
	abandonEntry(entry);
}

function settleLoaded(entry: ImageCacheEntry, image: HTMLImageElement): void {
	retainImage(image);
	clearRetryState(entry);
	detachImageLoad(entry);
	entry.loaded = true;
	entry.width = image.naturalWidth;
	entry.height = image.naturalHeight;
	entry.failedAttempts = 0;
	entry.failedCycles = 0;
	entry.retryDelayMs = IMAGE_RETRY_INITIAL_DELAY_MS;
	entry.failedUntil = 0;
	entry.retryOnSettle = false;
	try {
		notifySubscribers(entry, true);
	} finally {
		resolveRecovery(entry.src);
	}
}

function retryDelayForAttempt(entry: ImageCacheEntry): number {
	const growth = 2 * entry.retryDelayMs * Math.random();
	entry.retryDelayMs = Math.min(entry.retryDelayMs + growth, IMAGE_RETRY_MAX_DELAY_MS);
	return entry.retryDelayMs;
}

function startImageLoad(entry: ImageCacheEntry): void {
	const image = new Image();
	image.decoding = 'async';
	entry.image = image;
	entry.loadTimeoutId = window.setTimeout(() => {
		entry.loadTimeoutId = 0;
		failEntry(entry);
	}, IMAGE_LOAD_TIMEOUT_MS);
	image.onload = () => {
		detachImageLoad(entry);
		if (!isLoadedImage(image)) {
			scheduleRetryOrFail(entry);
			return;
		}
		settleLoaded(entry, image);
	};
	image.onerror = () => {
		detachImageLoad(entry);
		scheduleRetryOrFail(entry);
	};
	image.src = entry.src;
}

function hasLapsedAttachmentSignature(src: string): boolean {
	const signature = readAttachmentUrlSignature(src);
	return signature !== null && signature.expiresAtMs <= Date.now();
}

function scheduleRetryOrFail(entry: ImageCacheEntry): void {
	if (entry.subscribers.size === 0) {
		dropEntry(entry);
		return;
	}
	if (entry.failedAttempts >= IMAGE_RETRY_ATTEMPT_LIMIT || hasLapsedAttachmentSignature(entry.src)) {
		failEntry(entry);
		return;
	}
	entry.failedAttempts += 1;
	const resume = (): void => {
		clearRetryState(entry);
		if (!ownsCacheKey(entry)) {
			abandonEntry(entry);
			return;
		}
		if (entry.subscribers.size === 0) {
			dropEntry(entry);
			return;
		}
		startImageLoad(entry);
	};
	if (typeof navigator !== 'undefined' && navigator.onLine === false) {
		entry.connectivityListener = resume;
		window.addEventListener('online', resume, {once: true});
		return;
	}
	if (entry.retryOnSettle) {
		entry.retryOnSettle = false;
		resume();
		return;
	}
	entry.retryResume = resume;
	entry.retryTimeoutId = window.setTimeout(resume, retryDelayForAttempt(entry));
}

function expediteRetry(entry: ImageCacheEntry): void {
	if (entry.retryResume != null) {
		entry.retryResume();
		return;
	}
	if (entry.image != null) entry.retryOnSettle = true;
}

function createEntry(src: string): ImageCacheEntry {
	const entry: ImageCacheEntry = {
		src,
		loaded: false,
		width: 0,
		height: 0,
		image: null,
		subscribers: new Set(),
		failedAttempts: 0,
		failedCycles: 0,
		retryDelayMs: IMAGE_RETRY_INITIAL_DELAY_MS,
		failedUntil: 0,
		loadTimeoutId: 0,
		retryTimeoutId: 0,
		retryResume: null,
		retryOnSettle: false,
		connectivityListener: null,
	};
	imageCache.set(src, entry);
	return entry;
}

function rejectImageLoad(onError: (() => void) | undefined): () => void {
	if (onError) onError();
	return () => {};
}

export function hasImage(src: string | null | undefined): boolean {
	if (!acceptsImageSource(src)) return false;
	return imageCache.get(src)?.loaded === true;
}

export function hasFailedImage(src: string | null | undefined): boolean {
	if (!acceptsImageSource(src)) return false;
	const entry = imageCache.peek(src);
	return entry != null && isCoolingDown(entry);
}

export function getImageSize(src: string | null | undefined): CachedImageSize | undefined {
	if (!acceptsImageSource(src)) return undefined;
	const entry = imageCache.get(src);
	if (entry == null || !entry.loaded || entry.width <= 0 || entry.height <= 0) return undefined;
	return {width: entry.width, height: entry.height};
}

export function rememberImage(src: string | null | undefined, image: HTMLImageElement): void {
	if (!acceptsImageSource(src) || !imageHasSource(image, src) || !isLoadedImage(image)) return;
	const entry = imageCache.get(src) ?? createEntry(src);
	if (entry.loaded) return;
	settleLoaded(entry, image);
}

export function forgetImage(src: string | null | undefined): void {
	if (!acceptsImageSource(src)) return;
	const entry = imageCache.get(src);
	if (entry == null) return;
	dropEntry(entry);
}

export function loadImage(src: string | null | undefined, onLoad: () => void, onError?: () => void): () => void {
	if (!acceptsImageSource(src)) return rejectImageLoad(onError);
	const cached = imageCache.get(src);
	if (cached?.loaded === true) {
		onLoad();
		return () => {};
	}
	if (cached != null && (isCoolingDown(cached) || cached.subscribers.size >= MAX_PENDING_IMAGE_CALLBACKS_PER_LOAD)) {
		return rejectImageLoad(onError);
	}
	const entry = cached ?? createEntry(src);
	const subscriber: ImageSubscriber = {onLoad, onError};
	entry.subscribers.add(subscriber);
	if (!isLoadInFlight(entry)) {
		entry.failedUntil = 0;
		startImageLoad(entry);
	}
	return () => {
		entry.subscribers.delete(subscriber);
	};
}

export function reportImageError(src: string | null | undefined): void {
	if (!acceptsImageSource(src)) return;
	const entry = imageCache.get(src) ?? createEntry(src);
	if (isLoadInFlight(entry) || isCoolingDown(entry)) return;
	entry.loaded = false;
	entry.width = 0;
	entry.height = 0;
	failEntry(entry);
}

export function awaitImage(src: string | null | undefined, onLoad: () => void): () => void {
	if (!acceptsImageSource(src)) return () => {};
	if (hasImage(src)) {
		onLoad();
		return () => {};
	}
	const recovery = recoveries.get(src) ?? createRecovery(src);
	const waiter = (): void => onLoad();
	recovery.waiters.add(waiter);
	if (recovery.timeoutId === 0 && recovery.cancelLoad == null) attemptRecovery(recovery);
	return () => {
		recovery.waiters.delete(waiter);
		if (recovery.waiters.size === 0) stopRecovery(recovery);
	};
}

function createRecovery(src: string): ImageRecovery {
	installRecoveryWakeListeners();
	const recovery: ImageRecovery = {src, waiters: new Set(), timeoutId: 0, cancelLoad: null};
	recoveries.set(src, recovery);
	return recovery;
}

function clearRecoveryWork(recovery: ImageRecovery): void {
	if (recovery.timeoutId !== 0) {
		window.clearTimeout(recovery.timeoutId);
		recovery.timeoutId = 0;
	}
	const cancelLoad = recovery.cancelLoad;
	recovery.cancelLoad = null;
	cancelLoad?.();
}

function stopRecovery(recovery: ImageRecovery): void {
	clearRecoveryWork(recovery);
	if (recoveries.get(recovery.src) === recovery) recoveries.delete(recovery.src);
}

function resolveRecovery(src: string): void {
	const recovery = recoveries.get(src);
	if (recovery == null) return;
	const waiters = [...recovery.waiters];
	recovery.waiters.clear();
	stopRecovery(recovery);
	runCallbacks(waiters);
}

function scheduleRecovery(recovery: ImageRecovery): void {
	if (recoveries.get(recovery.src) !== recovery) return;
	const entry = imageCache.peek(recovery.src);
	const delay = entry != null && isCoolingDown(entry) ? entry.failedUntil - Date.now() : IMAGE_RETRY_INITIAL_DELAY_MS;
	recovery.timeoutId = window.setTimeout(() => {
		recovery.timeoutId = 0;
		attemptRecovery(recovery);
	}, delay);
}

function attemptRecovery(recovery: ImageRecovery): void {
	clearRecoveryWork(recovery);
	if (hasImage(recovery.src)) {
		resolveRecovery(recovery.src);
		return;
	}
	const entry = imageCache.peek(recovery.src);
	if (entry != null && isCoolingDown(entry)) {
		scheduleRecovery(recovery);
		return;
	}
	let settled = false;
	const cancelLoad = loadImage(
		recovery.src,
		() => {
			settled = true;
		},
		() => {
			settled = true;
			recovery.cancelLoad = null;
			scheduleRecovery(recovery);
		},
	);
	if (!settled) recovery.cancelLoad = cancelLoad;
}

function wakeRecoveries(): void {
	for (const recovery of [...recoveries.values()]) {
		const entry = imageCache.peek(recovery.src);
		if (recovery.cancelLoad != null) {
			if (entry != null) expediteRetry(entry);
			continue;
		}
		if (entry != null && !isLoadInFlight(entry)) entry.failedUntil = 0;
		attemptRecovery(recovery);
	}
}

function wakeRecoveriesOnAttention(): void {
	const now = Date.now();
	if (now - lastAttentionWakeAt < IMAGE_RECOVERY_ATTENTION_WAKE_INTERVAL_MS) return;
	lastAttentionWakeAt = now;
	wakeRecoveries();
}

function installRecoveryWakeListeners(): void {
	if (recoveryWakeListenersInstalled || typeof window === 'undefined') return;
	recoveryWakeListenersInstalled = true;
	window.addEventListener('online', wakeRecoveries);
	window.addEventListener('focus', wakeRecoveriesOnAttention);
	document.addEventListener('visibilitychange', () => {
		if (document.visibilityState === 'visible') wakeRecoveriesOnAttention();
	});
}

export function pinImage(src: string | null | undefined): () => void {
	return loadImage(src, () => {});
}

export function warmImage(src: string | null | undefined): void {
	loadImage(src, () => {});
}