@kbve/droid 0.0.5 → 0.1.1

package/src/lib/workers/db-worker.ts

@@ -9,18 +9,19 @@ interface SharedWorkerGlobalScope extends Worker {
 declare const self: SharedWorkerGlobalScope;
 
 class AppDexie extends Dexie {
-	settings!: Table<{ id: string; value: any }, string>;
-	meta!: Table<{ key: string; value: any }, string>;
-	i18n!: Table<{ key: string; value: string }, string>;
-	htmlservers!: Table<{ key: string; value: string }, string>;
-	servers!: Table<DiscordServer, string>;
-	tags!: Table<DiscordTag, string>;
-	profiles!: Table<Profile, string>;
-	ws_messages!: Table<{ key: string; message: any }, string>;
+	settings!: Table<{ id: string; value: unknown }>;
+	meta!: Table<{ key: string; value: unknown }>;
+	i18n!: Table<{ key: string; value: string }>;
+	htmlservers!: Table<{ key: string; value: string }>;
+	servers!: Table<DiscordServer>;
+	tags!: Table<DiscordTag>;
+	profiles!: Table<Profile>;
+	ws_messages!: Table<{ key: string; message: Record<string, unknown> }>;
+	auth_tokens!: Table<{ key: string; value: string; expires_at?: number }>;
 
 	constructor() {
 		super('AppStorage');
-		this.version(3).stores({
+		this.version(4).stores({
 			settings: '&id',
 			meta: '&key',
 			i18n: '&key',
@@ -29,15 +30,12 @@ class AppDexie extends Dexie {
 			tags: '&tag_id',
 			profiles: '&profile_id',
 			ws_messages: '&key',
+			auth_tokens: '&key',
 		});
 	}
 }
 const db = new AppDexie();
 
-function delay(ms: number) {
-	return new Promise((res) => setTimeout(res, ms));
-}
-
 function renderHtmlForServer(server: DiscordServer): string {
 	return `
 		<div class="flex flex-col gap-2 p-2">
@@ -51,19 +49,23 @@ function renderHtmlForServer(server: DiscordServer): string {
 
 // --- Comlink-Safe API ---
 const storageAPI = {
-
 	// WebSocket
 
 	async storeWsMessage(key: string, buffer: ArrayBuffer) {
-		const decoded = toReference(buffer).toObject();
+		const decoded = toReference(buffer).toObject() as Record<
+			string,
+			unknown
+		>;
 		await db.ws_messages.put({ key, message: decoded });
 	},
 
 	async getWsMessage(key: string) {
 		return (await db.ws_messages.get(key))?.message ?? null;
 	},
-	
-	async getAllWsMessages(): Promise<{ key: string; message: any }[]> {
+
+	async getAllWsMessages(): Promise<
+		{ key: string; message: Record<string, unknown> }[]
+	> {
 		const raw = await db.ws_messages.toArray();
 		return raw.sort((a, b) => {
 			const at = Number(a.key.split(':')[1]);
@@ -71,7 +73,7 @@ const storageAPI = {
 			return bt - at;
 		});
 	},
-	
+
 	async clearWsMessages() {
 		await db.ws_messages.clear();
 	},
@@ -95,20 +97,31 @@ const storageAPI = {
 		}));
 		await db.i18n.bulkPut(entries);
 	},
-	async loadI18nFromJSON(path = 'https://discord.sh/i18n/db.json') {
-	const res = await fetch(path);
-	const data = await res.json();
-	await storageAPI.putI18nBatch(data);
+	async loadI18nFromJSON(path: string) {
+		const res = await fetch(path);
+		if (!res.ok) {
+			console.warn(
+				`[db-worker] i18n fetch failed: ${res.status} ${res.statusText}`,
+			);
+			return;
+		}
+		const data = await res.json();
+		await storageAPI.putI18nBatch(data);
 	},
 	async getAllI18nKeys(): Promise<string[]> {
-		const all = await db.i18n.toCollection().primaryKeys();
-		return all as string[];
+		return (await db.i18n.toCollection().primaryKeys()) as string[];
 	},
 
-	async loadServersFromJSON(path = 'https://discord.sh/data/servers.json') {
+	async loadServersFromJSON(path: string) {
 		const res = await fetch(path);
+		if (!res.ok) {
+			console.warn(
+				`[db-worker] servers fetch failed: ${res.status} ${res.statusText}`,
+			);
+			return;
+		}
 		const data = await res.json();
-	
+
 		// The JSON should be a Record<string, DiscordServer>
 		const servers: DiscordServer[] = Object.values(data);
 		await storageAPI.putServers(servers);
@@ -118,26 +131,32 @@ const storageAPI = {
 	// HTML PreRender
 	async syncHtmlFromServers() {
 		const allServers = await db.servers.toArray();
-		const existingHtmlKeys = await db.htmlservers.toCollection().primaryKeys();
+		const existingHtmlKeys = await db.htmlservers
+			.toCollection()
+			.primaryKeys();
 		const missing: { key: string; value: string }[] = [];
-	
+
 		for (const server of allServers) {
 			if (!existingHtmlKeys.includes(server.server_id)) {
 				const html = renderHtmlForServer(server);
 				missing.push({ key: server.server_id, value: html });
 			}
 		}
-	
+
 		if (missing.length > 0) {
 			await db.htmlservers.bulkPut(missing);
-			console.info(`[syncHtmlFromServers] Generated ${missing.length} HTML cards.`);
+			console.info(
+				`[syncHtmlFromServers] Generated ${missing.length} HTML cards.`,
+			);
 		} else {
-			console.info('[syncHtmlFromServers] All servers already have HTML cards.');
+			console.info(
+				'[syncHtmlFromServers] All servers already have HTML cards.',
+			);
 		}
 	},
 
 	// Settings
-	async dbSet(id: string, value: any) {
+	async dbSet(id: string, value: unknown) {
 		await db.settings.put({ id, value });
 	},
 	async dbGet(id: string) {
@@ -192,12 +211,40 @@ const storageAPI = {
 	async getAllProfiles() {
 		return await db.profiles.toArray();
 	},
+
+	// Auth Tokens (IDB-backed auth storage)
+	async setAuthToken(key: string, value: string, expiresAt?: number) {
+		await db.auth_tokens.put({ key, value, expires_at: expiresAt });
+	},
+	async getAuthToken(key: string): Promise<string | null> {
+		const record = await db.auth_tokens.get(key);
+		if (!record) return null;
+		if (record.expires_at && Date.now() > record.expires_at) {
+			await db.auth_tokens.delete(key);
+			return null;
+		}
+		return record.value;
+	},
+	async removeAuthToken(key: string) {
+		await db.auth_tokens.delete(key);
+	},
+	async clearAuthTokens() {
+		await db.auth_tokens.clear();
+	},
 };
 
 export type LocalStorageAPI = typeof storageAPI;
 
+const ports = new Set<MessagePort>();
+
 self.onconnect = (event: MessageEvent) => {
 	const port = event.ports[0];
+	const isFirst = ports.size === 0;
+	ports.add(port);
 	port.start();
+	port.postMessage({ type: isFirst ? 'first-connect' : 'reconnect' });
+	port.addEventListener('message', (e: MessageEvent) => {
+		if (e.data?.type === 'close') ports.delete(port);
+	});
 	expose(storageAPI, port);
 };

package/src/lib/workers/events.spec.ts

@@ -0,0 +1,208 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// We need a fresh DroidEventBus for each test, so import the class-creating module
+// and re-instantiate. Since the module exports a singleton, we'll test via dynamic import.
+// Actually, let's just test the singleton and reset between tests.
+
+// The module exports a singleton `DroidEvents`. We can still test it
+// by carefully managing listener cleanup.
+
+import { DroidEvents } from './events';
+
+beforeEach(() => {
+	// Remove all listeners by re-creating internal state isn't possible
+	// with the singleton, so we rely on off() in each test.
+});
+
+describe('DroidEventBus', () => {
+	it('should register and fire a listener via on/emit', () => {
+		const handler = vi.fn();
+		DroidEvents.on('droid-ready', handler);
+
+		DroidEvents.emit('droid-ready', { timestamp: 123 });
+
+		expect(handler).toHaveBeenCalledOnce();
+		expect(handler).toHaveBeenCalledWith({ timestamp: 123 });
+
+		DroidEvents.off('droid-ready', handler);
+	});
+
+	it('should unregister a listener via off', () => {
+		const handler = vi.fn();
+		DroidEvents.on('droid-ready', handler);
+		DroidEvents.off('droid-ready', handler);
+
+		DroidEvents.emit('droid-ready', { timestamp: 1 });
+
+		expect(handler).not.toHaveBeenCalled();
+	});
+
+	it('should support multiple listeners on the same event', () => {
+		const h1 = vi.fn();
+		const h2 = vi.fn();
+		DroidEvents.on('droid-ready', h1);
+		DroidEvents.on('droid-ready', h2);
+
+		DroidEvents.emit('droid-ready', { timestamp: 1 });
+
+		expect(h1).toHaveBeenCalledOnce();
+		expect(h2).toHaveBeenCalledOnce();
+
+		DroidEvents.off('droid-ready', h1);
+		DroidEvents.off('droid-ready', h2);
+	});
+
+	it('should not fail when removing a listener that was never added', () => {
+		const handler = vi.fn();
+		expect(() => DroidEvents.off('droid-ready', handler)).not.toThrow();
+	});
+
+	it('should validate payload via Zod and reject invalid payloads', () => {
+		const handler = vi.fn();
+		DroidEvents.on('droid-ready', handler);
+
+		const consoleSpy = vi
+			.spyOn(console, 'error')
+			.mockImplementation(() => undefined);
+
+		// @ts-expect-error intentionally passing invalid payload
+		DroidEvents.emit('droid-ready', { timestamp: 'not-a-number' });
+
+		expect(handler).not.toHaveBeenCalled();
+		expect(consoleSpy).toHaveBeenCalledWith(
+			expect.stringContaining('[DroidEventBus] Invalid payload'),
+			expect.anything(),
+		);
+
+		consoleSpy.mockRestore();
+		DroidEvents.off('droid-ready', handler);
+	});
+
+	it('should dispatch a CustomEvent on window', () => {
+		const windowHandler = vi.fn();
+		window.addEventListener('droid-ready', windowHandler);
+
+		DroidEvents.emit('droid-ready', { timestamp: 42 });
+
+		expect(windowHandler).toHaveBeenCalledOnce();
+		const event = windowHandler.mock.calls[0][0] as CustomEvent;
+		expect(event.detail).toEqual({ timestamp: 42 });
+
+		window.removeEventListener('droid-ready', windowHandler);
+	});
+
+	it('should catch and log listener errors without breaking other listeners', () => {
+		const badHandler = vi.fn(() => {
+			throw new Error('boom');
+		});
+		const goodHandler = vi.fn();
+
+		DroidEvents.on('droid-ready', badHandler);
+		DroidEvents.on('droid-ready', goodHandler);
+
+		const consoleSpy = vi
+			.spyOn(console, 'error')
+			.mockImplementation(() => undefined);
+
+		DroidEvents.emit('droid-ready', { timestamp: 1 });
+
+		expect(badHandler).toHaveBeenCalledOnce();
+		expect(goodHandler).toHaveBeenCalledOnce();
+		expect(consoleSpy).toHaveBeenCalledWith(
+			expect.stringContaining('[DroidEventBus] Listener error'),
+			expect.anything(),
+		);
+
+		consoleSpy.mockRestore();
+		DroidEvents.off('droid-ready', badHandler);
+		DroidEvents.off('droid-ready', goodHandler);
+	});
+
+	it('should resolve wait() when the event fires', async () => {
+		const promise = DroidEvents.wait('droid-ready');
+
+		DroidEvents.emit('droid-ready', { timestamp: 999 });
+
+		const result = await promise;
+		expect(result).toEqual({ timestamp: 999 });
+	});
+
+	it('wait() should auto-unregister after resolving', async () => {
+		const promise = DroidEvents.wait('droid-ready');
+		DroidEvents.emit('droid-ready', { timestamp: 1 });
+		await promise;
+
+		// Emit again — the wait handler should not fire again
+		// (no way to directly test, but ensures no memory leak)
+		const handler = vi.fn();
+		DroidEvents.on('droid-ready', handler);
+		DroidEvents.emit('droid-ready', { timestamp: 2 });
+		expect(handler).toHaveBeenCalledOnce();
+		DroidEvents.off('droid-ready', handler);
+	});
+
+	it('should emit droid-downscale event with level payload', () => {
+		const handler = vi.fn();
+		DroidEvents.on('droid-downscale', handler);
+
+		DroidEvents.emit('droid-downscale', {
+			timestamp: Date.now(),
+			level: 'minimal',
+		});
+
+		expect(handler).toHaveBeenCalledOnce();
+		expect(handler.mock.calls[0][0].level).toBe('minimal');
+
+		DroidEvents.off('droid-downscale', handler);
+	});
+
+	it('should emit droid-upscale event with level payload', () => {
+		const handler = vi.fn();
+		DroidEvents.on('droid-upscale', handler);
+
+		DroidEvents.emit('droid-upscale', {
+			timestamp: Date.now(),
+			level: 'full',
+		});
+
+		expect(handler).toHaveBeenCalledOnce();
+		expect(handler.mock.calls[0][0].level).toBe('full');
+
+		DroidEvents.off('droid-upscale', handler);
+	});
+
+	it('should emit panel-open and panel-close events', () => {
+		const openHandler = vi.fn();
+		const closeHandler = vi.fn();
+		DroidEvents.on('panel-open', openHandler);
+		DroidEvents.on('panel-close', closeHandler);
+
+		DroidEvents.emit('panel-open', { id: 'left' });
+		DroidEvents.emit('panel-close', { id: 'right' });
+
+		expect(openHandler).toHaveBeenCalledWith({ id: 'left' });
+		expect(closeHandler).toHaveBeenCalledWith({ id: 'right' });
+
+		DroidEvents.off('panel-open', openHandler);
+		DroidEvents.off('panel-close', closeHandler);
+	});
+
+	it('should emit toast events', () => {
+		const handler = vi.fn();
+		DroidEvents.on('toast-added', handler);
+
+		DroidEvents.emit('toast-added', {
+			id: 'toast-1',
+			message: 'Hello',
+			severity: 'info',
+		});
+
+		expect(handler).toHaveBeenCalledWith({
+			id: 'toast-1',
+			message: 'Hello',
+			severity: 'info',
+		});
+
+		DroidEvents.off('toast-added', handler);
+	});
+});

package/src/lib/workers/events.ts

@@ -1,23 +1,26 @@
 import { DroidEventSchemas } from '../types/event-types';
-import type { DroidEventMap, EventKey, EventHandler  } from '../types/event-types';
-
-import { z } from 'zod';
-
+import type {
+	DroidEventMap,
+	EventKey,
+	EventHandler,
+} from '../types/event-types';
 
 class DroidEventBus {
-    private listeners = new Map<EventKey, Set<(payload: unknown) => void>>();
+	private listeners = new Map<EventKey, Set<(payload: unknown) => void>>();
 
-    on<K extends EventKey>(event: K, handler: EventHandler<K>) {
+	on<K extends EventKey>(event: K, handler: EventHandler<K>) {
 		let handlers = this.listeners.get(event);
-        if (!handlers) {
-            handlers = new Set();
-            this.listeners.set(event, handlers);
-        }
-        handlers.add(handler as (payload: unknown) => void);
+		if (!handlers) {
+			handlers = new Set();
+			this.listeners.set(event, handlers);
+		}
+		handlers.add(handler as (payload: unknown) => void);
 	}
 
 	off<K extends EventKey>(event: K, handler: EventHandler<K>) {
-		this.listeners.get(event)?.delete(handler as (payload: unknown) => void);
+		this.listeners
+			.get(event)
+			?.delete(handler as (payload: unknown) => void);
 	}
 
 	emit<K extends EventKey>(event: K, payload: DroidEventMap[K]) {
@@ -26,7 +29,10 @@ class DroidEventBus {
 			try {
 				schema.parse(payload);
 			} catch (err) {
-				console.error(`[DroidEventBus] Invalid payload for ${event}:`, err);
+				console.error(
+					`[DroidEventBus] Invalid payload for ${event}:`,
+					err,
+				);
 				return;
 			}
 		}
@@ -34,7 +40,14 @@ class DroidEventBus {
 		window.dispatchEvent(new CustomEvent(event, { detail: payload }));
 
 		for (const handler of this.listeners.get(event) ?? []) {
-			(handler as EventHandler<K>)(payload);
+			try {
+				(handler as EventHandler<K>)(payload);
+			} catch (err) {
+				console.error(
+					`[DroidEventBus] Listener error for ${event}:`,
+					err,
+				);
+			}
 		}
 	}
 

package/src/lib/workers/flexbuilder.ts

@@ -1,5 +1,5 @@
-import { Builder as FlexBuilder } from 'flatbuffers/ts/flexbuffers/builder';
-export { toReference } from 'flatbuffers/ts/flexbuffers/reference';
+import { Builder as FlexBuilder } from 'flatbuffers/js/flexbuffers/builder';
+export { toReference } from 'flatbuffers/js/flexbuffers/reference';
 
 export function builder(): FlexBuilder {
   return new FlexBuilder();

package/src/lib/workers/init.ts

@@ -1,40 +1,48 @@
-import type { Remote } from 'comlink'
-import type { LocalStorageAPI } from './db-worker'
+import type { Remote } from 'comlink';
+import type { LocalStorageAPI } from './db-worker';
 
 export interface InitWorkerOptions {
-	version: string
-	i18nPath?: string
-	locale?: string
-	defaults?: Record<string, any>
+	version: string;
+	i18nPath?: string;
+	dataPath?: string;
+	locale?: string;
+	defaults?: Record<string, string>;
 }
 
 export async function initializeWorkerDatabase(
 	worker: Remote<LocalStorageAPI>,
 	{
 		version,
-		i18nPath = 'https://discord.sh/i18n/db.json',
+		i18nPath,
+		dataPath,
 		locale = 'en',
 		defaults = {
 			welcome: 'Welcome to the app!',
 		},
-	}: InitWorkerOptions
+	}: InitWorkerOptions,
 ) {
-	console.log('[init-worker] Initializing database...')
+	console.log('[init-worker] Initializing database...');
 
 	try {
-		await worker.loadI18nFromJSON(i18nPath)
-		console.log(`[init-worker] i18n loaded from ${i18nPath}`)
+		if (i18nPath) {
+			await worker.loadI18nFromJSON(i18nPath);
+			console.log(`[init-worker] i18n loaded from ${i18nPath}`);
+		}
 
-		await worker.dbSet('locale', locale)
+		await worker.dbSet('locale', locale);
 
 		for (const [key, value] of Object.entries(defaults)) {
-			await worker.dbSet(key, value)
+			await worker.dbSet(key, value);
+		}
+
+		await worker.setVersion(version);
+
+		if (dataPath) {
+			void worker.loadServersFromJSON(dataPath);
 		}
 
-		await worker.setVersion(version)
-		void worker.loadServersFromJSON(); // await worker.loadServersFromJSON();
-		console.log(`[init-worker] DB initialized to version ${version}`)
+		console.log(`[init-worker] DB initialized to version ${version}`);
 	} catch (err) {
-		console.error('[init-worker] Initialization failed:', err)
+		console.error('[init-worker] Initialization failed:', err);
 	}
 }