@fairfox/polly 0.5.2 → 0.6.0

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@fairfox/polly",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "private": false,
   "type": "module",
   "description": "Multi-execution-context framework with reactive state and cross-context messaging for Chrome extensions, PWAs, and worker-based applications",
+  "workspaces": ["tests"],
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -42,6 +43,10 @@
     "./types": {
       "import": "./dist/src/shared/types/messages.js",
       "types": "./dist/shared/types/messages.d.ts"
+    },
+    "./verify": {
+      "import": "./dist/vendor/verify/src/public-api.js",
+      "types": "./dist/vendor/verify/src/public-api.d.ts"
     }
   },
   "files": ["dist", "templates", "README.md", "LICENSE"],
@@ -52,10 +57,18 @@
     "build:lib": "bun run build-lib.ts",
     "build:full-featured": "bun run scripts/build-user-extension.ts examples/full-featured",
     "build:full-featured:prod": "bun run scripts/build-user-extension.ts examples/full-featured --prod",
-    "typecheck": "bunx tsc --noEmit",
+    "typecheck": "bunx tsc --noEmit && bun run --cwd tests typecheck",
+    "typecheck:tests": "bun run --cwd tests typecheck",
     "lint": "biome check .",
     "lint:fix": "biome check --write .",
     "format": "biome format --write .",
+    "test": "bun run --cwd tests test",
+    "test:watch": "bun run --cwd tests test:watch",
+    "test:framework": "bun run --cwd tests test:framework",
+    "test:framework:ui": "bun run --cwd tests test:framework:ui",
+    "test:framework:debug": "bun run --cwd tests test:framework:debug",
+    "test:framework:headed": "bun run --cwd tests test:framework:headed",
+    "test:all": "bun run --cwd tests test:all",
     "prepublishOnly": "bun run typecheck && bun run lint && bun run build:lib",
     "publish:public": "npm publish --access public"
   },

package/templates/pwa/build.ts.template

@@ -3,54 +3,54 @@
  * Uses Bun's built-in bundler
  */
 
-import { rmSync, cpSync, mkdirSync } from 'node:fs'
-import { join } from 'node:path'
+import { cpSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
 
-const distDir = './dist'
+const distDir = "./dist";
 
 // Clean dist directory
-console.log('🧹 Cleaning dist directory...')
-rmSync(distDir, { recursive: true, force: true })
-mkdirSync(distDir, { recursive: true })
+console.log("🧹 Cleaning dist directory...");
+rmSync(distDir, { recursive: true, force: true });
+mkdirSync(distDir, { recursive: true });
 
 // Copy static files
-console.log('📋 Copying static files...')
-cpSync('./public', distDir, { recursive: true, force: true })
-cpSync('./index.html', join(distDir, 'index.html'))
+console.log("📋 Copying static files...");
+cpSync("./public", distDir, { recursive: true, force: true });
+cpSync("./index.html", join(distDir, "index.html"));
 
 // Build main application
-console.log('📦 Building main application...')
+console.log("📦 Building main application...");
 await Bun.build({
-  entrypoints: ['./src/main.ts'],
-  outdir: join(distDir, 'src'),
-  format: 'esm',
-  minify: true,
-  sourcemap: 'external',
-  target: 'browser',
-})
+	entrypoints: ["./src/main.ts"],
+	outdir: join(distDir, "src"),
+	format: "esm",
+	minify: true,
+	sourcemap: "external",
+	target: "browser",
+});
 
 // Build service worker
-console.log('⚙️  Building service worker...')
+console.log("⚙️  Building service worker...");
 await Bun.build({
-  entrypoints: ['./src/service-worker.ts'],
-  outdir: join(distDir, 'src'),
-  format: 'esm',
-  minify: true,
-  sourcemap: 'external',
-  target: 'browser',
-})
+	entrypoints: ["./src/service-worker.ts"],
+	outdir: join(distDir, "src"),
+	format: "esm",
+	minify: true,
+	sourcemap: "external",
+	target: "browser",
+});
 
 // Build shared worker
