@fairfox/polly 0.1.5 → 0.2.1

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

@@ -0,0 +1,161 @@
+/**
+ * Service Worker Context
+ * Handles background tasks, caching, and push notifications
+ */
+
+/// <reference lib="WebWorker" />
+declare const self: ServiceWorkerGlobalScope
+
+console.log('[SW] Service Worker loading...')
+
+// Cache configuration
+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...')
+
+  event.waitUntil(
+    caches.open(CACHE_NAME).then((cache) => {
+      console.log('[SW] Caching resources')
+      return cache.addAll(urlsToCache)
+    })
+  )
+
+  // Activate immediately
+  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()
+})
+
+// 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
+      })
+    })
+  )
+})
+
+// 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)
+  }
+})
+
+// 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)
+  )
+})
+
+// Notification click event
+self.addEventListener('notificationclick', (event) => {
+  console.log('[SW] Notification clicked')
+
+  event.notification.close()
+
+  event.waitUntil(
+    self.clients.openWindow('/')
+  )
+})
+
+console.log('[SW] Service Worker loaded')

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

@@ -0,0 +1,135 @@
+/**
+ * Shared Worker Context
+ * Shared state and coordination across multiple tabs/windows
+ */
+
+/// <reference lib="WebWorker" />
+declare const self: SharedWorkerGlobalScope
+
+console.log('[Shared Worker] Starting...')
+
+// Track connected ports (tabs/windows)
+const ports: MessagePort[] = []
+let messageCount = 0
+
+// Shared state across all tabs
+interface SharedState {
+  connectedTabs: number
+  totalMessages: number
+  lastActivity: number
+}
+
+const state: SharedState = {
+  connectedTabs: 0,
+  totalMessages: 0,
+  lastActivity: Date.now()
+}
+
+// Connection event - when a new tab connects
+self.addEventListener('connect', (event) => {
+  const port = event.ports[0]
+  ports.push(port)
+  state.connectedTabs = ports.length
+
+  console.log(`[Shared Worker] New connection. Total ports: ${ports.length}`)
+
+  // Send welcome message
+  port.postMessage({
+    type: 'CONNECTED',
+    state: state,
+    timestamp: Date.now()
+  })
+
+  // Listen for messages from this port
+  port.addEventListener('message', (messageEvent) => {
+    handleMessage(messageEvent.data, port)
+  })
+
+  // Start listening
+  port.start()
+
+  // Notify all tabs about new connection
+  broadcast({
+    type: 'TAB_CONNECTED',
+    connectedTabs: state.connectedTabs
+  })
+})
+
+function handleMessage(data: any, sourcePort: MessagePort) {
+  console.log('[Shared Worker] Received:', data)
+
+  state.totalMessages++
+  state.lastActivity = Date.now()
+
+  switch (data.type) {
+    case 'PING':
+      // Respond to ping
+      sourcePort.postMessage({
+        type: 'PONG',
+        timestamp: Date.now(),
+        originalTimestamp: data.timestamp,
+        state: state
+      })
+      break
+
+    case 'BROADCAST':
+      // Broadcast to all connected tabs
+      broadcast({
+        type: 'BROADCAST',
+        data: data.data,
+        from: 'shared-worker',
+        timestamp: Date.now()
+      })
+      break
+
+    case 'GET_STATE':
+      // Send current state
+      sourcePort.postMessage({
+        type: 'STATE',
+        state: state,
+        timestamp: Date.now()
+      })
+      break
+
+    case 'INCREMENT_COUNTER':
+      // Example of shared state manipulation
+      messageCount++
+      broadcast({
+        type: 'COUNTER_UPDATED',
+        count: messageCount,
+        timestamp: Date.now()
+      })
+      break
+
+    default:
+      console.log('[Shared Worker] Unknown message type:', data.type)
+      sourcePort.postMessage({
+        type: 'ERROR',
+        message: `Unknown message type: ${data.type}`
+      })
+  }
+}
+
+// Broadcast message to all connected tabs
+function broadcast(message: any) {
+  console.log(`[Shared Worker] Broadcasting to ${ports.length} ports:`, message)
+
+  ports.forEach((port) => {
+    try {
+      port.postMessage(message)
+    } catch (error) {
+      console.error('[Shared Worker] Failed to send message to port:', error)
+    }
+  })
+}
+
+// Periodic heartbeat to all tabs
+setInterval(() => {
+  broadcast({
+    type: 'HEARTBEAT',
+    state: state,
+    timestamp: Date.now()
+  })
+}, 30000) // Every 30 seconds
+
+console.log('[Shared Worker] Ready')

package/templates/pwa/tsconfig.json.template

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "lib": ["ES2022", "DOM", "DOM.Iterable", "WebWorker"],
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "isolatedModules": true,
+    "noEmit": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}