Low-Level Communication

/**
 * Low-level communication channel with the Angular Service Worker
 * Provides direct message passing and event handling capabilities
 */
class NgswCommChannel {
  /**
   * Observable that emits the current ServiceWorker instance
   * Emits when a new service worker becomes active
   */
  readonly worker: Observable<ServiceWorker>;
  
  /**
   * Observable that emits the ServiceWorkerRegistration
   * Provides access to the registration object
   */
  readonly registration: Observable<ServiceWorkerRegistration>;
  
  /**
   * Observable that emits all typed events from the service worker
   * Includes version events, push events, and error states
   */
  readonly events: Observable<TypedEvent>;
  
  /**
   * Whether the service worker is enabled and supported
   */
  get isEnabled(): boolean;
  
  /**
   * Send a message to the service worker without expecting a response
   * @param action - The action type to send
   * @param payload - The message payload
   * @returns Promise that resolves when message is sent
   */
  postMessage(action: string, payload: Object): Promise<void>;
  
  /**
   * Send a message and wait for an operation completion response
   * @param type - The message type
   * @param payload - The message payload  
   * @param operationNonce - Unique identifier for the operation
   * @returns Promise that resolves with operation result
   */
  postMessageWithOperation(
    type: string,
    payload: Object,
    operationNonce: number
  ): Promise<boolean>;
  
  /**
   * Generate a unique nonce for operation tracking
   * @returns Random number for operation identification
   */
  generateNonce(): number;
  
  /**
   * Filter events by type and return typed observable
   * @param type - Event type or array of types to filter
   * @returns Observable of filtered events
   */
  eventsOfType<T extends TypedEvent>(type: T['type'] | T['type'][]): Observable<T>;
  
  /**
   * Get the next event of a specific type
   * @param type - Event type to wait for
   * @returns Observable that emits once and completes
   */
  nextEventOfType<T extends TypedEvent>(type: T['type']): Observable<T>;
  
  /**
   * Wait for an operation to complete by nonce
   * @param nonce - Operation identifier to wait for
   * @returns Promise that resolves with operation success status
   */
  waitForOperationCompleted(nonce: number): Promise<boolean>;
}

import { inject } from '@angular/core';
import { NgswCommChannel } from '@angular/service-worker';

@Component({...})
export class AdvancedSwComponent {
  private sw = inject(NgswCommChannel);
  
  ngOnInit() {
    if (this.sw.isEnabled) {
      // Listen for all service worker events
      this.sw.events.subscribe(event => {
        console.log('SW Event:', event);
      });
      
      // Listen for specific event types
      this.sw.eventsOfType('VERSION_READY').subscribe(event => {
        console.log('New version ready:', event);
      });
      
      // Send custom message to service worker
      this.sendCustomMessage();
    }
  }
  
  async sendCustomMessage() {
    await this.sw.postMessage('CUSTOM_ACTION', {
      data: 'example payload'
    });
  }
  
  async performOperation() {
    const nonce = this.sw.generateNonce();
    try {
      const result = await this.sw.postMessageWithOperation(
        'CUSTOM_OPERATION',
        { nonce, param: 'value' },
        nonce
      );
      console.log('Operation result:', result);
    } catch (error) {
      console.error('Operation failed:', error);
    }
  }
}

/**
 * Base interface for all typed events
 */
interface TypedEvent {
  type: string;
}

/**
 * Event emitted when a push notification is received
 */
interface PushEvent {
  type: 'PUSH';
  data: any;
}

/**
 * Error message constant for unsupported service workers
 */
const ERR_SW_NOT_SUPPORTED: string;

type IncomingEvent = UnrecoverableStateEvent | VersionEvent;