prebid.js 7.25.0 → 7.26.0

package/modules/yieldoneBidAdapter.js

@@ -4,6 +4,17 @@ import {registerBidder} from '../src/adapters/bidderFactory.js';
 import { Renderer } from '../src/Renderer.js';
 import { BANNER, VIDEO } from '../src/mediaTypes.js';
 
+/**
+ * @typedef {import('../src/adapters/bidderFactory').Bid} Bid
+ * @typedef {import('../src/adapters/bidderFactory').BidRequest} BidRequest
+ * @typedef {import('../src/adapters/bidderFactory').BidderSpec} BidderSpec
+ * @typedef {import('../src/adapters/bidderFactory').ServerRequest} ServerRequest
+ * @typedef {import('../src/adapters/bidderFactory').ServerResponse} ServerResponse
+ * @typedef {import('../src/adapters/bidderFactory').SyncOptions} SyncOptions
+ * @typedef {import('../src/adapters/bidderFactory').UserSync} UserSync
+ * @typedef {import('../src/auction').BidderRequest} BidderRequest
+ */
+
 const BIDDER_CODE = 'yieldone';
 const ENDPOINT_URL = 'https://y.one.impact-ad.jp/h_bid';
 const USER_SYNC_URL = 'https://y.one.impact-ad.jp/push_sync';
@@ -13,13 +24,25 @@ const VIEWABLE_PERCENTAGE_URL = 'https://img.ak.impact-ad.jp/ic/pone/ivt/firstvi
 
 const DEFAULT_VIDEO_SIZE = {w: 640, h: 360};
 
