@kbve/droid 0.0.5 → 0.1.1

package/src/lib/types/bento.spec.ts

@@ -0,0 +1,116 @@
+import { describe, it, expect } from 'vitest';
+import {
+	BentoTileSchema,
+	BENTO_VARIANT_CLASS_MAP,
+	BENTO_ANIMATION_CLASS_MAP,
+	BENTO_BADGE_CLASS_MAP,
+} from './bento';
+
+const validTile = {
+	title: 'Test Tile',
+	primaryColor: 'blue-500',
+	secondaryColor: 'red-300',
+};
+
+describe('BentoTileSchema', () => {
+	it('accepts a minimal valid tile', () => {
+		const result = BentoTileSchema.safeParse(validTile);
+		expect(result.success).toBe(true);
+	});
+
+	it('rejects empty title', () => {
+		const result = BentoTileSchema.safeParse({
+			...validTile,
+			title: '',
+		});
+		expect(result.success).toBe(false);
+	});
+
+	it('rejects invalid primary color format', () => {
+		const result = BentoTileSchema.safeParse({
+			...validTile,
+			primaryColor: 'invalid',
+		});
+		expect(result.success).toBe(false);
+	});
+
+	it('accepts valid ULID id', () => {
+		const result = BentoTileSchema.safeParse({
+			...validTile,
+			id: '01ARZ3NDEKTSV4RRFFQ69G5FAV',
+		});
+		expect(result.success).toBe(true);
+	});
+
+	it('rejects invalid ULID id', () => {
+		const result = BentoTileSchema.safeParse({
+			...validTile,
+			id: 'not-a-ulid',
+		});
+		expect(result.success).toBe(false);
+	});
+
+	it('accepts valid span format', () => {
+		const result = BentoTileSchema.safeParse({
+			...validTile,
+			span: 'col-span-2',
+		});
+		expect(result.success).toBe(true);
+	});
+
+	it('requires target when href is provided', () => {
+		const result = BentoTileSchema.safeParse({
+			...validTile,
+			href: 'https://example.com',
+		});
+		expect(result.success).toBe(false);
+	});
+
+	it('accepts href with target', () => {
+		const result = BentoTileSchema.safeParse({
+			...validTile,
+			href: 'https://example.com',
+			target: '_blank',
+		});
+		expect(result.success).toBe(true);
+	});
+
+	it('requires badge text when badgeType is set', () => {
+		const result = BentoTileSchema.safeParse({
+			...validTile,
+			badgeType: 'success',
+		});
+		expect(result.success).toBe(false);
+	});
+
+	it('accepts badge with badgeType', () => {
+		const result = BentoTileSchema.safeParse({
+			...validTile,
+			badge: 'New',
+			badgeType: 'success',
+		});
+		expect(result.success).toBe(true);
+	});
+});
+
+describe('Bento class maps', () => {
+	it('BENTO_VARIANT_CLASS_MAP has all variants', () => {
+		expect(BENTO_VARIANT_CLASS_MAP).toHaveProperty('default');
+		expect(BENTO_VARIANT_CLASS_MAP).toHaveProperty('minimal');
+		expect(BENTO_VARIANT_CLASS_MAP).toHaveProperty('image-heavy');
+	});
+
+	it('BENTO_ANIMATION_CLASS_MAP has all animations', () => {
+		expect(BENTO_ANIMATION_CLASS_MAP).toHaveProperty('fade-in');
+		expect(BENTO_ANIMATION_CLASS_MAP).toHaveProperty('slide-up');
+		expect(BENTO_ANIMATION_CLASS_MAP).toHaveProperty('none');
+		expect(BENTO_ANIMATION_CLASS_MAP['none']).toBe('');
+	});
+
+	it('BENTO_BADGE_CLASS_MAP has all badge types', () => {
+		expect(BENTO_BADGE_CLASS_MAP).toHaveProperty('default');
+		expect(BENTO_BADGE_CLASS_MAP).toHaveProperty('success');
+		expect(BENTO_BADGE_CLASS_MAP).toHaveProperty('warning');
+		expect(BENTO_BADGE_CLASS_MAP).toHaveProperty('error');
+	});
+});

