@spooky-sync/core 0.0.1-canary.32 → 0.0.1-canary.321

package/dist/sw.js

@@ -0,0 +1,393 @@
+import { n as decodeTokenClaims } from "./worker-impersonation.js";
+import { a as sameBytes, i as isPushPayload, n as base64UrlToBytes, r as bytesToBase64Url, t as PUSH_PAYLOAD_VERSION } from "./worker-types.js";
+
+//#region src/sw/store.ts
+const PUSH_DB_NAME = "sp00ky-push";
+const PUSH_STORE_NAME = "kv";
+function memoryStore() {
+	const map = /* @__PURE__ */ new Map();
+	return {
+		get: async (key) => map.get(key),
+		set: async (key, value) => void map.set(key, value),
+		delete: async (key) => void map.delete(key)
+	};
+}
+function idbStore(dbName = PUSH_DB_NAME, storeName = PUSH_STORE_NAME, factory) {
+	let opening = null;
+	const open = () => {
+		if (opening) return opening;
+		const idb = factory ?? globalThis.indexedDB;
+		if (!idb) return Promise.reject(/* @__PURE__ */ new Error("indexedDB unavailable"));
+		opening = new Promise((resolve, reject) => {
+			const req = idb.open(dbName, 1);
+			req.onupgradeneeded = () => {
+				if (!req.result.objectStoreNames.contains(storeName)) req.result.createObjectStore(storeName);
+			};
+			req.onsuccess = () => {
+				const db = req.result;
+				db.onversionchange = () => {
+					db.close();
+					opening = null;
+				};
+				resolve(db);
+			};
+			req.onerror = () => {
+				opening = null;
+				reject(req.error);
+			};
+		});
+		return opening;
+	};
+	const run = async (mode, op) => {
+		const db = await open();
+		return new Promise((resolve, reject) => {
+			const tx = db.transaction(storeName, mode);
+			const req = op(tx.objectStore(storeName));
+			tx.oncomplete = () => resolve(req.result);
+			tx.onerror = () => reject(tx.error ?? req.error);
+			tx.onabort = () => reject(tx.error ?? req.error);
+		});
+	};
+	return {
+		get: (key) => run("readonly", (s) => s.get(key)),
+		set: async (key, value) => {
+			await run("readwrite", (s) => s.put(value, key));
+		},
+		delete: async (key) => {
+			await run("readwrite", (s) => s.delete(key));
+		}
+	};
+}
+let shared = null;
+/** IndexedDB when it exists, else one process-wide memory store. */
+function defaultStore() {
+	if (shared) return shared;
+	shared = typeof globalThis.indexedDB !== "undefined" ? idbStore() : memoryStore();
+	return shared;
+}
+
+//#endregion
+//#region src/sw/index.ts
+const DEFAULT_PLACEHOLDER = {
+	title: "New notification",
+	body: "Open the app to see what is new."
+};
+const PLACEHOLDER_TAG = "sp00ky-placeholder";
+const TOKEN_KEY = "token";
+/** The session the page bridged, or null (none, signed out, or its JWT expired). */
+async function getBridgedToken(store = defaultStore()) {
+	let value;
+	try {
+		value = await store.get(TOKEN_KEY);
+	} catch {
+		return null;
+	}
+	if (!value || typeof value.token !== "string") return null;
+	const { exp } = decodeTokenClaims(value.token);
+	if (exp !== null && exp * 1e3 <= Date.now()) return null;
+	return value;
+}
+function isTokenMessage(data) {
+	const m = data;
+	return !!m && m.type === "sp00ky:token" && typeof m.token === "string" && typeof m.userId === "string" && typeof m.endpoint === "string" && typeof m.namespace === "string" && typeof m.database === "string";
+}
+function dropUndefined(obj) {
+	for (const key of Object.keys(obj)) if (obj[key] === void 0) delete obj[key];
+	return obj;
+}
+/**
+* `showNotification(title, options)` arguments for a spec: every key passes
+* through except `title` and `url`; `tag` defaults to the topic; `data` gets
+* `url`, the payload and per-action urls next to the spec's own data.
+*/
+function notificationOptions(spec, payload, extraData) {
+	const { title, url, data, tag, actions, renotify, ...rest } = spec;
+	const actionUrls = {};
+	for (const a of actions ?? []) if (a && typeof a.url === "string") actionUrls[a.action] = a.url;
+	const finalTag = tag ?? payload?.topic;
+	return [title, dropUndefined({
+		...rest,
+		tag: finalTag,
+		actions: actions?.map(({ url: _url, ...a }) => a),
+		renotify: finalTag ? renotify : void 0,
+		data: dropUndefined({
+			...data,
+			url,
+			payload,
+			actionUrls: Object.keys(actionUrls).length > 0 ? actionUrls : void 0,
+			...extraData
+		})
+	})];
+}
+/** Wire the push, click, close, message and subscription-change handlers. Returns an uninstall. */
+function installPushHandlers(options = {}) {
+	const scope = options.scope ?? globalThis;
+	const store = options.store ?? defaultStore();
+	const suppress = options.suppressWhenVisible !== false;
+	const placeholder = options.placeholder ?? DEFAULT_PLACEHOLDER;
+	const resolveUrl = (url, payload) => {
+		if (options.resolveUrl) return options.resolveUrl(url, payload);
+		try {
+			return new URL(url, scope.registration?.scope || scope.location.origin).href;
+		} catch {
+			return url;
+		}
+	};
+	const windows = async () => {
+		return (await scope.clients.matchAll({
+			type: "window",
+			includeUncontrolled: true
+		})).filter((c) => {
+			try {
+				return new URL(c.url).origin === scope.location.origin;
+			} catch {
+				return false;
+			}
+		});
+	};
+	const visibleClients = async () => (await windows()).filter((c) => c.visibilityState === "visible");
+	const show = async (spec, payload, extraData) => {
+		const [title, opts] = notificationOptions(spec, payload, extraData);
+		await scope.registration.showNotification(title, opts);
+	};
+	const showPlaceholder = () => show({
+		...placeholder,
+		tag: PLACEHOLDER_TAG,
+		url: "/"
+	});
+	const ctxFor = (event, flag) => ({
+		event,
+		registration: scope.registration,
+		show: async (spec) => {
+			flag.shown = true;
+			await show(spec);
+		},
+		showPlaceholder: async () => {
+			flag.shown = true;
+			await showPlaceholder();
+		},
+		visibleClients,
+		bridged: () => getBridgedToken(store)
+	});
+	const renderLive = async (live, payload) => {
+		const bridged = await getBridgedToken(store);
+		if (!bridged) throw new Error("sp00ky push: no bridged session for live rendering");
+		const budget = live.timeoutMs ?? 8e3;
+		const started = Date.now();
+		const feed = await live.feed(bridged);
+		let rows = [];
+		try {
+			const sub = feed.subscribe(live.query(bridged.userId, payload), { onSet: (r) => void (rows = r) });
+			let timer;
+			const deadline = new Promise((_, reject) => {
+				timer = setTimeout(() => reject(/* @__PURE__ */ new Error("sp00ky push: live rows did not load in time")), budget);
+			});
+			try {
+				rows = await Promise.race([sub.ready, deadline]);
+			} finally {
+				clearTimeout(timer);
+			}
+			await feed.idle({
+				timeoutMs: Math.max(0, budget - (Date.now() - started)),
+				quietMs: live.quietMs
+			});
+			rows = sub.rows();
+		} finally {
+			await feed.close().catch(() => void 0);
+		}
+		const specs = rows.filter((row) => live.visible(row)).map((row) => live.render(row));
+		const wanted = new Set(specs.map((s) => s.tag));
+		const shown = await scope.registration.getNotifications();
+		let closed = 0;
+		for (const n of shown) if (n.data?.sp00kyLive && !wanted.has(n.tag)) {
+			n.close();
+			closed += 1;
+		}
+		for (const spec of specs) {
+			const existing = shown.find((n) => n.tag === spec.tag && n.data?.sp00kyLive);
+			if (existing && existing.title === spec.title && (existing.body ?? "") === (spec.body ?? "")) continue;
+			await show(spec, void 0, { sp00kyLive: true });
+		}
+		if ((await scope.registration.getNotifications()).length === 0 && (closed === 0 || live.silentClose === false)) await showPlaceholder();
+	};
+	const handlePush = async (event) => {
+		let payload = null;
+		try {
+			payload = event.data ? event.data.json() : null;
+		} catch {
+			payload = null;
+		}
+		if (!isPushPayload(payload)) {
+			await showPlaceholder();
+			return;
+		}
+		const flag = { shown: false };
+		const ctx = ctxFor(event, flag);
+		try {
+			if (options.onPush && await options.onPush(payload, ctx) === true) return;
+		} catch {
+			if (!flag.shown) await showPlaceholder();
+			return;
+		}
+		if (suppress) {
+			const visible = await visibleClients().catch(() => []);
+			if (visible.length > 0) {
+				const message = {
+					type: "sp00ky:push",
+					payload
+				};
+				for (const client of visible) client.postMessage(message);
+				return;
+			}
+		}
+		if (payload.notification) {
+			await show(options.render?.(payload) ?? {
+				...payload.notification,
+				title: payload.notification.title ?? placeholder.title
+			}, payload);
+			return;
+		}
+		try {
+			if (options.onNudge) {
+				await options.onNudge(payload, ctx);
+				return;
+			}
+			const custom = options.render?.(payload);
+			if (custom) {
+				await show(custom, payload);
+				return;
+			}
+			if (options.live) {
+				await renderLive(options.live, payload);
+				return;
+			}
+		} catch {
+			if (!flag.shown) await showPlaceholder();
+			return;
+		}
+		await showPlaceholder();
+	};
+	const handleClick = async (event) => {
+		const notification = event.notification;
+		const data = notification.data ?? {};
+		const payload = isPushPayload(data.payload) ? data.payload : void 0;
+		const action = event.action || void 0;
+		if (options.onClick && await options.onClick(event, payload, action) === true) return;
+		notification.close();
+		const url = resolveUrl(action && data.actionUrls?.[action] || data.url || "/", payload);
+		const open = await windows();
+		const target = open.find((c) => c.focused) ?? open.find((c) => c.visibilityState === "visible") ?? open[0];
+		if (!target) {
+			await scope.clients.openWindow(url);
+			return;
+		}
+		await target.focus().catch(() => void 0);
+		const message = {
+			type: "sp00ky:navigate",
+			url,
+			payload,
+			action
+		};
+		if (options.clickMode === "message") {
+			target.postMessage(message);
+			return;
+		}
+		if (target.url === url) return;
+		if (target.navigate) try {
+			await target.navigate(url);
+			return;
+		} catch {}
+		target.postMessage(message);
+	};
+	const handleClose = async (event) => {
+		const data = event.notification.data ?? {};
+		await options.onClose?.(event, isPushPayload(data.payload) ? data.payload : void 0);
+	};
+	const signOut = async () => {
+		await store.delete(TOKEN_KEY).catch(() => void 0);
+		const shown = await scope.registration.getNotifications().catch(() => []);
+		for (const n of shown) n.close();
+	};
+	const handleMessage = (event) => {
+		const data = event.data;
+		if (!data || typeof data !== "object") return;
+		if (event.origin && event.origin !== scope.location.origin) return;
+		let work = null;
+		if (isTokenMessage(data)) {
+			const value = {
+				token: data.token,
+				userId: data.userId,
+				endpoint: data.endpoint,
+				namespace: data.namespace,
+				database: data.database,
+				publicKey: typeof data.publicKey === "string" ? data.publicKey : void 0,
+				pushEndpoint: typeof data.pushEndpoint === "string" ? data.pushEndpoint : void 0,
+				at: Date.now()
+			};
+			work = store.set(TOKEN_KEY, dropUndefined({ ...value })).catch(() => void 0);
+		} else if (data.type === "sp00ky:signout") work = signOut();
+		if (work) event.waitUntil?.(work);
+	};
+	const handleSubscriptionChange = async (event) => {
+		if (options.resubscribe === false) return;
+		const bridged = await getBridgedToken(store);
+		let sub = event.newSubscription ?? null;
+		if (!sub) {
+			const key = event.oldSubscription?.options?.applicationServerKey ?? (bridged?.publicKey ? base64UrlToBytes(bridged.publicKey) : null);
+			const manager = scope.registration.pushManager;
+			if (key && manager) try {
+				sub = await manager.subscribe({
+					userVisibleOnly: true,
+					applicationServerKey: key
+				});
+			} catch {
+				sub = null;
+			}
+		}
+		const factory = options.live?.feed ?? options.feed;
+		if (sub && bridged && factory) {
+			let feed = null;
+			try {
+				feed = await factory(bridged);
+				const oldEndpoint = event.oldSubscription?.endpoint ?? bridged.pushEndpoint;
+				const [devices] = await feed.query("RETURN fn::push::list()");
+				const old = Array.isArray(devices) ? devices.find((d) => d.endpoint === oldEndpoint) : void 0;
+				await feed.query("RETURN fn::push::subscribe($sub, $opts)", {
+					sub: sub.toJSON(),
+					opts: dropUndefined({
+						label: old?.label ?? void 0,
+						rules: old?.rules ?? void 0,
+						meta: old?.meta ?? void 0,
+						userAgent: scope.navigator?.userAgent
+					})
+				});
+				if (oldEndpoint && oldEndpoint !== sub.endpoint) await feed.query("RETURN fn::push::unsubscribe($endpoint)", { endpoint: oldEndpoint });
+				await store.set(TOKEN_KEY, {
+					...bridged,
+					pushEndpoint: sub.endpoint
+				});
+			} catch {} finally {
+				await feed?.close().catch(() => void 0);
+			}
+		}
+		const message = {
+			type: "sp00ky:subscriptionchange",
+			endpoint: sub?.endpoint
+		};
+		for (const client of await windows().catch(() => [])) client.postMessage(message);
+	};
+	const listeners = [
+		["push", (event) => event.waitUntil(handlePush(event).catch(() => showPlaceholder().catch(() => void 0)))],
+		["notificationclick", (event) => event.waitUntil(handleClick(event).catch(() => void 0))],
+		["notificationclose", (event) => event.waitUntil?.(handleClose(event).catch(() => void 0))],
+		["message", handleMessage],
+		["pushsubscriptionchange", (event) => event.waitUntil(handleSubscriptionChange(event).catch(() => void 0))]
+	];
+	for (const [type, listener] of listeners) scope.addEventListener(type, listener);
+	return () => {
+		for (const [type, listener] of listeners) scope.removeEventListener(type, listener);
+	};
+}
+
+//#endregion
+export { DEFAULT_PLACEHOLDER, PUSH_DB_NAME, PUSH_PAYLOAD_VERSION, PUSH_STORE_NAME, base64UrlToBytes, bytesToBase64Url, defaultStore, getBridgedToken, idbStore, installPushHandlers, isPushPayload, memoryStore, notificationOptions, sameBytes };

package/dist/tabs-broker-worker.d.ts

@@ -0,0 +1,8 @@
+//#region src/services/tabs/tabs-broker-worker.d.ts
+/** Attach a connecting tab's port. Exported for the node test harness, which
+ *  drives the broker with fake MessagePort pairs instead of a SharedWorker. */
+declare function handleConnect(port: MessagePort): void;
+/** Test-only: wipe module state so each test starts with a fresh broker. */
+declare function __resetBrokerForTests(): void;
+//#endregion
+export { __resetBrokerForTests, handleConnect };