+/** @type BidderSpec */
 export const spec = {
   code: BIDDER_CODE,
   aliases: ['y1'],
   supportedMediaTypes: [BANNER, VIDEO],
+  /**
+   * Determines whether or not the given bid request is valid.
+   * @param {BidRequest} bid The bid params to validate.
+   * @returns {boolean} True if this is a valid bid, and false otherwise.
+   */
   isBidRequestValid: function(bid) {
     return !!(bid.params.placementId);
   },
+  /**
+   * Make a server request from the list of BidRequests.
+   * @param {Bid[]} validBidRequests - An array of bids.
+   * @param {BidderRequest} bidderRequest - bidder request object.
+   * @returns {ServerRequest|ServerRequest[]} ServerRequest Info describing the request to the server.
+   */
   buildRequests: function(validBidRequests, bidderRequest) {
     return validBidRequests.map(bidRequest => {
       const params = bidRequest.params;
@@ -96,6 +119,12 @@ export const spec = {
       };
     });
   },
+  /**
+   * Unpack the response from the server into a list of bids.
+   * @param {ServerResponse} serverResponse - A successful response from the server.
+   * @param {BidRequest} bidRequests
+   * @returns {Bid[]} - An array of bids which were nested inside the server.
+   */
   interpretResponse: function(serverResponse, bidRequest) {
     const bidResponses = [];
     const response = serverResponse.body;
@@ -188,6 +217,11 @@ export const spec = {
     }
     return bidResponses;
   },
+  /**
+   * Register the user sync pixels which should be dropped after the auction.
+   * @param {SyncOptions} syncOptions Which user syncs are allowed?
+   * @returns {UserSync[]} The user syncs which should be dropped.
+   */
   getUserSyncs: function(syncOptions) {
     if (syncOptions.iframeEnabled) {
       return [{
@@ -202,7 +236,7 @@ export const spec = {
  * NOTE: server side does not yet support multiple formats.
  * @param  {Object} bidRequest -
  * @param  {boolean} [enabledOldFormat = true] - default: `true`.
- * @return {string|null} - `"banner"` or `"video"` or `null`.
+ * @returns {string|null} - `"banner"` or `"video"` or `null`.
  */
 function getMediaType(bidRequest, enabledOldFormat = true) {
   let hasBannerType = Boolean(deepAccess(bidRequest, 'mediaTypes.banner'));
@@ -239,7 +273,7 @@ function getMediaType(bidRequest, enabledOldFormat = true) {
  * @param  {Object} bidRequest.banner -
  * @param  {Array<string>} bidRequest.banner.sizes -
  * @param  {boolean} [enabledOldFormat = true] - default: `true`.
- * @return {string} - strings like `"300x250"` or `"300x250,728x90"`.
+ * @returns {string} - strings like `"300x250"` or `"300x250,728x90"`.
  */
 function getBannerSizes(bidRequest, enabledOldFormat = true) {
   let sizes = deepAccess(bidRequest, 'mediaTypes.banner.sizes');
@@ -254,10 +288,10 @@ function getBannerSizes(bidRequest, enabledOldFormat = true) {
 /**
  * @param  {Object} bidRequest -
  * @param  {boolean} [enabledOldFormat = true] - default: `true`.
- * @param  {boolean} [enabledFlux = true] - default: `true`.
- * @return {{w: number, h: number}} -
+ * @param  {boolean} [enabled1x1 = true] - default: `true`.
+ * @returns {{w: number, h: number}} -
  */
-function getVideoSize(bidRequest, enabledOldFormat = true, enabledFlux = true) {
+function getVideoSize(bidRequest, enabledOldFormat = true, enabled1x1 = true) {
   /**
    * @param  {Array<number, number> | Array<Array<number, number>>} sizes -
    * @return {{w: number, h: number} | null} -
@@ -287,10 +321,10 @@ function getVideoSize(bidRequest, enabledOldFormat = true, enabledFlux = true) {
     playerSize = playerSize || _getPlayerSize(bidRequest.sizes);
   }
 
-  if (enabledFlux) {
-    // NOTE: `video.playerSize` in Flux is always [1,1].
+  if (enabled1x1) {
+    // NOTE: `video.playerSize` in 1x1 is always [1,1].
     if (playerSize && (playerSize.w === 1 && playerSize.h === 1)) {
-      // NOTE: `params.playerSize` is a specific object to support `FLUX`.
+      // NOTE: `params.playerSize` is a specific object to support `1x1`.
       playerSize = _getPlayerSize(deepAccess(bidRequest, 'params.playerSize'));
     }
   }
@@ -298,6 +332,11 @@ function getVideoSize(bidRequest, enabledOldFormat = true, enabledFlux = true) {
   return playerSize || DEFAULT_VIDEO_SIZE;
 }
 
+/**
+ * Create render for outstream video.
+ * @param {Object} serverResponse.body -
+ * @returns {Renderer} - Prebid Renderer object
+ */
 function newRenderer(response) {
   const renderer = Renderer.install({
     id: response.uid,
@@ -314,12 +353,21 @@ function newRenderer(response) {
   return renderer;
 }
 
+/**
+ * Handles an outstream response after the library is loaded
+ * @param {Object} bid
+ */
 function outstreamRender(bid) {
   bid.renderer.push(() => {
     window.DACIVTPREBID.renderPrebid(bid);
   });
 }
 
+/**
+ * Create render for cmer outstream video.
+ * @param {Object} serverResponse.body -
+ * @returns {Renderer} - Prebid Renderer object
+ */
 function newCmerRenderer(response) {
   const renderer = Renderer.install({
     id: response.uid,
@@ -336,6 +384,10 @@ function newCmerRenderer(response) {
   return renderer;
 }
 
+/**
+ * Handles an outstream response after the library is loaded
+ * @param {Object} bid
+ */
 function cmerRender(bid) {
   bid.renderer.push(() => {
     window.CMERYONEPREBID.renderPrebid(bid);

package/modules/yieldoneBidAdapter.md

@@ -13,8 +13,7 @@ Connect to YIELDONE for bids.
 THE YIELDONE adapter requires setup and approval from the YIELDONE team.
 Please reach out to your account team or y1s@platform-one.co.jp for more information.
 
-Note: THE YIELDONE adapter do not support "multi-format" scenario... if both
-banner and video are specified as mediatypes, YIELDONE will treat it as a video unit.
+YIELDONE adapter supports Banner, Video and Multi-Format(video, banner) currently.
 
 # Test Parameters
 ```javascript
@@ -24,13 +23,16 @@ var adUnits = [
       code: 'banner-div',
       mediaTypes: {
         banner: {
-          sizes: [[300, 250], [336, 280]]
+          sizes: [
+            [300, 250],
+            [336, 280]
+          ]
         }
       },
       bids: [{
          bidder: 'yieldone',
          params: {
-           placementId: '36891'
+           placementId: '36891'  // required
          }
        }]
    },
@@ -44,11 +46,109 @@ var adUnits = [
         },
       },
       bids: [{
-         bidder: 'yieldone',
-         params: {
-           placementId: '41993'
-         }
-       }]
+        bidder: "yieldone",
+        params: {
+          placementId: "36892",     // required
+          playerParams: {           // optional
+            wrapperWidth: "320px",  // optional
+            wrapperHeight: "180px"  // optional
+          },
+        }
+      }]
+   },
+   // Video adUnit(mediaTypes.video.playerSize: [1,1])
+   {
+      code: 'video-1x1-div',
+      mediaTypes: {
+        video: {
+          playerSize: [[1, 1]],
+          context: 'outstream'
+        },
+      },
+      bids: [{
+        bidder: 'yieldone',
+        params: {
+          placementId: "36892",     // required
+          playerSize: [640, 360],   // required
+          playerParams: {           // optional
+            wrapperWidth: "320px",  // optional
+            wrapperHeight: "180px"  // optional
+          },
+        }
+      }]
+   },
+   // Multi-Format adUnit
+   {
+      code: "multi-format-div",
+      mediaTypes: {
+        banner: {
+          sizes: [
+            [300, 250],
+            [1, 1]
+          ]
+        },
+        video: {
+          playerSize: [640, 360],
+          context: "outstream"
+        }
+      },
+      bids: [{
+        // * "video" bid object should be placed before "banner" bid object.
+        // This bid will request a "video" media type ad.
+        bidder: "yieldone",
+        params: {
+          placementId: "36892",     // required
+          playerParams: {           // required
+            wrapperWidth: "320px",  // optional
+            wrapperHeight: "180px"  // optional
+          },
+        }
+      },
+      {
+        // This bid will request a "banner" media type ad.
+        bidder: "yieldone",
+        params: {
+          placementId: "36891"  // required
+        }
+      }
+    ]
+   },
+   // Multi-Format adUnit(mediaTypes.video.playerSize: [1,1])
+   {
+      code: "multi-format-1x1-div",
+      mediaTypes: {
+        banner: {
+          sizes: [
+            [300, 250],
+            [1, 1]
+          ]
+        },
+        video: {
+          playerSize: [1, 1],
+          context: "outstream"
+        }
+      },
+      bids: [{
+        // * "video" bid object should be placed before "banner" bid object.
+        // This bid will request a "video" media type ad.
+        bidder: "yieldone",
+        params: {
+          placementId: "36892",     // required
+          playerSize: [640, 360],   // required
+          playerParams: {           // required
+            wrapperWidth: "320px",  // optional
+            wrapperHeight: "180px"  // optional
+          },
+        }
+      },
+      {
+        // This bid will request a "banner" media type ad.
+        bidder: "yieldone",
+        params: {
+          placementId: "36891"  // required
+        }
+      }
+    ]
    }
 ```
 

package/modules/zeta_global_sspBidAdapter.js

@@ -129,6 +129,10 @@ export const spec = {
       deepSetValue(payload, 'regs.ext.us_privacy', bidderRequest.uspConsent);
     }
 
+    if (bidderRequest?.timeout) {
+      payload.tmax = bidderRequest.timeout;
+    }
+
     provideEids(validBidRequests[0], payload);
     const url = params.shortname ? ENDPOINT_URL.concat('?shortname=', params.shortname) : ENDPOINT_URL;
     return {

package/modules/zeusPrimeRtdProvider.js

@@ -0,0 +1,357 @@
+/**
+ * This module adds Zeus Insights For Publishers (ZIP) provider to the real time data module
+ * The {@link module:modules/realTimeData} module is required
+ *
+ * This module will request the article topics for the current page and add them as page keyvalues
+ * for the ad requests.
+ *
+ * @module modules/zeusInsightsForPublishersRtdProvider
+ * @requires module:modules/realTimeData
+ */
+
+import { logInfo, logError, logWarn, logMessage } from '../src/utils.js'
+import { submodule } from '../src/hook.js'
+import { ajaxBuilder } from '../src/ajax.js'
+
+class Logger {
+  get showDebug() {
+    if (this._showDebug === true || this._showDebug === false) {
+      return this._showDebug
+    }
+
+    return window.zeusPrime?.debug || false
+  }
+  set showDebug(shouldShow) {
+    this._showDebug = shouldShow
+  }
+
+  get error() {
+    return logError.bind(this, 'zeusPrimeRtdProvider: ')
+  }
+  get warn() {
+    return logWarn.bind(this, 'zeusPrimeRtdProvider: ')
+  }
+  get info() {
+    return logInfo.bind(this, 'zeusPrimeRtdProvider: ')
+  }
+  get debug() {
+    if (this.showDebug) {
+      return logMessage.bind(this, 'zeusPrimeRtdProvider: ')
+    }
+
+    return () => {}
+  }
+}
+
+var logger = new Logger()
+
+function loadCommandQueue() {
+  window.zeusPrime = window.zeusPrime || { cmd: [] }
+  const queue = [...window.zeusPrime.cmd]
+
+  window.zeusPrime.cmd = []
+  window.zeusPrime.cmd.push = (callback) => {
+    callback(window.zeusPrime)
+  }
+
+  queue.forEach((callback) => callback(window.zeusPrime))
+}
+
+function markStatusComplete(key) {
+  const status = window?.zeusPrime?.status
+  if (status) {
+    status[key] = true
+  }
+}
+
+function createStatus() {
+  if (window.zeusPrime && !window.zeusPrime.status) {
+    Object.defineProperty(window.zeusPrime, 'status', {
+      enumerable: false,
+      value: {
+        initComplete: false,
+        primeKeyValueSet: false,
+        insightsReqSent: false,
+        insightsReqReceived: false,
+        insightsKeyValueSet: false,
+        scriptComplete: false,
+      },
+    })
+  }
+}
+
+function loadPrimeQueryParams() {
+  try {
+    const params = new URLSearchParams(window.location.search)
+    params.forEach((paramValue, paramKey) => {
+      if (!paramKey.startsWith('zeus_prime_')) {
+        return
+      }
+
+      let key = paramKey.replace('zeus_prime_', '')
+      let value = paramValue.toLowerCase()
+
+      if (value === 'true' || value === '1') {
+        value = true
+      } else if (value === 'false' || value === '0') {
+        value = false
+      }
+
+      window.zeusPrime[key] = value
+    })
+  } catch (_) {}
+}
+
+const DEFAULT_API = 'https://insights.zeustechnology.com'
+
+function init(gamId = null, options = {}) {
+  window.zeusPrime = window.zeusPrime || { cmd: [] }
+
+  window.zeusPrime.gamId = gamId || options.gamId || window.zeusPrime.gamId || undefined
+  window.zeusPrime.api = DEFAULT_API
+  window.zeusPrime.hostname = options.hostname || window.location?.hostname || ''
+  window.zeusPrime.pathname = options.pathname || window.location?.pathname || ''
+  window.zeusPrime.pageUrl = `${window.zeusPrime.hostname}${window.zeusPrime.pathname}`
+  window.zeusPrime.pageHash = options.pageHash || null
+  window.zeusPrime.debug = window.zeusPrime.debug || options.debug === true || false
+  window.zeusPrime.disabled = window.zeusPrime.disabled || options.disabled === true || false
+
+  loadPrimeQueryParams()
+
+  logger.showDebug = window.zeusPrime.debug
+
+  createStatus()
+  markStatusComplete('initComplete')
+}
+
+function setTargeting() {
+  const { gamId, hostname } = window.zeusPrime
+
+  if (typeof gamId !== 'string') {
+    throw new Error(`window.zeusPrime.gamId must be a string. Received: ${String(gamId)}`)
+  }
+
+  addKeyValueToGoogletag(`zeus_${gamId}`, hostname)
+  logger.debug(`Setting zeus_${gamId}=${hostname}`)
+  markStatusComplete('primeKeyValueSet')
+}
+
+function setPrimeAsDisabled() {
+  addKeyValueToGoogletag('zeus_prime', 'false')
+  logger.debug('Disabling prime; Setting key-value zeus_prime to false')
+}
+
+function addKeyValueToGoogletag(key, value) {
+  window.googletag = window.googletag || { cmd: [] }
+  window.googletag.cmd.push(function () {
+    window.googletag.pubads().setTargeting(key, value)
+  })
+}
+
+function isInsightsPage(pathname = '') {
+  const NOT_SECTIONS = [
+    {
+      test: /\/search/,
+      type: 'search',
+    },
+    {
+      test: /\/author/,
+      type: 'author',
+    },
+    {
+      test: /\/event/,
+      type: 'event',
+    },
+    {
+      test: /\/homepage/,
+      type: 'front',
+    },
+    {
+      test: /^\/?$/,
+      type: 'front',
+    },
+  ]
+
+  const typeObj = NOT_SECTIONS.find((pg) => pathname.match(pg.test))
+  return typeObj === undefined
+}
+
+async function getUrlHash(canonical) {
+  try {
+    const buf = await window.crypto.subtle.digest(
+      'SHA-1',
+      new TextEncoder('utf-8').encode(canonical)
+    )
+    const hashed = Array.prototype.map
+      .call(new Uint8Array(buf), (x) => `00${x.toString(16)}`.slice(-2))
+      .join('')
+
+    return hashed
+  } catch (e) {
+    logger.error('Failed to load hash', e.message)
+    logger.debug('Exception', e)
+    return ''
+  }
+}
+
+async function sendPrebidRequest(url) {
+  return new Promise((resolve, reject) => {
+    const ajax = ajaxBuilder()
+    ajax(url, {
+      success: (responseText, response) => {
+        resolve({
+          ...response,
+          status: response.status,
+          json: () => JSON.parse(responseText),
+        })
+      },
+
+      error: (responseText, response) => {
+        if (!response.status) {
+          reject(response)
+        }
+
+        let json = responseText
+        if (responseText) {
+          try {
+            json = JSON.parse(responseText)
+          } catch (_) {
+            json = null
+          }
+        }
+
+        resolve({
+          status: response.status,
+          json: () => json || null,
+          responseValue: json,
+        })
+      },
+    })
+  })
+}
+
+async function requestTopics() {
+  const { api, hostname, pageUrl } = window.zeusPrime
+
+  if (!window.zeusPrime.pageHash) {
+    window.zeusPrime.pageHash = await getUrlHash(pageUrl)
+  }
+
+  const pageHash = window.zeusPrime.pageHash
+  const zeusInsightsUrl = `${api}/${hostname}/${pageHash}?article_location=${pageUrl}`
+
+  logger.debug('Requesting topics', zeusInsightsUrl)
+  try {
+    markStatusComplete('insightsReqSent')
+    const response = await sendPrebidRequest(zeusInsightsUrl)
+    if (response.status === 200) {
+      logger.debug('topics found')
+      markStatusComplete('insightsReqReceived')
+      return await response.json()
+    } else if (
+      response.status === 204 ||
+      response.status < 200 ||
+      (response.status >= 300 && response.status <= 399)
+    ) {
+      logger.debug('no topics found')
+      markStatusComplete('insightsReqReceived')
+      return null
+    } else {
+      logger.error(`Topics request returned error: ${response.status}`)
+      markStatusComplete('insightsReqReceived')
+      return null
+    }
+  } catch (e) {
+    logger.error('failed to request topics', e)
+    return null
+  }
+}
+
+function setTopicsTargeting(topics = []) {
+  if (topics.length === 0) {
+    return
+  }
+
+  window.googletag = window.googletag || { cmd: [] }
+  window.googletag.cmd.push(function () {
+    window.googletag.pubads().setTargeting('zeus_insights', topics)
+  })
+
+  markStatusComplete('insightsKeyValueSet')
+}
+
+async function startTopicsRequest() {
+  if (isInsightsPage(window.zeusPrime.pathname)) {
+    const response = await requestTopics()
+    if (response) {
+      setTopicsTargeting(response?.topics)
+    }
+  } else {
+    logger.debug('This page is not eligible for topics, request will be skipped')
+  }
+}
+
+async function run(gamId, options = {}) {
+  logger.showDebug = options.debug || false
+
+  try {
+    init(gamId, options)
+    loadCommandQueue()
+
+    if (window.zeusPrime.disabled) {
+      setPrimeAsDisabled()
+    } else {
+      setTargeting()
+      await startTopicsRequest()
+    }
+  } catch (e) {
+    logger.error('Failed to run.', e.message || e)
+  } finally {
+    markStatusComplete('scriptComplete')
+  }
+}
+
+/**
+ * @preserve
+ * Initializes the ZeusPrime RTD Submodule. The config provides the GamID for this
+ * site that is used to configure Prime.
+ * @param {object} config The Prebid configuration for this module.
+ * @param {object} config.params The parameters for this module.
+ * @param {string} config.params.gamId The Gam ID (or Network Code) in GAM for this site.
+ */
+function initModule(config) {
+  const { params } = config || {}
+  const { gamId, ...rest } = params || {}
+  run(gamId, rest)
+}
+
+/**
+ * @preserve
+ * @type {RtdSubmodule}
+ */
+const zeusPrimeSubmodule = {
+  /**
+   * @preserve
+   * The name of the plugin.
+   * @type {string}
+   */
+  name: 'zeusPrime',
+
+  /**
+   * @preserve
+   * ZeusPrime use
+   */
+  init: initModule,
+}
+
+/**
+ * @preserve
+ * Register the Sub Module.
+ */
+function registerSubModule() {
+  submodule('realTimeData', zeusPrimeSubmodule)
+}
+
+registerSubModule()
+
+export { zeusPrimeSubmodule }