void 0.7.3 → 0.7.4

package/dist/runtime/live-client.mjs

@@ -0,0 +1,283 @@
+//#region src/runtime/live-client.ts
+function connectLiveStream(url, options = {}) {
+	const EventSourceCtor = options.eventSource ?? globalThis.EventSource;
+	if (!EventSourceCtor) throw new Error("live: EventSource is not available in this runtime.");
+	const ResolvedEventSource = EventSourceCtor;
+	const fetchImpl = options.fetch ?? fetch;
+	const connectionId = crypto.randomUUID();
+	const subscriptions = /* @__PURE__ */ new Map();
+	const subscriptionVersions = /* @__PURE__ */ new Map();
+	let source = null;
+	let openPromise = null;
+	let rejectOpen = null;
+	let reconnectTimer = null;
+	let resubscribeOnNextOpen = false;
+	let resubscribeWithNextFlush = false;
+	let closed = false;
+	let pendingOperations = [];
+	let pendingFlush = null;
+	let flushChain = Promise.resolve();
+	let nextSubscriptionVersion = 0;
+	const retryDelay = options.retryDelay ?? 1e3;
+	if (!Number.isFinite(retryDelay) || retryDelay < 0) throw new Error("live: retryDelay must be a non-negative finite number.");
+	function streamUrl() {
+		const resolved = new URL(String(url), globalThis.location?.href);
+		resolved.searchParams.set("connectionId", connectionId);
+		return resolved.href;
+	}
+	function ensureOpen() {
+		if (closed) return Promise.reject(/* @__PURE__ */ new Error("live: stream is closed."));
+		const shouldResubscribe = resubscribeOnNextOpen;
+		if (reconnectTimer != null) {
+			clearTimeout(reconnectTimer);
+			reconnectTimer = null;
+		}
+		if (openPromise) return openPromise;
+		resubscribeOnNextOpen = false;
+		if (shouldResubscribe) resubscribeWithNextFlush = true;
+		return openSource(false);
+	}
+	function openSource(resubscribeOnOpen) {
+		const current = new ResolvedEventSource(streamUrl(), { withCredentials: options.withCredentials });
+		source = current;
+		let opened = false;
+		openPromise = new Promise((resolve, reject) => {
+			rejectOpen = reject;
+			const onOpen = () => {
+				if (source !== current) return;
+				if (!opened) {
+					opened = true;
+					rejectOpen = null;
+					resolve();
+					if (resubscribeOnOpen) resubscribeAll().catch(reportError);
+					return;
+				}
+				resubscribeAll().catch(reportError);
+			};
+			const onError = (event) => {
+				reportError(event);
+				if (source !== current) return;
+				if (!opened) {
+					current.removeEventListener("open", onOpen);
+					current.removeEventListener("error", onError);
+					current.removeEventListener("message", onMessage);
+					current.close();
+					source = null;
+					openPromise = null;
+					rejectOpen = null;
+					reject(/* @__PURE__ */ new Error("live: stream failed to open."));
+					if (resubscribeOnOpen) scheduleReconnectTimer();
+					return;
+				}
+				scheduleReconnect(current);
+			};
+			current.addEventListener("open", onOpen);
+			current.addEventListener("error", onError);
+			current.addEventListener("message", onMessage);
+		});
+		return openPromise;
+	}
+	function scheduleReconnect(current) {
+		if (closed || reconnectTimer != null) return;
+		current.close();
+		if (source === current) {
+			source = null;
+			openPromise = null;
+		}
+		if (!options.keepOpen && subscriptions.size === 0) return;
+		scheduleReconnectTimer();
+	}
+	function scheduleReconnectTimer() {
+		if (closed || reconnectTimer != null || !options.keepOpen && subscriptions.size === 0) return;
+		resubscribeOnNextOpen = true;
+		reconnectTimer = setTimeout(() => {
+			reconnectTimer = null;
+			if (closed || !options.keepOpen && subscriptions.size === 0) {
+				resubscribeOnNextOpen = false;
+				return;
+			}
+			resubscribeOnNextOpen = false;
+			openSource(true).catch((error) => {
+				if (!closed) reportError(error);
+			});
+		}, retryDelay);
+	}
+	function reportError(error) {
+		if (error instanceof Event || error instanceof Error) options.onError?.(error);
+		else options.onError?.(new Error(String(error)));
+	}
+	function onMessage(raw) {
+		const message = raw;
+		let event;
+		try {
+			event = JSON.parse(String(message.data));
+		} catch (error) {
+			reportError(error);
+			return;
+		}
+		const subscription = subscriptions.get(event.subscriptionId);
+		if (!subscription) return;
+		if (subscription.topic !== event.topic) return;
+		if (event.eventId) subscription.lastEventId = event.eventId;
+		subscription.onEvent?.(event);
+	}
+	function enqueue(operation) {
+		const promise = new Promise((resolve, reject) => {
+			pendingOperations.push({
+				operation,
+				resolve,
+				reject
+			});
+		});
+		scheduleFlush();
+		return promise;
+	}
+	function scheduleFlush() {
+		if (pendingFlush) return;
+		const scheduled = flushChain.then(flush);
+		pendingFlush = scheduled;
+		flushChain = scheduled.catch(() => {});
+		scheduled.finally(() => {
+			if (pendingFlush === scheduled) pendingFlush = null;
+			if (pendingOperations.length > 0) scheduleFlush();
+		});
+	}
+	async function flush() {
+		const pending = pendingOperations;
+		pendingOperations = [];
+		if (pending.length === 0) return;
+		try {
+			await ensureOpen();
+			let operations = pending.map((entry) => entry.operation);
+			if (resubscribeWithNextFlush) {
+				resubscribeWithNextFlush = false;
+				const pendingIds = new Set(operations.map((operation) => operation.id));
+				operations = [...[...subscriptions.values()].filter((subscription) => !pendingIds.has(subscription.id)).map((subscription) => ({
+					kind: "subscribe",
+					id: subscription.id,
+					topic: subscription.topic,
+					...subscription.lastEventId !== void 0 && { lastEventId: subscription.lastEventId }
+				})), ...operations];
+			}
+			const headers = new Headers(typeof options.headers === "function" ? await options.headers() : options.headers);
+			headers.set("content-type", "application/json");
+			const response = await fetchImpl(String(url), {
+				method: "POST",
+				headers,
+				credentials: options.withCredentials ? "include" : "same-origin",
+				body: JSON.stringify({
+					connectionId,
+					operations
+				})
+			});
+			const result = await response.json();
+			if (!response.ok || !result.accepted) throw new Error(result.accepted ? response.statusText : result.error.message);
+			const remaining = [...result.results];
+			for (const entry of pending) {
+				const index = remaining.findIndex((item) => item.id === entry.operation.id && item.kind === entry.operation.kind);
+				const item = index === -1 ? void 0 : remaining.splice(index, 1)[0];
+				if (!item) entry.reject(/* @__PURE__ */ new Error(`live: missing control result for ${entry.operation.id}.`));
+				else if (item.ok) entry.resolve();
+				else entry.reject(new Error(item.error.message));
+			}
+		} catch (error) {
+			for (const entry of pending) entry.reject(error);
+		}
+	}
+	async function resubscribeAll() {
+		const activeSubscriptions = [...subscriptions.values()];
+		if (activeSubscriptions.length === 0) return;
+		await Promise.all(activeSubscriptions.map((subscription) => enqueue({
+			kind: "subscribe",
+			id: subscription.id,
+			topic: subscription.topic,
+			...subscription.lastEventId !== void 0 && { lastEventId: subscription.lastEventId }
+		})));
+	}
+	function closeIfIdle() {
+		if (!options.keepOpen && subscriptions.size === 0) {
+			if (reconnectTimer != null) {
+				clearTimeout(reconnectTimer);
+				reconnectTimer = null;
+			}
+			resubscribeOnNextOpen = false;
+			resubscribeWithNextFlush = false;
+			source?.close();
+			source = null;
+			openPromise = null;
+			rejectOpen = null;
+		}
+	}
+	return {
+		connectionId,
+		async subscribe(subscribeOptions) {
+			const version = ++nextSubscriptionVersion;
+			const previousSubscription = subscriptions.get(subscribeOptions.id);
+			const previousVersion = subscriptionVersions.get(subscribeOptions.id);
+			subscriptionVersions.set(subscribeOptions.id, version);
+			const subscription = {
+				id: subscribeOptions.id,
+				topic: subscribeOptions.topic,
+				lastEventId: subscribeOptions.lastEventId,
+				onEvent: subscribeOptions.onEvent
+			};
+			subscriptions.set(subscription.id, subscription);
+			try {
+				await enqueue({
+					kind: "subscribe",
+					id: subscription.id,
+					topic: subscription.topic,
+					...subscription.lastEventId !== void 0 && { lastEventId: subscription.lastEventId }
+				});
+			} catch (error) {
+				if (subscriptionVersions.get(subscription.id) === version) if (previousSubscription) {
+					subscriptions.set(subscription.id, previousSubscription);
+					if (previousVersion != null) subscriptionVersions.set(subscription.id, previousVersion);
+					else subscriptionVersions.delete(subscription.id);
+				} else {
+					subscriptions.delete(subscription.id);
+					subscriptionVersions.delete(subscription.id);
+				}
+				queueMicrotask(closeIfIdle);
+				throw error;
+			}
+			if (closed) throw new Error("live: stream is closed.");
+			let unsubscribed = false;
+			return async () => {
+				if (unsubscribed) return;
+				unsubscribed = true;
+				if (subscriptionVersions.get(subscription.id) !== version || subscriptions.get(subscription.id) !== subscription) return;
+				await enqueue({
+					kind: "unsubscribe",
+					id: subscription.id
+				});
+				if (subscriptions.get(subscription.id) === subscription) {
+					subscriptions.delete(subscription.id);
+					subscriptionVersions.delete(subscription.id);
+				}
+				closeIfIdle();
+			};
+		},
+		close() {
+			const closeError = /* @__PURE__ */ new Error("live: stream is closed.");
+			closed = true;
+			subscriptions.clear();
+			subscriptionVersions.clear();
+			if (reconnectTimer != null) {
+				clearTimeout(reconnectTimer);
+				reconnectTimer = null;
+			}
+			resubscribeOnNextOpen = false;
+			resubscribeWithNextFlush = false;
+			for (const entry of pendingOperations) entry.reject(closeError);
+			pendingOperations = [];
+			rejectOpen?.(closeError);
+			rejectOpen = null;
+			source?.close();
+			source = null;
+			openPromise = null;
+		}
+	};
+}
+//#endregion
+export { connectLiveStream };

package/dist/runtime/live-server.d.mts

@@ -0,0 +1,13 @@
+/// <reference types="@cloudflare/workers-types" />
+//#region src/runtime/live-server.d.ts
+type LiveDurableObjectEnv = Record<string, unknown>;
+interface LiveDurableObjectInstance {
+  fetch(request: Request): Promise<Response>;
+  alarm?(): Promise<void>;
+}
+interface LiveDurableObjectClass {
+  new (state: DurableObjectState, env: LiveDurableObjectEnv): LiveDurableObjectInstance;
+}
+declare function createLiveDurableObject(): LiveDurableObjectClass;
+//#endregion
+export { LiveDurableObjectClass, LiveDurableObjectInstance, createLiveDurableObject };