prebid.js 7.22.0 → 7.24.0

package/modules/videoModule/coreVideo.js

@@ -0,0 +1,234 @@
+import { module } from '../../src/hook.js';
+import { ParentModule, SubmoduleBuilder } from '../../libraries/video/shared/parentModule.js';
+
+// define, ortb object,  events
+
+/**
+ * Video Provider Submodule interface. All submodules of the Core Video module must adhere to this.
+ * @description attached to a video player instance.
+ * @typedef {Object} VideoProvider
+ * @function init - Instantiates the Video Provider and the video player, if not already instantiated.
+ * @function getId - retrieves the div id (unique identifier) of the attached player instance.
+ * @function getOrtbVideo - retrieves the oRTB Video params for a player's current video session.
+ * @function getOrtbContent - retrieves the oRTB Content params for a player's current video session.
+ * @function setAdTagUrl - Requests that a player render the ad in the provided ad tag url.
+ * @function onEvent - attaches an event listener to the player instance.
+ * @function offEvent - removes event listener to the player instance.
+ * @function destroy - deallocates the player instance
+ */
+
+/**
+ * @function VideoProvider#init
+ */
+
+/**
+ * @function VideoProvider#getId
+ * @returns {string}
+ */
+
+/**
+ * @function VideoProvider#getOrtbVideo
+ * @returns {Object}
+ */
+
+/**
+ * @function VideoProvider#getOrtbContent
+ * @returns {Object}
+ */
+
+/**
+ * @function VideoProvider#setAdTagUrl
+ * @param {string} adTagUrl - URL to a VAST ad tag
+ * @param {Object} options - Optional params
+ */
+
+/**
+ * @function VideoProvider#onEvent
+ * @param {string} event - name of event for which the listener should be added
+ * @param {function} callback - function that will get called when the event is triggered
+ * @param {Object} basePayload - Base payload for every event; includes common parameters such as divId and type. Event payload should be built on top of this.
+ */
+
+/**
+ * @function VideoProvider#offEvent
+ * @param {string} event - name of event for which the attached listener should be removed
+ * @param {function} callback - function that was assigned as a callback when the listener was added
+ */
+
+/**
+ * @function VideoProvider#destroy
+ */
+
+/**
+ * @typedef {Object} videoProviderConfig
+ * @name videoProviderConfig
+ * @summary contains data indicating which submodule to create and which player instance to attach it to
+ * @property {string} divId - unique identifier of the player instance
+ * @property {number} vendorCode - numeric identifier of the Video Provider type i.e. video.js or jwplayer
+ * @property {playerConfig} playerConfig
+ */
+
+/**
+ * @typedef {Object} playerConfig
+ * @name playerConfig
+ * @summary contains data indicating the behavior the player instance should have
+ * @property {boolean} autoStart - determines if the player should start automatically when instantiated
+ * @property {boolean} mute - determines if the player should be muted when instantiated
+ * @property {string} licenseKey - authentication key required for commercial players. Optional for free players.
+ * @property {playerVendorParams} params
+ */
+
+/**
+ * @typedef playerVendorParams
+ * @name playerVendorParams
+ * @summary configuration options specific to a Video Vendor's Provider
+ * @property {Object} vendorConfig - the settings object which can be used as an argument when instantiating a player. Specific to the video player's API.
+ */
+
+/**
+ * @typedef videoEvent
+ *
+ */
+
+/**
+ * Routes commands to the appropriate video submodule.
+ * @typedef {Object} VideoCore
+ * @class
+ * @function registerProvider
+ * @function getOrtbVideo
+ * @function getOrtbContent
+ * @function setAdTagUrl
+ * @function onEvents
+ * @function offEvents
+ */
+
+/**
+ * @summary Maps a Video Provider factory to the video player's vendor code.
+ * @type {vendorSubmoduleDirectory}
+ */
+const videoVendorDirectory = {};
+
+/**
+ * @constructor
+ * @param {ParentModule} parentModule_
+ * @returns {VideoCore}
+ */
+export function VideoCore(parentModule_) {
+  const parentModule = parentModule_;
+
+  /**
+   * requests that a submodule be instantiated for the specific player instance described by the @providerConfig
+   * @name VideoCore#registerProvider
+   * @param {videoProviderConfig} providerConfig
+   */
+  function registerProvider(providerConfig) {
+    try {
+      parentModule.registerSubmodule(providerConfig.divId, providerConfig.vendorCode, providerConfig);
+    } catch (e) {}
+  }
+
+  /**
+   * @name VideoCore#getOrtbVideo
+   * @summary Obtains the oRTB Video params for a player's current video session.
+   * @param {string} divId - unique identifier of the player instance
+   * @returns {Object} oRTB Video params
+   */
+  function getOrtbVideo(divId) {
+    const submodule = parentModule.getSubmodule(divId);
+    return submodule && submodule.getOrtbVideo();
+  }
+
+  /**
+   * @name VideoCore#getOrtbContent
+   * @summary Obtains the oRTB Content params for a player's current video session.
+   * @param {string} divId - unique identifier of the player instance
+   * @returns {Object} oRTB Content params
+   */
+  function getOrtbContent(divId) {
+    const submodule = parentModule.getSubmodule(divId);
+    return submodule && submodule.getOrtbContent();
+  }
+
+  /**
+   * @name VideoCore#setAdTagUrl
+   * @summary Requests that a player render the ad in the provided ad tag
+   * @param {string} adTagUrl - URL to a VAST ad tag
+   * @param {string} divId - unique identifier of the player instance
+   * @param {Object} options - additional params
+   */
+  function setAdTagUrl(adTagUrl, divId, options) {
+    const submodule = parentModule.getSubmodule(divId);
+    submodule && submodule.setAdTagUrl(adTagUrl, options);
+  }
+
+  /**
+   * @name VideoCore#onEvents
+   * @summary attaches event listeners
+   * @param {[string]} events - List of event names for which the listener should be added
+   * @param {function} callback - function that will get called when one of the events is triggered
+   * @param {string} divId - unique identifier of the player instance
+   */
+  function onEvents(events, callback, divId) {
+    if (!callback) {
+      return;
+    }
+
+    const submodule = parentModule.getSubmodule(divId);
+    if (!submodule) {
+      return;
+    }
+
+    for (let i = 0; i < events.length; i++) {
+      const type = events[i];
+      const basePayload = {
+        divId,
+        type
+      };
+      submodule.onEvent(type, callback, basePayload);
+    }
+  }
+
+  /**
+   * @name VideoCore#offEvents
+   * @summary removes event listeners
+   * @param {[string]} events - List of event names for which the listener should be removed
+   * @param {function} callback - function that was assigned as a callback when the listener was added
+   * @param {string} divId - unique identifier of the player instance
+   */
+  function offEvents(events, callback, divId) {
+    const submodule = parentModule.getSubmodule(divId);
+    if (!submodule) {
+      return;
+    }
+
+    events.forEach(event => {
+      submodule.offEvent(event, callback);
+    });
+  }
+
+  return {
+    registerProvider,
+    getOrtbVideo,
+    getOrtbContent,
+    setAdTagUrl,
+    onEvents,
+    offEvents
+  };
+}
+
+/**
+ * @function videoCoreFactory
+ * @summary Factory to create a Video Core instance
+ * @returns {VideoCore}
+ */
+export function videoCoreFactory() {
+  const videoSubmoduleBuilder = SubmoduleBuilder(videoVendorDirectory);
+  const parentModule = ParentModule(videoSubmoduleBuilder);
+  return VideoCore(parentModule);
+}
+
+function attachVideoProvider(submoduleFactory) {
+  videoVendorDirectory[submoduleFactory.vendorCode] = submoduleFactory;
+}
+
+module('video', attachVideoProvider);

