Class Dispatcher

src/core/dispatcher.ts:6–122

import { EventListener } from "./event_listener"

export class Dispatcher implements BindingObserverDelegate {
  readonly application: Application
  private eventListenerMaps: Map<EventTarget, Map<string, EventListener>>
  private started: boolean

  constructor(application: Application) {
    this.application = application
    this.eventListenerMaps = new Map()
    this.started = false
  }

  start() {
    if (!this.started) {
      this.started = true
      this.eventListeners.forEach((eventListener) => eventListener.connect())
    }
  }

  stop() {
    if (this.started) {
      this.started = false
      this.eventListeners.forEach((eventListener) => eventListener.disconnect())
    }
  }

  get eventListeners(): EventListener[] {
    return Array.from(this.eventListenerMaps.values()).reduce(
      (listeners, map) => listeners.concat(Array.from(map.values())),
      [] as EventListener[]
    )
  }

  // Binding observer delegate

  bindingConnected(binding: Binding) {
    this.fetchEventListenerForBinding(binding).bindingConnected(binding)
  }

  bindingDisconnected(binding: Binding, clearEventListeners = false) {
    this.fetchEventListenerForBinding(binding).bindingDisconnected(binding)
    if (clearEventListeners) this.clearEventListenersForBinding(binding)
  }

  // Error handling

  handleError(error: Error, message: string, detail: object = {}) {
    this.application.handleError(error, `Error ${message}`, detail)
  }

  private clearEventListenersForBinding(binding: Binding) {
    const eventListener = this.fetchEventListenerForBinding(binding)
    if (!eventListener.hasBindings()) {
      eventListener.disconnect()
      this.removeMappedEventListenerFor(binding)
    }
  }

  private removeMappedEventListenerFor(binding: Binding) {