Class MessageSender

packages/nodebox/src/messages.ts:214–365

}

export class MessageSender {
  private emitter: EventTarget;
  private channel: MessageChannel;
  private receiverPort: MessagePort;
  private receiverReadyPromise: DeferredPromise<void>;

  constructor(private readonly target: Window) {
    this.emitter = new EventTarget();
    this.channel = new MessageChannel();
    this.receiverPort = this.channel.port1;

    const receiverReadyPromise = new DeferredPromise<void>();
    const handshakeListener = (message: MessageEvent) => {
      if (message.data.type === 'internal/ready') {
        debug('[message-sender]: runtime is ready');
        receiverReadyPromise.resolve();
      }
    };
    window.addEventListener('message', handshakeListener);
    receiverReadyPromise.then(() => {
      window.removeEventListener('message', handshakeListener);
    });
    this.receiverReadyPromise = receiverReadyPromise;

    // Attach a message listener once.
    this.receiverPort.onmessage = (evt) => {
      const data = evt.data;
      if (data.type != null) {
        debug('[message-sender]: emitting "%s" event...', data.type, data.payload);
        this.emitter.dispatchEvent(new MessageEvent(data.type, { data: data.payload }));
      }
    };
  }

  public async handshake(): Promise<void> {
    const handshakePromise = new DeferredPromise<void>();

    await this.receiverReadyPromise;

    debug('[message-sender]: sending handshake');
    this.target.postMessage(
      {
        type: 'internal/handshake',
      },
      '*',
      [this.channel.port2]
    );

    this.on('internal/handshake/done', () => {
      handshakePromise.resolve();
      clearTimeout(rejectionTimeout);
    });

    const rejectionTimeout = setTimeout(() => {
      handshakePromise.reject(new Error('MessageSender: Handshake timeout'));
    }, 5000);

    return handshakePromise;