@verdant-web/store 5.4.4 → 5.6.0

package/src/files/EntityFile.ts

@@ -1,6 +1,11 @@
-import { EventSubscriber, FileData } from '@verdant-web/common';
+import {
+	EventSubscriber,
+	FileData,
+	FileRef,
+	ObjectIdentifier,
+	PropertyName,
+} from '@verdant-web/common';
 import { Context } from '../context/context.js';
-import { Entity } from '../entities/Entity.js';
 
 export type EntityFileEvents = {
 	change: () => void;
@@ -9,12 +14,23 @@ export type EntityFileEvents = {
 export const UPDATE = Symbol('entity-file-update');
 export const MARK_FAILED = Symbol('entity-file-mark-failed');
 
-// this one goes on Entity
-export const CHILD_FILE_CHANGED = Symbol('child-file-changed');
+export interface EntityFileContext {
+	readonly oid: ObjectIdentifier;
+	readonly key: PropertyName;
+	getFileRef(): FileRef | null;
+	applyFileRef(file: FileRef): void;
+	subscribe(callback: () => void): () => void;
+	onChange(): void;
+}
 
 export type EntityFileSnapshot = {
 	id: string;
 	url?: string | null;
+	name: string;
+	remote: boolean;
+	type: string;
+	file?: Blob | null;
+	alt: string | null;
 };
 
 /**
@@ -30,26 +46,29 @@ export class EntityFile extends EventSubscriber<EntityFileEvents> {
 	private _failedReason: string | undefined;
 	private _downloadRemote = false;
 	private _uploaded = false;
+	private _alt: string | null = null;
 	private ctx: Context;
 	private unsubscribes: (() => void)[] = [];
-	private parent: Entity;
+	private fileContext: EntityFileContext;
 
 	constructor(
 		public readonly id: string,
 		{
 			downloadRemote = false,
 			ctx,
-			parent,
+			fileContext,
 		}: {
 			downloadRemote?: boolean;
 			ctx: Context;
-			parent: Entity;
+			fileContext: EntityFileContext;
 		},
 	) {
 		super();
 		this.ctx = ctx;
-		this.parent = parent;
+		this.fileContext = fileContext;
 		this._downloadRemote = downloadRemote;
+		this._alt = fileContext.getFileRef()?.alt ?? null;
+		this.unsubscribes.push(fileContext.subscribe(this.onContextChange));
 
 		this.unsubscribes.push(
 			this.ctx.internalEvents.subscribe(`fileUploaded:${id}`, this.onUploaded),
@@ -68,9 +87,31 @@ export class EntityFile extends EventSubscriber<EntityFileEvents> {
 	get error() {
 		return this._failedReason || null;
 	}
+	get alt() {
+		return this._alt;
+	}
+
+	setAlt = (alt: string | null) => {
+		const file = this.fileContext.getFileRef();
+		if (!file || file.id !== this.id) {
+			throw new Error(
+				'Cannot set alt text on a file which is no longer present',
+			);
+		}
+		if ((file.alt ?? null) === alt) return;
+		this.fileContext.applyFileRef({ ...file, alt });
+	};
+
+	private onContextChange = () => {
+		const nextAlt = this.fileContext.getFileRef()?.alt ?? null;
+		if (nextAlt !== this._alt) {
+			this._alt = nextAlt;
+			this.emitChange();
+		}
+	};
 
 	private emitChange() {
-		this.parent[CHILD_FILE_CHANGED](this);
+		this.fileContext.onChange();
 		this.emit('change');
 	}
 
@@ -135,7 +176,7 @@ export class EntityFile extends EventSubscriber<EntityFileEvents> {
 		this.dispose();
 	};
 
-	getSnapshot(): FileData {
+	getSnapshot(): EntityFileSnapshot {
 		return {
 			id: this.id,
 			url: this._fileData?.url ?? this._objectUrl ?? undefined,
@@ -143,6 +184,7 @@ export class EntityFile extends EventSubscriber<EntityFileEvents> {
 			remote: this._fileData?.remote ?? false,
 			type: this.type ?? '',
 			file: this._fileData?.file,
+			alt: this.alt,
 		};
 	}
 }

package/src/files/FileManager.ts

@@ -1,15 +1,20 @@
 import { FileData } from '@verdant-web/common';
 import { Context } from '../context/context.js';
-import { Entity } from '../entities/Entity.js';
 import { Disposable } from '../internal.js';
 import { Sync } from '../sync/Sync.js';
-import { EntityFile, MARK_FAILED, UPDATE } from './EntityFile.js';
+import {
+	EntityFile,
+	EntityFileContext,
+	MARK_FAILED,
+	UPDATE,
+} from './EntityFile.js';
 
 export class FileManager extends Disposable {
 	private sync;
 	private context;
 
-	private cache = new Map<string, EntityFile>();
+	private cache = new Map<string, WeakRef<EntityFile>>();
+	private fileData = new Map<string, WeakRef<FileData>>();
 
 	constructor({ sync, context }: { sync: Sync; context: Context }) {
 		super();
@@ -23,24 +28,17 @@ export class FileManager extends Disposable {
 		);
 	}
 
-	add = async (file: FileData, parent: Entity) => {
-		// immediately cache the file
-		let entityFile = this.cache.get(file.id);
-		if (!entityFile) {
-			entityFile = new EntityFile(file.id, { ctx: this.context, parent });
-			this.cache.set(file.id, entityFile);
-		}
-
+	add = async (file: FileData) => {
 		if (!file.remote) {
 			// immediately update local files.
-			entityFile[UPDATE](file);
+			this.updateFileData(file);
 		}
 		// this will download any original remote file and trigger a re-upload to the
 		// new file's identity, in addition to storing it on disk
 		const processedFile = await (
 			await this.context.files
 		).add(file, { cloneRemote: true });
-		entityFile[UPDATE](processedFile);
+		this.updateFileData(processedFile);
 	};
 
 	/**
@@ -49,22 +47,49 @@ export class FileManager extends Disposable {
 	 */
 	get = (
 		id: string,
-		options: { downloadRemote?: boolean; ctx: Context; parent: Entity },
+		options: {
+			downloadRemote?: boolean;
+			ctx: Context;
+			fileContext: EntityFileContext;
+		},
 	) => {
-		if (this.cache.has(id)) {
-			return this.cache.get(id)!;
+		const cacheKey = `${options.fileContext.oid}:${String(options.fileContext.key)}:${id}`;
+		const cachedFile = this.cache.get(cacheKey)?.deref();
+		if (cachedFile) {
+			return cachedFile;
 		}
+		this.cache.delete(cacheKey);
 		const file = new EntityFile(id, options);
-		this.cache.set(id, file);
-		this.load(file);
+		this.cache.set(cacheKey, this.context.weakRef(file));
+		const data = this.fileData.get(id)?.deref();
+		if (data) {
+			file[UPDATE](data);
+		} else {
+			this.fileData.delete(id);
+			this.load(file);
+		}
 		return file;
 	};
 
+	private updateFileData = (data: FileData) => {
+		this.fileData.set(data.id, this.context.weakRef(data));
+		for (const [key, fileRef] of this.cache) {
+			const file = fileRef.deref();
+			if (!file) {
+				this.cache.delete(key);
+				continue;
+			}
+			if (file.id === data.id) {
+				file[UPDATE](data);
+			}
+		}
+	};
+
 	private load = async (file: EntityFile) => {
 		const fileData = await (await this.context.files).get(file.id);
 		// immediately apply any file data we have
 		if (fileData) {
-			file[UPDATE](fileData);
+			this.updateFileData(fileData);
 		}
 
 		if (!fileData?.url && (!fileData || fileData.remote)) {
@@ -96,7 +121,7 @@ export class FileManager extends Disposable {
 						url: result.data.url,
 					};
 					await (await this.context.files).update(copyWithUrl);
-					file[UPDATE](result.data);
+					this.updateFileData(result.data);
 				} else {
 					this.context.log('error', 'Failed to load file', result);
 					if (!fileData) {

package/src/sync/PresenceManager.ts

@@ -134,29 +134,32 @@ export class PresenceManager<
 		let selfChanged = false;
 		const peerIdsSet = new Set<string>(this.peerIds);
 
+		const peerSnapshot =
+			message.type === 'sync-resp' ||
+			(message.type === 'server-ack' && message.peerPresence)
+				? message.peerPresence
+				: undefined;
+
 		if (message.type === 'presence-changed') {
 			if (this.isSelf(localReplicaInfo, message.userInfo)) {
-				this._self = message.userInfo;
-				this._selfReplicaIds.add(message.userInfo.replicaId);
+				this.updateSelf(localReplicaInfo, message.userInfo);
 				selfChanged = true;
-				this.emit('selfChanged', message.userInfo);
 			} else {
 				peerIdsSet.add(message.userInfo.id);
 				this._peers[message.userInfo.id] = message.userInfo;
 				peersChanged = true;
 				this.emit('peerChanged', message.userInfo.id, message.userInfo);
 			}
-		} else if (message.type === 'sync-resp') {
+		} else if (peerSnapshot) {
 			// reset to provided presence data, which includes all peers.
+			const previousPeerIds = this._peerIds;
 			this._peers = {};
 			peerIdsSet.clear();
 
-			for (const [id, userInfo] of Object.entries(message.peerPresence)) {
+			for (const [id, userInfo] of Object.entries(peerSnapshot)) {
 				if (this.isSelf(localReplicaInfo, userInfo)) {
-					this._self = userInfo;
-					this._selfReplicaIds.add(userInfo.replicaId);
+					this.updateSelf(localReplicaInfo, userInfo);
 					selfChanged = true;
-					this.emit('selfChanged', userInfo);
 				} else {
 					peersChanged = true;
 					peerIdsSet.add(id);
@@ -164,6 +167,10 @@ export class PresenceManager<
 					this.emit('peerChanged', id, userInfo);
 				}
 			}
+			// also notify when peers have all left
+			if (previousPeerIds.length !== peerIdsSet.size) {
+				peersChanged = true;
+			}
 		} else if (message.type === 'presence-offline') {
 			peerIdsSet.delete(message.userId);
 			const lastPresence = this._peers[message.userId];
@@ -182,6 +189,25 @@ export class PresenceManager<
 		}
 	};
 
+	private updateSelf = (
+		localReplicaInfo: LocalReplicaInfo,
+		userInfo: UserInfo<Profile, Presence>,
+	) => {
+		this._self = userInfo;
+		if (userInfo.replicaIds) {
+			// the server reports the full set of this user's active replicas,
+			// so replace rather than accumulate; that way replicas which go
+			// away are forgotten.
+			this._selfReplicaIds = new Set([
+				localReplicaInfo.id,
+				...userInfo.replicaIds,
+			]);
+		} else {
+			this._selfReplicaIds.add(userInfo.replicaId);
+		}
+		this.emit('selfChanged', userInfo);
+	};
+
 	update = async (presence: Partial<Presence>) => {
 		this._updateBatch.update({
 			items: [{ presence }],

package/src/sync/Sync.ts

@@ -306,21 +306,25 @@ export class ServerSync<Presence = any, Profile = any>
 			// automatically shift between transport modes depending
 			// on whether any peers are present (matching view if
 			// applicable)
+			const shouldUseRealtime = () => {
+				const hasPeers = this.presence.getViewPeers().length > 0;
+				return (
+					hasPeers ||
+					(automaticTransportSelection !== 'peers-only' &&
+						this.presence.selfReplicaIds.size > 1)
+				);
+			};
 			const decideIfUpgrade = () => {
 				if (switchoverTimeout) {
 					clearTimeout(switchoverTimeout);
 				}
-				const hasPeers = this.presence.getViewPeers().length > 0;
-				const shouldUpgrade =
-					hasPeers ||
-					(automaticTransportSelection !== 'peers-only' &&
-						this.presence.selfReplicaIds.size > 1);
+				const shouldUpgrade = shouldUseRealtime();
 				if (shouldUpgrade && this.mode === 'pull') {
 					this.setMode('realtime');
 				} else if (!shouldUpgrade && this.mode === 'realtime') {
 					// wait 1 second then switch to pull mode if still empty
 					switchoverTimeout = setTimeout(() => {
-						if (this.presence.getViewPeers().length === 0) {
+						if (!shouldUseRealtime() && this.mode === 'realtime') {
 							this.setMode('pull');
 						}
 					}, 1000);