package/modules/videoModule/gamAdServerSubmodule.js

@@ -0,0 +1,27 @@
+import { GAM_VENDOR } from '../../libraries/video/constants/vendorCodes.js';
+import { getGlobal } from '../../src/prebidGlobal.js';
+
+/**
+ * @constructor
+ * @param {Object} dfpModule_ - the DFP ad server module
+ * @returns {AdServerProvider}
+ */
+function GamAdServerProvider(dfpModule_) {
+  const dfp = dfpModule_;
+
+  function getAdTagUrl(adUnit, baseAdTag, params) {
+    return dfp.buildVideoUrl({ adUnit: adUnit, url: baseAdTag, params });
+  }
+
+  return {
+    getAdTagUrl
+  }
+}
+
+export function gamSubmoduleFactory() {
+  const dfp = getGlobal().adServers.dfp;
+  const gamProvider = GamAdServerProvider(dfp);
+  return gamProvider;
+}
+
+gamSubmoduleFactory.vendorCode = GAM_VENDOR;

package/modules/videoModule/index.js

@@ -0,0 +1,244 @@
+import { config } from '../../src/config.js';
+import { find } from '../../src/polyfill.js';
+import * as events from '../../src/events.js';
+import { mergeDeep } from '../../src/utils.js';
+import { getGlobal } from '../../src/prebidGlobal.js';
+import CONSTANTS from '../../src/constants.json';
+import {
+  videoEvents, AUCTION_AD_LOAD_ATTEMPT, AD_IMPRESSION, AD_ERROR, BID_IMPRESSION, BID_ERROR, AUCTION_AD_LOAD_ABORT
+} from '../../libraries/video/constants/events.js'
+import { PLACEMENT } from '../../libraries/video/constants/ortb.js';
+import { videoCoreFactory } from './coreVideo.js';
+import { gamSubmoduleFactory } from './gamAdServerSubmodule.js';
+import { videoImpressionVerifierFactory } from './videoImpressionVerifier.js';
+
+const videoKey = 'video';
+
+const allVideoEvents = Object.keys(videoEvents).map(eventKey => videoEvents[eventKey]);
+events.addEvents(allVideoEvents.concat([AUCTION_AD_LOAD_ATTEMPT, AUCTION_AD_LOAD_ABORT, BID_IMPRESSION, BID_ERROR]).map(getExternalVideoEventName));
+
+/**
+ * This module adds User Video support to prebid.js
+ * @module modules/videoModule
+ */
+export function PbVideo(videoCore_, getConfig_, pbGlobal_, pbEvents_, videoEvents_, gamAdServerFactory_, videoImpressionVerifierFactory_) {
+  const videoCore = videoCore_;
+  const getConfig = getConfig_;
+  const pbGlobal = pbGlobal_;
+  const requestBids = pbGlobal.requestBids;
+  const pbEvents = pbEvents_;
+  const videoEvents = videoEvents_;
+  const gamAdServerFactory = gamAdServerFactory_;
+  let gamSubmodule;
+  let mainContentDivId;
+  let contentEnrichmentEnabled = true;
+  const videoImpressionVerifierFactory = videoImpressionVerifierFactory_;
+  let videoImpressionVerifier;
+
+  function init() {
+    const cache = getConfig('cache');
+    videoImpressionVerifier = videoImpressionVerifierFactory(!!cache);
+    getConfig(videoKey, ({ video }) => {
+      video.providers.forEach(provider => {
+        videoCore.registerProvider(provider);
+        videoCore.onEvents(videoEvents, (type, payload) => {
+          pbEvents.emit(getExternalVideoEventName(type), payload);
+        }, provider.divId);
+
+        const adServerConfig = provider.adServer;
+        if (!gamSubmodule && adServerConfig) {
+          gamSubmodule = gamAdServerFactory();
+        }
+      });
+      contentEnrichmentEnabled = video.contentEnrichmentEnabled !== false;
+      mainContentDivId = contentEnrichmentEnabled ? video.mainContentDivId : null;
+    });
+
+    requestBids.before(beforeBidsRequested, 40);
+
+    pbEvents.on(CONSTANTS.EVENTS.BID_ADJUSTMENT, function (bid) {
+      videoImpressionVerifier.trackBid(bid);
+    });
+
+    pbEvents.on(getExternalVideoEventName(AD_IMPRESSION), function (payload) {
+      triggerVideoBidEvent(BID_IMPRESSION, payload);
+    });
+
+    pbEvents.on(getExternalVideoEventName(AD_ERROR), function (payload) {
+      triggerVideoBidEvent(BID_ERROR, payload);
+    });
+  }
+
+  function renderBid(divId, bid, options = {}) {
+    const adUrl = bid.vastUrl;
+    options.adXml = bid.vastXml;
+    options.winner = bid.bidder;
+    loadAdTag(adUrl, divId, options);
+  }
+
+  function getOrtbVideo(divId) {
+    return videoCore.getOrtbVideo(divId);
+  }
+
+  function getOrtbContent(divId) {
+    return videoCore.getOrtbContent(divId);
+  }
+
+  return { init, renderBid, getOrtbVideo, getOrtbContent };
+
+  function beforeBidsRequested(nextFn, bidderRequest) {
+    enrichAuction(bidderRequest);
+
+    const bidsBackHandler = bidderRequest.bidsBackHandler;
+    if (!bidsBackHandler || typeof bidsBackHandler !== 'function') {
+      pbEvents.on(CONSTANTS.EVENTS.AUCTION_END, auctionEnd);
+    }
+
+    return nextFn.call(this, bidderRequest);
+  }
+
+  function enrichAuction(bidderRequest) {
+    if (mainContentDivId) {
+      enrichOrtb2(mainContentDivId, bidderRequest);
+    }
+
+    const adUnits = bidderRequest.adUnits || pbGlobal.adUnits || [];
+    adUnits.forEach(adUnit => {
+      const divId = getDivId(adUnit);
+      enrichAdUnit(adUnit, divId);
+      if (contentEnrichmentEnabled && !mainContentDivId) {
+        enrichOrtb2(divId, bidderRequest);
+      }
+    });
+  }
+
+  function getDivId(adUnit) {
+    const videoConfig = adUnit.video;
+    if (!adUnit.mediaTypes.video || !videoConfig) {
+      return;
+    }
+
+    return videoConfig.divId;
+  }
+
+  function enrichAdUnit(adUnit, videoDivId) {
+    const ortbVideo = getOrtbVideo(videoDivId);
+    if (!ortbVideo) {
+      return;
+    }
+
+    const video = Object.assign({}, adUnit.mediaTypes.video, ortbVideo);
+
+    video.context = ortbVideo.placement === PLACEMENT.INSTREAM ? 'instream' : 'outstream';
+
+    const width = ortbVideo.w;
+    const height = ortbVideo.h;
+    if (width && height) {
+      video.playerSize = [width, height];
+    }
+
+    adUnit.mediaTypes.video = video;
+  }
+
+  function enrichOrtb2(divId, bidderRequest) {
+    const ortbContent = getOrtbContent(divId);
+    if (!ortbContent) {
+      return;
+    }
+    bidderRequest.ortb2 = mergeDeep({}, bidderRequest.ortb2, { site: { content: ortbContent } });
+  }
+
+  function auctionEnd(auctionResult) {
+    auctionResult.adUnits.forEach(adUnit => {
+      if (adUnit.video) {
+        renderWinningBid(adUnit);
+      }
+    });
+    pbEvents.off(CONSTANTS.EVENTS.AUCTION_END, auctionEnd);
+  }
+
+  function getAdServerConfig(adUnitVideoConfig) {
+    const globalVideoConfig = getConfig(videoKey);
+    const globalProviderConfig = globalVideoConfig.providers.find(provider => provider.divId === adUnitVideoConfig.divId) || {};
+    if (!globalVideoConfig.adServer && !globalProviderConfig.adServer && !adUnitVideoConfig.adServer) {
+      return;
+    }
+    return mergeDeep({}, globalVideoConfig.adServer, globalProviderConfig.adServer, adUnitVideoConfig.adServer);
+  }
+
+  function renderWinningBid(adUnit) {
+    const adUnitCode = adUnit.code;
+    const options = { adUnitCode };
+
+    const videoConfig = adUnit.video;
+    const divId = videoConfig.divId;
+    const adServerConfig = getAdServerConfig(videoConfig);
+    let adUrl;
+    if (adServerConfig) {
+      adUrl = gamSubmodule.getAdTagUrl(adUnit, adServerConfig.baseAdTagUrl, adServerConfig.params);
+    }
+
+    if (adUrl) {
+      loadAdTag(adUrl, divId, options);
+      return;
+    }
+
+    const highestCpmBids = pbGlobal.getHighestCpmBids(adUnitCode);
+    if (!highestCpmBids.length) {
+      pbEvents.emit(getExternalVideoEventName(AUCTION_AD_LOAD_ABORT), options);
+      return;
+    }
+
+    const highestBid = highestCpmBids.shift();
+    if (!highestBid) {
+      return;
+    }
+
+    renderBid(divId, highestBid, options);
+  }
+
+  // options: adXml, winner, adUnitCode,
+  function loadAdTag(adTagUrl, divId, options) {
+    const payload = Object.assign({ adTagUrl }, options);
+    pbEvents.emit(getExternalVideoEventName(AUCTION_AD_LOAD_ATTEMPT), payload);
+    videoCore.setAdTagUrl(adTagUrl, divId, options);
+  }
+
+  function triggerVideoBidEvent(eventName, adEventPayload) {
+    const bid = getBid(adEventPayload);
+    if (!bid) {
+      return;
+    }
+
+    pbGlobal.markWinningBidAsUsed(bid);
+    pbEvents.emit(getExternalVideoEventName(eventName), { bid, adEvent: adEventPayload });
+  }
+
+  function getBid(adPayload) {
+    const { adId, adTagUrl, wrapperAdIds } = adPayload;
+    const bidIdentifiers = videoImpressionVerifier.getBidIdentifiers(adId, adTagUrl, wrapperAdIds);
+    if (!bidIdentifiers) {
+      return;
+    }
+
+    const { adUnitCode, requestId, auctionId } = bidIdentifiers;
+    const bidAdId = bidIdentifiers.adId;
+    const { bids } = pbGlobal.getBidResponsesForAdUnitCode(adUnitCode);
+    return find(bids, bid => bid.adId === bidAdId && bid.requestId === requestId && bid.auctionId === auctionId);
+  }
+}
+
+export function pbVideoFactory() {
+  const videoCore = videoCoreFactory();
+  const pbGlobal = getGlobal();
+  const pbVideo = PbVideo(videoCore, config.getConfig, pbGlobal, events, allVideoEvents, gamSubmoduleFactory, videoImpressionVerifierFactory);
+  pbVideo.init();
+  pbGlobal.videoModule = pbVideo;
+  return pbVideo;
+}
+
+function getExternalVideoEventName(eventName) {
+  return videoKey + eventName.replace(/^./, eventName[0].toUpperCase());
+}
+
+pbVideoFactory();

