@schibstedspain/openads-appnexus/dist/openads-appnexus/service/ReplayEventBus.js

OpenAds AppNexus module for handle ads

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _map = require('babel-runtime/core-js/map');

var _map2 = _interopRequireDefault(_map);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _observerErrorThrown = require('./observerErrorThrown');

var _generateUUID = require('./generateUUID');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var ReplayEventBus = function () {
  function ReplayEventBus() {
    (0, _classCallCheck3.default)(this, ReplayEventBus);

    this._subscriptions = new _map2.default();
    this._pendingEvents = new _map2.default();
  }

  (0, _createClass3.default)(ReplayEventBus, [{
    key: 'register',
    value: function register(_ref) {
      var eventName = _ref.eventName,
          observer = _ref.observer;

      var subscriptionId = (0, _generateUUID.generateUUID)();
      var subscription = {
        id: subscriptionId,
        observer: observer
      };
      if (!eventName) {
        throw new Error('Event Name is required');
      }
      if (typeof observer !== 'function') {
        throw new Error('Observer must be a function');
      }
      if (!this._subscriptions.has(eventName)) {
        this._subscriptions.set(eventName, [subscription]);
      } else {
        this._subscriptions.get(eventName).push(subscription);
      }
      this._replayPendingEvents({ eventName: eventName, subscription: subscription });
      return subscriptionId;
    }
  }, {
    key: 'raise',
    value: function raise(_ref2) {
      var _this = this;

      var event = _ref2.event;

      if (!this._subscriptions.has(event.eventName)) {
        this._addPendingEvent({ event: event });
      } else {
        this._subscriptions.get(event.eventName).forEach(function (subscription) {
          return _this._processEvent({ event: event, subscription: subscription });
        });
      }
    }
  }, {
    key: '_addPendingEvent',
    value: function _addPendingEvent(_ref3) {
      var event = _ref3.event;

      if (!this._pendingEvents.has(event.eventName)) {
        this._pendingEvents.set(event.eventName, [event]);
      } else {
        this._pendingEvents.get(event.eventName).push(event);
      }
    }
  }, {
    key: '_replayPendingEvents',
    value: function _replayPendingEvents(_ref4) {
      var eventName = _ref4.eventName,
          subscription = _ref4.subscription;

      if (this._pendingEvents.has(eventName)) {
        var pendingEvent = this._pendingEvents.get(eventName).shift();
        if (pendingEvent) {
          this._processEvent({ event: pendingEvent, subscription: subscription });
        }
      }
    }
  }, {
    key: '_processEvent',
    value: function _processEvent(_ref5) {
      var _this2 = this;

      var event = _ref5.event,
          subscription = _ref5.subscription;

      try {
        subscription.observer({
          event: event.eventName,
          payload: event.payload,
          dispatcher: function dispatcher(data) {
            return _this2.raise({ event: data });
          }
        });
      } catch (err) {
        this.raise({
          event: (0, _observerErrorThrown.observerErrorThrown)({
            message: 'Error processing the observer.',
            error: err
          })
        });
      }
    }
  }, {
    key: 'unregister',
    value: function unregister(_ref6) {
      var eventName = _ref6.eventName,
          subscriptionId = _ref6.subscriptionId;

      if (this._subscriptions.has(eventName)) {
        var subscriptionIndex = this._subscriptions.get(eventName).findIndex(function (subscription) {
          return subscription.id === subscriptionId;
        });
        if (subscriptionIndex > -1) {
          this._subscriptions.get(eventName).splice(subscriptionIndex, 1);
          return true;
        }
      }
      return false;
    }
  }, {
    key: 'discardPendingEvents',
    value: function discardPendingEvents(_ref7) {
      var eventName = _ref7.eventName;

      this._pendingEvents.delete(eventName);
    }
  }, {
    key: 'getNumberOfRegisteredEvents',
    value: function getNumberOfRegisteredEvents() {
      return this._subscriptions.size;
    }
  }, {
    key: 'getNumberOfSubscriptionsRegisteredForAnEvent',
    value: function getNumberOfSubscriptionsRegisteredForAnEvent(_ref8) {
      var eventName = _ref8.eventName;

      return this._subscriptions.has(eventName) ? this._subscriptions.get(eventName).length : 0;
    }
  }, {
    key: 'getNumberOfPendingEvents',
    value: function getNumberOfPendingEvents(_ref9) {
      var eventName = _ref9.eventName;

      return this._pendingEvents.has(eventName) ? this._pendingEvents.get(eventName).length : 0;
    }
  }, {
    key: 'clear',
    value: function clear() {
      var _ref10 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
          eventName = _ref10.eventName;

      if (!eventName) {
        this._pendingEvents.clear();
        this._subscriptions.clear();
      } else {
        this._pendingEvents.delete(eventName);
        this._subscriptions.delete(eventName);
      }
    }
  }]);
  return ReplayEventBus;
}();

var replayEventBus = new ReplayEventBus();
exports.default = replayEventBus;