prebid.js 6.6.0 → 6.10.0

package/modules/vibrantmediaBidAdapter.js

@@ -0,0 +1,220 @@
+/*
+ * Vibrant Media Ltd.
+ *
+ * Prebid Adapter for sending bid requests to the prebid server and bid responses back to the client
+ *
+ * Note: Only BANNER and VIDEO are currently supported by the prebid server.
+ */
+
+import {logError, logInfo} from '../src/utils.js';
+import {registerBidder} from '../src/adapters/bidderFactory.js';
+import {BANNER, NATIVE, VIDEO} from '../src/mediaTypes.js';
+import {OUTSTREAM} from '../src/video.js';
+
+const BIDDER_CODE = 'vibrantmedia';
+const VIBRANT_MEDIA_PREBID_URL = 'https://prebid.intellitxt.com/prebid';
+const SUPPORTED_MEDIA_TYPES = [BANNER, NATIVE, VIDEO];
+
+/**
+ * Returns whether the given bid request contains at least one supported media request, which has valid data. (We can
+ * ignore invalid/unsupported ones, as they will be filtered out by the prebid server.)
+ *
+ * @param {*} bidRequest the bid requests sent by the Prebid API.
+ *
+ * @return {boolean} true if the given bid request contains at least one supported media request with valid details,
+ *                   otherwise false.
+ */
+const areValidSupportedMediaTypesPresent = function(bidRequest) {
+  const mediaTypes = Object.keys(bidRequest.mediaTypes);
+
+  return mediaTypes.some(function(mediaType) {
+    if (mediaType === BANNER) {
+      return true;
+    } else if (mediaType === VIDEO) {
+      return (bidRequest.mediaTypes[VIDEO].context === OUTSTREAM);
+    } else if (mediaType === NATIVE) {
+      return !!bidRequest.mediaTypes[NATIVE].image;
+    }
+
+    return false;
+  });
+};
+
+/**
+ * Returns whether the given URL contains just a domain, and not (for example) a subdirectory or query parameters.
+ * @param {string} url the URL to check.
+ * @returns {boolean} whether the URL contains just a domain.
+ */
+const isBaseUrl = function(url) {
+  const urlMinusScheme = url.substring(url.indexOf('://') + 3);
+  const endOfDomain = urlMinusScheme.indexOf('/');
+  return (endOfDomain === -1) || (endOfDomain === (urlMinusScheme.length - 1));
+};
+
+/**
+ * Returns transformed bid requests that are in a format native to the prebid server.
+ *
+ * @param {*[]} bidRequests the bid requests sent by the Prebid API.
+ *
+ * @returns {*[]} the transformed bid requests.
+ */
+const transformBidRequests = function(bidRequests) {
+  const transformedBidRequests = [];
+
+  bidRequests.forEach(function(bidRequest) {
+    const params = bidRequest.params || {};
+    const transformedBidRequest = {
+      code: bidRequest.adUnitCode || bidRequest.code,
+      id: bidRequest.placementId || params.placementId || params.invCode,
+      requestId: bidRequest.bidId || bidRequest.transactionId,
+      bidder: bidRequest.bidder,
+      mediaTypes: bidRequest.mediaTypes,
+      bids: bidRequest.bids,
+      sizes: bidRequest.sizes
+    };
+
+    transformedBidRequests.push(transformedBidRequest);
+  });
+
+  return transformedBidRequests;
+};
+
+/** @type {BidderSpec} */
+export const spec = {
+  code: BIDDER_CODE,
+  supportedMediaTypes: SUPPORTED_MEDIA_TYPES,
+
+  /**
+   * Transforms the 'raw' bid params into ones that this adapter can use, prior to creating the bid request.
+   *
+   * @param {object} bidParams the params to transform.
+   *
+   * @returns {object} the bid params.
+   */
+  transformBidParams: function(bidParams) {
+    return bidParams;
+  },
+
+  /**
+   * Determines whether or not the given bid request is valid. For all bid requests passed to the buildRequests
+   * function, each will have been passed to this function and this function will have returned true.
+   *
+   * @param {object} bid the bid params to validate.
+   *
+   * @return {boolean} true if this is a valid bid, otherwise false.
+   * @see SUPPORTED_MEDIA_TYPES
+   */
+  isBidRequestValid: function(bid) {
+    const areBidRequestParamsValid = !!(bid.params.placementId || (bid.params.member && bid.params.invCode));
+    return areBidRequestParamsValid && areValidSupportedMediaTypesPresent(bid);
+  },
+
+  /**
+   * Return a prebid server request from the list of bid requests.
+   *
+   * @param {BidRequest[]}  validBidRequests an array of bids validated via the isBidRequestValid function.
+   * @param {BidderRequest} bidderRequest    an object with data common to all bid requests.
+   *
+   * @return ServerRequest Info describing the request to the prebid server.
+   */
+  buildRequests: function(validBidRequests, bidderRequest) {
+    const transformedBidRequests = transformBidRequests(validBidRequests);
+
+    var url = window.parent.location.href;
+
+    if ((window.self === window.top) && (!url || (url.substr(0, 4) !== 'http') || isBaseUrl(url))) {
+      url = document.URL;
+    }
+
+    url = encodeURIComponent(url);
+
+    const prebidData = {
+      url,
+      gdpr: bidderRequest.gdprConsent,
+      usp: bidderRequest.uspConsent,
+      window: {
+        width: window.innerWidth,
+        height: window.innerHeight,
+      },
+      biddata: transformedBidRequests,
+    };
+
+    return {
+      method: 'POST',
+      url: VIBRANT_MEDIA_PREBID_URL,
+      data: JSON.stringify(prebidData)
+    };
+  },
+
+  /**
+   * Translate the Kormorant prebid server response into a list of bids.
+   *
+   * @param {ServerResponse} serverResponse a successful response from the prebid server.
+   * @param {BidRequest}     bidRequest     the original bid request associated with this response.
+   *
+   * @return {Bid[]} an array of bids returned by the prebid server, translated into the expected Prebid.js format.
+   */
+  interpretResponse: function(serverResponse, bidRequest) {
+    const bids = serverResponse.body;
+
+    bids.forEach(function(bid) {
+      bid.adResponse = serverResponse;
+    });
+
+    return bids;
+  },
+
+  /**
+   * Called if the Prebid API gives up waiting for a prebid server response.
+   *
+   * Example timeout data:
+   *
+   * [{
+   *   "bidder": "example",
+   *   "bidId": "51ef8751f9aead",
+   *   "params": {
+   *     ...
+   *   },
+   *   "adUnitCode": "div-gpt-ad-1460505748561-0",
+   *   "timeout": 3000,
+   *   "auctionId": "18fd8b8b0bd757"
+   * }]
+   *
+   * @param {{}} timeoutData data relating to the timeout.
+   */
+  onTimeout: function(timeoutData) {
+    logError('Timed out waiting for bids: ' + JSON.stringify(timeoutData));
+  },
+
+  /**
+   * Called when a bid returned by the prebid server is successful.
+   *
+   * Example bid won data:
+   *
+   * {
+   *   "bidder": "example",
+   *   "width": 300,
+   *   "height": 250,
+   *   "adId": "330a22bdea4cac",
+   *   "mediaType": "banner",
+   *   "cpm": 0.28
+   *   "ad": "...",
+   *   "requestId": "418b37f85e772c",
+   *   "adUnitCode": "div-gpt-ad-1460505748561-0",
+   *   "size": "350x250",
+   *   "adserverTargeting": {
+   *     "hb_bidder": "example",
+   *     "hb_adid": "330a22bdea4cac",
+   *     "hb_pb": "0.20",
+   *     "hb_size": "350x250"
+   *   }
+   * }
+   *
+   * @param {*} bidData the data associated with the won bid. See example above for data format.
+   */
+  onBidWon: function(bidData) {
+    logInfo('Bid won: ' + JSON.stringify(bidData));
+  }
+};
+
+registerBidder(spec);

