@kbve/droid 0.0.1 → 0.0.3

package/src/lib/workers/data.ts

@@ -0,0 +1,215 @@
+import { PayloadFormat, JediEnvelopeFlex, MessageKind } from '../types/jedi';
+import { builder, toReference } from './flexbuilder';
+
+
+function buildFlexPayload<T extends Record<string, any>>(payload: T): Uint8Array {
+	const b = builder();
+	b.startMap();
+
+	for (const [key, value] of Object.entries(payload)) {
+		b.addKey(key);
+		b.add(value);
+	}
+
+	b.end();
+	return b.finish();
+}
+
+export function wrapEnvelope<T extends Record<string, any>>(
+	payload: T,
+	kind: number,
+	format: PayloadFormat,
+	metadata?: Uint8Array,
+	version = 1,
+): Uint8Array {
+	let serializedPayload: Uint8Array;
+
+	if (format === PayloadFormat.FLEX) {
+		serializedPayload = buildFlexPayload(payload);
+	} else if (format === PayloadFormat.JSON) {
+		serializedPayload = new TextEncoder().encode(JSON.stringify(payload));
+	} else {
+		throw new Error('Unsupported format for wrapEnvelope');
+	}
+
+	const b = builder();
+	b.startMap();
+	b.addKey('version');  b.add(version);
+	b.addKey('kind');     b.add(kind);
+	b.addKey('format');   b.add(format);
+	b.addKey('payload');  b.add(serializedPayload);
+	b.addKey('metadata'); b.add(metadata ?? new Uint8Array());
+	b.end();
+
+	return b.finish();
+}
+
+export function unwrapEnvelope<T = unknown>(
+	buffer: Uint8Array | ArrayBuffer
+): { envelope: JediEnvelopeFlex; payload: T } {
+	const view = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+
+	const root = toReference(view.buffer as ArrayBuffer).toObject() as Record<string, any>;
+
+	if (
+		typeof root['version'] !== 'number' ||
+		typeof root['kind'] !== 'number' ||
+		typeof root['format'] !== 'number' ||
+		!root['payload']
+	) {
+		console.error('[unwrapEnvelope] Bad root:', root);
+		throw new Error('[unwrapEnvelope] Invalid envelope structure');
+	}
+
+	const envelope: JediEnvelopeFlex = {
+		version: root['version'],
+		kind: root['kind'],
+		format: root['format'],
+		payload: new Uint8Array(root['payload']),
+		metadata: root['metadata'] ? new Uint8Array(root['metadata']) : undefined,
+	};
+
+	let parsedPayload: T;
+
+	if (envelope.format === PayloadFormat.FLEX) {
+		const ref = toReference(envelope.payload.buffer as ArrayBuffer);
+		parsedPayload = ref.toObject() as T;
+	} else if (envelope.format === PayloadFormat.JSON) {
+		parsedPayload = JSON.parse(new TextDecoder().decode(envelope.payload)) as T;
+	} else {
+		throw new Error(`[unwrapEnvelope] Unsupported format: ${envelope.format}`);
+	}
+
+	return { envelope, payload: parsedPayload };
+}
+
+export function unwrapFlexToJson(buffer: Uint8Array) {
+	return toReference(buffer.buffer as ArrayBuffer).toObject();
+}
+
+export function inspectFlex(buffer: Uint8Array | ArrayBuffer): void {
+	try {
+		const view = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+		const obj = unwrapFlexToJson(view);
+		console.log('[FlexObject]', JSON.stringify(obj, null, 2));
+	} catch (err) {
+		console.error('[Flex Decode Error]', err);
+	}
+}
+
+export function hasKind(kind: number, flag: number): boolean {
+	return (kind & flag) === flag;
+}
+
+
+//	Redis Helpers
+
+export function wrapRedisSet(key: string, value: string): Uint8Array {
+	return wrapEnvelope(
+		{ key, value },
+		MessageKind.SET | MessageKind.REDIS,
+		PayloadFormat.FLEX
+	);
+}
+
+export function wrapRedisGet(key: string): Uint8Array {
+	return wrapEnvelope(
+		{ key },
+		MessageKind.GET | MessageKind.REDIS,
+		PayloadFormat.FLEX
+	);
+}
+
+export function wrapRedisDel(key: string): Uint8Array {
+	return wrapEnvelope(
+		{ key },
+		MessageKind.DEL | MessageKind.REDIS,
+		PayloadFormat.FLEX
+	);
+}
+
+export function parseRedisPayload<T = unknown>(envelopeBytes: Uint8Array): {
+	envelope: JediEnvelopeFlex;
+	payload: T;
+} {
+	const result = unwrapEnvelope<T>(envelopeBytes);
+	if (!hasKind(result.envelope.kind, MessageKind.REDIS)) {
+		throw new Error('[Redis] Not a Redis envelope');
+	}
+	return result;
+}
+
+export function wrapRedisXAdd(
+	stream: string,
+	fields: Record<string, string>,
+	id = '*',
+): Uint8Array {
+	return wrapEnvelope(
+		{ stream, id, fields },
+		MessageKind.ADD | MessageKind.STREAM | MessageKind.REDIS,
+		PayloadFormat.FLEX,
+	);
+}
+
+export function wrapRedisXRead(
+	streams: { stream: string; id: string }[],
+	count?: number,
+	block?: number,
+): Uint8Array {
+
+	const inner = builder();
+	inner.startMap();
+
+	inner.addKey('streams');
+	inner.startVector(); 
+	for (const { stream, id } of streams) {
+		inner.startMap();
+		inner.addKey('stream'); inner.add(stream);
+		inner.addKey('id');     inner.add(id);
+		inner.end();
+	  }
+	inner.end();
+
+	if (count !== undefined) {
+		inner.addKey('count'); inner.add(count);
+	}
+	if (block !== undefined) {
+		inner.addKey('block'); inner.add(block);
+	}
+
+	inner.end();
+	const serializedPayload = inner.finish();
+
+	const b = builder();
+	b.startMap();
+	b.addKey('version');  b.add(1);
+	b.addKey('kind');     b.add(MessageKind.READ | MessageKind.STREAM | MessageKind.REDIS);
+	b.addKey('format');   b.add(PayloadFormat.FLEX);
+	b.addKey('payload');  b.add(serializedPayload); 
+	b.addKey('metadata'); b.add(new Uint8Array());
+	b.end();
+
+	return b.finish();
+}
+
+
+
+export const scopeData = {
+	wrapEnvelope,
+	unwrapEnvelope,
+	MessageKind,
+	PayloadFormat,
+	unwrapFlexToJson,
+	inspectFlex,
+	hasKind,
+    redis: {
+		wrapRedisSet,
+		wrapRedisGet,
+		wrapRedisDel,
+		wrapRedisXAdd,
+		wrapRedisXRead,
+		parseRedisPayload,
+	}
+};
+
+export type FlexDataAPI = typeof scopeData;

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

