Source: lib/util/fake_event_target.js

  1. /** @license
  2.  * Copyright 2016 Google LLC
  3.  * SPDX-License-Identifier: Apache-2.0
  4.  */
  6. goog.provide('shaka.util.FakeEventTarget');
  8. goog.require('goog.asserts');
  9. goog.require('shaka.log');
  10. goog.require('shaka.util.FakeEvent');
  11. goog.require('shaka.util.MultiMap');
  14. /**
  15.  * @summary A work-alike for EventTarget.  Only DOM elements may be true
  16.  * EventTargets, but this can be used as a base class to provide event dispatch
  17.  * to non-DOM classes.  Only FakeEvents should be dispatched.
  18.  *
  19.  * @implements {EventTarget}
  20.  * @exportInterface
  21.  */
  22. shaka.util.FakeEventTarget = class {
  23.   constructor() {
  24.     /**
  25.      * @private {!shaka.util.MultiMap.<shaka.util.FakeEventTarget.ListenerType>}
  26.      */
  27.     this.listeners_ = new shaka.util.MultiMap();
  29.     /**
  30.      * The target of all dispatched events.  Defaults to |this|.
  31.      * @type {EventTarget}
  32.      */
  33.     this.dispatchTarget = this;
  34.   }
  36.   /**
  37.    * Add an event listener to this object.
  38.    *
  39.    * @param {string} type The event type to listen for.
  40.    * @param {shaka.util.FakeEventTarget.ListenerType} listener The callback or
  41.    *   listener object to invoke.
  42.    * @param {(!AddEventListenerOptions|boolean)=} options Ignored.
  43.    * @override
  44.    * @exportInterface
  45.    */
  46.   addEventListener(type, listener, options) {
  47.     this.listeners_.push(type, listener);
  48.   }
  50.   /**
  51.    * Remove an event listener from this object.
  52.    *
  53.    * @param {string} type The event type for which you wish to remove a
  54.    *   listener.
  55.    * @param {shaka.util.FakeEventTarget.ListenerType} listener The callback or
  56.    *   listener object to remove.
  57.    * @param {(EventListenerOptions|boolean)=} options Ignored.
  58.    * @override
  59.    * @exportInterface
  60.    */
  61.   removeEventListener(type, listener, options) {
  62.     this.listeners_.remove(type, listener);
  63.   }
  65.   /**
  66.    * Dispatch an event from this object.
  67.    *
  68.    * @param {!Event} event The event to be dispatched from this object.
  69.    * @return {boolean} True if the default action was prevented.
  70.    * @override
  71.    * @exportInterface
  72.    */
  73.   dispatchEvent(event) {
  74.     // In many browsers, it is complex to overwrite properties of actual Events.
  75.     // Here we expect only to dispatch FakeEvents, which are simpler.
  76.     goog.asserts.assert(event instanceof shaka.util.FakeEvent,
  77.         'FakeEventTarget can only dispatch FakeEvents!');
  79.     const listeners = this.listeners_.get(event.type) || [];
  81.     // Execute this event on listeners until the event has been stopped or we
  82.     // run out of listeners.
  83.     for (const listener of listeners) {
  84.       // Do this every time, since events can be re-dispatched from handlers.
  85.       event.target = this.dispatchTarget;
  86.       event.currentTarget = this.dispatchTarget;
  88.       try {
  89.         // Check for the |handleEvent| member to test if this is a
  90.         // |EventListener| instance or a basic function.
  91.         if (listener.handleEvent) {
  92.           listener.handleEvent(event);
  93.         } else {
  94.           // eslint-disable-next-line no-restricted-syntax
  95.           listener.call(this, event);
  96.         }
  97.       } catch (exception) {
  98.         // Exceptions during event handlers should not affect the caller,
  99.         // but should appear on the console as uncaught, according to MDN:
  100.         // https://mzl.la/2JXgwRo
  101.         shaka.log.error('Uncaught exception in event handler', exception,
  102.             exception ? exception.message : null,
  103.             exception ? exception.stack : null);
  104.       }
  106.       if (event.stopped) {
  107.         break;
  108.       }
  109.     }
  111.     return event.defaultPrevented;
  112.   }
  113. };
  115. /**
  116.  * These are the listener types defined in the closure extern for EventTarget.
  117.  * @typedef {EventListener|function(!Event):*}
  118.  * @exportInterface
  119.  */
  120. shaka.util.FakeEventTarget.ListenerType;