loro-repo 0.5.2 → 0.6.0

package/dist/transport/websocket.js

@@ -1,5 +1,4 @@
-import { LoroAdaptor } from "loro-adaptors/loro";
-import { bytesToHex } from "loro-protocol";
+import { LoroAdaptor, LoroEphemeralAdaptor } from "loro-adaptors/loro";
 import { LoroWebsocketClient } from "loro-websocket";
 import { FlockAdaptor } from "loro-adaptors/flock";
 
@@ -58,14 +57,28 @@ function withTimeout(promise, timeoutMs) {
 		});
 	});
 }
-function normalizeRoomId(roomId, fallback) {
-	if (typeof roomId === "string" && roomId.length > 0) return roomId;
-	if (roomId instanceof Uint8Array && roomId.length > 0) try {
-		return bytesToHex(roomId);
-	} catch {
-		return fallback;
+function createStatusEmitter(initial = "connecting") {
+	return {
+		status: initial,
+		listeners: /* @__PURE__ */ new Set()
+	};
+}
+function emitStatus(emitter, status) {
+	if (!emitter) return;
+	emitter.status = status;
+	const listeners = Array.from(emitter.listeners);
+	for (const cb of listeners) try {
+		cb(status);
+	} catch (error) {
+		debug("status listener error", error);
+	}
+}
+function mapClientStatusToRoom(status) {
+	switch (status) {
+		case "connected": return "joined";
+		case "connecting": return "reconnecting";
+		default: return "disconnected";
 	}
-	return fallback;
 }
 function bytesEqual(a, b) {
 	if (a === b) return true;
@@ -81,24 +94,85 @@ function bytesEqual(a, b) {
 var WebSocketTransportAdapter = class {
 	options;
 	client;
+	clientListeners = [];
 	metadataSession;
 	docSessions = /* @__PURE__ */ new Map();
+	ephemeralSessions = /* @__PURE__ */ new Map();
 	constructor(options) {
 		this.options = options;
 	}
-	async connect(_options) {
+	trackClientListener(unsubscribe) {
+		this.clientListeners.push(unsubscribe);
+	}
+	propagateClientStatus(status) {
+		const mapped = mapClientStatusToRoom(status);
+		const meta = this.metadataSession;
+		if (meta) this.dispatchRoomStatus("meta", { roomId: meta.roomId }, mapped, meta.statusEmitter, meta.statusListener);
+		for (const session of this.docSessions.values()) this.dispatchRoomStatus("doc", {
+			roomId: session.roomId,
+			docId: session.docId
+		}, mapped, session.statusEmitter, session.statusListener);
+		for (const session of this.ephemeralSessions.values()) this.dispatchRoomStatus("ephemeral", { roomId: session.roomId }, mapped, session.statusEmitter, void 0);
+	}
+	dispatchRoomStatus(kind, payload, status, emitter, listener) {
+		emitStatus(emitter, status);
+		try {
+			listener?.(status);
+		} catch (error) {
+			debug("room listener error", error);
+		}
+		try {
+			this.options.onRoomStatusChange?.({
+				kind,
+				...payload,
+				status
+			});
+		} catch (error) {
+			debug("global room status listener error", error);
+		}
+	}
+	cleanupClientListeners() {
+		while (this.clientListeners.length > 0) {
+			const unsubscribe = this.clientListeners.pop();
+			try {
+				unsubscribe?.();
+			} catch {}
+		}
+	}
+	async connect(options) {
 		const client = this.ensureClient();
-		debug("connect requested", { status: client.getStatus() });
+		debug("connect requested", {
+			status: client.getStatus(),
+			resetBackoff: Boolean(options?.resetBackoff)
+		});
 		try {
-			await client.connect();
+			await client.connect.call(client, options?.resetBackoff ? { resetBackoff: options.resetBackoff } : void 0);
 			debug("client.connect resolved");
-			await client.waitConnected();
+			await withTimeout(client.waitConnected(), options?.timeout);
 			debug("client.waitConnected resolved", { status: client.getStatus() });
 		} catch (error) {
 			debug("connect failed", error);
 			throw error;
 		}
 	}
+	async reconnect(options) {
+		const client = this.ensureClient();
+		debug("reconnect requested", {
+			status: client.getStatus(),
+			resetBackoff: Boolean(options?.resetBackoff)
+		});
+		try {
+			const connectFn = client.connect;
+			if (options?.resetBackoff) await connectFn.call(client, { resetBackoff: true });
+			else if (client.retryNow) await client.retryNow.call(client);
+			else await connectFn.call(client);
+			await withTimeout(client.waitConnected(), options?.timeout);
+			debug("reconnect completed", { status: client.getStatus() });
+		} catch (error) {
+			debug("reconnect failed", error);
+			throw error;
+		}
+	}
 	async close() {
 		debug("close requested", {
 			docSessions: this.docSessions.size,
@@ -106,10 +180,13 @@ var WebSocketTransportAdapter = class {
 		});
 		for (const [docId] of this.docSessions) await this.leaveDocSession(docId).catch(() => {});
 		this.docSessions.clear();
+		for (const [roomId] of this.ephemeralSessions) await this.leaveEphemeralSession(roomId).catch(() => {});
+		this.ephemeralSessions.clear();
 		await this.teardownMetadataSession().catch(() => {});
 		if (this.client) {
 			const client = this.client;
 			this.client = void 0;
+			this.cleanupClientListeners();
 			client.destroy();
 			debug("websocket client destroyed");
 		}
@@ -118,6 +195,30 @@ var WebSocketTransportAdapter = class {
 	isConnected() {
 		return this.client?.getStatus() === "connected";
 	}
+	getStatus() {
+		return this.ensureClient().getStatus();
+	}
+	getLatency() {
+		return this.ensureClient().getLatency?.();
+	}
+	onStatusChange(listener) {
+		const unsubscribe = this.ensureClient().onStatusChange(listener);
+		this.trackClientListener(unsubscribe);
+		return () => {
+			unsubscribe();
+			const idx = this.clientListeners.indexOf(unsubscribe);
+			if (idx >= 0) this.clientListeners.splice(idx, 1);
+		};
+	}
+	onLatency(listener) {
+		const unsubscribe = this.ensureClient().onLatency(listener);
+		this.trackClientListener(unsubscribe);
+		return () => {
+			unsubscribe();
+			const idx = this.clientListeners.indexOf(unsubscribe);
+			if (idx >= 0) this.clientListeners.splice(idx, 1);
+		};
+	}
 	async syncMeta(flock, options) {
 		debug("syncMeta requested", { roomId: this.options.metadataRoomId });
 		try {
@@ -136,9 +237,8 @@ var WebSocketTransportAdapter = class {
 		}
 	}
 	joinMetaRoom(flock, params) {
-		const fallback = this.options.metadataRoomId ?? "";
-		const roomId = normalizeRoomId(params?.roomId, fallback);
-		if (!roomId) throw new Error("Metadata room id not configured");
+		const roomId = this.options.metadataRoomId ?? "repo:meta";
+		let statusEmitterRef;
 		const session = (async () => {
 			let auth;
 			const authWay = params?.auth ?? this.options.metadataAuth;
@@ -148,10 +248,13 @@ var WebSocketTransportAdapter = class {
 				roomId,
 				hasAuth: Boolean(auth && auth.length)
 			});
-			return this.ensureMetadataSession(flock, {
+			const ensure = this.ensureMetadataSession(flock, {
 				roomId,
-				auth
+				auth,
+				onStatusChange: params?.onStatusChange
 			});
+			statusEmitterRef = (await ensure).statusEmitter;
+			return ensure;
 		})();
 		const firstSynced = session.then((session$1) => session$1.firstSynced);
 		const getConnected = () => this.isConnected();
@@ -172,6 +275,31 @@ var WebSocketTransportAdapter = class {
 			firstSyncedWithRemote: firstSynced,
 			get connected() {
 				return getConnected();
+			},
+			get status() {
+				return statusEmitterRef?.status ?? "connecting";
+			},
+			onStatusChange: (listener) => {
+				const attach = (emitter) => {
+					emitter.listeners.add(listener);
+					try {
+						listener(emitter.status);
+					} catch (error) {
+						debug("metadata onStatusChange listener error", error);
+					}
+					return () => emitter.listeners.delete(listener);
+				};
+				if (statusEmitterRef) {
+					const cleanup = attach(statusEmitterRef);
+					return () => cleanup();
+				}
+				let unsubscribed = false;
+				const cleanupPromise = session.then((resolved) => attach(resolved.statusEmitter));
+				return () => {
+					if (unsubscribed) return;
+					unsubscribed = true;
+					cleanupPromise.then((cleanup) => cleanup()).catch(() => {});
+				};
 			}
 		};
 		session.then((session$1) => {
@@ -204,10 +332,13 @@ var WebSocketTransportAdapter = class {
 	joinDocRoom(docId, doc, params) {
 		debug("joinDocRoom requested", {
 			docId,
-			roomParamType: params?.roomId ? typeof params.roomId === "string" ? "string" : "uint8array" : void 0,
 			hasAuthOverride: Boolean(params?.auth && params.auth.length)
 		});
-		const ensure = this.ensureDocSession(docId, doc, params ?? {});
+		let statusEmitterRef;
+		const ensure = this.ensureDocSession(docId, doc, params ?? {}).then((session) => {
+			statusEmitterRef = session.statusEmitter;
+			return session;
+		});
 		const firstSynced = ensure.then((session) => session.firstSynced);
 		const getConnected = () => this.isConnected();
 		const subscription = {
@@ -225,6 +356,31 @@ var WebSocketTransportAdapter = class {
 			firstSyncedWithRemote: firstSynced,
 			get connected() {
 				return getConnected();
+			},
+			get status() {
+				return statusEmitterRef?.status ?? "connecting";
+			},
+			onStatusChange: (listener) => {
+				const attach = (emitter) => {
+					emitter.listeners.add(listener);
+					try {
+						listener(emitter.status);
+					} catch (error) {
+						debug("doc onStatusChange listener error", error);
+					}
+					return () => emitter.listeners.delete(listener);
+				};
+				if (statusEmitterRef) {
+					const cleanup = attach(statusEmitterRef);
+					return () => cleanup();
+				}
+				let unsubscribed = false;
+				const cleanupPromise = ensure.then((session) => attach(session.statusEmitter));
+				return () => {
+					if (unsubscribed) return;
+					unsubscribed = true;
+					cleanupPromise.then((cleanup) => cleanup()).catch(() => {});
+				};
 			}
 		};
 		ensure.then((session) => {
@@ -237,6 +393,69 @@ var WebSocketTransportAdapter = class {
 		});
 		return subscription;
 	}
+	joinEphemeralRoom(roomId) {
+		debug("joinEphemeralRoom requested", { roomId });
+		let statusEmitterRef;
+		const ensure = this.ensureEphemeralSession(roomId).then((session) => {
+			statusEmitterRef = session.statusEmitter;
+			return session;
+		});
+		const store = this.ephemeralSessions.get(roomId)?.store;
+		if (!store) throw new Error("Failed to initialize ephemeral session");
+		const firstSynced = ensure.then((session) => session.firstSynced);
+		const getConnected = () => this.isConnected();
+		const subscription = {
+			store,
+			unsubscribe: () => {
+				ensure.then((session) => {
+					session.refCount = Math.max(0, session.refCount - 1);
+					debug("ephemeral session refCount decremented", {
+						roomId,
+						refCount: session.refCount
+					});
+					if (session.refCount === 0) this.leaveEphemeralSession(roomId).catch(() => {});
+				});
+			},
+			firstSyncedWithRemote: firstSynced,
+			get connected() {
+				return getConnected();
+			},
+			get status() {
+				return statusEmitterRef?.status ?? "connecting";
+			},
+			onStatusChange: (listener) => {
+				const attach = (emitter) => {
+					emitter.listeners.add(listener);
+					try {
+						listener(emitter.status);
+					} catch (error) {
+						debug("ephemeral onStatusChange listener error", error);
+					}
+					return () => emitter.listeners.delete(listener);
+				};
+				if (statusEmitterRef) {
+					const cleanup = attach(statusEmitterRef);
+					return () => cleanup();
+				}
+				let unsubscribed = false;
+				const cleanupPromise = ensure.then((session) => attach(session.statusEmitter));
+				return () => {
+					if (unsubscribed) return;
+					unsubscribed = true;
+					cleanupPromise.then((cleanup) => cleanup()).catch(() => {});
+				};
+			}
+		};
+		ensure.then((session) => {
+			subscription.store = session.store;
+			session.refCount += 1;
+			debug("ephemeral session refCount incremented", {
+				roomId,
+				refCount: session.refCount
+			});
+		});
+		return subscription;
+	}
 	ensureClient() {
 		if (this.client) {
 			debug("reusing websocket client", { status: this.client.getStatus() });
@@ -251,9 +470,18 @@ var WebSocketTransportAdapter = class {
 			url,
 			...clientOptions
 		});
+		this.trackClientListener(client.onStatusChange((status) => {
+			this.propagateClientStatus(status);
+			this.options.onStatusChange?.(status);
+		}));
+		if (this.options.onLatency) this.trackClientListener(client.onLatency(this.options.onLatency));
 		this.client = client;
+		this.propagateClientStatus(client.getStatus());
 		return client;
 	}
+	get websocketClient() {
+		return this.ensureClient();
+	}
 	async ensureMetadataSession(flock, params) {
 		debug("ensureMetadataSession invoked", {
 			roomId: params.roomId,
@@ -274,6 +502,9 @@ var WebSocketTransportAdapter = class {
 			await this.teardownMetadataSession(this.metadataSession).catch(() => {});
 		}
 		const adaptor = new FlockAdaptor(flock, this.options.metadataAdaptorConfig);
+		const statusEmitter = createStatusEmitter("connecting");
+		if (params.onStatusChange) statusEmitter.listeners.add(params.onStatusChange);
+		this.dispatchRoomStatus("meta", { roomId: params.roomId }, "connecting", statusEmitter, params.onStatusChange);
 		debug("joining metadata room", {
 			roomId: params.roomId,
 			hasAuth: Boolean(params.auth && params.auth.length)
@@ -283,6 +514,7 @@ var WebSocketTransportAdapter = class {
 			crdtAdaptor: adaptor,
 			auth: params.auth
 		});
+		this.dispatchRoomStatus("meta", { roomId: params.roomId }, "joined", statusEmitter, params.onStatusChange);
 		const firstSynced = room.waitForReachingServerVersion();
 		firstSynced.then(() => {
 			debug("metadata session firstSynced resolved", { roomId: params.roomId });
@@ -299,7 +531,9 @@ var WebSocketTransportAdapter = class {
 			flock,
 			roomId: params.roomId,
 			auth: params.auth,
-			refCount: 0
+			refCount: 0,
+			statusEmitter,
+			statusListener: params.onStatusChange
 		};
 		this.metadataSession = session;
 		return session;
@@ -321,6 +555,7 @@ var WebSocketTransportAdapter = class {
 			await room.destroy().catch(() => {});
 		}
 		adaptor.destroy();
+		this.dispatchRoomStatus("meta", { roomId: target.roomId }, "disconnected", target.statusEmitter, target.statusListener);
 		debug("metadata session destroyed", { roomId: target.roomId });
 	}
 	async ensureDocSession(docId, doc, params) {
@@ -332,8 +567,7 @@ var WebSocketTransportAdapter = class {
 			status: client.getStatus()
 		});
 		const existing = this.docSessions.get(docId);
-		const derivedRoomId = this.options.docRoomId?.(docId) ?? docId;
-		const roomId = normalizeRoomId(params.roomId, derivedRoomId);
+		const roomId = this.options.docRoomId?.(docId) ?? docId;
 		let auth;
 		auth = await (params.auth ?? this.options.docAuth?.(docId));
 		debug("doc session params resolved", {
@@ -358,6 +592,12 @@ var WebSocketTransportAdapter = class {
 			await this.leaveDocSession(docId).catch(() => {});
 		}
 		const adaptor = new LoroAdaptor(doc);
+		const statusEmitter = createStatusEmitter("connecting");
+		if (params.onStatusChange) statusEmitter.listeners.add(params.onStatusChange);
+		this.dispatchRoomStatus("doc", {
+			roomId,
+			docId
+		}, "connecting", statusEmitter, params.onStatusChange);
 		debug("joining doc room", {
 			docId,
 			roomId,
@@ -368,6 +608,10 @@ var WebSocketTransportAdapter = class {
 			crdtAdaptor: adaptor,
 			auth
 		});
+		this.dispatchRoomStatus("doc", {
+			roomId,
+			docId
+		}, "joined", statusEmitter, params.onStatusChange);
 		const firstSynced = room.waitForReachingServerVersion();
 		firstSynced.then(() => {
 			debug("doc session firstSynced resolved", {
@@ -387,11 +631,66 @@ var WebSocketTransportAdapter = class {
 			firstSynced,
 			doc,
 			roomId,
-			refCount: 0
+			docId,
+			refCount: 0,
+			statusEmitter,
+			statusListener: params.onStatusChange
 		};
 		this.docSessions.set(docId, session);
 		return session;
 	}
+	async ensureEphemeralSession(roomId) {
+		debug("ensureEphemeralSession invoked", { roomId });
+		const existing = this.ephemeralSessions.get(roomId);
+		if (existing) {
+			debug("reusing ephemeral session", {
+				roomId,
+				refCount: existing.refCount
+			});
+			return existing;
+		}
+		const adaptor = new LoroEphemeralAdaptor();
+		const statusEmitter = createStatusEmitter("connecting");
+		this.dispatchRoomStatus("ephemeral", { roomId }, "connecting", statusEmitter, void 0);
+		const session = {
+			adaptor,
+			store: adaptor.getStore(),
+			roomId,
+			firstSynced: Promise.resolve(),
+			refCount: 0,
+			statusEmitter
+		};
+		this.ephemeralSessions.set(roomId, session);
+		const client = this.ensureClient();
+		await client.waitConnected();
+		debug("websocket client ready for ephemeral session", {
+			roomId,
+			status: client.getStatus()
+		});
+		try {
+			const room = await client.join({
+				roomId,
+				crdtAdaptor: adaptor
+			});
+			this.dispatchRoomStatus("ephemeral", { roomId }, "joined", statusEmitter, void 0);
+			const firstSynced = room.waitForReachingServerVersion();
+			firstSynced.then(() => {
+				debug("ephemeral session firstSynced resolved", { roomId });
+			}, (error) => {
+				debug("ephemeral session firstSynced rejected", {
+					roomId,
+					error
+				});
+			});
+			session.room = room;
+			session.firstSynced = firstSynced;
+			return session;
+		} catch (error) {
+			this.ephemeralSessions.delete(roomId);
+			adaptor.destroy();
+			throw error;
+		}
+	}
 	async leaveDocSession(docId) {
 		const session = this.docSessions.get(docId);
 		if (!session) {
@@ -418,11 +717,37 @@ var WebSocketTransportAdapter = class {
 			await session.room.destroy().catch(() => {});
 		}
 		session.adaptor.destroy();
+		this.dispatchRoomStatus("doc", {
+			roomId: session.roomId,
+			docId: session.docId
+		}, "disconnected", session.statusEmitter, session.statusListener);
 		debug("doc session destroyed", {
 			docId,
 			roomId: session.roomId
 		});
 	}
+	async leaveEphemeralSession(roomId) {
+		const session = this.ephemeralSessions.get(roomId);
+		if (!session) {
+			debug("leaveEphemeralSession invoked but no session found", { roomId });
+			return;
+		}
+		this.ephemeralSessions.delete(roomId);
+		debug("leaving ephemeral session", { roomId });
+		try {
+			await session.room?.leave();
+			debug("ephemeral room left", { roomId });
+		} catch (error) {
+			debug("ephemeral room leave failed; destroying", {
+				roomId,
+				error
+			});
+			await session.room?.destroy().catch(() => {});
+		}
+		session.adaptor.destroy();
+		this.dispatchRoomStatus("ephemeral", { roomId: session.roomId }, "disconnected", session.statusEmitter, void 0);
+		debug("ephemeral session destroyed", { roomId });
+	}
 };
 
 //#endregion