@@ -0,0 +1,203 @@
+import { expose } from 'comlink';
+import Dexie, { type Table } from 'dexie';
+import type { DiscordServer, DiscordTag, Profile } from '../types/discord';
+import { toReference } from './flexbuilder';
+
+interface SharedWorkerGlobalScope extends Worker {
+	onconnect: (event: MessageEvent) => void;
+}
+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>;
+
+	constructor() {
+		super('AppStorage');
+		this.version(3).stores({
+			settings: '&id',
+			meta: '&key',
+			i18n: '&key',
+			htmlservers: '&key',
+			servers: '&server_id',
+			tags: '&tag_id',
+			profiles: '&profile_id',
+			ws_messages: '&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">
+			<img src="${server.logo}" alt="${server.name}" class="w-12 h-12 rounded-full" />
+			<h3 class="text-lg font-bold">${server.name}</h3>
+			<p class="text-sm opacity-70">${server.summary}</p>
+			<a href="${server.invite}" class="text-purple-400 underline text-xs">Join Join Join</a>
+		</div>
+	`.trim();
+}
+
+// --- Comlink-Safe API ---
+const storageAPI = {
+
+	// WebSocket
+
+	async storeWsMessage(key: string, buffer: ArrayBuffer) {
+		const decoded = toReference(buffer).toObject();
+		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 }[]> {
+		const raw = await db.ws_messages.toArray();
+		return raw.sort((a, b) => {
+			const at = Number(a.key.split(':')[1]);
+			const bt = Number(b.key.split(':')[1]);
+			return bt - at;
+		});
+	},
+	
+	async clearWsMessages() {
+		await db.ws_messages.clear();
+	},
+
+	// I18n
+	async getTranslation(key: string) {
+		return (await db.i18n.get(key))?.value ?? null;
+	},
+	async getTranslations(keys: string[]) {
+		const result: Record<string, string> = {};
+		for (const key of keys) {
+			const val = await db.i18n.get(key);
+			if (val) result[key] = val.value;
+		}
+		return result;
+	},
+	async putI18nBatch(data: Record<string, string>) {
+		const entries = Object.entries(data).map(([key, value]) => ({
+			key,
+			value,
+		}));
+		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 getAllI18nKeys(): Promise<string[]> {
+		const all = await db.i18n.toCollection().primaryKeys();
+		return all as string[];
+	},
+
+	async loadServersFromJSON(path = 'https://discord.sh/data/servers.json') {
+		const res = await fetch(path);
+		const data = await res.json();
+	
+		// The JSON should be a Record<string, DiscordServer>
+		const servers: DiscordServer[] = Object.values(data);
+		await storageAPI.putServers(servers);
+		await storageAPI.syncHtmlFromServers();
+	},
+
+	// HTML PreRender
+	async syncHtmlFromServers() {
+		const allServers = await db.servers.toArray();
+		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.`);
+		} else {
+			console.info('[syncHtmlFromServers] All servers already have HTML cards.');
+		}
+	},
+
+	// Settings
+	async dbSet(id: string, value: any) {
+		await db.settings.put({ id, value });
+	},
+	async dbGet(id: string) {
+		return (await db.settings.get(id))?.value ?? null;
+	},
+	async dbClear() {
+		await db.settings.clear();
+	},
+
+	// Meta
+	async setVersion(version: string) {
+		await db.meta.put({ key: 'version', value: version });
+	},
+	async getVersion() {
+		return (await db.meta.get('version'))?.value ?? null;
+	},
+	async markSeeded() {
+		await db.meta.put({ key: 'db_seeded', value: true });
+	},
+	async checkSeeded() {
+		return (await db.meta.get('db_seeded'))?.value === true;
+	},
+
+	// Servers
+	async putServers(servers: DiscordServer[]) {
+		await db.servers.bulkPut(servers);
+	},
+	async getAllServers() {
+		return await db.servers.toArray();
+	},
+
+	// HTML servers
+	async putHtmlCards(data: { key: string; value: string }[]) {
+		await db.htmlservers.bulkPut(data);
+	},
+	async getHtmlCard(key: string) {
+		return (await db.htmlservers.get(key))?.value ?? null;
+	},
+
+	// Tags
+	async putTags(tags: DiscordTag[]) {
+		await db.tags.bulkPut(tags);
+	},
+	async getAllTags() {
+		return await db.tags.toArray();
+	},
+
+	// Profiles
+	async putProfiles(profiles: Profile[]) {
+		await db.profiles.bulkPut(profiles);
+	},
+	async getAllProfiles() {
+		return await db.profiles.toArray();
+	},
+};
+
+export type LocalStorageAPI = typeof storageAPI;
+
+self.onconnect = (event: MessageEvent) => {
+	const port = event.ports[0];
+	port.start();
+	expose(storageAPI, port);
+};