package/src/lib/types/bento.ts

@@ -5,7 +5,12 @@ export const BENTO_VARIANTS = ['default', 'minimal', 'image-heavy'] as const;
 export const BENTO_ANIMATIONS = ['fade-in', 'slide-up', 'none'] as const;
 export const BENTO_TARGETS = ['_self', '_blank', '_parent', '_top'] as const;
 export const BENTO_ROLES = ['button', 'link', 'region', 'article'] as const;
-export const BENTO_BADGE_TYPES = ['default', 'success', 'warning', 'error'] as const;
+export const BENTO_BADGE_TYPES = [
+	'default',
+	'success',
+	'warning',
+	'error',
+] as const;
 
 // Regex validators
 const tailwindColorRegex = /^[a-z]+-(100|200|300|400|500|600|700|800|900)$/;
@@ -13,68 +18,102 @@ const spanRegex = /^(?:(?:[a-z]+:)?(col|row)-span-\d+\s*)+$/;
 const ulidRegex = /^01[0-9A-HJKMNP-TV-Z]{24}$/;
 
 // Schema
-export const BentoTileSchema = z.object({
-  id: z.string().regex(ulidRegex, 'Invalid ULID format').optional(),
-
-  title: z.string().min(1, 'Title is required'),
-  subtitle: z.string().optional(),
-  description: z.string().optional(),
-  span: z.string().regex(spanRegex, 'Invalid span format (e.g., col-span-2, row-span-1)').optional(),
-
-  primaryColor: z.string().regex(tailwindColorRegex, 'Invalid Tailwind color format (e.g., blue-500)'),
-  secondaryColor: z.string().regex(tailwindColorRegex, 'Invalid Tailwind color format (e.g., blue-500)'),
-
-  icon: z.string().optional(),
-  backgroundImage: z.string().url().optional(),
-
-  onclick: z.string().optional(),
-  href: z.string().url().optional(),
-  target: z.enum(BENTO_TARGETS).optional(),
-
-  ariaLabel: z.string().optional(),
-  role: z.enum(BENTO_ROLES).optional(),
-
-  variant: z.enum(BENTO_VARIANTS).optional(),
-  animation: z.enum(BENTO_ANIMATIONS).optional(),
-
-  badge: z.string().optional(),
-  badgeType: z.enum(BENTO_BADGE_TYPES).optional(),
-
-  priority: z.number().int().min(0).optional(),
-  tooltip: z.string().optional(),
-  disabled: z.boolean().optional(),
-
-  meta: z.record(z.any()).optional(),
-  dataset: z.record(z.string()).optional(),
-  className: z.string().optional(),
-}).refine(
-  (data) => !data.href || (data.href && data.target),
-  { message: 'target is required when href is provided', path: ['target'] }
-).refine(
-  (data) => !data.badgeType || (data.badge && data.badge.length > 0),
-  { message: 'badge must be provided if badgeType is set', path: ['badge'] }
-);
+export const BentoTileSchema = z
+	.object({
+		id: z.string().regex(ulidRegex, 'Invalid ULID format').optional(),
+
+		title: z.string().min(1, 'Title is required'),
+		subtitle: z.string().optional(),
+		description: z.string().optional(),
+		span: z
+			.string()
+			.regex(
+				spanRegex,
+				'Invalid span format (e.g., col-span-2, row-span-1)',
+			)
+			.optional(),
+
+		primaryColor: z
+			.string()
+			.regex(
+				tailwindColorRegex,
+				'Invalid Tailwind color format (e.g., blue-500)',
+			),
+		secondaryColor: z
+			.string()
+			.regex(
+				tailwindColorRegex,
+				'Invalid Tailwind color format (e.g., blue-500)',
+			),
+
+		icon: z.string().optional(),
+		backgroundImage: z.string().url().optional(),
+
+		onclick: z.string().optional(),
+		href: z.string().url().optional(),
+		target: z.enum(BENTO_TARGETS).optional(),
+
+		ariaLabel: z.string().optional(),
+		role: z.enum(BENTO_ROLES).optional(),
+
+		variant: z.enum(BENTO_VARIANTS).optional(),
+		animation: z.enum(BENTO_ANIMATIONS).optional(),
+
+		badge: z.string().optional(),
+		badgeType: z.enum(BENTO_BADGE_TYPES).optional(),
+
+		priority: z.number().int().min(0).optional(),
+		tooltip: z.string().optional(),
+		disabled: z.boolean().optional(),
+
+		meta: z.record(z.string(), z.any()).optional(),
+		dataset: z.record(z.string(), z.string()).optional(),
+		className: z.string().optional(),
+	})
+	.refine((data) => !data.href || (data.href && data.target), {
+		message: 'target is required when href is provided',
+		path: ['target'],
+	})
+	.refine(
+		(data) => !data.badgeType || (data.badge && data.badge.length > 0),
+		{
+			message: 'badge must be provided if badgeType is set',
+			path: ['badge'],
+		},
+	);
 
 // Types
 export type BentoTile = z.infer<typeof BentoTileSchema>;
 export type BentoVariantClass = { base: string; hover?: string };
 
 // Mappings