package/modules/vibrantmediaBidAdapter.md

@@ -0,0 +1,92 @@
+## Overview
+
+**Module Name:** Vibrant Media Bidder Adapter
+
+**Module Type:** Bidder Adapter
+
+**Maintainer:** kormorant@vibrantmedia.com
+
+## Description
+
+Module that allows Vibrant Media to provide ad bids for banner, native and video (outstream only).
+
+## Test Parameters
+
+```javascript
+var adUnits = [
+  // Banner ad unit
+  {
+    code: 'test-banner',
+    mediaTypes: {
+      banner: {
+        sizes: [[300, 250], [300, 600]]
+      }
+    },
+    bids: [{
+      bidder: 'vibrantmedia',
+      params: {
+        placementId: 12345
+      }
+    }]
+  },
+
+  // Video (outstream) ad unit
+  {
+    code: 'test-video-outstream',
+    sizes: [[300, 250]],
+    mediaTypes: {
+      video: {
+        playerSize: [[300, 250]],
+        context: 'outstream',
+        minduration: 1,      // Minimum ad duration, in seconds
+        maxduration: 60,     // Maximum ad duration, in seconds
+        skip: 0,             // 1 - true, 0 - false
+        skipafter: 5,        // Number of seconds before the video can be skipped
+        playbackmethod: [2], // Auto-play without sound
+        protocols: [1, 2, 3] // VAST 1.0, 2.0 and 3.0
+      }
+    },
+    bids: [
+      {
+        bidder: 'vibrantmedia',
+        params: {
+          placementId: 67890,
+          video: {
+            skippable: true,
+            playback_method: 'auto_play_sound_off'
+          }
+        }
+      }
+    ]
+  },
+
+  // Native ad unit
+  {
+    code: 'test-native',
+    mediaTypes: {
+      native: {
+        image: {
+          required: true,
+          sizes: [300, 250]
+        },
+        title: {
+          required: true
+        },
+        sponsoredBy: {
+          required: true
+        },
+        clickUrl: {
+          required: true
+        },
+      }
+    },
+    bids: [{
+      bidder: 'vibrantmedia',
+      params: {
+        placementId: 13579,
+        allowSmallerSizes: true
+      }
+    }]
+  }
+];
+```

