Skip to content

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

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

import {fromBinary, toBinary} from '@bufbuild/protobuf';
import {
	createEmptySyncedPreferences,
	type SyncedPreferences,
	SyncedPreferencesSchema,
} from '@fluxer/schema/src/domains/user/SyncedPreferencesCodec';

export type SyncedPreferencesField = Exclude<keyof SyncedPreferences, '$typeName' | '$unknown'>;

export type {SyncedPreferences};

interface TopLevelFieldChunk {
	field: number;
	bytes: Uint8Array;
}

export const SYNCED_PREFERENCES_FIELDS = SyncedPreferencesSchema.fields.map(
	(field) => field.localName as SyncedPreferencesField,
);
const SYNCED_PREFERENCES_FIELD_NAMES = new Set<string>(SYNCED_PREFERENCES_FIELDS.map(String));
const FIELD_TO_NUMBER = new Map<SyncedPreferencesField, number>(
	SyncedPreferencesSchema.fields.map((field) => [field.localName as SyncedPreferencesField, field.number]),
);
const NUMBER_TO_FIELD = new Map<number, SyncedPreferencesField>(
	SyncedPreferencesSchema.fields.map((field) => [field.number, field.localName as SyncedPreferencesField]),
);

export function isSyncedPreferencesField(value: unknown): value is SyncedPreferencesField {
	return typeof value === 'string' && SYNCED_PREFERENCES_FIELD_NAMES.has(value);
}

function fieldNumber(field: SyncedPreferencesField): number {
	const number = FIELD_TO_NUMBER.get(field);
	if (number == null) {
		throw new Error(`Unknown synced preferences field: ${String(field)}`);
	}
	return number;
}

function fieldName(number: number): SyncedPreferencesField | null {
	return NUMBER_TO_FIELD.get(number) ?? null;
}

function toFieldNames(fieldNumbers: ArrayLike<number>): Array<SyncedPreferencesField> {
	const fields: Array<SyncedPreferencesField> = [];
	for (let index = 0; index < fieldNumbers.length; index += 1) {
		const number = fieldNumbers[index];
		const field = fieldName(number);
		if (field != null) fields.push(field);
	}
	return fields;
}

function parseTopLevelFieldChunks(bytes: Uint8Array): Array<TopLevelFieldChunk> {
	const chunks: Array<TopLevelFieldChunk> = [];
	let offset = 0;
	while (offset < bytes.byteLength) {
		const start = offset;
		const key = readVarint(bytes, offset);
		if (key == null) break;
		offset = key.nextOffset;
		const field = key.value >> 3;
		const nextOffset = skipWireValue(bytes, offset, key.value & 7);
		if (nextOffset == null) break;
		offset = nextOffset;
		chunks.push({field, bytes: bytes.slice(start, offset)});
	}
	return chunks;
}

function indexFieldChunks(chunks: ReadonlyArray<TopLevelFieldChunk>): Map<number, Array<Uint8Array>> {
	const fields = new Map<number, Array<Uint8Array>>();
	for (const chunk of chunks) {
		const entries = fields.get(chunk.field) ?? [];
		entries.push(chunk.bytes);
		fields.set(chunk.field, entries);
	}
	return fields;
}

function readVarint(bytes: Uint8Array, offset: number): {value: number; nextOffset: number} | null {
	let value = 0;
	let shift = 0;
	while (offset < bytes.byteLength) {
		const byte = bytes[offset++];
		value |= (byte & 0x7f) << shift;
		if ((byte & 0x80) === 0) {
			return {value, nextOffset: offset};
		}
		shift += 7;
	}
	return null;
}

function skipWireValue(bytes: Uint8Array, offset: number, wireType: number): number | null {
	if (wireType === 0) {
		return readVarint(bytes, offset)?.nextOffset ?? null;
	}
	if (wireType === 1) {
		const nextOffset = offset + 8;
		return nextOffset <= bytes.byteLength ? nextOffset : null;
	}
	if (wireType === 2) {
		const length = readVarint(bytes, offset);
		if (length == null) return null;
		const nextOffset = length.nextOffset + length.value;
		return nextOffset <= bytes.byteLength ? nextOffset : null;
	}
	if (wireType === 5) {
		const nextOffset = offset + 4;
		return nextOffset <= bytes.byteLength ? nextOffset : null;
	}
	return null;
}

function concatChunks(chunks: ReadonlyArray<Uint8Array>): Uint8Array {
	let total = 0;
	for (const chunk of chunks) total += chunk.byteLength;
	const out = new Uint8Array(total);
	let offset = 0;
	for (const chunk of chunks) {
		out.set(chunk, offset);
		offset += chunk.byteLength;
	}
	return out;
}