package/src/lib/workers/events.ts

@@ -0,0 +1,52 @@
+import { DroidEventSchemas } from '../types/event-types';
+import type { DroidEventMap, EventKey, EventHandler  } from '../types/event-types';
+
+import { z } from 'zod';
+
+
+class DroidEventBus {
+    private listeners = new Map<EventKey, Set<(payload: unknown) => void>>();
+
+    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);
+	}
+
+	off<K extends EventKey>(event: K, handler: EventHandler<K>) {
+		this.listeners.get(event)?.delete(handler as (payload: unknown) => void);
+	}
+
+	emit<K extends EventKey>(event: K, payload: DroidEventMap[K]) {
+		const schema = DroidEventSchemas[event];
+		if (schema) {
+			try {
+				schema.parse(payload);
+			} catch (err) {
+				console.error(`[DroidEventBus] Invalid payload for ${event}:`, err);
+				return;
+			}
+		}
+
+		window.dispatchEvent(new CustomEvent(event, { detail: payload }));
+
+		for (const handler of this.listeners.get(event) ?? []) {
+			(handler as EventHandler<K>)(payload);
+		}
+	}
+
+	wait<K extends EventKey>(event: K): Promise<DroidEventMap[K]> {
+		return new Promise((resolve) => {
+			const fn: EventHandler<K> = (payload) => {
+				this.off(event, fn);
+				resolve(payload);
+			};
+			this.on(event, fn);
+		});
+	}
+}
+
+export const DroidEvents = new DroidEventBus();

package/src/lib/workers/flexbuilder.ts

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

package/src/lib/workers/init.ts

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