package/modules/videoModule/videoImpressionVerifier.js

@@ -0,0 +1,206 @@
+import { find } from '../../src/polyfill.js';
+import { vastXmlEditorFactory } from '../../libraries/video/shared/vastXmlEditor.js';
+import { generateUUID } from '../../src/utils.js';
+
+export const PB_PREFIX = 'pb_';
+export const UUID_MARKER = PB_PREFIX + 'uuid';
+
+/**
+ * Video Impression Verifier interface. All implementations of a Video Impression Verifier must comply with this interface.
+ * @description adds tracking markers to an ad and extracts the bid identifiers from ad event information.
+ * @typedef {Object} VideoImpressionVerifier
+ * @function trackBid - requests that a bid's ad be tracked for impression verification.
+ * @function getBidIdentifiers - requests information from the ad event data that can be used to match the ad to a tracked bid.
+ */
+
+/**
+ * @function VideoImpressionVerifier#trackBid
+ * @param {Object} bid - Bid that should be tracked.
+ * @return {String} - Identifier for the bid being tracked.
+ */
+
+/**
+ * @function VideoImpressionVerifier#getBidIdentifiers
+ * @param {String} adId - In the VAST tag, this value is present in the Ad element's id property.
+ * @param {String} adTagUrl - The ad tag url that was loaded into the player.
+ * @param {[String]} adWrapperIds - List of ad id's that were obtained from the different wrappers. Each redirect points to an ad wrapper.
+ * @return {bidIdentifier} - Object allowing the bid matching the ad event to be identified.
+ */
+
+/**
+ * @typedef {Object} bidIdentifier
+ * @property {String} adId - Bid identifier.
+ * @property {String} adUnitCode - Identifier for the Ad Unit for which the bid was made.
+ * @property {String} auctionId - Id of the auction in which the bid was made.
+ * @property {String} requestId - Id of the bid request which resulted in the bid.
+ */
+
+/**
+ * Factory function for obtaining a Video Impression Verifier.
+ * @param {Boolean} isCacheUsed - wether Prebid is configured to use a cache.
+ * @return {VideoImpressionVerifier}
+ */
+export function videoImpressionVerifierFactory(isCacheUsed) {
+  const vastXmlEditor = vastXmlEditorFactory();
+  const bidTracker = tracker();
+  if (isCacheUsed) {
+    return cachedVideoImpressionVerifier(vastXmlEditor, bidTracker);
+  }
+
+  return videoImpressionVerifier(vastXmlEditor, bidTracker);
+}
+
+export function videoImpressionVerifier(vastXmlEditor_, bidTracker_) {
+  const verifier = baseImpressionVerifier(bidTracker_);
+  const superTrackBid = verifier.trackBid;
+  const vastXmlEditor = vastXmlEditor_;
+
+  verifier.trackBid = function(bid) {
+    let { vastXml, vastUrl } = bid;
+    if (!vastXml && !vastUrl) {
+      return;
+    }
+
+    const uuid = superTrackBid(bid);
+
+    if (vastUrl) {
+      const url = new URL(vastUrl);
+      url.searchParams.append(UUID_MARKER, uuid);
+      bid.vastUrl = url.toString();
+    } else if (vastXml) {
+      bid.vastXml = vastXmlEditor.getVastXmlWithTracking(vastXml, uuid);
+    }
+
+    return uuid;
+  }
+
+  return verifier;
+}
+
+export function cachedVideoImpressionVerifier(vastXmlEditor_, bidTracker_) {
+  const verifier = baseImpressionVerifier(bidTracker_);
+  const superTrackBid = verifier.trackBid;
+  const superGetBidIdentifiers = verifier.getBidIdentifiers;
+  const vastXmlEditor = vastXmlEditor_;
+
+  verifier.trackBid = function (bid, globalAdUnits) {
+    const adIdOverride = superTrackBid(bid);
+    let { vastXml, vastUrl, adId, adUnitCode } = bid;
+    const adUnit = find(globalAdUnits, adUnit => adUnitCode === adUnit.code);
+    const videoConfig = adUnit && adUnit.video;
+    const adServerConfig = videoConfig && videoConfig.adServer;
+    const trackingConfig = adServerConfig && adServerConfig.tracking;
+    let impressionUrl;
+    let impressionId;
+    let errorUrl;
+    const impressionTracking = trackingConfig.impression;
+    const errorTracking = trackingConfig.error;
+
+    if (impressionTracking) {
+      impressionUrl = getTrackingUrl(impressionTracking.getUrl, bid);
+      impressionId = impressionTracking.id || adId + '-impression';
+    }
+
+    if (errorTracking) {
+      errorUrl = getTrackingUrl(errorTracking.getUrl, bid);
+    }
+
+    if (vastXml) {
+      vastXml = vastXmlEditor.getVastXmlWithTracking(vastXml, adIdOverride, impressionUrl, impressionId, errorUrl);
+    } else if (vastUrl) {
+      vastXml = vastXmlEditor.buildVastWrapper(adIdOverride, vastUrl, impressionUrl, impressionId, errorUrl);
+    }
+
+    bid.vastXml = vastXml;
+    return adIdOverride;
+  }
+
+  verifier.getBidIdentifiers = function (adId, adTagUrl, adWrapperIds) {
+    // When the video is cached, the ad tag loaded into the player is a parent wrapper of the cache url.
+    // As a result, the ad tag Url cannot include identifiers.
+    return superGetBidIdentifiers(adId, null, adWrapperIds);
+  }
+
+  return verifier;
+
+  function getTrackingUrl(getUrl, bid) {
+    if (!getUrl || typeof getUrl !== 'function') {
+      return;
+    }
+
+    return getUrl(bid);
+  }
+}
+
+export function baseImpressionVerifier(bidTracker_) {
+  const bidTracker = bidTracker_;
+
+  function trackBid(bid) {
+    let { adId, adUnitCode, requestId, auctionId } = bid;
+    const trackingId = PB_PREFIX + generateUUID(10 ** 13);
+    bidTracker.store(trackingId, { adId, adUnitCode, requestId, auctionId });
+    return trackingId;
+  }
+
+  function getBidIdentifiers(adId, adTagUrl, adWrapperIds) {
+    return bidTracker.remove(adId) || getBidForAdTagUrl(adTagUrl) || getBidForAdWrappers(adWrapperIds);
+  }
+
+  return {
+    trackBid,
+    getBidIdentifiers
+  };
+
+  function getBidForAdTagUrl(adTagUrl) {
+    if (!adTagUrl) {
+      return;
+    }
+
+    let url;
+    try {
+      url = new URL(adTagUrl);
+    } catch (e) {
+      return;
+    }
+
+    const queryParams = url.searchParams;
+    let uuid = queryParams.get(UUID_MARKER);
+    return uuid && bidTracker.remove(uuid);
+  }
+
+  function getBidForAdWrappers(adWrapperIds) {
+    if (!adWrapperIds || !adWrapperIds.length) {
+      return;
+    }
+
+    for (const wrapperId in adWrapperIds) {
+      const bidInfo = bidTracker.remove(wrapperId);
+      if (bidInfo) {
+        return bidInfo;
+      }
+    }
+  }
+}
+
+export function tracker() {
+  const model = {};
+
+  function store(key, value) {
+    model[key] = value;
+  }
+
+  function remove(key) {
+    const value = model[key];
+    if (!value) {
+      return;
+    }
+
+    delete model[key];
+    return value;
+  }
+
+  return {
+    store,
+    remove
+  }
+}