function replaceField(target: Uint8Array, source: Uint8Array, field: number): Uint8Array {
	const targetFields = parseTopLevelFieldChunks(target);
	const sourceChunks = indexFieldChunks(parseTopLevelFieldChunks(source)).get(field) ?? [];
	const pieces: Array<Uint8Array> = [];
	let inserted = false;
	for (const chunk of targetFields) {
		if (chunk.field === field) {
			if (!inserted) {
				for (const sourceChunk of sourceChunks) pieces.push(sourceChunk);
				inserted = true;
			}
			continue;
		}
		pieces.push(chunk.bytes);
	}
	if (!inserted) {
		for (const sourceChunk of sourceChunks) pieces.push(sourceChunk);
	}
	return concatChunks(pieces);
}

function chunksEqual(left: Array<Uint8Array> | undefined, right: Array<Uint8Array> | undefined): boolean {
	if (left == null || right == null) return left == null && right == null;
	if (left.length !== right.length) return false;
	return left.every((chunk, index) => {
		const other = right[index];
		if (chunk.byteLength !== other.byteLength) return false;
		for (let i = 0; i < chunk.byteLength; i += 1) {
			if (chunk[i] !== other[i]) return false;
		}
		return true;
	});
}

function changedFieldNumbers(left: Uint8Array, right: Uint8Array): Array<number> {
	const leftFields = indexFieldChunks(parseTopLevelFieldChunks(left));
	const rightFields = indexFieldChunks(parseTopLevelFieldChunks(right));
	const fieldNumbers = new Set([...leftFields.keys(), ...rightFields.keys()]);
	return Array.from(fieldNumbers)
		.sort((a, b) => a - b)
		.filter((field) => !chunksEqual(leftFields.get(field), rightFields.get(field)));
}

export function preferencesToBytes(preferences: SyncedPreferences): Uint8Array {
	return toBinary(SyncedPreferencesSchema, preferences);
}

export function preferencesFromBytes(bytes: Uint8Array): SyncedPreferences {
	if (bytes.byteLength === 0) return createEmptySyncedPreferences();
	return fromBinary(SyncedPreferencesSchema, bytes);
}

export function changedSyncedPreferenceFields(
	left: SyncedPreferences,
	right: SyncedPreferences,
): Array<SyncedPreferencesField> {
	return toFieldNames(changedFieldNumbers(preferencesToBytes(left), preferencesToBytes(right)));
}

export function syncedPreferencesEqual(left: SyncedPreferences, right: SyncedPreferences): boolean {
	return changedFieldNumbers(preferencesToBytes(left), preferencesToBytes(right)).length === 0;
}

export function mergeIncomingSyncedPreferences(args: {
	local: SyncedPreferences;
	wire: SyncedPreferences;
	incoming: SyncedPreferences;
	protectedFields: Iterable<SyncedPreferencesField>;
	recentlyAckedFields: Iterable<SyncedPreferencesField>;
	inFlight: SyncedPreferences | null;
	syncInFlight: boolean;
}): {
	merged: SyncedPreferences;
	wire: SyncedPreferences;
	dirtyFields: Array<SyncedPreferencesField>;
} {
	const localBytes = preferencesToBytes(args.local);
	const incomingBytes = preferencesToBytes(args.incoming);
	const inFlightBytes = args.inFlight == null ? null : preferencesToBytes(args.inFlight);
	const protectedSet = new Set<number>();
	for (const field of args.protectedFields) protectedSet.add(fieldNumber(field));
	const ackedSet = new Set<number>();
	for (const field of args.recentlyAckedFields) ackedSet.add(fieldNumber(field));
	const localFields = indexFieldChunks(parseTopLevelFieldChunks(localBytes));
	const incomingFields = indexFieldChunks(parseTopLevelFieldChunks(incomingBytes));
	const inFlightFields =
		inFlightBytes == null
			? new Map<number, Array<Uint8Array>>()
			: indexFieldChunks(parseTopLevelFieldChunks(inFlightBytes));
	let merged = incomingBytes;
	let wire = incomingBytes;
	const dirtyFieldNumbers: Array<number> = [];
	const fieldNumbers = new Set([...localFields.keys(), ...incomingFields.keys(), ...inFlightFields.keys()]);
	for (const field of Array.from(fieldNumbers).sort((a, b) => a - b)) {
		if (protectedSet.has(field)) {
			merged = replaceField(merged, localBytes, field);
			continue;
		}
		if (ackedSet.has(field) && !chunksEqual(incomingFields.get(field), localFields.get(field))) {
			merged = replaceField(merged, localBytes, field);
			wire = replaceField(wire, localBytes, field);
			continue;
		}
		if (
			args.syncInFlight &&
			inFlightBytes != null &&
			!chunksEqual(incomingFields.get(field), inFlightFields.get(field))
		) {
			dirtyFieldNumbers.push(field);
		}
	}
	return {
		merged: preferencesFromBytes(merged),
		wire: preferencesFromBytes(wire),
		dirtyFields: toFieldNames(dirtyFieldNumbers),
	};
}