@highfivve/ad-tag 5.12.1 → 5.13.1

package/lib/ads/adPipeline.js

@@ -6,6 +6,7 @@ import { generateAdUnitPathVariables } from './adUnitPath';
 import { createAssetLoaderService } from '../util/assetLoaderService';
 import { uuidV4 } from '../util/uuid';
 import { getMoliLabelsFromQueryParam, getMoliLabelsFromStorage } from '../util/debugLabels';
+import { adVolumeToLabels } from '../util/adVolume';
 export const HIGH_PRIORITY = 100;
 export const LOW_PRIORITY = 10;
 export const mkInitStep = (name, fn) => {
@@ -86,6 +87,7 @@ export class AdPipeline {
         return this.tcData.then(consentData => {
             const extraLabels = [
                 ...(config.targeting?.labels || []),
+                ...adVolumeToLabels(runtimeConfig.adVolume ?? config.targeting?.adVolume),
                 ...runtimeConfig.labels,
                 ...getMoliLabelsFromQueryParam(this.window),
                 ...getMoliLabelsFromStorage(this.window)

package/lib/ads/googleAdManager.js

@@ -5,6 +5,7 @@ import { AssetLoadMethod } from '../util/assetLoaderService';
 import { tcfapi } from '../types/tcfapi';
 import { createTestSlots } from '../util/test-slots';
 import { resolveAdUnitPath } from './adUnitPath';
+import { findGoogletagSlot } from './findGoogletagSlot';
 import { formatKey, CUSTOM_INTERSTITIAL_FORMAT, CUSTOM_ANCHOR_BOTTOM_FORMAT, CUSTOM_ANCHOR_TOP_FORMAT } from './keyValues';
 const testAdSlot = (domId, adUnitPath) => ({
     setCollapseEmptyDiv() {
@@ -124,17 +125,23 @@ export const gptDestroyAdSlots = () => {
                 }
                 return Promise.resolve();
             case 'requested':
-                const allGptSlots = context.window__.googletag.pubads().getSlots();
                 const gptSlots = slots
-                    .map(slot => allGptSlots.find(s => s.getSlotElementId() === slot.domId))
+                    .map(slot => findGoogletagSlot({
+                    domId: slot.domId,
+                    adUnitPath: resolveAdUnitPath(slot.adUnitPath, context.adUnitPathVariables__)
+                }, context.window__.googletag))
                     .filter(isNotNull);
                 return destroySelectedSlots(gptSlots);
             case 'excluded':
                 if (isNextRequestAdsCall) {
+                    const excludedAdUnitPaths = context.config__.slots
+                        .filter(moliSlot => cleanup.slotIds.includes(moliSlot.domId))
+                        .map(moliSlot => resolveAdUnitPath(moliSlot.adUnitPath, context.adUnitPathVariables__));
                     const destroyableSlots = context.window__.googletag
                         .pubads()
                         .getSlots()
-                        .filter(slot => !cleanup.slotIds.includes(slot.getSlotElementId()));
+                        .filter(slot => !cleanup.slotIds.includes(slot.getSlotElementId()) &&
+                        !excludedAdUnitPaths.includes(slot.getAdUnitPath()));
                     return destroySelectedSlots(destroyableSlots);
                 }
                 return Promise.resolve();

package/lib/ads/moli.js

@@ -24,58 +24,13 @@ export const createMoliTag = (window) => {
         modules: []
     };
     function setTargeting(key, value) {
-        switch (state.state) {
-            case 'configurable':
-            case 'configured': {
-                state.runtimeConfig.keyValues[key] = value;
-                break;
-            }
-            case 'spa-finished':
-            case 'spa-requestAds': {
-                state.nextRuntimeConfig.keyValues[key] = value;
-                break;
-            }
-            default: {
-                getLogger(state.runtimeConfig, window).error('MoliGlobal', `Setting key-value after configuration: ${key} : ${value}`);
-                break;
-            }
-        }
+        setConfig({ targeting: { [key]: value } });
     }
     function addLabel(label) {
-        switch (state.state) {
-            case 'configurable':
-            case 'configured': {
-                state.runtimeConfig.labels.push(label);
-                break;
-            }
-            case 'spa-requestAds':
-            case 'spa-finished': {
-                state.nextRuntimeConfig.labels.push(label);
-                break;
-            }
-            default: {
-                getLogger(state.runtimeConfig, window).error('MoliGlobal', `Adding label after configure: ${label}`);
-                break;
-            }
-        }
+        setConfig({ labels: [label] });
     }
     function setAdUnitPathVariables(variables) {
-        switch (state.state) {
-            case 'configurable':
-            case 'configured': {
-                state.runtimeConfig.adUnitPathVariables = variables;
-                break;
-            }
-            case 'spa-requestAds':
-            case 'spa-finished': {
-                state.nextRuntimeConfig.adUnitPathVariables = variables;
-                break;
-            }
-            default: {
-                getLogger(state.runtimeConfig, window).error('MoliGlobal', `Setting unit path variables after configuration: ${variables}`);
-                break;
-            }
-        }
+        setConfig({ adUnitPathVariables: variables });
     }
     function getAdUnitPathVariables() {
         const domain = extractTopPrivateDomainFromHostname(window.location.hostname) || 'unknown';
@@ -640,37 +595,73 @@ export const createMoliTag = (window) => {
     function setABtestTargeting() {
         const abTestValues = getAbTestValues(window, QueryParameters.abTest, BrowserStorageKeys.abTest);
         const abTestValue = abTestValues.length > 0 ? Number(abTestValues[0].value) : Math.floor(Math.random() * 100) + 1;
-        setTargeting(QueryParameters.abTest, abTestValue.toString());
+        setConfig({ targeting: { [QueryParameters.abTest]: abTestValue.toString() } });
     }
     function addDomainLabel(domainFromConfig) {
         const domain = domainFromConfig || extractTopPrivateDomainFromHostname(window.location.hostname);
         if (domain) {
-            addLabel(domain);
+            setConfig({ labels: [domain] });
         }
     }
     function addGeoLabels(geoFromConfig) {
         const { country, continent } = geoFromConfig ?? detectGeoFromBrowser();
-        if (country) {
-            addLabel(country);
-        }
-        if (continent) {
-            addLabel(continent);
+        const labels = [country, continent].filter((label) => !!label);
+        if (labels.length > 0) {
+            setConfig({ labels });
         }
     }
     function setAudience(audience) {
+        setConfig({ audience: audience });
+    }
+    function validateConfigOverrides(partial) {
+        const validated = {
+            labels: partial.labels,
+            targeting: partial.targeting,
+            audience: partial.audience,
+            adUnitPathVariables: partial.adUnitPathVariables
+        };
+        if (partial.adVolume !== undefined) {
+            if (Number.isInteger(partial.adVolume) && partial.adVolume >= 1 && partial.adVolume <= 10) {
+                validated.adVolume = partial.adVolume;
+            }
+            else {
+                getLogger(state.runtimeConfig, window).warn('MoliGlobal', `Ignoring invalid adVolume in setConfig(): ${partial.adVolume}. Must be an integer between 1 and 10.`);
+            }
+        }
+        return validated;
+    }
+    function applyConfigOverrides(target, validated) {
+        if (validated.adVolume !== undefined) {
+            target.adVolume = validated.adVolume;
+        }
+        if (validated.labels !== undefined) {
+            target.labels.push(...validated.labels);
+        }
+        if (validated.targeting !== undefined) {
+            Object.assign(target.keyValues, validated.targeting);
+        }
+        if (validated.audience !== undefined) {
+            target.audience = validated.audience;
+        }
+        if (validated.adUnitPathVariables !== undefined) {
+            target.adUnitPathVariables = validated.adUnitPathVariables;
+        }
+    }
+    function setConfig(partial) {
+        const validated = validateConfigOverrides(partial);
         switch (state.state) {
             case 'configurable':
             case 'configured': {
-                state.runtimeConfig.audience = audience;
+                applyConfigOverrides(state.runtimeConfig, validated);
                 break;
             }
             case 'spa-finished':
             case 'spa-requestAds': {
-                state.nextRuntimeConfig.audience = audience;
+                applyConfigOverrides(state.nextRuntimeConfig, validated);
                 break;
             }
             default: {
-                getLogger(state.runtimeConfig, window).error('MoliGlobal', `Setting audience targeting after configuration: ${JSON.stringify(audience)}`);
+                getLogger(state.runtimeConfig, window).error('MoliGlobal', `Setting config after configuration: ${JSON.stringify(partial)}`);
                 break;
             }
         }
@@ -727,6 +718,7 @@ export const createMoliTag = (window) => {
         getState: getState,
         openConsole: openConsole,
         setAudience: setAudience,
+        setConfig: setConfig,
         addEventListener: eventService.addEventListener,
         removeEventListener: eventService.removeEventListener
     };

package/lib/bundle/configureFromEndpoint.js

@@ -13,9 +13,14 @@ if (currentScript) {
         .filter(l => l.length > 0);
     if (labels.length > 0) {
         window.moli.que.push(moli => {
-            moli.beforeRequestAds(() => labels.forEach(label => moli.addLabel(label)));
+            moli.beforeRequestAds(() => moli.setConfig({ labels }));
         });
     }
+    const adVolumeAttr = currentScript.getAttribute('data-ad-volume');
+    if (adVolumeAttr !== null) {
+        const adVolume = parseInt(adVolumeAttr, 10);
+        window.moli.que.push(moli => moli.setConfig({ adVolume }));
+    }
     window.moli.configLabel = version;
     const endpoint = currentScript.getAttribute('data-endpoint') ?? 'api.h5v.eu/publishers';
     const fallback = currentScript.getAttribute('data-endpoint-fallback') ?? 'cdn.h5v.eu/publishers';

package/lib/gen/packageJson.js

@@ -1,3 +1,3 @@
 export const packageJson = {
-    version: '5.12.1'
+    version: '5.13.1'
 };

package/lib/util/adVolume.js

@@ -0,0 +1,6 @@
+export const adVolumeToLabels = (adVolume) => {
+    if (adVolume === undefined) {
+        return [];
+    }
+    return Array.from({ length: adVolume }, (_, index) => `av${index + 1}`);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@highfivve/ad-tag",
-  "version": "5.12.1",
+  "version": "5.13.1",
   "license": "Apache-2.0",
   "description": "An ad tag implementation called moli",
   "main": "./lib/index.js",