-export const BENTO_VARIANT_CLASS_MAP: Record<(typeof BENTO_VARIANTS)[number], BentoVariantClass> = {
-  default: { base: 'p-4 flex flex-col justify-between' },
-  minimal: { base: 'p-2 bg-opacity-30 backdrop-blur-sm', hover: 'bg-opacity-50' },
-  'image-heavy': { base: 'p-0 overflow-hidden', hover: 'scale-105' },
+export const BENTO_VARIANT_CLASS_MAP: Record<
+	(typeof BENTO_VARIANTS)[number],
+	BentoVariantClass
+> = {
+	default: { base: 'p-4 flex flex-col justify-between' },
+	minimal: {
+		base: 'p-2 bg-opacity-30 backdrop-blur-sm',
+		hover: 'bg-opacity-50',
+	},
+	'image-heavy': { base: 'p-0 overflow-hidden', hover: 'scale-105' },
 };
 
-export const BENTO_ANIMATION_CLASS_MAP: Record<(typeof BENTO_ANIMATIONS)[number], string> = {
-  'fade-in': 'animate-fade-in',
-  'slide-up': 'animate-slide-up',
-  none: '',
+export const BENTO_ANIMATION_CLASS_MAP: Record<
+	(typeof BENTO_ANIMATIONS)[number],
+	string
+> = {
+	'fade-in': 'animate-fade-in',
+	'slide-up': 'animate-slide-up',
+	none: '',
 };
 
-export const BENTO_BADGE_CLASS_MAP: Record<(typeof BENTO_BADGE_TYPES)[number], string> = {
-  default: 'bg-white/30 text-white',
-  success: 'bg-green-500/80 text-white',
-  warning: 'bg-yellow-500/80 text-black',
-  error: 'bg-red-500/80 text-white',
+export const BENTO_BADGE_CLASS_MAP: Record<
+	(typeof BENTO_BADGE_TYPES)[number],
+	string
+> = {
+	default: 'bg-white/30 text-white',
+	success: 'bg-green-500/80 text-white',
+	warning: 'bg-yellow-500/80 text-black',
+	error: 'bg-red-500/80 text-white',
 };

package/src/lib/types/event-types.spec.ts

@@ -0,0 +1,93 @@
+import { describe, it, expect } from 'vitest';
+import {
+	DroidEventSchemas,
+	DroidReadySchema,
+	DroidFirstConnectSchema,
+	DroidDownscaleSchema,
+	DroidUpscaleSchema,
+} from './event-types';
+
+describe('DroidEventSchemas', () => {
+	it('has all expected event keys', () => {
+		const keys = Object.keys(DroidEventSchemas);
+		expect(keys).toContain('droid-first-connect');
+		expect(keys).toContain('droid-ready');
+		expect(keys).toContain('droid-mod-ready');
+		expect(keys).toContain('droid-downscale');
+		expect(keys).toContain('droid-upscale');
+		expect(keys).toContain('panel-open');
+		expect(keys).toContain('panel-close');
+		expect(keys).toContain('toast-added');
+		expect(keys).toContain('toast-removed');
+		expect(keys).toContain('tooltip-opened');
+		expect(keys).toContain('tooltip-closed');
+		expect(keys).toContain('modal-opened');
+		expect(keys).toContain('modal-closed');
+	});
+
+	it('has exactly 13 event types', () => {
+		expect(Object.keys(DroidEventSchemas)).toHaveLength(13);
+	});
+});
+
+describe('DroidReadySchema', () => {
+	it('accepts valid payload', () => {
+		const result = DroidReadySchema.safeParse({ timestamp: 123 });
+		expect(result.success).toBe(true);
+	});
+
+	it('rejects missing timestamp', () => {
+		const result = DroidReadySchema.safeParse({});
+		expect(result.success).toBe(false);
+	});
+
+	it('rejects non-number timestamp', () => {
+		const result = DroidReadySchema.safeParse({ timestamp: 'now' });
+		expect(result.success).toBe(false);
+	});
+});
+
+describe('DroidFirstConnectSchema', () => {
+	it('accepts valid payload', () => {
+		const result = DroidFirstConnectSchema.safeParse({
+			timestamp: 1,
+			workersFirst: { db: true, ws: false },
+		});
+		expect(result.success).toBe(true);
+	});
+
+	it('rejects missing workersFirst', () => {
+		const result = DroidFirstConnectSchema.safeParse({ timestamp: 1 });
+		expect(result.success).toBe(false);
+	});
+});
+
+describe('DroidDownscaleSchema', () => {
+	it('accepts valid payload', () => {
+		const result = DroidDownscaleSchema.safeParse({
+			timestamp: 1,
+			level: 'minimal',
+		});
+		expect(result.success).toBe(true);
+	});
+
+	it('rejects missing level', () => {
+		const result = DroidDownscaleSchema.safeParse({ timestamp: 1 });
+		expect(result.success).toBe(false);
+	});
+});
+
+describe('DroidUpscaleSchema', () => {
+	it('accepts valid payload', () => {
+		const result = DroidUpscaleSchema.safeParse({
+			timestamp: 1,
+			level: 'full',
+		});
+		expect(result.success).toBe(true);
+	});
+
+	it('rejects missing timestamp', () => {
+		const result = DroidUpscaleSchema.safeParse({ level: 'full' });
+		expect(result.success).toBe(false);
+	});
+});

package/src/lib/types/event-types.ts

@@ -1,5 +1,10 @@
 import { z } from 'zod';
 import { PanelIdSchema } from './panel-types';
+import {
+	ToastPayloadSchema,
+	TooltipPayloadSchema,
+	ModalPayloadSchema,
+} from './ui-event-types';
 
 export const ModMetaSchema = z.object({
 	name: z.string(),
@@ -20,16 +25,47 @@ export const DroidReadySchema = z.object({
 	timestamp: z.number(),
 });
 
+export const DroidFirstConnectSchema = z.object({
+	timestamp: z.number(),
+	workersFirst: z.object({
+		db: z.boolean(),
+		ws: z.boolean(),
+	}),
+});
+
+export const DroidDownscaleSchema = z.object({
+	timestamp: z.number(),
+	level: z.string(),
+});
+
+export const DroidUpscaleSchema = z.object({
+	timestamp: z.number(),
+	level: z.string(),
+});
+
 export const DroidEventSchemas = {
-	'droid-ready': DroidReadySchema, 
+	'droid-first-connect': DroidFirstConnectSchema,
+	'droid-ready': DroidReadySchema,
 	'droid-mod-ready': DroidModReadySchema,
+	'droid-downscale': DroidDownscaleSchema,
+	'droid-upscale': DroidUpscaleSchema,
 	'panel-open': PanelEventSchema,
 	'panel-close': PanelEventSchema,
+	'toast-added': ToastPayloadSchema,
+	'toast-removed': ToastPayloadSchema.pick({ id: true }),
+	'tooltip-opened': TooltipPayloadSchema,
+	'tooltip-closed': TooltipPayloadSchema.pick({ id: true }),
+	'modal-opened': ModalPayloadSchema,
+	'modal-closed': ModalPayloadSchema.pick({ id: true }),
 };
 
 export type DroidEventMap = {
-	[K in keyof typeof DroidEventSchemas]: z.infer<(typeof DroidEventSchemas)[K]>;
+	[K in keyof typeof DroidEventSchemas]: z.infer<
+		(typeof DroidEventSchemas)[K]
+	>;
 };
 
 export type EventKey = keyof DroidEventMap;
-export type EventHandler<K extends EventKey> = (payload: DroidEventMap[K]) => void;
+export type EventHandler<K extends EventKey> = (
+	payload: DroidEventMap[K],
+) => void;

package/src/lib/types/modules.ts

@@ -1,8 +1,13 @@
 import type { Remote } from 'comlink';
 
+export interface ModInitContext {
+	emitFromWorker?: (msg: unknown) => void;
+}
+
 export interface BaseModAPI {
 	getMeta(): Promise<ModMeta>;
-	init?(ctx: any): void | Promise<void>;
+	init?(ctx: ModInitContext): void | Promise<void>;
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	[key: string]: any;
 }
 
@@ -31,8 +36,10 @@ export interface ModManager {
 
 export interface SupabaseModAPI extends BaseModAPI {
 	configure(url: string, key: string): Promise<void>;
-	queryTestTable(): Promise<{ data: any; error: any }>;
-	insertTest(payload: Record<string, any>): Promise<{ data: any; error: any }>;
+	queryTestTable(): Promise<{ data: unknown; error: unknown }>;
+	insertTest(
+		payload: Record<string, unknown>,
+	): Promise<{ data: unknown; error: unknown }>;
 }
 
 export type VirtualNode = {
@@ -40,7 +47,7 @@ export type VirtualNode = {
 	id?: string;
 	key?: string;
 	class?: string;
-	attrs?: Record<string, any>;
+	attrs?: Record<string, string | number | boolean>;
 	style?: Partial<CSSStyleDeclaration>;
 	children?: (string | VirtualNode)[];
-};
+};

package/src/lib/types/ui-event-types.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import type { VirtualNode } from './modules';
+
+// Recursive VirtualNode schema matching the type in modules.ts.
+// Validates worker-produced descriptors at runtime.
+const VirtualNodeSchema: z.ZodType<VirtualNode, VirtualNode> = z.lazy(() =>
+	z.object({
+		tag: z.string(),
+		id: z.string().optional(),
+		key: z.string().optional(),
+		class: z.string().optional(),
+		attrs: z.record(z.string(), z.any()).optional(),
+		style: z.record(z.string(), z.string()).optional(),
+		children: z.array(z.union([z.string(), VirtualNodeSchema])).optional(),
+	}),
+);
+
+// ── Toast ──
+
+export const ToastSeveritySchema = z.enum([
+	'success',
+	'warning',
+	'error',
+	'info',
+]);
+export type ToastSeverity = z.infer<typeof ToastSeveritySchema>;
+
+export const ToastPayloadSchema = z.object({
+	id: z.string(),
+	message: z.string(),
+	severity: ToastSeveritySchema,
+	duration: z.number().positive().optional(),
+	vnode: VirtualNodeSchema.optional(),
+});
+export type ToastPayload = z.infer<typeof ToastPayloadSchema>;
+
+// ── Tooltip ──
+
+export const TooltipPositionSchema = z.enum([
+	'top',
+	'bottom',
+	'left',
+	'right',
+	'auto',
+]);
+export type TooltipPosition = z.infer<typeof TooltipPositionSchema>;
+
+export const TooltipPayloadSchema = z.object({
+	id: z.string(),
+	content: z.union([z.string(), VirtualNodeSchema]).optional(),
+	position: TooltipPositionSchema.optional(),
+	anchor: z.string().optional(),
+});
+export type TooltipPayload = z.infer<typeof TooltipPayloadSchema>;
+
+// ── Modal ──
+
+export const ModalPayloadSchema = z.object({
+	id: z.string(),
+	content: VirtualNodeSchema.optional(),
+	title: z.string().optional(),
+	metadata: z.record(z.string(), z.any()).optional(),
+});
+export type ModalPayload = z.infer<typeof ModalPayloadSchema>;
+
+export { VirtualNodeSchema };