prebid.js 5.14.0 → 5.18.0

package/src/targeting.js

@@ -1,4 +1,7 @@
-import { uniques, isGptPubadsDefined, getHighestCpm, getOldestHighestCpmBid, groupBy, isAdUnitCodeMatchingSlot, timestamp, deepAccess, deepClone, logError, logWarn, logInfo } from './utils.js';
+import {
+  uniques, isGptPubadsDefined, getHighestCpm, getOldestHighestCpmBid, groupBy, isAdUnitCodeMatchingSlot, timestamp,
+  deepAccess, deepClone, logError, logWarn, logInfo, isFn, isArray, logMessage, isStr
+} from './utils.js';
 import { config } from './config.js';
 import { NATIVE_TARGETING_KEYS } from './native.js';
 import { auctionManager } from './auctionManager.js';
@@ -8,7 +11,6 @@ import { hook } from './hook.js';
 import includes from 'core-js-pure/features/array/includes.js';
 import find from 'core-js-pure/features/array/find.js';
 
-const utils = require('./utils.js');
 var CONSTANTS = require('./constants.json');
 
 var pbTargetingKeys = [];
@@ -122,13 +124,13 @@ export function newTargeting(auctionManager) {
       const adUnitCodes = getAdUnitCodes(adUnitCode);
       const adUnits = auctionManager.getAdUnits().filter(adUnit => includes(adUnitCodes, adUnit.code));
       window.googletag.pubads().getSlots().forEach(slot => {
-        let customSlotMatchingFunc = utils.isFn(customSlotMatching) && customSlotMatching(slot);
+        let customSlotMatchingFunc = isFn(customSlotMatching) && customSlotMatching(slot);
         pbTargetingKeys.forEach(function(key) {
           // reset only registered adunits
           adUnits.forEach(function(unit) {
             if (unit.code === slot.getAdUnitPath() ||
                 unit.code === slot.getSlotElementId() ||
-                (utils.isFn(customSlotMatchingFunc) && customSlotMatchingFunc(unit.code))) {
+                (isFn(customSlotMatchingFunc) && customSlotMatchingFunc(unit.code))) {
               slot.setTargeting(key, null);
             }
           });
@@ -160,7 +162,7 @@ export function newTargeting(auctionManager) {
    */
   function bidShouldBeAddedToTargeting(bid, adUnitCodes) {
     return bid.adserverTargeting && adUnitCodes &&
-      ((utils.isArray(adUnitCodes) && includes(adUnitCodes, bid.adUnitCode)) ||
+      ((isArray(adUnitCodes) && includes(adUnitCodes, bid.adUnitCode)) ||
       (typeof adUnitCodes === 'string' && bid.adUnitCode === adUnitCodes));
   };
 
@@ -379,21 +381,18 @@ export function newTargeting(auctionManager) {
   targeting.setTargetingForGPT = function(targetingConfig, customSlotMatching) {
     window.googletag.pubads().getSlots().forEach(slot => {
       Object.keys(targetingConfig).filter(customSlotMatching ? customSlotMatching(slot) : isAdUnitCodeMatchingSlot(slot))
-        .forEach(targetId =>
+        .forEach(targetId => {
           Object.keys(targetingConfig[targetId]).forEach(key => {
-            let valueArr = targetingConfig[targetId][key];
-            if (typeof valueArr === 'string') {
-              valueArr = valueArr.split(',');
+            let value = targetingConfig[targetId][key];
+            if (typeof value === 'string' && value.indexOf(',') !== -1) {
+              // due to the check the array will be formed only if string has ',' else plain string will be assigned as value
+              value = value.split(',');
             }
-            valueArr = (valueArr.length > 1) ? [valueArr] : valueArr;
-            valueArr.map((value) => {
-              utils.logMessage(`Attempting to set key value for slot: ${slot.getSlotElementId()} key: ${key} value: ${value}`);
-              return value;
-            }).forEach(value => {
-              slot.setTargeting(key, value);
-            });
-          })
-        )
+            targetingConfig[targetId][key] = value;
+          });
+          logMessage(`Attempting to set targeting-map for slot: ${slot.getSlotElementId()} with targeting-map:`, targetingConfig[targetId]);
+          slot.updateTargetingFromMap(targetingConfig[targetId])
+        })
     })
   };
 
@@ -405,7 +404,7 @@ export function newTargeting(auctionManager) {
   function getAdUnitCodes(adUnitCode) {
     if (typeof adUnitCode === 'string') {
       return [adUnitCode];
-    } else if (utils.isArray(adUnitCode)) {
+    } else if (isArray(adUnitCode)) {
       return adUnitCode;
     }
     return auctionManager.getAdUnitCodes() || [];
@@ -455,14 +454,14 @@ export function newTargeting(auctionManager) {
     try {
       targeting.resetPresetTargetingAST(adUnitCodes);
     } catch (e) {
-      utils.logError('unable to reset targeting for AST' + e)
+      logError('unable to reset targeting for AST' + e)
     }
 
     Object.keys(astTargeting).forEach(targetId =>
       Object.keys(astTargeting[targetId]).forEach(key => {
-        utils.logMessage(`Attempting to set targeting for targetId: ${targetId} key: ${key} value: ${astTargeting[targetId][key]}`);
+        logMessage(`Attempting to set targeting for targetId: ${targetId} key: ${key} value: ${astTargeting[targetId][key]}`);
         // setKeywords supports string and array as value
-        if (utils.isStr(astTargeting[targetId][key]) || utils.isArray(astTargeting[targetId][key])) {
+        if (isStr(astTargeting[targetId][key]) || isArray(astTargeting[targetId][key])) {
           let keywordsObj = {};
           let regex = /pt[0-9]/;
           if (key.search(regex) < 0) {
@@ -527,7 +526,7 @@ export function newTargeting(auctionManager) {
   function mergeAdServerTargeting(acc, bid, index, arr) {
     function concatTargetingValue(key) {
       return function(currentBidElement) {
-        if (!utils.isArray(currentBidElement.adserverTargeting[key])) {
+        if (!isArray(currentBidElement.adserverTargeting[key])) {
           currentBidElement.adserverTargeting[key] = [currentBidElement.adserverTargeting[key]];
         }
         currentBidElement.adserverTargeting[key] = currentBidElement.adserverTargeting[key].concat(bid.adserverTargeting[key]).filter(uniques);
@@ -634,8 +633,8 @@ export function newTargeting(auctionManager) {
 
       return Object.keys(aut)
         .map(function(key) {
-          if (utils.isStr(aut[key])) aut[key] = aut[key].split(',').map(s => s.trim());
-          if (!utils.isArray(aut[key])) aut[key] = [ aut[key] ];
+          if (isStr(aut[key])) aut[key] = aut[key].split(',').map(s => s.trim());
+          if (!isArray(aut[key])) aut[key] = [ aut[key] ];
           return { [key]: aut[key] };
         });
     }
@@ -648,7 +647,7 @@ export function newTargeting(auctionManager) {
   }
 
   targeting.isApntagDefined = function() {
-    if (window.apntag && utils.isFn(window.apntag.setKeywords)) {
+    if (window.apntag && isFn(window.apntag.setKeywords)) {
       return true;
     }
   };

package/src/userSync.js

@@ -1,4 +1,7 @@
-import * as utils from './utils.js';
+import {
+  deepClone, isPlainObject, logError, shuffle, logMessage, triggerPixel, insertUserSyncIframe, isArray,
+  logWarn, isStr, isSafariBrowser
+} from './utils.js';
 import { config } from './config.js';
 import includes from 'core-js-pure/features/array/includes.js';
 import { getCoreStorageManager } from './storageManager.js';
@@ -18,7 +21,7 @@ export const USERSYNC_DEFAULT_CONFIG = {
 
 // Set userSync default values
 config.setDefaults({
-  'userSync': utils.deepClone(USERSYNC_DEFAULT_CONFIG)
+  'userSync': deepClone(USERSYNC_DEFAULT_CONFIG)
 });
 
 const storage = getCoreStorageManager('usersync');
@@ -54,7 +57,7 @@ export function newUserSync(userSyncDependencies) {
     // if userSync.filterSettings does not contain image/all configs, merge in default image config to ensure image pixels are fired
     if (conf.userSync) {
       let fs = conf.userSync.filterSettings;
-      if (utils.isPlainObject(fs)) {
+      if (isPlainObject(fs)) {
         if (!fs.image && !fs.all) {
           conf.userSync.filterSettings.image = {
             bidders: '*',
@@ -91,12 +94,12 @@ export function newUserSync(userSyncDependencies) {
     }
 
     try {
-      // Image pixels
-      fireImagePixels();
       // Iframe syncs
       loadIframes();
+      // Image pixels
+      fireImagePixels();
     } catch (e) {
-      return utils.logError('Error firing user syncs', e);
+      return logError('Error firing user syncs', e);
     }
     // Reset the user sync queue
     queue = getDefaultQueue();
@@ -106,7 +109,7 @@ export function newUserSync(userSyncDependencies) {
     // Randomize the order of the pixels before firing
     // This is to avoid giving any bidder who has registered multiple syncs
     // any preferential treatment and balancing them out
-    utils.shuffle(queue).forEach((sync) => {
+    shuffle(queue).forEach((sync) => {
       fn(sync);
       hasFiredBidder.add(sync[0]);
     });
@@ -123,9 +126,9 @@ export function newUserSync(userSyncDependencies) {
     }
     forEachFire(queue.image, (sync) => {
       let [bidderName, trackingPixelUrl] = sync;
-      utils.logMessage(`Invoking image pixel user sync for bidder: ${bidderName}`);
+      logMessage(`Invoking image pixel user sync for bidder: ${bidderName}`);
       // Create image object and add the src url
-      utils.triggerPixel(trackingPixelUrl);
+      triggerPixel(trackingPixelUrl);
     });
   }
 
@@ -138,11 +141,21 @@ export function newUserSync(userSyncDependencies) {
     if (!(permittedPixels.iframe)) {
       return;
     }
+
     forEachFire(queue.iframe, (sync) => {
       let [bidderName, iframeUrl] = sync;
-      utils.logMessage(`Invoking iframe user sync for bidder: ${bidderName}`);
+      logMessage(`Invoking iframe user sync for bidder: ${bidderName}`);
       // Insert iframe into DOM
-      utils.insertUserSyncIframe(iframeUrl);
+      insertUserSyncIframe(iframeUrl);
+      // for a bidder, if iframe sync is present then remove image pixel
+      removeImagePixelsForBidder(queue, bidderName);
+    });
+  }
+
+  function removeImagePixelsForBidder(queue, iframeSyncBidderName) {
+    queue.image = queue.image.filter(imageSync => {
+      let imageSyncBidderName = imageSync[0];
+      return imageSyncBidderName !== iframeSyncBidderName
     });
   }
 
@@ -177,21 +190,21 @@ export function newUserSync(userSyncDependencies) {
    */
   publicApi.registerSync = (type, bidder, url) => {
     if (hasFiredBidder.has(bidder)) {
-      return utils.logMessage(`already fired syncs for "${bidder}", ignoring registerSync call`);
+      return logMessage(`already fired syncs for "${bidder}", ignoring registerSync call`);
     }
-    if (!usConfig.syncEnabled || !utils.isArray(queue[type])) {
-      return utils.logWarn(`User sync type "${type}" not supported`);
+    if (!usConfig.syncEnabled || !isArray(queue[type])) {
+      return logWarn(`User sync type "${type}" not supported`);
     }
     if (!bidder) {
-      return utils.logWarn(`Bidder is required for registering sync`);
+      return logWarn(`Bidder is required for registering sync`);
     }
     if (usConfig.syncsPerBidder !== 0 && Number(numAdapterBids[bidder]) >= usConfig.syncsPerBidder) {
-      return utils.logWarn(`Number of user syncs exceeded for "${bidder}"`);
+      return logWarn(`Number of user syncs exceeded for "${bidder}"`);
     }
 
     const canBidderRegisterSync = publicApi.canBidderRegisterSync(type, bidder);
     if (!canBidderRegisterSync) {
-      return utils.logWarn(`Bidder "${bidder}" not permitted to register their "${type}" userSync pixels.`);
+      return logWarn(`Bidder "${bidder}" not permitted to register their "${type}" userSync pixels.`);
     }
 
     // the bidder's pixel has passed all checks and is allowed to register
@@ -238,7 +251,7 @@ export function newUserSync(userSyncDependencies) {
    */
   function isFilterConfigValid(filterConfig, type) {
     if (filterConfig.all && filterConfig[type]) {
-      utils.logWarn(`Detected presence of the "filterSettings.all" and "filterSettings.${type}" in userSync config.  You cannot mix "all" with "iframe/image" configs; they are mutually exclusive.`);
+      logWarn(`Detected presence of the "filterSettings.all" and "filterSettings.${type}" in userSync config.  You cannot mix "all" with "iframe/image" configs; they are mutually exclusive.`);
       return false;
     }
 
@@ -255,12 +268,12 @@ export function newUserSync(userSyncDependencies) {
     let biddersField = activeConfig.bidders;
 
     if (filterField && filterField !== 'include' && filterField !== 'exclude') {
-      utils.logWarn(`UserSync "filterSettings.${activeConfigName}.filter" setting '${filterField}' is not a valid option; use either 'include' or 'exclude'.`);
+      logWarn(`UserSync "filterSettings.${activeConfigName}.filter" setting '${filterField}' is not a valid option; use either 'include' or 'exclude'.`);
       return false;
     }
 
-    if (biddersField !== '*' && !(Array.isArray(biddersField) && biddersField.length > 0 && biddersField.every(bidderInList => utils.isStr(bidderInList) && bidderInList !== '*'))) {
-      utils.logWarn(`Detected an invalid setup in userSync "filterSettings.${activeConfigName}.bidders"; use either '*' (to represent all bidders) or an array of bidders.`);
+    if (biddersField !== '*' && !(Array.isArray(biddersField) && biddersField.length > 0 && biddersField.every(bidderInList => isStr(bidderInList) && bidderInList !== '*'))) {
+      logWarn(`Detected an invalid setup in userSync "filterSettings.${activeConfigName}.bidders"; use either '*' (to represent all bidders) or an array of bidders.`);
       return false;
     }
 
@@ -302,7 +315,7 @@ export function newUserSync(userSyncDependencies) {
   return publicApi;
 }
 
-const browserSupportsCookies = !utils.isSafariBrowser() && storage.cookiesAreEnabled();
+const browserSupportsCookies = !isSafariBrowser() && storage.cookiesAreEnabled();
 
 export const userSync = newUserSync({
   config: config.getConfig('userSync'),

package/src/videoCache.js

@@ -11,7 +11,7 @@
 
 import { ajax } from './ajax.js';
 import { config } from './config.js';
-import * as utils from './utils.js';
+import { isPlainObject } from './utils.js';
 
 /**
  * @typedef {object} CacheableUrlBid
@@ -73,7 +73,7 @@ function toStorageRequest(bid) {
     payload.bidid = bid.requestId;
     payload.aid = bid.auctionId;
     // function has a thisArg set to bidderRequest for accessing the auctionStart
-    if (utils.isPlainObject(this) && this.hasOwnProperty('auctionStart')) {
+    if (isPlainObject(this) && this.hasOwnProperty('auctionStart')) {
       payload.timestamp = this.auctionStart;
     }
   }

package/test/.eslintrc.js

@@ -8,7 +8,8 @@ module.exports = {
     '$$PREBID_GLOBAL$$': false
   },
   parserOptions: {
-    sourceType: 'module'
+    sourceType: 'module',
+    ecmaVersion: 2018
   },
   rules: {
     'comma-dangle': 'off',

package/test/spec/modules/adfBidAdapter_spec.js

@@ -331,6 +331,61 @@ describe('Adf adapter', function () {
         }
       });
 
+      describe('price floors', function () {
+        it('should not add if floors module not configured', function () {
+          const validBidRequests = [{ bidId: 'bidId', params: {mid: 1000}, mediaTypes: {video: {}} }];
+          let imp = getRequestImps(validBidRequests)[0];
+
+          assert.equal(imp.bidfloor, undefined);
+          assert.equal(imp.bidfloorcur, undefined);
+        });
+
+        it('should not add if floor price not defined', function () {
+          const validBidRequests = [ getBidWithFloor() ];
+          let imp = getRequestImps(validBidRequests)[0];
+
+          assert.equal(imp.bidfloor, undefined);
+          assert.equal(imp.bidfloorcur, 'USD');
+        });
+
+        it('should request floor price in adserver currency', function () {
+          config.setConfig({ currency: { adServerCurrency: 'DKK' } });
+          const validBidRequests = [ getBidWithFloor() ];
+          let imp = getRequestImps(validBidRequests)[0];
+
+          assert.equal(imp.bidfloor, undefined);
+          assert.equal(imp.bidfloorcur, 'DKK');
+        });
+
+        it('should add correct floor values', function () {
+          const expectedFloors = [ 1, 1.3, 0.5 ];
+          const validBidRequests = expectedFloors.map(getBidWithFloor);
+          let imps = getRequestImps(validBidRequests);
+
+          expectedFloors.forEach((floor, index) => {
+            assert.equal(imps[index].bidfloor, floor);
+            assert.equal(imps[index].bidfloorcur, 'USD');
+          });
+        });
+
+        function getBidWithFloor(floor) {
+          return {
+            params: { mid: 1 },
+            mediaTypes: { video: {} },
+            getFloor: ({ currency }) => {
+              return {
+                currency: currency,
+                floor
+              }
+            }
+          };
+        }
+
+        function getRequestImps(validBidRequests) {
+          return JSON.parse(spec.buildRequests(validBidRequests, { refererInfo: { referer: 'page' } }).data).imp;
+        }
+      });
+
       describe('multiple media types', function () {
         it('should use single media type for bidding', function () {
           let validBidRequests = [{