package/modules/viewability.js

@@ -0,0 +1,177 @@
+import { logWarn, logInfo, isStr, isFn, triggerPixel, insertHtmlIntoIframe } from '../src/utils.js';
+import { getGlobal } from '../src/prebidGlobal.js';
+import find from 'prebidjs-polyfill/find.js';
+
+export const MODULE_NAME = 'viewability';
+
+export function init() {
+  (getGlobal()).viewability = {
+    startMeasurement: startMeasurement,
+    stopMeasurement: stopMeasurement,
+  };
+
+  listenMessagesFromCreative();
+}
+
+const observers = {};
+
+function isValid(vid, element, tracker, criteria) {
+  if (!element) {
+    logWarn(`${MODULE_NAME}: no html element provided`);
+    return false;
+  }
+
+  let validTracker = tracker &&
+    ((tracker.method === 'img' && isStr(tracker.value)) ||
+    (tracker.method === 'js' && isStr(tracker.value)) ||
+    (tracker.method === 'callback' && isFn(tracker.value)));
+
+  if (!validTracker) {
+    logWarn(`${MODULE_NAME}: invalid tracker`, tracker);
+    return false;
+  }
+
+  if (!criteria || !criteria.inViewThreshold || !criteria.timeInView) {
+    logWarn(`${MODULE_NAME}: missing criteria`, criteria);
+    return false;
+  }
+
+  if (!vid || observers[vid]) {
+    logWarn(`${MODULE_NAME}: must provide an unregistered vid`, vid);
+    return false;
+  }
+
+  return true;
+}
+
+function stopObserving(observer, vid, element) {
+  observer.unobserve(element);
+  observers[vid].done = true;
+}
+
+function fireViewabilityTracker(element, tracker) {
+  switch (tracker.method) {
+    case 'img':
+      triggerPixel(tracker.value, () => {
+        logInfo(`${MODULE_NAME}: viewability pixel fired`, tracker.value);
+      });
+      break;
+    case 'js':
+      insertHtmlIntoIframe(`<script src="${tracker.value}"></script>`);
+      break;
+    case 'callback':
+      tracker.value(element);
+      break;
+  }
+}
+
+function viewabilityCriteriaMet(observer, vid, element, tracker) {
+  stopObserving(observer, vid, element);
+  fireViewabilityTracker(element, tracker);
+}
+
+/**
+ * Start measuring viewability of an element
+ * @typedef {{ method: string='img','js','callback', value: string|function }} ViewabilityTracker { method: 'img', value: 'http://my.tracker/123' }
+ * @typedef {{ inViewThreshold: number, timeInView: number }} ViewabilityCriteria { inViewThreshold: 0.5, timeInView: 1000 }
+ * @param {string} vid unique viewability identifier
+ * @param {HTMLElement} element
+ * @param {ViewabilityTracker} tracker
+ * @param {ViewabilityCriteria} criteria
+ */
+export function startMeasurement(vid, element, tracker, criteria) {
+  if (!isValid(vid, element, tracker, criteria)) {
+    return;
+  }
+
+  const options = {
+    root: null,
+    rootMargin: '0px',
+    threshold: criteria.inViewThreshold,
+  };
+
+  let observer;
+  let viewable = false;
+  let stateChange = (entries) => {
+    viewable = entries[0].isIntersecting;
+
+    if (viewable) {
+      observers[vid].timeoutId = window.setTimeout(() => {
+        viewabilityCriteriaMet(observer, vid, element, tracker);
+      }, criteria.timeInView);
+    } else if (observers[vid].timeoutId) {
+      window.clearTimeout(observers[vid].timeoutId);
+    }
+  };
+
+  observer = new IntersectionObserver(stateChange, options);
+  observers[vid] = {
+    observer: observer,
+    element: element,
+    timeoutId: null,
+    done: false,
+  };
+
+  observer.observe(element);
+
+  logInfo(`${MODULE_NAME}: startMeasurement called with:`, arguments);
+}
+
+/**
+ * Stop measuring viewability of an element
+ * @param {string} vid unique viewability identifier
+ */
+export function stopMeasurement(vid) {
+  if (!vid || !observers[vid]) {
+    logWarn(`${MODULE_NAME}: must provide a registered vid`, vid);
+    return;
+  }
+
+  observers[vid].observer.unobserve(observers[vid].element);
+  if (observers[vid].timeoutId) {
+    window.clearTimeout(observers[vid].timeoutId);
+  }
+
+  // allow the observer under this vid to be created again
+  if (!observers[vid].done) {
+    delete observers[vid];
+  }
+}
+
+function listenMessagesFromCreative() {
+  window.addEventListener('message', receiveMessage, false);
+}
+
+/**
+ * Recieve messages from creatives
+ * @param {MessageEvent} evt
+ */
+export function receiveMessage(evt) {
+  var key = evt.message ? 'message' : 'data';
+  var data = {};
+  try {
+    data = JSON.parse(evt[key]);
+  } catch (e) {
+    return;
+  }
+
+  if (!data || data.message !== 'Prebid Viewability') {
+    return;
+  }
+
+  switch (data.action) {
+    case 'startMeasurement':
+      let element = data.elementId && document.getElementById(data.elementId);
+      if (!element) {
+        element = find(document.getElementsByTagName('IFRAME'), iframe => (iframe.contentWindow || iframe.contentDocument.defaultView) == evt.source);
+      }
+
+      startMeasurement(data.vid, element, data.tracker, data.criteria);
+      break;
+    case 'stopMeasurement':
+      stopMeasurement(data.vid);
+      break;
+  }
+}
+
+init();

