prebid.js 9.4.0 → 9.5.0

package/modules/pubxaiAnalyticsAdapter.js

@@ -1,204 +1,346 @@
-import { deepAccess, parseSizesInput, getWindowLocation, buildUrl } from '../src/utils.js';
-import { ajax } from '../src/ajax.js';
 import adapter from '../libraries/analyticsAdapter/AnalyticsAdapter.js';
+import {
+  getGptSlotInfoForAdUnitCode, getGptSlotForAdUnitCode
+} from '../libraries/gptUtils/gptUtils.js';
+import { getDeviceType, getBrowser, getOS } from '../libraries/userAgentUtils/index.js';
+import { MODULE_TYPE_ANALYTICS } from '../src/activities/modules.js';
 import adapterManager from '../src/adapterManager.js';
+import { sendBeacon } from '../src/ajax.js'
 import { EVENTS } from '../src/constants.js';
-import {getGlobal} from '../src/prebidGlobal.js';
-import {getGptSlotInfoForAdUnitCode} from '../libraries/gptUtils/gptUtils.js';
+import { getGlobal } from '../src/prebidGlobal.js';
+import { getStorageManager } from '../src/storageManager.js';
+import {
+  deepAccess, parseSizesInput, getWindowLocation, buildUrl, cyrb53Hash
+} from '../src/utils.js';
+
+let initOptions;
 
 const emptyUrl = '';
 const analyticsType = 'endpoint';
-const pubxaiAnalyticsVersion = 'v1.2.0';
+const adapterCode = 'pubxai';
+const pubxaiAnalyticsVersion = 'v2.0.0';
 const defaultHost = 'api.pbxai.com';
 const auctionPath = '/analytics/auction';
 const winningBidPath = '/analytics/bidwon';
+const storage = getStorageManager({ moduleType: MODULE_TYPE_ANALYTICS, moduleName: adapterCode })
 
