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

OpenAds AppNexus connector with Prebid features

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

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

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

var ReplayEventBus =
/*#__PURE__*/
function () {
  function ReplayEventBus() {
    this._subscriptions = new Map();
    this._pendingEvents = new Map();
  }

  var _proto = ReplayEventBus.prototype;

  _proto.register = 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;
  };

  _proto.raise = 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
        });
      });
    }
  };

  _proto._addPendingEvent = 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);
    }
  };

  _proto._replayPendingEvents = 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
        });
      }
    }
  };

  _proto._processEvent = 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
        })
      });
    }
  };

  _proto.unregister = 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;
  };

  _proto.discardPendingEvents = function discardPendingEvents(_ref7) {
    var eventName = _ref7.eventName;

    this._pendingEvents.delete(eventName);
  };

  _proto.getNumberOfRegisteredEvents = function getNumberOfRegisteredEvents() {
    return this._subscriptions.size;
  };

  _proto.getNumberOfSubscriptionsRegisteredForAnEvent = function getNumberOfSubscriptionsRegisteredForAnEvent(_ref8) {
    var eventName = _ref8.eventName;
    return this._subscriptions.has(eventName) ? this._subscriptions.get(eventName).length : 0;
  };

  _proto.getNumberOfPendingEvents = function getNumberOfPendingEvents(_ref9) {
    var eventName = _ref9.eventName;
    return this._pendingEvents.has(eventName) ? this._pendingEvents.get(eventName).length : 0;
  };

  _proto.clear = function clear(_temp) {
    var _ref10 = _temp === void 0 ? {} : _temp,
        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();
var _default = replayEventBus;
exports.default = _default;