package/modules/viewability.md

@@ -0,0 +1,87 @@
+# Overview
+
+Module Name: Viewability
+
+Purpose: Track when a given HTML element becomes viewable
+
+Maintainer: atrajkovic@magnite.com
+
+# Configuration
+
+Module does not need any configuration, as long as you include it in your PBJS bundle.
+Viewability module has only two functions `startMeasurement` and `stopMeasurement` which can be used to enable more complex viewability measurements. Since it allows tracking from within creative (possibly inside a safe frame) this module registers a message listener, for messages with a format that is described bellow.
+
+## `startMeasurement`
+
+| startMeasurement Arg Object | Scope | Type | Description | Example |
+| --------------------- | -------- | ------------ | -------------------------------------------------------------------------------- | --------- |
+| vid | Required | String | Unique viewability identifier, used to reference particular observer | `"ae0f9"` |
+| element | Required | HTMLElement |  Reference to an HTML element that needs to be tracked | `document.getElementById('test_div')` |
+| tracker | Required | ViewabilityTracker | How viewaility event is communicated back to the parties of interest | `{ method: 'img', value: 'http://my.tracker/123' }` |
+| criteria | Required | ViewabilityCriteria| Defines custom viewability criteria using the threshold and duration provided  | `{ inViewThreshold: 0.5, timeInView: 1000 }` |
+
+| ViewabilityTracker | Scope | Type | Description | Example |
+| --------------------- | -------- | ------------ | -------------------------------------------------------------------------------- | --------- |
+| method | Required | String | Type of method for Tracker | `'img' OR 'js' OR 'callback'` |
+| value | Required | String | URL string for 'img' and 'js' Trackers, or a function for 'callback' Tracker | `'http://my.tracker/123'` |
+
+| ViewabilityCriteria | Scope | Type | Description | Example |
+| --------------------- | -------- | ------------ | -------------------------------------------------------------------------------- | --------- |
+| inViewThreshold | Required | Number | Represents a percentage threshold for the Element to be registered as in view | `0.5` |
+| timeInView | Required | Number | Number of milliseconds that a given element needs to be in view continuously, above the threshold | `1000` |
+
+## Please Note:
+- `vid` allows for multiple trackers, with different criteria to be registered for a given HTML element, independently. It's not autogenerated by `startMeasurement()`, it needs to be provided by the caller so that it doesn't have to be posted back to the source iframe (in case viewability is started from within the creative).
+- In case of 'callback' method, HTML element is being passed back to the callback function.
+- When a tracker needs to be started, without direct access to pbjs, postMessage mechanism can be used to invoke `startMeasurement`, with a following payload: `vid`, `tracker` and `criteria` as described above, but also with `message: 'Prebid Viewability'` and `action: 'startMeasurement'`. Optionally payload can provide `elementId`, if available at that time (for ad servers where name of the iframe is known, or adservers that render outside an iframe). If `elementId` is not provided, viewability module will try to find the iframe that corresponds to the message source. 
+
+
+## `stopMeasurement`
+
+| stopMeasurement Arg Object | Scope | Type | Description | Example |
+| --------------------- | -------- | ------------ | -------------------------------------------------------------------------------- | --------- |
+| vid | Required | String | Unique viewability identifier, referencing an already started viewability tracker. | `"ae0f9"` |
+
+## Please Note:
+- When a tracker needs to be stopped, without direct access to pbjs, postMessage mechanism can be used here as well. To invoke `stopMeasurement`, you provide the payload with `vid`, `message: 'Prebid Viewability'` and `action: 'stopMeasurement`. Check the example bellow.
+
+# Examples
+
+## Example of starting a viewability measurement, when you have direct access to pbjs
+```
+pbjs.viewability.startMeasurement(
+    'ae0f9', 
+    document.getElementById('test_div'),
+    { method: 'img', value: 'http://my.tracker/123' },
+    { inViewThreshold: 0.5, timeInView: 1000 }
+);
+```
+
+## Example of starting a viewability measurement from within a rendered creative
+```
+let viewabilityRecord = {
+    vid: 'ae0f9',
+    tracker: { method: 'img', value: 'http://my.tracker/123'},
+    criteria: { inViewThreshold: 0.5, timeInView: 1000 },
+    message: 'Prebid Viewability',
+    action: 'startMeasurement'
+}
+
+window.parent.postMessage(JSON.stringify(viewabilityRecord), '*');
+```
+
+## Example of stopping the viewability measurement, when you have direct access to pbjs
+```
+pbjs.viewability.stopMeasurement('ae0f9');
+```
+
+## Example of stopping the viewability measurement from within a rendered creative
+```
+let viewabilityRecord = {
+    vid: 'ae0f9',
+    message: 'Prebid Viewability',
+    action: 'stopMeasurement'
+}
+
+window.parent.postMessage(JSON.stringify(viewabilityRecord), '*');
+```