-console.log('👥 Building shared worker...')
+console.log("👥 Building shared worker...");
 await Bun.build({
-  entrypoints: ['./src/shared-worker.ts'],
-  outdir: join(distDir, 'src'),
-  format: 'esm',
-  minify: true,
-  sourcemap: 'external',
-  target: 'browser',
-})
-
-console.log('✅ Build complete!')
-console.log(`\n📦 Output: ${distDir}/`)
-console.log('\n💡 To serve: bun run serve')
+	entrypoints: ["./src/shared-worker.ts"],
+	outdir: join(distDir, "src"),
+	format: "esm",
+	minify: true,
+	sourcemap: "external",
+	target: "browser",
+});
+
+console.log("✅ Build complete!");
+console.log(`\n📦 Output: ${distDir}/`);
+console.log("\n💡 To serve: bun run serve");

package/templates/pwa/server.ts.template

@@ -3,56 +3,56 @@
  * Serves the application with hot reload support
  */
 
-const port = 3000
-
-const server = Bun.serve({
-  port,
-  async fetch(req) {
-    const url = new URL(req.url)
-    let filePath = url.pathname
-
-    // Serve root
-    if (filePath === '/') {
-      filePath = '/index.html'
-    }
-
-    // Try to serve from public directory first
-    const publicFile = Bun.file(`./public${filePath}`)
-    if (await publicFile.exists()) {
-      return new Response(publicFile)
-    }
-
-    // Try to serve from root
-    const rootFile = Bun.file(`.${filePath}`)
-    if (await rootFile.exists()) {
-      return new Response(rootFile)
-    }
-
-    // Handle TypeScript files - transpile on the fly
-    if (filePath.endsWith('.ts')) {
-      const tsFile = Bun.file(`.${filePath}`)
-      if (await tsFile.exists()) {
-        const transpiled = await Bun.build({
-          entrypoints: [`.${filePath}`],
-          format: 'esm',
-          target: 'browser',
-        })
-
-        if (transpiled.outputs.length > 0) {
-          return new Response(transpiled.outputs[0], {
-            headers: {
-              'Content-Type': 'application/javascript',
-            },
-          })
-        }
-      }
-    }
-
-    // 404
-    return new Response('Not Found', { status: 404 })
-  },
-})
-
-console.log(`🚀 Server running at http://localhost:${port}`)
-console.log(`\n📱 PWA: {{PROJECT_NAME}}`)
-console.log(`\n💡 Open in browser and check the console for worker messages`)
+const port = 3000;
+
+Bun.serve({
+	port,
+	async fetch(req) {
+		const url = new URL(req.url);
+		let filePath = url.pathname;
+
+		// Serve root
+		if (filePath === "/") {
+			filePath = "/index.html";
+		}
+
+		// Try to serve from public directory first
+		const publicFile = Bun.file(`./public${filePath}`);
+		if (await publicFile.exists()) {
+			return new Response(publicFile);
+		}
+
+		// Try to serve from root
+		const rootFile = Bun.file(`.${filePath}`);
+		if (await rootFile.exists()) {
+			return new Response(rootFile);
+		}
+
+		// Handle TypeScript files - transpile on the fly
+		if (filePath.endsWith(".ts")) {
+			const tsFile = Bun.file(`.${filePath}`);
+			if (await tsFile.exists()) {
+				const transpiled = await Bun.build({
+					entrypoints: [`.${filePath}`],
+					format: "esm",
+					target: "browser",
+				});
+
+				if (transpiled.outputs.length > 0) {
+					return new Response(transpiled.outputs[0], {
+						headers: {
+							"Content-Type": "application/javascript",
+						},
+					});
+				}
+			}
+		}
+
+		// 404
+		return new Response("Not Found", { status: 404 });
+	},
+});
+
+console.log(`🚀 Server running at http://localhost:${port}`);
+console.log(`\n📱 PWA: {{PROJECT_NAME}}`);
+console.log("\n💡 Open in browser and check the console for worker messages");

