@tencentcloud/web-push 1.0.2 → 1.0.3

package/src/core/event-emitter.ts

@@ -0,0 +1,61 @@
+import { EVENT } from '../types';
+import { logger } from '../utils/logger';
+
+export class EventEmitter {
+  private events: Map<EVENT, Map<string, Function>> = new Map();
+
+  on(eventName: EVENT, listener: Function): string {
+    if (!this.events.has(eventName)) {
+      this.events.set(eventName, new Map());
+    }
+
+    const listenerId = Math.random().toString(36).substr(2, 9);
+    this.events.get(eventName)!.set(listenerId, listener);
+
+    return listenerId;
+  }
+
+  off(eventName: EVENT, listener: Function): boolean {
+    const eventMap = this.events.get(eventName);
+    if (!eventMap) {
+      return false;
+    }
+
+    for (const [id, fn] of eventMap.entries()) {
+      if (fn === listener) {
+        eventMap.delete(id);
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  emit(eventName: EVENT, ...args: any[]): void {
+    const eventMap = this.events.get(eventName);
+    if (!eventMap) {
+      return;
+    }
+
+    eventMap.forEach((listener) => {
+      try {
+        listener(...args);
+      } catch (error) {
+        logger.error(`Event listener error for ${eventName}:`, error);
+      }
+    });
+  }
+
+  removeAllListeners(eventName?: EVENT): void {
+    if (eventName) {
+      this.events.delete(eventName);
+    } else {
+      this.events.clear();
+    }
+  }
+
+  listenerCount(eventName: EVENT): number {
+    const eventMap = this.events.get(eventName);
+    return eventMap ? eventMap.size : 0;
+  }
+}

package/src/core/service-worker-manager.ts

@@ -0,0 +1,614 @@
+import { ServiceWorkerMessage } from '../types';
+import { logger } from '../utils/logger';
+import { EventEmitter } from './event-emitter';
+import { EVENT, SubscriptionInfo } from '../types';
+import { Validator, ValidationError } from '../utils/validator';
+import { getBrowserInfo } from '../utils/browser-support';
+import { Storage } from '../utils/storage';
+
+export class ServiceWorkerManager {
+  private static instance: ServiceWorkerManager;
+  private registration: ServiceWorkerRegistration | null = null;
+  private eventEmitter: EventEmitter;
+  private swUrl: string = '/sw.js';
+
+  private constructor(eventEmitter: EventEmitter) {
+    this.eventEmitter = eventEmitter;
+    this.setupMessageListener();
+  }
+
+  static getInstance(eventEmitter: EventEmitter): ServiceWorkerManager {
+    if (!ServiceWorkerManager.instance) {
+      ServiceWorkerManager.instance = new ServiceWorkerManager(eventEmitter);
+    }
+    return ServiceWorkerManager.instance;
+  }
+
+  private async checkServiceWorkerExists(url: string): Promise<boolean> {
+    try {
+      const response = await fetch(url, { method: 'HEAD' });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  private async autoDetectServiceWorkerUrl(): Promise<void> {
+    if (typeof window !== 'undefined') {
+      const currentPath = window.location.pathname;
+      const basePath = currentPath.endsWith('/')
+        ? currentPath
+        : currentPath + '/';
+
+      if (basePath !== '/') {
+        this.swUrl = './sw.js';
+        logger.log(
+          'Detected subdirectory deployment, using relative path:',
+          this.swUrl
+        );
+      } else {
+        this.swUrl = '/sw.js';
+        logger.log(
+          'Detected root directory deployment, using absolute path:',
+          this.swUrl
+        );
+      }
+
+      const isAvailable = await this.checkServiceWorkerExists(this.swUrl);
+      if (!isAvailable) {
+        logger.warn(
+          'Default Service Worker path not available, will try other paths during registration'
+        );
+      }
+    }
+  }
+
+  setServiceWorkerUrl(url: string): void {
+    try {
+      Validator.validateServiceWorkerPath(url);
+
+      this.swUrl = url;
+      logger.log('Manually set Service Worker path:', url);
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        logger.error(
+          'Set Service Worker path parameter validation failed',
+          error.message
+        );
+        throw error;
+      }
+      throw new Error('Failed to set Service Worker path');
+    }
+  }
+
+  async register(): Promise<ServiceWorkerRegistration> {
+    if (!('serviceWorker' in navigator)) {
+      throw new Error('Service Worker is not supported');
+    }
+
+    await this.autoDetectServiceWorkerUrl();
+
+    const possibleUrls = [
+      this.swUrl,
+      './sw.js',
+      '/sw.js',
+      '/dist/sw.js',
+      '/assets/sw.js',
+    ];
+
+    const uniqueUrls = [...new Set(possibleUrls)];
+    let lastError: Error | null = null;
+
+    for (const url of uniqueUrls) {
+      try {
+        logger.log('Attempting to register Service Worker:', url);
+        this.registration = await navigator.serviceWorker.register(url);
+
+        this.swUrl = url;
+        logger.log('Service Worker registration successful', {
+          url,
+          registration: this.registration,
+        });
+
+        await this.waitForServiceWorkerReady();
+
+        return this.registration;
+      } catch (error) {
+        lastError = error as Error;
+        logger.warn(`Service Worker registration failed (${url}):`, error);
+        continue;
+      }
+    }
+
+    logger.error('All Service Worker paths failed to register', lastError);
+    throw new Error(
+      `Service Worker registration failed: ${lastError?.message || 'Unknown error'}. Please ensure sw.js file exists in one of the following paths: ${uniqueUrls.join(', ')}`
+    );
+  }
+
+  private async waitForServiceWorkerReady(): Promise<void> {
+    if (!this.registration) {
+      throw new Error('Service Worker not registered');
+    }
+
+    return new Promise((resolve) => {
+      if (this.registration!.active) {
+        resolve();
+        return;
+      }
+
+      const worker =
+        this.registration!.installing || this.registration!.waiting;
+      if (worker) {
+        worker.addEventListener('statechange', () => {
+          if (worker.state === 'activated') {
+            resolve();
+          }
+        });
+      }
+    });
+  }
+
+  async getPushSubscription(vapidPublicKey: string): Promise<SubscriptionInfo> {
+    try {
+      Validator.validateValue('vapidPublicKey', vapidPublicKey, {
+        required: true,
+        type: 'string',
+        min: 1,
+        max: 512,
+        message: 'VAPID public key must be a valid string',
+      });
+
+      if (!this.registration) {
+        throw new Error('Service Worker not registered');
+      }
+
+      const storedVapidKey = this.getStoredVapidPublicKey();
+
+      let subscription = await this.registration.pushManager.getSubscription();
+
+      if (subscription && storedVapidKey !== vapidPublicKey) {
+        logger.log(
+          'VAPID public key changed, unsubscribing existing subscription'
+        );
+        await subscription.unsubscribe();
+        subscription = null;
+      }
+
+      if (!subscription) {
+        subscription = await this.registration.pushManager.subscribe({
+          userVisibleOnly: true,
+          applicationServerKey: this.urlBase64ToUint8Array(
+            vapidPublicKey
+          ) as BufferSource,
+        });
+        this.setStoreVapidPublicKey(vapidPublicKey);
+      }
+
+      logger.log('Get push subscription successful', subscription);
+
+      const subscriptionInfo = this.getSubscriptionInfo(subscription);
+      logger.log('Extracted subscription information:', {
+        token: subscriptionInfo.token,
+        auth: subscriptionInfo.auth,
+        p256dh: subscriptionInfo.p256dh,
+        endpoint: subscriptionInfo.endpoint,
+      });
+      return {
+        subscription,
+        token: subscriptionInfo.token || '',
+        auth: subscriptionInfo.auth || '',
+        p256dh: subscriptionInfo.p256dh || '',
+        endpoint: subscriptionInfo.endpoint || '',
+      };
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        logger.error(
+          'Get push subscription parameter validation failed',
+          error.message
+        );
+        throw error;
+      }
+      logger.error('Get push subscription failed', error);
+      throw error;
+    }
+  }
+
+  private getSubscriptionInfo(subscription: PushSubscription): {
+    token: string | null;
+    auth: string | null;
+    p256dh: string | null;
+    endpoint: string | null;
+  } {
+    if (!subscription || !subscription.endpoint) {
+      return {
+        token: null,
+        auth: null,
+        p256dh: null,
+        endpoint: null,
+      };
+    }
+
+    const endpoint = subscription.endpoint;
+    const browserInfo = getBrowserInfo();
+
+    const keys = subscription.getKey
+      ? {
+          auth: subscription.getKey('auth')
+            ? this.arrayBufferToBase64(subscription.getKey('auth')!)
+            : null,
+          p256dh: subscription.getKey('p256dh')
+            ? this.arrayBufferToBase64(subscription.getKey('p256dh')!)
+            : null,
+        }
+      : {
+          auth: null,
+          p256dh: null,
+        };
+
+    logger.log('Extract push subscription information', {
+      browser: `${browserInfo.name} ${browserInfo.version}`,
+      hasAuth: !!keys.auth,
+      hasP256dh: !!keys.p256dh,
+    });
+
+    try {
+      if (browserInfo.name === 'Chrome' || browserInfo.name === 'Edge') {
+        const fcmMatch = endpoint.match(
+          /https:\/\/fcm\.googleapis\.com\/fcm\/send\/(.+)/
+        );
+        if (fcmMatch) {
+          logger.log('Extract Token using Chrome/Edge FCM format');
+          return {
+            token: fcmMatch[1],
+            auth: keys.auth,
+            p256dh: keys.p256dh,
+            endpoint: endpoint,
+          };
+        }
+
+        const gcmMatch = endpoint.match(
+          /https:\/\/android\.googleapis\.com\/gcm\/send\/(.+)/
+        );
+        if (gcmMatch) {
+          logger.log('Extract Token using Chrome/Edge GCM format');
+          return {
+            token: gcmMatch[1],
+            auth: keys.auth,
+            p256dh: keys.p256dh,
+            endpoint: endpoint,
+          };
+        }
+      } else if (browserInfo.name === 'Firefox') {
+        const mozillaV2Match = endpoint.match(
+          /https:\/\/updates\.push\.services\.mozilla\.com\/wpush\/v(\d+)\/(.+)/
+        );
+        if (mozillaV2Match) {
+          logger.log(
+            `Extract Token using Firefox WebPush v${mozillaV2Match[1]} format`
+          );
+          return {
+            token: mozillaV2Match[2],
+            auth: keys.auth,
+            p256dh: keys.p256dh,
+            endpoint: endpoint,
+          };
+        }
+
+        const mozillaV1Match = endpoint.match(
+          /https:\/\/updates\.push\.services\.mozilla\.com\/push\/(.+)/
+        );
+        if (mozillaV1Match) {
+          logger.log('Extract Token using Firefox legacy format');
+          return {
+            token: mozillaV1Match[1],
+            auth: keys.auth,
+            p256dh: keys.p256dh,
+            endpoint: endpoint,
+          };
+        }
+      } else if (browserInfo.name === 'Safari') {
+        if (browserInfo.majorVersion >= 16) {
+          const safariWebPushMatch = endpoint.match(
+            /https:\/\/web\.push\.apple\.com\/(.+)/
+          );
+          if (safariWebPushMatch) {
+            logger.log('Extract Token using Safari Web Push format');
+            return {
+              token: safariWebPushMatch[1],
+              auth: keys.auth,
+              p256dh: keys.p256dh,
+              endpoint: endpoint,
+            };
+          }
+        }
+
+        if (endpoint.includes('safari') || endpoint.includes('apple')) {
+          logger.log(
+            'Safari push notification uses complete endpoint as identifier'
+          );
+          return {
+            token: this.generateSafariToken(endpoint),
+            auth: keys.auth,
+            p256dh: keys.p256dh,
+            endpoint: endpoint,
+          };
+        }
+      } else if (browserInfo.name === 'Opera') {
+        const operaFcmMatch = endpoint.match(
+          /https:\/\/fcm\.googleapis\.com\/fcm\/send\/(.+)/
+        );
+        if (operaFcmMatch) {
+          logger.log('Extract Token using Opera FCM format');
+          return {
+            token: operaFcmMatch[1],
+            auth: keys.auth,
+            p256dh: keys.p256dh,
+            endpoint: endpoint,
+          };
+        }
+      } else if (browserInfo.name === 'Samsung Internet') {
+        const samsungFcmMatch = endpoint.match(
+          /https:\/\/fcm\.googleapis\.com\/fcm\/send\/(.+)/
+        );
+        if (samsungFcmMatch) {
+          logger.log('Extract Token using Samsung Internet FCM format');
+          return {
+            token: samsungFcmMatch[1],
+            auth: keys.auth,
+            p256dh: keys.p256dh,
+            endpoint: endpoint,
+          };
+        }
+      }
+
+      const genericPatterns = [
+        {
+          pattern: /https:\/\/fcm\.googleapis\.com\/fcm\/send\/(.+)/,
+          name: 'FCM Standard',
+        },
+        {
+          pattern: /https:\/\/android\.googleapis\.com\/gcm\/send\/(.+)/,
+          name: 'GCM Legacy',
+        },
+        {
+          pattern: /https:\/\/gcm-http\.googleapis\.com\/gcm\/(.+)/,
+          name: 'GCM HTTP',
+        },
+
+        {
+          pattern:
+            /https:\/\/updates\.push\.services\.mozilla\.com\/wpush\/v\d+\/(.+)/,
+          name: 'Mozilla WebPush',
+        },
+        {
+          pattern:
+            /https:\/\/updates\.push\.services\.mozilla\.com\/push\/(.+)/,
+          name: 'Mozilla Legacy',
+        },
+
+        {
+          pattern: /https:\/\/.*\.notify\.windows\.com\/.*\/(.+)/,
+          name: 'Windows Notification',
+        },
+
+        {
+          pattern: /https:\/\/web\.push\.apple\.com\/(.+)/,
+          name: 'Apple Web Push',
+        },
+
+        { pattern: /https:\/\/.*\/push\/(.+)/, name: 'Generic Push' },
+        { pattern: /https:\/\/.*\/wpush\/(.+)/, name: 'Generic WebPush' },
+      ];
+
+      for (const { pattern, name } of genericPatterns) {
+        const match = endpoint.match(pattern);
+        if (match && match[1]) {
+          logger.log(`Extract Token using generic pattern: ${name}`, {
+            browser: browserInfo.name,
+            pattern: pattern.source,
+          });
+          return {
+            token: match[1],
+            auth: keys.auth,
+            p256dh: keys.p256dh,
+            endpoint: endpoint,
+          };
+        }
+      }
+
+      logger.warn(
+        'Unable to extract standard Token from push endpoint, generating unique identifier',
+        {
+          browser: `${browserInfo.name} ${browserInfo.version}`,
+          endpointLength: endpoint.length,
+          endpointStart: endpoint.substring(0, 50) + '...',
+        }
+      );
+
+      const fallbackToken = this.generateFallbackToken(endpoint, browserInfo);
+      return {
+        token: fallbackToken,
+        auth: keys.auth,
+        p256dh: keys.p256dh,
+        endpoint: endpoint,
+      };
+    } catch (error) {
+      logger.error(
+        'Error occurred during push subscription information extraction',
+        {
+          error: error instanceof Error ? error.message : error,
+          browser: browserInfo.name,
+          endpointDomain: endpoint.split('/')[2],
+        }
+      );
+
+      const fallbackToken = this.generateFallbackToken(endpoint, browserInfo);
+      return {
+        token: fallbackToken,
+        auth: keys.auth,
+        p256dh: keys.p256dh,
+        endpoint: endpoint,
+      };
+    }
+  }
+
+  private generateSafariToken(endpoint: string): string {
+    const safariMatch = endpoint.match(/https:\/\/.*safari.*\/(.+)/);
+    if (safariMatch) {
+      return `safari_${safariMatch[1]}`;
+    }
+
+    return `safari_${this.generateEndpointHash(endpoint)}`;
+  }
+
+  private generateFallbackToken(endpoint: string, browserInfo: any): string {
+    const hash = this.generateEndpointHash(endpoint);
+    const browserPrefix = browserInfo.name.toLowerCase().replace(/\s+/g, '');
+    const timestamp = Date.now().toString(36);
+
+    return `${browserPrefix}_${hash}_${timestamp}`;
+  }
+
+  private generateEndpointHash(endpoint: string): string {
+    let hash = 0;
+    for (let i = 0; i < endpoint.length; i++) {
+      const char = endpoint.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+
+    return Math.abs(hash).toString(36);
+  }
+
+  async unsubscribe(): Promise<boolean> {
+    if (!this.registration) {
+      return false;
+    }
+
+    const subscription = await this.registration.pushManager.getSubscription();
+    if (subscription) {
+      const result = await subscription.unsubscribe();
+      logger.log('Unsubscribe from push notifications', result);
+      this.clearStoredVapidPublicKey();
+      return result;
+    }
+
+    return true;
+  }
+
+  async unregister(): Promise<boolean> {
+    if (!this.registration) {
+      return false;
+    }
+
+    const result = await this.registration.unregister();
+    this.registration = null;
+    this.clearStoredVapidPublicKey();
+    logger.log('Unregister Service Worker', result);
+    return result;
+  }
+
+  private setupMessageListener(): void {
+    if ('serviceWorker' in navigator) {
+      navigator.serviceWorker.addEventListener('message', (event) => {
+        const message: ServiceWorkerMessage = event.data;
+        this.handleServiceWorkerMessage(message);
+      });
+    }
+  }
+
+  private handleServiceWorkerMessage(message: ServiceWorkerMessage): void {
+    logger.log('Received Service Worker message', message);
+
+    switch (message.type) {
+      case 'MESSAGE_RECEIVED':
+        this.eventEmitter.emit(EVENT.MESSAGE_RECEIVED, message.data);
+        break;
+      case 'NOTIFICATION_CLICKED':
+        this.eventEmitter.emit(EVENT.NOTIFICATION_CLICKED, message.data);
+        break;
+      case 'MESSAGE_REVOKED':
+        this.eventEmitter.emit(EVENT.MESSAGE_REVOKED, message.data);
+        break;
+    }
+  }
+
+  async postMessage(message: any): Promise<void> {
+    try {
+      Validator.validateValue('message', message, {
+        required: true,
+        message: 'Message content cannot be empty',
+      });
+
+      if (!this.registration || !this.registration.active) {
+        throw new Error('Service Worker not activated');
+      }
+
+      this.registration.active.postMessage(message);
+      logger.log('Send message to Service Worker successful', message);
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        logger.error('Send message parameter validation failed', error.message);
+        throw error;
+      }
+      logger.error('Send message to Service Worker failed', error);
+      throw error;
+    }
+  }
+
+  private arrayBufferToBase64(buffer: ArrayBuffer): string {
+    const bytes = new Uint8Array(buffer);
+    let binary = '';
+    for (let i = 0; i < bytes.byteLength; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return window.btoa(binary);
+  }
+
+  private urlBase64ToUint8Array(base64String: string): Uint8Array {
+    const padding = '='.repeat((4 - (base64String.length % 4)) % 4);
+    const base64 = (base64String + padding)
+      .replace(/-/g, '+')
+      .replace(/_/g, '/');
+
+    const rawData = window.atob(base64);
+    const outputArray = new Uint8Array(rawData.length);
+
+    for (let i = 0; i < rawData.length; ++i) {
+      outputArray[i] = rawData.charCodeAt(i);
+    }
+    return outputArray;
+  }
+
+  getRegistration(): ServiceWorkerRegistration | null {
+    return this.registration;
+  }
+
+  private getStoredVapidPublicKey(): string | null {
+    try {
+      return Storage.get<string>('sdk_vapid_key');
+    } catch (error) {
+      logger.error('Failed to get stored VAPID public key', error);
+      return null;
+    }
+  }
+
+  private setStoreVapidPublicKey(vapidPublicKey: string): void {
+    try {
+      Storage.set('sdk_vapid_key', vapidPublicKey);
+      logger.log('VAPID public key stored successfully');
+    } catch (error) {
+      logger.error('Failed to store VAPID public key', error);
+    }
+  }
+
+  private clearStoredVapidPublicKey(): void {
+    try {
+      Storage.remove('sdk_vapid_key');
+      logger.log('VAPID public key cleared successfully');
+    } catch (error) {
+      logger.error('Failed to clear VAPID public key', error);
+    }
+  }
+}