package/modules/viewdeosDXBidAdapter.js

@@ -2,7 +2,7 @@ import { deepAccess, isArray, flatten, logError, parseSizesInput } from '../src/
 import {registerBidder} from '../src/adapters/bidderFactory.js';
 import {VIDEO, BANNER} from '../src/mediaTypes.js';
 import {Renderer} from '../src/Renderer.js';
-import findIndex from 'core-js-pure/features/array/find-index.js';
+import findIndex from 'prebidjs-polyfill/findIndex.js';
 
 const URL = 'https://ghb.sync.viewdeos.com/auction/';
 const OUTSTREAM_SRC = 'https://player.sync.viewdeos.com/outstream-unit/2.01/outstream.min.js';

package/modules/voxBidAdapter.js

@@ -1,7 +1,7 @@
 import { _map, logWarn, deepAccess, isArray } from '../src/utils.js';
 import { registerBidder } from '../src/adapters/bidderFactory.js'
 import {BANNER, VIDEO} from '../src/mediaTypes.js'
-import find from 'core-js-pure/features/array/find.js';
+import find from 'prebidjs-polyfill/find.js';
 import {auctionManager} from '../src/auctionManager.js';
 import {Renderer} from '../src/Renderer.js';
 

package/modules/waardexBidAdapter.js

@@ -2,7 +2,7 @@ import { logError, isArray, deepAccess, getBidIdParameter } from '../src/utils.j
 import {registerBidder} from '../src/adapters/bidderFactory.js';
 import {BANNER, VIDEO} from '../src/mediaTypes.js';
 import {config} from '../src/config.js';
-import find from 'core-js-pure/features/array/find.js';
+import find from 'prebidjs-polyfill/find.js';
 
 const ENDPOINT = `https://hb.justbidit.xyz:8843/prebid`;
 const BIDDER_CODE = 'waardex';