package/templates/pwa/src/service-worker.ts.template

@@ -4,158 +4,154 @@
  */
 
 /// <reference lib="WebWorker" />
-declare const self: ServiceWorkerGlobalScope
+declare const self: ServiceWorkerGlobalScope;
 
-console.log('[SW] Service Worker loading...')
+console.log("[SW] Service Worker loading...");
 
 // Cache configuration
-const CACHE_NAME = '{{PROJECT_NAME}}-v1'
-const urlsToCache = [
-  '/',
-  '/index.html',
-  '/src/main.ts'
-]
+const CACHE_NAME = "{{PROJECT_NAME}}-v1";
+const urlsToCache = ["/", "/index.html", "/src/main.ts"];
 
 // Install event - cache resources
-self.addEventListener('install', (event) => {
-  console.log('[SW] Installing...')
+self.addEventListener("install", (event) => {
+	console.log("[SW] Installing...");
 
-  event.waitUntil(
-    caches.open(CACHE_NAME).then((cache) => {
-      console.log('[SW] Caching resources')
-      return cache.addAll(urlsToCache)
-    })
-  )
+	event.waitUntil(
+		caches.open(CACHE_NAME).then((cache) => {
+			console.log("[SW] Caching resources");
+			return cache.addAll(urlsToCache);
+		}),
+	);
 
-  // Activate immediately
-  self.skipWaiting()
-})
+	// Activate immediately
+	void self.skipWaiting();
+});
 
 // Activate event - clean up old caches
-self.addEventListener('activate', (event) => {
-  console.log('[SW] Activating...')
-
-  event.waitUntil(
-    caches.keys().then((cacheNames) => {
-      return Promise.all(
-        cacheNames
-          .filter((name) => name !== CACHE_NAME)
-          .map((name) => caches.delete(name))
-      )
-    })
-  )
-
-  // Take control immediately
-  return self.clients.claim()
-})
+self.addEventListener("activate", (event) => {
+	console.log("[SW] Activating...");
+
+	event.waitUntil(
+		caches.keys().then((cacheNames) => {
+			return Promise.all(
+				cacheNames
+					.filter((name) => name !== CACHE_NAME)
+					.map((name) => caches.delete(name)),
+			);
+		}),
+	);
+
+	// Take control immediately
+	void self.clients.claim();
+});
 
 // Fetch event - serve from cache, fallback to network
-self.addEventListener('fetch', (event) => {
-  event.respondWith(
-    caches.match(event.request).then((response) => {
-      // Cache hit - return response
-      if (response) {
-        return response
-      }
-
-      // Clone the request
-      const fetchRequest = event.request.clone()
-
-      return fetch(fetchRequest).then((response) => {
-        // Check if valid response
-        if (!response || response.status !== 200 || response.type !== 'basic') {
-          return response
-        }
-
-        // Clone the response
-        const responseToCache = response.clone()
-
-        caches.open(CACHE_NAME).then((cache) => {
-          cache.put(event.request, responseToCache)
-        })
-
-        return response
-      })
-    })
-  )
-})
+self.addEventListener("fetch", (event) => {
+	event.respondWith(
+		caches.match(event.request).then((response) => {
+			// Cache hit - return response
+			if (response) {
+				return response;
+			}
+
+			// Clone the request
+			const fetchRequest = event.request.clone();
+
+			return fetch(fetchRequest).then((response) => {
+				// Check if valid response
+				if (
+					!response ||
+					response.status !== 200 ||
+					response.type !== "basic"
+				) {
+					return response;
+				}
+
+				// Clone the response
+				const responseToCache = response.clone();
+
+				void caches.open(CACHE_NAME).then((cache) => {
+					void cache.put(event.request, responseToCache);
+				});
+
+				return response;
+			});
+		}),
+	);
+});
 
 // Message handling
