prebid.js 7.4.0 → 7.7.0

package/modules/eplanningBidAdapter.js

@@ -1,4 +1,4 @@
-import {getWindowSelf, isEmpty, parseSizesInput} from '../src/utils.js';
+import {getWindowSelf, isEmpty, parseSizesInput, isGptPubadsDefined, isSlotMatchingAdUnitCode} from '../src/utils.js';
 import {getGlobal} from '../src/prebidGlobal.js';
 import {registerBidder} from '../src/adapters/bidderFactory.js';
 import {getStorageManager} from '../src/storageManager.js';
@@ -291,13 +291,25 @@ function getCharset() {
 
 function waitForElementsPresent(elements) {
   const observer = new MutationObserver(function (mutationList, observer) {
+    let index;
+    let adView;
     if (mutationList && Array.isArray(mutationList)) {
       mutationList.forEach(mr => {
         if (mr && mr.addedNodes && Array.isArray(mr.addedNodes)) {
           mr.addedNodes.forEach(ad => {
-            let index = elements.indexOf(ad.id);
+            index = elements.indexOf(ad.id);
+            adView = ad;
+            if (index < 0) {
+              elements.forEach(code => {
+                let div = _getAdSlotHTMLElement(code);
+                if (div && div.contains(ad) && div.getBoundingClientRect().width > 0) {
+                  index = elements.indexOf(div.id);
+                  adView = div;
+                }
+              });
+            }
             if (index >= 0) {
-              registerViewability(ad);
+              registerViewability(adView, elements[index]);
               elements.splice(index, 1);
               if (!elements.length) {
                 observer.disconnect();
@@ -318,19 +330,41 @@ function waitForElementsPresent(elements) {
   });
 }
 
-function registerViewability(div) {
+function registerViewability(div, name) {
   visibilityHandler({
-    name: div.id,
+    name: name,
     div: div
   });
 }
 
+function _mapAdUnitPathToElementId(adUnitCode) {
+  if (isGptPubadsDefined()) {
+    // eslint-disable-next-line no-undef
+    const adSlots = googletag.pubads().getSlots();
+    const isMatchingAdSlot = isSlotMatchingAdUnitCode(adUnitCode);
+
+    for (let i = 0; i < adSlots.length; i++) {
+      if (isMatchingAdSlot(adSlots[i])) {
+        const id = adSlots[i].getSlotElementId();
+        return id;
+      }
+    }
+  }
+
+  return null;
+}
+
+function _getAdSlotHTMLElement(adUnitCode) {
+  return document.getElementById(adUnitCode) ||
+    document.getElementById(_mapAdUnitPathToElementId(adUnitCode));
+}
+
 function registerViewabilityAllBids(bids) {
   let elementsNotPresent = [];
   bids.forEach(bid => {
-    let div = document.getElementById(bid.adUnitCode);
+    let div = _getAdSlotHTMLElement(bid.adUnitCode);
     if (div) {
-      registerViewability(div);
+      registerViewability(div, bid.adUnitCode);
     } else {
       elementsNotPresent.push(bid.adUnitCode);
     }
@@ -345,114 +379,65 @@ function getViewabilityTracker() {
   let VIEWABILITY_TIME = 1000;
   let VIEWABILITY_MIN_RATIO = 0.5;
   let publicApi;
-  let context;
-
-  function segmentIsOutsideTheVisibleRange(visibleRangeEnd, p1, p2) {
-    return p1 > visibleRangeEnd || p2 < 0;
-  }
-
-  function segmentBeginsBeforeTheVisibleRange(p1) {
-    return p1 < 0;
-  }
-
-  function segmentEndsAfterTheVisibleRange(visibleRangeEnd, p2) {
-    return p2 < visibleRangeEnd;
-  }
-
-  function axialVisibilityRatio(visibleRangeEnd, p1, p2) {
-    let visibilityRatio = 0;
-    if (!segmentIsOutsideTheVisibleRange(visibleRangeEnd, p1, p2)) {
-      if (segmentBeginsBeforeTheVisibleRange(p1)) {
-        visibilityRatio = p2 / (p2 - p1);
+  let observer;
+  let visibilityAds = {};
+
+  function intersectionCallback(entries) {
+    entries.forEach(function(entry) {
+      var adBox = entry.target;
+      if (entry.isIntersecting) {
+        if (entry.intersectionRatio >= VIEWABILITY_MIN_RATIO && entry.boundingClientRect && entry.boundingClientRect.height > 0 && entry.boundingClientRect.width > 0) {
+          visibilityAds[adBox.id] = true;
+        }
       } else {
-        visibilityRatio = segmentEndsAfterTheVisibleRange(visibleRangeEnd, p2) ? 1 : (visibleRangeEnd - p1) / (p2 - p1);
+        visibilityAds[adBox.id] = false;
       }
-    }
-    return visibilityRatio;
-  }
-
-  function isNotHiddenByNonFriendlyIframe() {
-    try { return (window === window.top) || window.frameElement; } catch (e) {}
-  }
-
-  function defineContext(e) {
-    try {
-      context = e && window.document.body.contains(e) ? window : (window.top.document.body.contains(e) ? top : undefined);
-    } catch (err) {}
-    return context;
-  }
-
-  function getContext(e) {
-    return context;
-  }
-
-  function verticalVisibilityRatio(position) {
-    return axialVisibilityRatio(getContext().innerHeight, position.top, position.bottom);
-  }
-
-  function horizontalVisibilityRatio(position) {
-    return axialVisibilityRatio(getContext().innerWidth, position.left, position.right);
-  }
-
-  function itIsNotHiddenByBannerAreaPosition(e) {
-    let position = e.getBoundingClientRect();
-    return (verticalVisibilityRatio(position) * horizontalVisibilityRatio(position)) > VIEWABILITY_MIN_RATIO;
-  }
-
-  function itIsNotHiddenByDisplayStyleCascade(e) {
-    return e.offsetHeight > 0 && e.offsetWidth > 0;
-  }
-
-  function itIsNotHiddenByOpacityStyleCascade(e) {
-    let s = e.style;
-    let p = e.parentNode;
-    return !(s && parseFloat(s.opacity) === 0) && (!p || itIsNotHiddenByOpacityStyleCascade(p));
-  }
-
-  function itIsNotHiddenByVisibilityStyleCascade(e) {
-    return getContext().getComputedStyle(e).visibility !== 'hidden';
-  }
-
-  function itIsNotHiddenByTabFocus() {
-    try { return getContext().top.document.hasFocus(); } catch (e) {}
-  }
-
-  function isDefined(e) {
-    return (e !== null) && (typeof e !== 'undefined');
+    });
   }
 
-  function itIsNotHiddenByOrphanBranch() {
-    return isDefined(getContext());
+  function observedElementIsVisible(element) {
+    return visibilityAds[element.id] && document.visibilityState && document.visibilityState === 'visible';
   }
 
-  function isContextInAnIframe() {
-    return isDefined(getContext().frameElement);
+  function defineObserver() {
+    if (!observer) {
+      var observerConfig = {
+        root: null,
+        rootMargin: '0px',
+        threshold: [VIEWABILITY_MIN_RATIO]
+      };
+      observer = new IntersectionObserver(intersectionCallback.bind(this), observerConfig);
+    }
   }
-
   function processIntervalVisibilityStatus(elapsedVisibleIntervals, element, callback) {
-    let visibleIntervals = isVisible(element) ? (elapsedVisibleIntervals + 1) : 0;
+    let visibleIntervals = observedElementIsVisible(element) ? (elapsedVisibleIntervals + 1) : 0;
     if (visibleIntervals === TIME_PARTITIONS) {
+      stopObserveViewability(element)
       callback();
     } else {
       setTimeout(processIntervalVisibilityStatus.bind(this, visibleIntervals, element, callback), VIEWABILITY_TIME / TIME_PARTITIONS);
     }
   }
 
-  function isVisible(element) {
-    defineContext(element);
-    return isNotHiddenByNonFriendlyIframe() &&
-      itIsNotHiddenByOrphanBranch() &&
-      itIsNotHiddenByTabFocus() &&
-      itIsNotHiddenByDisplayStyleCascade(element) &&
-      itIsNotHiddenByVisibilityStyleCascade(element) &&
-      itIsNotHiddenByOpacityStyleCascade(element) &&
-      itIsNotHiddenByBannerAreaPosition(element) &&
-      (!isContextInAnIframe() || isVisible(getContext().frameElement));
+  function stopObserveViewability(element) {
+    delete visibilityAds[element.id];
+    observer.unobserve(element);
+  }
+
+  function observeAds(element) {
+    observer.observe(element);
+  }
+
+  function initAndVerifyVisibility(element, callback) {
+    if (element) {
+      defineObserver();
+      observeAds(element);
+      processIntervalVisibilityStatus(0, element, callback);
+    }
   }
 
   publicApi = {
-    isVisible: isVisible,
-    onView: processIntervalVisibilityStatus.bind(this, 0)
+    onView: initAndVerifyVisibility.bind(this)
   };
 
   return publicApi;

package/modules/gdprEnforcement.js

@@ -18,8 +18,6 @@ const TCF2 = {
   'purpose7': { id: 7, name: 'measurement' }
 }
 
-const VENDORLESS_MODULE_TYPES = ['fpid-module'];
-
 /*
   These rules would be used if `consentManagement.gdpr.rules` is undefined by the publisher.
 */
@@ -125,10 +123,9 @@ function getGvlidForAnalyticsAdapter(code) {
  * @param {Object} consentData - gdpr consent data
  * @param {string=} currentModule - Bidder code of the current module
  * @param {number=} gvlId - GVL ID for the module
- * @param {string=} moduleType module type
  * @returns {boolean}
  */
-export function validateRules(rule, consentData, currentModule, gvlId, moduleType) {
+export function validateRules(rule, consentData, currentModule, gvlId) {
   const purposeId = TCF2[Object.keys(TCF2).filter(purposeName => TCF2[purposeName].name === rule.purpose)[0]].id;
 
   // return 'true' if vendor present in 'vendorExceptions'
@@ -141,14 +138,12 @@ export function validateRules(rule, consentData, currentModule, gvlId, moduleTyp
   const vendorConsent = deepAccess(consentData, `vendorData.vendor.consents.${gvlId}`);
   const liTransparency = deepAccess(consentData, `vendorData.purpose.legitimateInterests.${purposeId}`);
 
-  const vendorlessModule = includes(VENDORLESS_MODULE_TYPES, moduleType);
-
   /*
     Since vendor exceptions have already been handled, the purpose as a whole is allowed if it's not being enforced
     or the user has consented. Similar with vendors.
   */
   const purposeAllowed = rule.enforcePurpose === false || purposeConsent === true;
-  const vendorAllowed = rule.enforceVendor === false || vendorConsent === true || vendorlessModule === true;
+  const vendorAllowed = rule.enforceVendor === false || vendorConsent === true;
 
   /*
     Few if any vendors should be declaring Legitimate Interest for Device Access (Purpose 1), but some are claiming
@@ -167,16 +162,15 @@ export function validateRules(rule, consentData, currentModule, gvlId, moduleTyp
  * @param {Function} fn reference to original function (used by hook logic)
  * @param {Number=} gvlid gvlid of the module
  * @param {string=} moduleName name of the module
- * @param {string=} moduleType module type
  */
-export function deviceAccessHook(fn, gvlid, moduleName, moduleType, result) {
+export function deviceAccessHook(fn, gvlid, moduleName, result) {
   result = Object.assign({}, {
     hasEnforcementHook: true
   });
   if (!hasDeviceAccess()) {
     logWarn('Device access is disabled by Publisher');
     result.valid = false;
-    fn.call(this, gvlid, moduleName, moduleType, result);
+    fn.call(this, gvlid, moduleName, result);
   } else {
     const consentData = gdprDataHandler.getConsentData();
     if (consentData && consentData.gdprApplies) {
@@ -188,19 +182,19 @@ export function deviceAccessHook(fn, gvlid, moduleName, moduleType, result) {
         gvlid = getGvlid(moduleName) || gvlid;
       }
       const curModule = moduleName || curBidder;
-      let isAllowed = validateRules(purpose1Rule, consentData, curModule, gvlid, moduleType);
+      let isAllowed = validateRules(purpose1Rule, consentData, curModule, gvlid);
       if (isAllowed) {
         result.valid = true;
-        fn.call(this, gvlid, moduleName, moduleType, result);
+        fn.call(this, gvlid, moduleName, result);
       } else {
         curModule && logWarn(`TCF2 denied device access for ${curModule}`);
         result.valid = false;
         storageBlocked.push(curModule);
-        fn.call(this, gvlid, moduleName, moduleType, result);
+        fn.call(this, gvlid, moduleName, result);
       }
     } else {
       result.valid = true;
-      fn.call(this, gvlid, moduleName, moduleType, result);
+      fn.call(this, gvlid, moduleName, result);
     }
   }
 }

package/modules/gridNMBidAdapter.js

@@ -1,4 +1,13 @@
-import { isStr, deepAccess, isArray, isNumber, logError, logWarn, parseGPTSingleSizeArrayToRtbSize } from '../src/utils.js';
+import {
+  isStr,
+  deepAccess,
+  isArray,
+  isNumber,
+  logError,
+  logWarn,
+  parseGPTSingleSizeArrayToRtbSize,
+  mergeDeep
+} from '../src/utils.js';
 import { registerBidder } from '../src/adapters/bidderFactory.js';
 import { Renderer } from '../src/Renderer.js';
 import { VIDEO } from '../src/mediaTypes.js';
@@ -153,9 +162,7 @@ export const spec = {
         user = {
           data: [{
             name: 'iow_labs_pub_data',
-            segment: jwpseg.map((seg) => {
-              return {name: 'jwpseg', value: seg};
-            })
+            segment: segmentProcessing(jwpseg, 'jwpseg'),
           }]
         };
       }
@@ -174,9 +181,27 @@ export const spec = {
         user.ext = userExt;
       }
 
+      const ortb2UserData = deepAccess(bidderRequest, 'ortb2.user.data');
+      if (ortb2UserData && ortb2UserData.length) {
+        if (!user) {
+          user = { data: [] };
+        }
+        user = mergeDeep(user, {
+          data: [...ortb2UserData]
+        });
+      }
+
       if (user) {
         request.user = user;
       }
+      const site = deepAccess(bidderRequest, 'ortb2.site');
+      if (site) {
+        const data = deepAccess(site, 'content.data');
+        if (data && data.length) {
+          const siteContent = request.site.content || {};
+          request.site.content = mergeDeep(siteContent, { data });
+        }
+      }
 
       if (gdprConsent && gdprConsent.gdprApplies) {
         request.regs = {
@@ -408,4 +433,20 @@ export function getSyncUrl() {
   return SYNC_URL;
 }
 
+function segmentProcessing(segment, forceSegName) {
+  return segment
+    .map((seg) => {
+      const value = seg && (seg.value || seg.id || seg);
+      if (typeof value === 'string' || typeof value === 'number') {
+        return {
+          value: value.toString(),
+          ...(forceSegName && { name: forceSegName }),
+          ...(seg.name && { name: seg.name }),
+        };
+      }
+      return null;
+    })
+    .filter((seg) => !!seg);
+}
+
 registerBidder(spec);

package/modules/hadronAnalyticsAdapter.md

@@ -33,7 +33,7 @@ The following configuration parameters are available:
 
 ```javascript
 pbjs.enableAnalytics({
-    provider: 'hadron',
+    provider: 'hadronAnalytics',
     options: {
         partnerId: 1234, // change to the Partner ID you got from Audigent
         eventsToTrack: ['auctionEnd','bidWon']
@@ -41,8 +41,8 @@ pbjs.enableAnalytics({
 });
 ```
 
-| Parameter | Scope | Type | Description                                             | Example |
-| --- | --- | --- |---------------------------------------------------------| --- |
-| provider | Required | String | The name of this module: `hadronAnalytics`              | `hadronAnalytics` |
-| options.partnerId | Required | Number | This is the Audigent Partner ID obtained from Audigent. | `1234` |
+| Parameter             | Scope    | Type             | Description                                             | Example                   |
+|-----------------------|----------|------------------|---------------------------------------------------------|---------------------------|
+| provider              | Required | String           | The name of this module: `hadronAnalytics`              | `hadronAnalytics`         |
+| options.partnerId     | Required | Number           | This is the Audigent Partner ID obtained from Audigent. | `1234`                    |
 | options.eventsToTrack | Optional | Array of strings | Overrides the set of tracked events                     | `['auctionEnd','bidWon']` |

package/modules/hadronIdSystem.js

@@ -12,6 +12,7 @@ import { isFn, isStr, isPlainObject, logError } from '../src/utils.js';
 
 const MODULE_NAME = 'hadronId';
 const AU_GVLID = 561;
+const DEFAULT_HADRON_URL_ENDPOINT = 'https://id.hadron.ad.gt/api/v1/pbhid';
 
 export const storage = getStorageManager({gvlid: AU_GVLID, moduleName: 'hadron'});
 
@@ -29,6 +30,15 @@ function paramOrDefault(param, defaultVal, arg) {
   return defaultVal;
 }
 
+/**
+ * @param {string} url
+ * @param {string} params
+ * @returns {string}
+ */
+const urlAddParams = (url, params) => {
+  return url + (url.indexOf('?') > -1 ? '&' : '?') + params
+}
+
 /** @type {Submodule} */
 export const hadronIdSubmodule = {
   /**
@@ -39,8 +49,8 @@ export const hadronIdSubmodule = {
   /**
    * decode the stored id value for passing to bid requests
    * @function
-   * @param {{value:string}} value
-   * @returns {{hadronId:Object}}
+   * @param {string} value
+   * @returns {Object}
    */
   decode(value) {
     let hadronId = storage.getDataFromLocalStorage('auHadronId');
@@ -59,9 +69,12 @@ export const hadronIdSubmodule = {
     if (!isPlainObject(config.params)) {
       config.params = {};
     }
-    const url = paramOrDefault(config.params.url,
-      `https://id.hadron.ad.gt/api/v1/pbhid`,
-      config.params.urlArg);
+    const partnerId = config.params.partnerId | 0;
+
+    const url = urlAddParams(
+      paramOrDefault(config.params.url, DEFAULT_HADRON_URL_ENDPOINT, config.params.urlArg),
+      `partner_id=${partnerId}&_it=prebid`
+    );
 
     const resp = function (callback) {
       let hadronId = storage.getDataFromLocalStorage('auHadronId');

package/modules/hadronIdSystem.md

@@ -11,6 +11,9 @@ pbjs.setConfig({
     usersync: {
         userIds: [{
             name: 'hadronId',
+            params: {
+                partnerId: 1234   // change it to the Partner ID you'll get from Audigent
+            },
             storage: {
                 name: 'hadronId',
                 type: 'html5'
@@ -22,14 +25,15 @@ pbjs.setConfig({
 ## Parameter Descriptions for the `usersync` Configuration Section
 The below parameters apply only to the HadronID User ID Module integration.
 
-| Param under usersync.userIds[] | Scope | Type | Description | Example |
-| --- | --- | --- | --- | --- |
-| name | Required | String | ID value for the HadronID module - `"hadronId"` | `"hadronId"` |
-| storage | Required | Object | The publisher must specify the local storage in which to store the results of the call to get the user ID. This can be either cookie or HTML5 storage. | |
-| storage.type | Required | String | This is where the results of the user ID will be stored. The recommended method is `localStorage` by specifying `html5`. | `"html5"` |
-| storage.name | Required | String | The name of the cookie or html5 local storage where the user ID will be stored. | `"hadronid"` |
-| storage.expires | Optional | Integer | How long (in days) the user ID information will be stored. | `365` |
-| value | Optional | Object | Used only if the page has a separate mechanism for storing the Hadron ID. The value is an object containing the values to be sent to the adapters. In this scenario, no URL is called and nothing is added to local storage | `{"hadronId": "eb33b0cb-8d35-4722-b9c0-1a31d4064888"}` |
-| params | Optional | Object | Used to store params for the id system |
-| params.url | Optional | String | Set an alternate GET url for HadronId with this parameter |
-| params.urlArg | Optional | Object | Optional url parameter for params.url |
+| Param under usersync.userIds[] | Scope    | Type    | Description                                                                                                                                                                                                                 | Example                                                |
+|--------------------------------|----------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------|
+| name                           | Required | String  | ID value for the HadronID module - `"hadronId"`                                                                                                                                                                             | `"hadronId"`                                           |
+| storage                        | Required | Object  | The publisher must specify the local storage in which to store the results of the call to get the user ID. This can be either cookie or HTML5 storage.                                                                      |                                                        |
+| storage.type                   | Required | String  | This is where the results of the user ID will be stored. The recommended method is `localStorage` by specifying `html5`.                                                                                                    | `"html5"`                                              |
+| storage.name                   | Required | String  | The name of the cookie or html5 local storage where the user ID will be stored.                                                                                                                                             | `"hadronid"`                                           |
+| storage.expires                | Optional | Integer | How long (in days) the user ID information will be stored.                                                                                                                                                                  | `365`                                                  |
+| value                          | Optional | Object  | Used only if the page has a separate mechanism for storing the Hadron ID. The value is an object containing the values to be sent to the adapters. In this scenario, no URL is called and nothing is added to local storage | `{"hadronId": "eb33b0cb-8d35-4722-b9c0-1a31d4064888"}` |
+| params                         | Optional | Object  | Used to store params for the id system                                                                                                                                                                                      |
+| params.partnerId               | Required | Number  | This is the Audigent Partner ID obtained from Audigent.                                                                                                                                                                     | `1234`                                                 |
+| params.url                     | Optional | String  | Set an alternate GET url for HadronId with this parameter                                                                                                                                                                   |
+| params.urlArg                  | Optional | Object  | Optional url parameter for params.url                                                                                                                                                                                       |

package/modules/hadronRtdProvider.js

@@ -23,6 +23,15 @@ export const HALOID_LOCAL_NAME = 'auHadronId';
 export const RTD_LOCAL_NAME = 'auHadronRtd';
 export const storage = getStorageManager({gvlid: AU_GVLID, moduleName: SUBMODULE_NAME});
 
+/**
+ * @param {string} url
+ * @param {string} params
+ * @returns {string}
+ */
+const urlAddParams = (url, params) => {
+  return url + (url.indexOf('?') > -1 ? '&' : '?') + params
+}
+
 /**
  * Deep set an object unless value present.
  * @param {Object} obj
@@ -165,8 +174,12 @@ export function getRealTimeData(bidConfig, onDone, rtdConfig, userConsent) {
       userIds.hadronId = hadronId;
       getRealTimeDataAsync(bidConfig, onDone, rtdConfig, userConsent, userIds);
     }
+    const partnerId = rtdConfig.params.partnerId | 0;
     const hadronIdUrl = rtdConfig.params && rtdConfig.params.hadronIdUrl;
-    const scriptUrl = paramOrDefault(hadronIdUrl, HADRON_ID_DEFAULT_URL, userIds);
+    const scriptUrl = urlAddParams(
+      paramOrDefault(hadronIdUrl, HADRON_ID_DEFAULT_URL, userIds),
+      `partner_id=${partnerId}&_it=prebid`
+    );
     loadExternalScript(scriptUrl, 'hadron', () => {
       logInfo(LOG_PREFIX, 'hadronIdTag loaded', scriptUrl);
     })

package/modules/hadronRtdProvider.md

@@ -44,8 +44,9 @@ pbjs.setConfig(
                 params: {
                     segmentCache: false,
                     requestParams: {
-                        publisherId: 1234
-                    }
+                        publisherId: 1234  // deprecated, use partnerId instead
+                    },
+                    partnerId: 1234
                 }
             }
         ]
@@ -56,15 +57,17 @@ pbjs.setConfig(
 
 ### Parameter Descriptions for the Hadron Configuration Section
 
-| Name  |Type | Description   | Notes  |
-| :------------ | :------------ | :------------ |:------------ |
-| name | String | Real time data module name | Always 'hadron' |
-| waitForIt | Boolean | Required to ensure that the auction is delayed until prefetch is complete | Optional. Defaults to false |
-| params | Object | | |
-| params.handleRtd | Function | A passable RTD handler that allows custom adunit and ortb2 logic to be configured. The function signature is (bidConfig, rtd, rtdConfig, pbConfig) => {}. | Optional |
-| params.segmentCache | Boolean | This parameter tells the Hadron RTD module to attempt reading segments from a local storage cache instead of always requesting them from the Audigent server. | Optional. Defaults to false. |
-| params.requestParams | Object | Publisher partner specific configuration options, such as optional publisher id and other segment query related metadata to be submitted to Audigent's backend with each request.  Contact prebid@audigent.com for more information. | Optional |
-| params.hadronIdUrl | String | Parameter to specify alternate hadronid endpoint url. | Optional |
+| Name                             | Type     | Description                                                                                                                                                                                                                          | Notes                        |
+|:---------------------------------|:---------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:-----------------------------|
+| name                             | String   | Real time data module name                                                                                                                                                                                                           | Always 'hadron'              |
+| waitForIt                        | Boolean  | Required to ensure that the auction is delayed until prefetch is complete                                                                                                                                                            | Optional. Defaults to false  |
+| params                           | Object   |                                                                                                                                                                                                                                      |                              |
+| params.partnerId                 | Number   | This is the Audigent Partner ID obtained from Audigent.                                                                                                                                                                              | `1234`                       |
+| params.handleRtd                 | Function | A passable RTD handler that allows custom adunit and ortb2 logic to be configured. The function signature is (bidConfig, rtd, rtdConfig, pbConfig) => {}.                                                                            | Optional                     |
+| params.segmentCache              | Boolean  | This parameter tells the Hadron RTD module to attempt reading segments from a local storage cache instead of always requesting them from the Audigent server.                                                                        | Optional. Defaults to false. |
+| params.requestParams             | Object   | Publisher partner specific configuration options, such as optional publisher id and other segment query related metadata to be submitted to Audigent's backend with each request.  Contact prebid@audigent.com for more information. | Optional                     |
+| params.requestParams.publisherId | Object   | (deprecated) Publisher id and other segment query related metadata to be submitted to Audigent's backend with each request.  Contact prebid@audigent.com for more information.                                                       | Optional                     |
+| params.hadronIdUrl               | String   | Parameter to specify alternate hadronid endpoint url.                                                                                                                                                                                | Optional                     |
 
 ### Publisher Customized RTD Handling
 As indicated above, it is possible to provide your own bid augmentation
@@ -100,8 +103,9 @@ pbjs.setConfig(
                     },
                     segmentCache: false,
                     requestParams: {
-                        publisherId: 1234
-                    }
+                        publisherId: 1234  // deprecated, use partnerId instead
+                    },
+                    partnerId: 1234
                 }
             }
         ]

package/modules/imRtdProvider.js

@@ -42,14 +42,6 @@ function setImDataInCookie(value) {
 */
 export function getBidderFunction(bidderName) {
   const biddersFunction = {
-    ix: function (bid, data) {
-      if (data.im_segments && data.im_segments.length) {
-        config.setConfig({
-          ix: {firstPartyData: {im_segments: data.im_segments}},
-        });
-      }
-      return bid
-    },
     pubmatic: function (bid, data) {
       if (data.im_segments && data.im_segments.length) {
         const dctr = deepAccess(bid, 'params.dctr');

package/modules/impactifyBidAdapter.js

@@ -37,9 +37,13 @@ const createOpenRtbRequest = (validBidRequests, bidderRequest) => {
     source: {tid: bidderRequest.auctionId}
   };
 
+  // Get the url parameters
+  const queryString = window.location.search;
+  const urlParams = new URLSearchParams(queryString);
+  const checkPrebid = urlParams.get('_checkPrebid');
   // Force impactify debugging parameter
-  if (window.localStorage.getItem('_im_db_bidder') != null) {
-    request.test = Number(window.localStorage.getItem('_im_db_bidder'));
+  if (checkPrebid != null) {
+    request.test = Number(checkPrebid);
   }
 
   // Set Schain in request