prebid.js 7.26.0 → 7.28.0

package/modules/adhashBidAdapter.js

@@ -1,10 +1,12 @@
 import {registerBidder} from '../src/adapters/bidderFactory.js';
-import {includes} from '../src/polyfill.js';
-import {BANNER} from '../src/mediaTypes.js';
+import { getStorageManager } from '../src/storageManager.js';
+import { includes } from '../src/polyfill.js';
+import { BANNER } from '../src/mediaTypes.js';
 
-const VERSION = '1.0';
+const VERSION = '3.2';
 const BAD_WORD_STEP = 0.1;
 const BAD_WORD_MIN = 0.2;
+const ADHASH_BIDDER_CODE = 'adhash';
 
 /**
  * Function that checks the page where the ads are being served for brand safety.
@@ -54,43 +56,92 @@ function brandSafety(badWords, maxScore) {
     return positive ? result : -result;
   };
 
+  /**
+   * Checks what rule will match in the given array with words
+   * @param {string} rule rule type (full, partial, starts, ends, regexp)
+   * @param {string} decodedWord decoded word
+   * @param {array} wordsToMatch array to find a match
+   * @returns {object|boolean} matched rule and occurances. If nothing is matched returns false
+   */
+  const wordsMatchedWithRule = function (rule, decodedWord, wordsToMatch) {
+    if (rule === 'full' && wordsToMatch && wordsToMatch.includes(decodedWord)) {
+      return { rule, occurances: wordsToMatch.filter(element => element === decodedWord).length };
+    } else if (rule === 'partial' && wordsToMatch && wordsToMatch.some(element => element.indexOf(decodedWord) > -1)) {
+      return { rule, occurances: wordsToMatch.filter(element => element.indexOf(decodedWord) > -1).length };
+    } else if (rule === 'starts' && wordsToMatch && wordsToMatch.some(word => word.startsWith(decodedWord))) {
+      return { rule, occurances: wordsToMatch.filter(element => element.startsWith(decodedWord)).length };
+    } else if (rule === 'ends' && wordsToMatch && wordsToMatch.some(word => word.endsWith(decodedWord))) {
+      return { rule, occurances: wordsToMatch.filter(element => element.endsWith(decodedWord)).length };
+    } else if (rule === 'regexp' && wordsToMatch && wordsToMatch.some(element => element.match(new RegExp(decodedWord, 'i')))) {
+      return { rule, occurances: wordsToMatch.filter(element => element.match(new RegExp(decodedWord, 'i'))).length };
+    }
+    return false;
+  };
+
   // Default parameters if the bidder is unable to send some of them
   badWords = badWords || [];
   maxScore = parseInt(maxScore) || 10;
 
   try {
     let score = 0;
+    const decodedUrl = decodeURI(window.top.location.href.substring(window.top.location.origin.length));
+    const wordsAndNumbersInUrl = decodedUrl
+      .replaceAll(/[-,\._/\?=&#%]/g, ' ')
+      .replaceAll(/\s\s+/g, ' ')
+      .toLowerCase()
+      .trim();
     const content = window.top.document.body.innerText.toLowerCase();
-    const words = content.trim().split(/\s+/).length;
+    const contentWords = content.trim().split(/\s+/).length;
+    // \p{L} matches a single unicode code point in the category 'letter'. Matches any kind of letter from any language.
+    const regexp = new RegExp('[\\p{L}]+', 'gu');
+    const words = content.match(regexp);
+    const wordsInUrl = wordsAndNumbersInUrl.match(regexp);
+
     for (const [word, rule, points] of badWords) {
-      if (rule === 'full' && new RegExp('\\b' + rot13(word) + '\\b', 'i').test(content)) {
-        const occurances = content.match(new RegExp('\\b' + rot13(word) + '\\b', 'g')).length;
-        score += scoreCalculator(points, occurances);
-      } else if (rule === 'partial' && content.indexOf(rot13(word.toLowerCase())) > -1) {
-        const occurances = content.match(new RegExp(rot13(word), 'g')).length;
-        score += scoreCalculator(points, occurances);
+      const decodedWord = rot13(word.toLowerCase());
+
+      // Checks the words in the url of the page only for negative words. Don't serve any ad when at least one match is found
+      if (points > 0) {
+        const matchedRuleInUrl = wordsMatchedWithRule(rule, decodedWord, wordsInUrl);
+        if (matchedRuleInUrl.rule) {
+          return false;
+        }
+      }
+
+      // Check if site content's words match any of our brand safety rules
+      const matchedRule = wordsMatchedWithRule(rule, decodedWord, words);
+      if (matchedRule.rule === 'full') {
+        score += scoreCalculator(points, matchedRule.occurances);
+      } else if (matchedRule.rule === 'partial') {
+        score += scoreCalculator(points, matchedRule.occurances);
+      } else if (matchedRule.rule === 'starts') {
+        score += scoreCalculator(points, matchedRule.occurances);
+      } else if (matchedRule.rule === 'ends') {
+        score += scoreCalculator(points, matchedRule.occurances);
+      } else if (matchedRule.rule === 'regexp') {
+        score += scoreCalculator(points, matchedRule.occurances);
       }
     }
-    return score < maxScore * words / 500;
+    return score < (maxScore * contentWords) / 1000;
   } catch (e) {
     return true;
   }
 }
 
 export const spec = {
-  code: 'adhash',
-  url: 'https://bidder.adhash.com/rtb?version=' + VERSION + '&prebid=true',
+  code: ADHASH_BIDDER_CODE,
   supportedMediaTypes: [ BANNER ],
 
   isBidRequestValid: (bid) => {
     try {
-      const { publisherId, platformURL } = bid.params;
+      const { publisherId, platformURL, bidderURL } = bid.params;
       return (
         includes(Object.keys(bid.mediaTypes), BANNER) &&
         typeof publisherId === 'string' &&
         publisherId.length === 42 &&
         typeof platformURL === 'string' &&
-        platformURL.length >= 13
+        platformURL.length >= 13 &&
+        (!bidderURL || bidderURL.indexOf('https://') === 0)
       );
     } catch (error) {
       return false;
@@ -98,24 +149,51 @@ export const spec = {
   },
 
   buildRequests: (validBidRequests, bidderRequest) => {
+    const storage = getStorageManager({ bidderCode: ADHASH_BIDDER_CODE });
     const { gdprConsent } = bidderRequest;
-    const { url } = spec;
     const bidRequests = [];
-    let referrer = '';
-    if (bidderRequest && bidderRequest.refererInfo) {
-      // TODO: is 'page' the right value here?
-      referrer = bidderRequest.refererInfo.page;
-    }
-    for (var i = 0; i < validBidRequests.length; i++) {
-      var index = Math.floor(Math.random() * validBidRequests[i].sizes.length);
-      var size = validBidRequests[i].sizes[index].join('x');
+    const body = document.body;
+    const html = document.documentElement;
+    const pageHeight = Math.max(
+      body.scrollHeight,
+      body.offsetHeight,
+      html.clientHeight,
+      html.scrollHeight,
+      html.offsetHeight
+    );
+    const pageWidth = Math.max(body.scrollWidth, body.offsetWidth, html.clientWidth, html.scrollWidth, html.offsetWidth);
+
+    for (let i = 0; i < validBidRequests.length; i++) {
+      const bidderURL = validBidRequests[i].params.bidderURL || 'https://bidder.adhash.com';
+      const url = `${bidderURL}/rtb?version=${VERSION}&prebid=true`;
+      const index = Math.floor(Math.random() * validBidRequests[i].sizes.length);
+      const size = validBidRequests[i].sizes[index].join('x');
+
+      let recentAds = [];
+      if (storage.localStorageIsEnabled()) {
+        const prefix = validBidRequests[i].params.prefix || 'adHash';
+        recentAds = JSON.parse(storage.getDataFromLocalStorage(prefix + 'recentAds') || '[]');
+      }
+
+      // Needed for the ad density calculation
+      var adHeight = validBidRequests[i].sizes[index][1];
+      var adWidth = validBidRequests[i].sizes[index][0];
+      if (!window.adsCount) {
+        window.adsCount = 0;
+      }
+      if (!window.adsTotalSurface) {
+        window.adsTotalSurface = 0;
+      }
+      window.adsTotalSurface += adHeight * adWidth;
+      window.adsCount++;
+
       bidRequests.push({
         method: 'POST',
         url: url + '&publisher=' + validBidRequests[i].params.publisherId,
         bidRequest: validBidRequests[i],
         data: {
           timezone: new Date().getTimezoneOffset() / 60,
-          location: referrer,
+          location: bidderRequest.refererInfo ? bidderRequest.refererInfo.topmostLocation : '',
           publisherId: validBidRequests[i].params.publisherId,
           size: {
             screenWidth: window.screen.width,
@@ -131,10 +209,14 @@ export const spec = {
             position: validBidRequests[i].adUnitCode
           }],
           blockedCreatives: [],
-          currentTimestamp: new Date().getTime(),
-          recentAds: [],
+          currentTimestamp: (new Date().getTime() / 1000) | 0,
+          recentAds: recentAds,
           GDPRApplies: gdprConsent ? gdprConsent.gdprApplies : null,
-          GDPR: gdprConsent ? gdprConsent.consentString : null
+          GDPR: gdprConsent ? gdprConsent.consentString : null,
+          servedAdsCount: window.adsCount,
+          adsTotalSurface: window.adsTotalSurface,
+          pageHeight: pageHeight,
+          pageWidth: pageWidth
         },
         options: {
           withCredentials: false,
@@ -157,7 +239,11 @@ export const spec = {
     }
 
     const publisherURL = JSON.stringify(request.bidRequest.params.platformURL);
+    const bidderURL = request.bidRequest.params.bidderURL || 'https://bidder.adhash.com';
     const oneTimeId = request.bidRequest.adUnitCode + Math.random().toFixed(16).replace('0.', '.');
+    const globalScript = !request.bidRequest.params.globalScript
+      ? `<script src="${bidderURL}/static/scripts/creative.min.js"></script>`
+      : '';
     const bidderResponse = JSON.stringify({ responseText: JSON.stringify(responseBody) });
     const requestData = JSON.stringify(request.data);
 
@@ -165,8 +251,7 @@ export const spec = {
       requestId: request.bidRequest.bidId,
       cpm: responseBody.creatives[0].costEUR,
       ad:
-        `<div id="${oneTimeId}"></div>
-        <script src="https://bidder.adhash.com/static/scripts/creative.min.js"></script>
+        `<div id="${oneTimeId}"></div>${globalScript}
         <script>callAdvertiser(${bidderResponse},['${oneTimeId}'],${requestData},${publisherURL})</script>`,
       width: request.bidRequest.sizes[0][0],
       height: request.bidRequest.sizes[0][1],

package/modules/adhashBidAdapter.md

@@ -3,7 +3,7 @@
 ```
 Module Name: AdHash Bidder Adapter
 Module Type: Bidder Adapter
-Maintainer: damyan@adhash.org
+Maintainer: damyan@adhash.com
 ```
 
 # Description
@@ -14,8 +14,6 @@ Here is what you need for Prebid integration with AdHash:
 3. Use the Publisher ID and Platform URL as parameters in params.
 
 Please note that a number of AdHash functionalities are not supported in the Prebid.js integration:
-* Cookie-less frequency and recency capping;
-* Audience segments;
 * Price floors and passback tags, as they are not needed in the Prebid.js setup;
 * Reservation for direct deals only, as bids are evaluated based on their price.
 

package/modules/admaticBidAdapter.js

@@ -1,7 +1,7 @@
 import { getValue, logError, deepAccess, getBidIdParameter, isArray } from '../src/utils.js';
 import { registerBidder } from '../src/adapters/bidderFactory.js';
 import { BANNER, VIDEO } from '../src/mediaTypes.js';
-const SYNC_URL = 'https://cdn.serve.admatic.com.tr/showad/sync.html';
+let SYNC_URL = '';
 const BIDDER_CODE = 'admatic';
 export const spec = {
   code: BIDDER_CODE,
@@ -59,6 +59,15 @@ export const spec = {
     };
 
     if (payload) {
+      switch (bidderName) {
+        case 'pixad':
+          SYNC_URL = 'https://static.pixad.com.tr/sync.html';
+          break;
+        default:
+          SYNC_URL = 'https://cdn.serve.admatic.com.tr/showad/sync.html';
+          break;
+      }
+
       return { method: 'POST', url: `https://${host}/pb?bidder=${bidderName}`, data: payload, options: { contentType: 'application/json' } };
     }
   },

package/modules/admixerBidAdapter.js

@@ -5,7 +5,7 @@ import {BANNER, VIDEO, NATIVE} from '../src/mediaTypes.js';
 import { convertOrtbRequestToProprietaryNative } from '../src/native.js';
 
 const BIDDER_CODE = 'admixer';
-const ALIASES = ['go2net', 'adblender', 'adsyield', 'futureads'];
+const ALIASES = ['go2net', 'adblender', 'adsyield', 'futureads', 'smn'];
 const ENDPOINT_URL = 'https://inv-nets.admixer.net/prebid.1.2.aspx';
 export const spec = {
   code: BIDDER_CODE,