-self.addEventListener('message', (event) => {
-  console.log('[SW] Received message:', event.data)
-
-  switch (event.data.type) {
-    case 'PING':
-      // Respond to ping
-      event.ports[0]?.postMessage({
-        type: 'PONG',
-        timestamp: Date.now(),
-        originalTimestamp: event.data.timestamp
-      })
-
-      // Also broadcast to all clients
-      self.clients.matchAll().then((clients) => {
-        clients.forEach((client) => {
-          client.postMessage({
-            type: 'PONG',
-            from: 'service-worker',
-            timestamp: Date.now()
-          })
-        })
-      })
-      break
-
-    case 'BROADCAST':
-      // Broadcast to all clients
-      self.clients.matchAll().then((clients) => {
-        console.log(`[SW] Broadcasting to ${clients.length} clients`)
-        clients.forEach((client) => {
-          client.postMessage({
-            type: 'BROADCAST',
-            data: event.data.data,
-            from: 'service-worker',
-            timestamp: Date.now()
-          })
-        })
-      })
-      break
-
-    case 'SKIP_WAITING':
-      self.skipWaiting()
-      break
-
-    default:
-      console.log('[SW] Unknown message type:', event.data.type)
-  }
-})
+self.addEventListener("message", (event) => {
+	console.log("[SW] Received message:", event.data);
+
+	switch (event.data.type) {
+		case "PING":
+			// Respond to ping
+			event.ports[0]?.postMessage({
+				type: "PONG",
+				timestamp: Date.now(),
+				originalTimestamp: event.data.timestamp,
+			});
+
+			// Also broadcast to all clients
+			void self.clients.matchAll().then((clients) => {
+				for (const client of clients) {
+					client.postMessage({
+						type: "PONG",
+						from: "service-worker",
+						timestamp: Date.now(),
+					});
+				}
+			});
+			break;
+
+		case "BROADCAST":
+			// Broadcast to all clients
+			void self.clients.matchAll().then((clients) => {
+				console.log(`[SW] Broadcasting to ${clients.length} clients`);
+				for (const client of clients) {
+					client.postMessage({
+						type: "BROADCAST",
+						data: event.data.data,
+						from: "service-worker",
+						timestamp: Date.now(),
+					});
+				}
+			});
+			break;
+
+		case "SKIP_WAITING":
+			void self.skipWaiting();
+			break;
+
+		default:
+			console.log("[SW] Unknown message type:", event.data.type);
+	}
+});
 
 // Push notification event (example)
-self.addEventListener('push', (event) => {
-  console.log('[SW] Push received')
-
-  const data = event.data?.json() ?? {}
-  const title = data.title || '{{PROJECT_NAME}}'
-  const options = {
-    body: data.body || 'New notification',
-    icon: '/icon-192.png',
-    badge: '/icon-192.png',
-    data: data
-  }
-
-  event.waitUntil(
-    self.registration.showNotification(title, options)
-  )
-})
+self.addEventListener("push", (event) => {
+	console.log("[SW] Push received");
+
+	const data = event.data?.json() ?? {};
+	const title = data.title || "{{PROJECT_NAME}}";
+	const options = {
+		body: data.body || "New notification",
+		icon: "/icon-192.png",
+		badge: "/icon-192.png",
+		data: data,
+	};
+
+	event.waitUntil(self.registration.showNotification(title, options));
+});
 
 // Notification click event
-self.addEventListener('notificationclick', (event) => {
-  console.log('[SW] Notification clicked')
+self.addEventListener("notificationclick", (event) => {
+	console.log("[SW] Notification clicked");
 
-  event.notification.close()
+	event.notification.close();
 
-  event.waitUntil(
-    self.clients.openWindow('/')
-  )
-})
+	event.waitUntil(self.clients.openWindow("/"));
+});
 
-console.log('[SW] Service Worker loaded')
+console.log("[SW] Service Worker loaded");