-let initOptions;
-let auctionTimestamp;
-let auctionCache = [];
-let events = {
-  bids: [],
-  floorDetail: {},
-  pageDetail: {},
-  deviceDetail: {}
-};
-
-function getStorage() {
-  return null;
-}
-
-var pubxaiAnalyticsAdapter = Object.assign(adapter(
+/**
+ * The sendCache is a global cache object which tracks the pending sends
+ * back to pubx.ai. The data may be removed from this cache, post send.
+ */
+export const sendCache = new Proxy(
+  {},
   {
-    emptyUrl,
-    analyticsType
-  }), {
-  track({ eventType, args }) {
-    if (typeof args !== 'undefined') {
-      if (eventType === EVENTS.BID_TIMEOUT) {
-        args.forEach(item => { mapBidResponse(item, 'timeout'); });
-      } else if (eventType === EVENTS.AUCTION_INIT) {
-        events.auctionInit = args;
-        events.floorDetail = {};
-        events.bids = [];
-        const floorData = deepAccess(args, 'bidderRequests.0.bids.0.floorData');
-        if (typeof floorData !== 'undefined') {
-          Object.assign(events.floorDetail, floorData);
-        }
-        auctionTimestamp = args.timestamp;
-      } else if (eventType === EVENTS.BID_RESPONSE) {
-        mapBidResponse(args, 'response');
-      } else if (eventType === EVENTS.BID_WON) {
-        send({
-          winningBid: mapBidResponse(args, 'bidwon')
-        }, 'bidwon');
+    get: (target, name) => {
+      if (!target.hasOwnProperty(name)) {
+        target[name] = [];
       }
-    }
-    if (eventType === EVENTS.AUCTION_END) {
-      send(events, 'auctionEnd');
-    }
+      return target[name];
+    },
   }
-});
+);
 
-function mapBidResponse(bidResponse, status) {
-  if (typeof bidResponse !== 'undefined') {
-    let bid = {
-      adUnitCode: bidResponse.adUnitCode,
-      gptSlotCode: getGptSlotInfoForAdUnitCode(bidResponse.adUnitCode).gptSlot || null,
-      auctionId: bidResponse.auctionId,
-      bidderCode: bidResponse.bidder,
-      cpm: bidResponse.cpm,
-      creativeId: bidResponse.creativeId,
-      currency: bidResponse.currency,
-      floorData: bidResponse.floorData,
-      mediaType: bidResponse.mediaType,
-      netRevenue: bidResponse.netRevenue,
-      requestTimestamp: bidResponse.requestTimestamp,
-      responseTimestamp: bidResponse.responseTimestamp,
-      status: bidResponse.status,
-      statusMessage: bidResponse.statusMessage,
-      timeToRespond: bidResponse.timeToRespond,
-      transactionId: bidResponse.transactionId
-    };
-    if (status !== 'bidwon') {
-      Object.assign(bid, {
-        bidId: status === 'timeout' ? bidResponse.bidId : bidResponse.requestId,
-        renderStatus: status === 'timeout' ? 3 : 2,
-        sizes: parseSizesInput(bidResponse.size).toString(),
-      });
-      events.bids.push(bid);
-    } else {
-      Object.assign(bid, {
-        bidId: bidResponse.requestId,
-        floorProvider: events.floorDetail?.floorProvider || null,
-        floorFetchStatus: events.floorDetail?.fetchStatus || null,
-        floorLocation: events.floorDetail?.location || null,
-        floorModelVersion: events.floorDetail?.modelVersion || null,
-        floorSkipRate: events.floorDetail?.skipRate || 0,
-        isFloorSkipped: events.floorDetail?.skipped || false,
-        isWinningBid: true,
-        placementId: bidResponse.params ? deepAccess(bidResponse, 'params.0.placementId') : null,
-        renderedSize: bidResponse.size,
-        renderStatus: 4
-      });
-      return bid;
-    }
+/**
+ * auctionCache is a global cache object which stores all auction histories
+ * for the session. When getting a key from the auction cache, any
+ * information already known about the auction or associated data (floor
+ * data configured by prebid, browser data, user data etc) is added to
+ * the cache automatically.
+ */
+export const auctionCache = new Proxy(
+  {},
+  {
+    get: (target, name) => {
+      if (!target.hasOwnProperty(name)) {
+        target[name] = {
+          bids: [],
+          auctionDetail: {
+            refreshRank: Object.keys(target).length,
+            auctionId: name,
+          },
+          floorDetail: {},
+          pageDetail: {
+            host: getWindowLocation().host,
+            path: getWindowLocation().pathname,
+            search: getWindowLocation().search,
+          },
+          deviceDetail: {
+            platform: navigator.platform,
+            deviceType: getDeviceType(),
+            deviceOS: getOS(),
+            browser: getBrowser(),
+          },
+          userDetail: {
+            userIdTypes: Object.keys(getGlobal().getUserIds?.() || {}),
+          },
+          consentDetail: {
+            consentTypes: Object.keys(getGlobal().getConsentMetadata?.() || {}),
+          },
+          pmacDetail: JSON.parse(storage.getDataFromLocalStorage('pubx:pmac')) || {}, // {auction_1: {floor:0.23,maxBid:0.34,bidCount:3},auction_2:{floor:0.13,maxBid:0.14,bidCount:2}
+          initOptions: {
+            ...initOptions,
+            auctionId: name, // back-compat
+          },
+          sendAs: [],
+        };
+      }
+      return target[name];
+    },
   }
-}
+);
 
-export function getDeviceType() {
-  if ((/ipad|android 3.0|xoom|sch-i800|playbook|tablet|kindle/i.test(navigator.userAgent.toLowerCase()))) {
-    return 'tablet';
+/**
+ * Fetch extra ad server data for a specific ad slot (bid)
+ * @param {object} bid an output from extractBid
+ * @returns {object} key value pairs from the adserver
+ */
+const getAdServerDataForBid = (bid) => {
+  const gptSlot = getGptSlotForAdUnitCode(bid);
+  if (gptSlot) {
+    return Object.fromEntries(
+      gptSlot
+        .getTargetingKeys()
+        .filter(
+          (key) =>
+            key.startsWith('pubx-') ||
+            (key.startsWith('hb_') && (key.match(/_/g) || []).length === 1)
+        )
+        .map((key) => [key, gptSlot.getTargeting(key)])
+    );
   }
-  if ((/iphone|ipod|android|blackberry|opera|mini|windows\sce|palm|smartphone|iemobile/i.test(navigator.userAgent.toLowerCase()))) {
-    return 'mobile';
-  }
-  return 'desktop';
-}
+  return {}; // TODO: support more ad servers
+};
 
-export function getBrowser() {
-  if (/Chrome/.test(navigator.userAgent) && /Google Inc/.test(navigator.vendor)) return 'Chrome';
-  else if (navigator.userAgent.match('CriOS')) return 'Chrome';
-  else if (/Firefox/.test(navigator.userAgent)) return 'Firefox';
-  else if (/Edg/.test(navigator.userAgent)) return 'Microsoft Edge';
-  else if (/Safari/.test(navigator.userAgent) && /Apple Computer/.test(navigator.vendor)) return 'Safari';
-  else if (/Trident/.test(navigator.userAgent) || /MSIE/.test(navigator.userAgent)) return 'Internet Explorer';
-  else return 'Others';
-}
+/**
+ * extracts and derives valuable data from a prebid bidder bidResponse object
+ * @param {object} bidResponse a prebid bidder bidResponse (see
+ * https://docs.prebid.org/dev-docs/publisher-api-reference/getBidResponses.html)
+ * @returns {object}
+ */
+const extractBid = (bidResponse) => {
+  return {
+    adUnitCode: bidResponse.adUnitCode,
+    gptSlotCode:
+      getGptSlotInfoForAdUnitCode(bidResponse.adUnitCode).gptSlot || null,
+    auctionId: bidResponse.auctionId,
+    bidderCode: bidResponse.bidder,
+    cpm: bidResponse.cpm,
+    creativeId: bidResponse.creativeId,
+    dealId: bidResponse.dealId,
+    currency: bidResponse.currency,
+    floorData: bidResponse.floorData,
+    mediaType: bidResponse.mediaType,
+    netRevenue: bidResponse.netRevenue,
+    requestTimestamp: bidResponse.requestTimestamp,
+    responseTimestamp: bidResponse.responseTimestamp,
+    status: bidResponse.status,
+    sizes: parseSizesInput(bidResponse.size).toString(),
+    statusMessage: bidResponse.statusMessage,
+    timeToRespond: bidResponse.timeToRespond,
+    transactionId: bidResponse.transactionId,
+    bidId: bidResponse.bidId || bidResponse.requestId,
+    placementId: bidResponse.params
+      ? deepAccess(bidResponse, 'params.0.placementId')
+      : null,
+    source: bidResponse.source || 'null',
+  };
+};
 
-export function getOS() {
-  if (navigator.userAgent.indexOf('Android') != -1) return 'Android';
-  if (navigator.userAgent.indexOf('like Mac') != -1) return 'iOS';
-  if (navigator.userAgent.indexOf('Win') != -1) return 'Windows';
-  if (navigator.userAgent.indexOf('Mac') != -1) return 'Macintosh';
-  if (navigator.userAgent.indexOf('Linux') != -1) return 'Linux';
-  if (navigator.appVersion.indexOf('X11') != -1) return 'Unix';
-  return 'Others';
-}
+/**
+ * Track the events emitted by prebid and handle each case. See https://docs.prebid.org/dev-docs/publisher-api-reference/getEvents.html for more info
+ * @param {object} event the prebid event emmitted
+ * @param {string} event.eventType the type of the event
+ * @param {object} event.args the arguments of the emitted event
+ */
+const track = ({ eventType, args }) => {
+  switch (eventType) {
+    // handle invalid bids, and remove them from the adUnit cache
+    case EVENTS.BID_TIMEOUT:
+      args.map(extractBid).forEach((bid) => {
+        bid.renderStatus = 3;
+        auctionCache[bid.auctionId].bids.push(bid);
+      });
+      break;
+    // handle valid bid responses and record them as part of an auction
+    case EVENTS.BID_RESPONSE:
+      const bid = Object.assign(extractBid(args), { renderStatus: 2 });
+      auctionCache[bid.auctionId].bids.push(bid);
+      break;
+    // capture extra information from the auction, and if there were no bids
+    // (and so no chance of a win) send the auction
+    case EVENTS.AUCTION_END:
+      Object.assign(
+        auctionCache[args.auctionId].floorDetail,
+        args.adUnits
+          .map((i) => i?.bids.length && i.bids[0]?.floorData)
+          .find((i) => i) || {}
+      );
+      auctionCache[args.auctionId].deviceDetail.cdep = args.bidderRequests
+        .map((bidRequest) => bidRequest.ortb2?.device?.ext?.cdep)
+        .find((i) => i);
+      Object.assign(auctionCache[args.auctionId].auctionDetail, {
+        adUnitCodes: args.adUnits.map((i) => i.code),
+        timestamp: args.timestamp,
+      });
+      if (
+        auctionCache[args.auctionId].bids.every((bid) => bid.renderStatus === 3)
+      ) {
+        prepareSend(args.auctionId);
+      }
+      break;
+    // send the prebid winning bid back to pubx
+    case EVENTS.BID_WON:
+      const winningBid = extractBid(args);
+      const floorDetail = auctionCache[winningBid.auctionId].floorDetail;
+      Object.assign(winningBid, {
+        floorProvider: floorDetail?.floorProvider || null,
+        floorFetchStatus: floorDetail?.fetchStatus || null,
+        floorLocation: floorDetail?.location || null,
+        floorModelVersion: floorDetail?.modelVersion || null,
+        floorSkipRate: floorDetail?.skipRate || 0,
+        isFloorSkipped: floorDetail?.skipped || false,
+        isWinningBid: true,
+        renderedSize: args.size,
+        renderStatus: 4,
+      });
+      winningBid.adServerData = getAdServerDataForBid(winningBid);
+      auctionCache[winningBid.auctionId].winningBid = winningBid;
+      prepareSend(winningBid.auctionId);
+      break;
+    // do nothing
+    default:
+      break;
+  }
+};
 
-// add sampling rate
-pubxaiAnalyticsAdapter.shouldFireEventRequest = function (samplingRate = 1) {
-  return (Math.floor((Math.random() * samplingRate + 1)) === parseInt(samplingRate));
+/**
+ * If true, send data back to pubxai
+ * @param {string} auctionId
+ * @param {number} samplingRate
+ * @returns {boolean}
+ */
+const shouldFireEventRequest = (auctionId, samplingRate = 1) => {
+  return parseInt(cyrb53Hash(auctionId)) % samplingRate === 0;
 };
 
-function send(data, status) {
-  if (pubxaiAnalyticsAdapter.shouldFireEventRequest(initOptions.samplingRate)) {
-    let location = getWindowLocation();
-    const storage = getStorage();
-    data.initOptions = initOptions;
-    data.pageDetail = {};
-    Object.assign(data.pageDetail, {
-      host: location.host,
-      path: location.pathname,
-      search: location.search
-    });
-    if (typeof data !== 'undefined' && typeof data.auctionInit !== 'undefined') {
-      data.pageDetail.adUnits = data.auctionInit.adUnitCodes;
-      data.initOptions.auctionId = data.auctionInit.auctionId;
-      delete data.auctionInit;
-
-      data.pmcDetail = {};
-      Object.assign(data.pmcDetail, {
-        bidDensity: storage ? storage.getItem('pbx:dpbid') : null,
-        maxBid: storage ? storage.getItem('pbx:mxbid') : null,
-        auctionId: storage ? storage.getItem('pbx:aucid') : null,
-      });
+/**
+ * prepare the payload for sending auction data back to pubx.ai
+ * @param {string} auctionId the auction to send
+ */
+const prepareSend = (auctionId) => {
+  const auctionData = Object.assign({}, auctionCache[auctionId]);
+  if (!shouldFireEventRequest(auctionId, initOptions.samplingRate)) {
+    return;
+  }
+  [
+    {
+      path: winningBidPath,
+      requiredKeys: [
+        'winningBid',
+        'pageDetail',
+        'deviceDetail',
+        'floorDetail',
+        'auctionDetail',
+        'userDetail',
+        'consentDetail',
+        'pmacDetail',
+        'initOptions',
+      ],
+      eventType: 'win',
+    },
+    {
+      path: auctionPath,
+      requiredKeys: [
+        'bids',
+        'pageDetail',
+        'deviceDetail',
+        'floorDetail',
+        'auctionDetail',
+        'userDetail',
+        'consentDetail',
+        'pmacDetail',
+        'initOptions',
+      ],
+      eventType: 'auction',
+    },
+  ].forEach(({ path, requiredKeys, eventType }) => {
+    const data = Object.fromEntries(
+      requiredKeys.map((key) => [key, auctionData[key]])
+    );
+    if (
+      auctionCache[auctionId].sendAs.includes(eventType) ||
+      !requiredKeys.every((key) => !!auctionData[key])
+    ) {
+      return;
     }
-    data.deviceDetail = {};
-    Object.assign(data.deviceDetail, {
-      platform: navigator.platform,
-      deviceType: getDeviceType(),
-      deviceOS: getOS(),
-      browser: getBrowser()
-    });
-
-    let pubxaiAnalyticsRequestUrl = buildUrl({
+    const pubxaiAnalyticsRequestUrl = buildUrl({
       protocol: 'https',
-      hostname: (initOptions && initOptions.hostName) || defaultHost,
-      pathname: status == 'bidwon' ? winningBidPath : auctionPath,
+      hostname:
+        (auctionData.initOptions && auctionData.initOptions.hostName) ||
+        defaultHost,
+      pathname: path,
       search: {
-        auctionTimestamp: auctionTimestamp,
+        auctionTimestamp: auctionData.auctionDetail.timestamp,
         pubxaiAnalyticsVersion: pubxaiAnalyticsVersion,
-        prebidVersion: getGlobal().version
+        prebidVersion: '$prebid.version$',
+      },
+    });
+    sendCache[pubxaiAnalyticsRequestUrl].push(data);
+    auctionCache[auctionId].sendAs.push(eventType);
+  });
+};
+
+const send = () => {
+  const toBlob = (d) => new Blob([JSON.stringify(d)], { type: 'text/json' });
+
+  Object.entries(sendCache).forEach(([requestUrl, events]) => {
+    let payloadStart = 0;
+
+    events.forEach((event, index, arr) => {
+      const payload = arr.slice(payloadStart, index + 2);
+      const payloadTooLarge = toBlob(payload).size > 65536;
+
+      if (payloadTooLarge || index + 1 === arr.length) {
+        sendBeacon(
+          requestUrl,
+          toBlob(payloadTooLarge ? payload.slice(0, -1) : payload)
+        );
+        payloadStart = index;
       }
     });
-    if (status == 'bidwon') {
-      ajax(pubxaiAnalyticsRequestUrl, undefined, JSON.stringify(data), { method: 'POST', contentType: 'text/json' });
-    } else if (status == 'auctionEnd' && auctionCache.indexOf(data.initOptions.auctionId) === -1) {
-      ajax(pubxaiAnalyticsRequestUrl, undefined, JSON.stringify(data), { method: 'POST', contentType: 'text/json' });
-      auctionCache.push(data.initOptions.auctionId);
+
+    events.splice(0);
+  });
+};
+
+// register event listener to send logs when user leaves page
+if (document.visibilityState) {
+  document.addEventListener('visibilitychange', () => {
+    if (document.visibilityState === 'hidden') {
+      send();
     }
-  }
+  });
 }
 
-pubxaiAnalyticsAdapter.originEnableAnalytics = pubxaiAnalyticsAdapter.enableAnalytics;
-pubxaiAnalyticsAdapter.enableAnalytics = function (config) {
+// declare the analytics adapter
+var pubxaiAnalyticsAdapter = Object.assign(
+  adapter({
+    emptyUrl,
+    analyticsType,
+  }),
+  { track }
+);
+
+pubxaiAnalyticsAdapter.originEnableAnalytics =
+  pubxaiAnalyticsAdapter.enableAnalytics;
+pubxaiAnalyticsAdapter.enableAnalytics = (config) => {
   initOptions = config.options;
   pubxaiAnalyticsAdapter.originEnableAnalytics(config);
 };
 
 adapterManager.registerAnalyticsAdapter({
   adapter: pubxaiAnalyticsAdapter,
-  code: 'pubxai'
+  code: adapterCode,
 });
 
 export default pubxaiAnalyticsAdapter;

package/modules/relevatehealthBidAdapter.js

@@ -142,7 +142,8 @@ function buildUser(bid) {
   if (bid && bid.params) {
     return {
       id: bid.params.user_id && typeof bid.params.user_id == 'string' ? bid.params.user_id : '',
-      buyeruid: localStorage.getItem('adx_profile_guid') ? localStorage.getItem('adx_profile_guid') : '',
+      // TODO: commented out because of rule violations
+      buyeruid: '', // localStorage.getItem('adx_profile_guid') ? localStorage.getItem('adx_profile_guid') : '',
       keywords: bid.params.keywords && typeof bid.params.keywords == 'string' ? bid.params.keywords : '',
       customdata: bid.params.customdata && typeof bid.params.customdata == 'string' ? bid.params.customdata : ''
     };

package/modules/richaudienceBidAdapter.js

@@ -151,7 +151,7 @@ export const spec = {
    *
    * @param {syncOptions} Publisher prebid configuration
    * @param {serverResponses} Response from the server
-   * @param {gdprConsent} GPDR consent object
+   * @param {gdprConsent} GDPR consent object
    * @returns {Array}
    */
   getUserSyncs: function (syncOptions, responses, gdprConsent, uspConsent, gppConsent) {

package/modules/rtdModule/index.js

@@ -188,10 +188,12 @@ let _dataProviders = [];
 let _userConsent;
 
 /**
- * Register a RTD submodule.
+ * Register a Real-Time Data (RTD) submodule.
  *
- * @param {RtdSubmodule} submodule
- * @returns {function()} a de-registration function that will unregister the module when called.
+ * @param {Object} submodule The RTD submodule to register.
+ * @param {string} submodule.name The name of the RTD submodule.
+ * @param {number} [submodule.gvlid] The Global Vendor List ID (GVLID) of the RTD submodule.
+ * @returns {function(): void} A de-registration function that will unregister the module when called.
  */
 export function attachRealTimeDataProvider(submodule) {
   registeredSubModules.push(submodule);

package/modules/sirdataRtdProvider.js

@@ -219,6 +219,8 @@ export function postContentForSemanticAnalysis(postContentToken, actualUrl) {
 
       // Use the Beacon API if supported to send the payload
       if ('sendBeacon' in navigator) {
+        // TODO FIX RULES VIOLATION
+        // eslint-disable-next-line prebid/no-member
         navigator.sendBeacon(url, payload);
       } else {
         // Fallback to using AJAX if Beacon API is not supported

package/modules/sizeMapping.js

@@ -4,7 +4,6 @@ import {includes} from '../src/polyfill.js';
 import {BANNER, VIDEO} from '../src/mediaTypes.js';
 import {setupAdUnitMediaTypes} from '../src/adapterManager.js';
 
-let installed = false;
 let sizeConfig = [];
 
 /**
@@ -24,11 +23,9 @@ let sizeConfig = [];
  */
 export function setSizeConfig(config) {
   sizeConfig = config;
-  if (!installed) {
-    setupAdUnitMediaTypes.before((next, adUnit, labels) => next(processAdUnitsForLabels(adUnit, labels), labels));
-    installed = true;
-  }
 }
+
+setupAdUnitMediaTypes.before((next, adUnit, labels) => next(processAdUnitsForLabels(adUnit, labels), labels));
 config.getConfig('sizeConfig', config => setSizeConfig(config.sizeConfig));
 
 /**

package/modules/smaatoBidAdapter.js

@@ -19,10 +19,11 @@ import {ortbConverter} from '../libraries/ortbConverter/converter.js';
 
 const BIDDER_CODE = 'smaato';
 const SMAATO_ENDPOINT = 'https://prebid.ad.smaato.net/oapi/prebid';
-const SMAATO_CLIENT = 'prebid_js_$prebid.version$_3.1'
+const SMAATO_CLIENT = 'prebid_js_$prebid.version$_3.2'
 const TTL = 300;
 const CURRENCY = 'USD';
 const SUPPORTED_MEDIA_TYPES = [BANNER, VIDEO, NATIVE];
+const SYNC_URL = 'https://s.ad.smaato.net/c/?adExInit=p'
 
 export const spec = {
   code: BIDDER_CODE,
@@ -196,6 +197,22 @@ export const spec = {
    * @return {UserSync[]} The user syncs which should be dropped.
    */
   getUserSyncs: (syncOptions, serverResponses, gdprConsent, uspConsent) => {
+    if (syncOptions && syncOptions.pixelEnabled) {
+      let gdprParams = '';
+      if (gdprConsent && gdprConsent.consentString) {
+        if (typeof gdprConsent.gdprApplies === 'boolean') {
+          gdprParams = `&gdpr=${Number(gdprConsent.gdprApplies)}&gdpr_consent=${gdprConsent.consentString}`;
+        } else {
+          gdprParams = `&gdpr_consent=${gdprConsent.consentString}`;
+        }
+      }
+
+      return [{
+        type: 'image',
+        url: SYNC_URL + gdprParams
+      }];
+    }
+
     return [];
   }
 }