@highfivve/ad-tag 5.12.0 → 5.13.0

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/adService.js

@@ -5,6 +5,7 @@ import domready from '../util/domready';
 import { prebidClearAuction, prebidConfigure, prebidDefineSlots, prebidInit, prebidPrepareRequestAds, prebidRemoveAdUnits, prebidRenderAds, prebidRequestBids } from './prebid';
 import { a9Configure, a9Init, a9RequestBids, a9ClearTargetingStep, a9PublisherAudiences } from './a9';
 import { flatten, isNotNull } from '../util/arrayUtils';
+import { mkInfiniteSlot } from '../util/mkInfiniteSlot';
 import { executeDebugDelay, getDebugDelayFromLocalStorage } from '../util/debugDelay';
 import { createGlobalAuctionContext } from './globalAuctionContext';
 import { getDeviceLabel } from 'ad-tag/ads/labelConfigService';
@@ -137,6 +138,7 @@ export class AdService {
             this.logger.info('AdService', `RequestAds[${this.requestAdsCalls}]`, refreshSlots, refreshBuckets);
             this.eventService.emit('beforeRequestAds', { runtimeConfig: runtimeConfig });
             try {
+                const queuedInfiniteSlots = this.resolveInfiniteSlots(refreshInfiniteSlots, config);
                 const immediatelyLoadedSlots = config.slots
                     .map(slot => {
                     if (isManualSlot(slot)) {
@@ -145,9 +147,7 @@ export class AdService {
                             : null;
                     }
                     else if (isInfiniteSlot(slot)) {
-                        return refreshInfiniteSlots.some(infiniteSlot => infiniteSlot.artificialDomId === slot.domId)
-                            ? slot
-                            : null;
+                        return null;
                     }
                     else if (isBackfillSlot(slot)) {
                         return null;
@@ -157,6 +157,7 @@ export class AdService {
                     }
                 })
                     .filter(isNotNull)
+                    .concat(queuedInfiniteSlots)
                     .filter(isSlotAvailable(this.window));
                 if (config.buckets?.enabled) {
                     const buckets = new Map();
@@ -193,6 +194,16 @@ export class AdService {
                 return Promise.reject(e);
             }
         };
+        this.resolveInfiniteSlots = (infiniteSlots, config) => infiniteSlots
+            .map(({ idOfConfiguredSlot, artificialDomId }) => {
+            const configuredSlot = config.slots.find(slot => slot.domId === idOfConfiguredSlot && isInfiniteSlot(slot));
+            if (!configuredSlot) {
+                this.logger.error('AdService', `no ad slot with an 'infinite' loading behaviour configured for domId ${idOfConfiguredSlot}`);
+                return null;
+            }
+            return mkInfiniteSlot(configuredSlot, artificialDomId);
+        })
+            .filter(isNotNull);
         this.rewardedAd = () => {
             return this.globalAuctionContext.rewardedAd();
         };
@@ -208,6 +219,14 @@ export class AdService {
             this.adPipeline = new AdPipeline(adPipelineConfig, this.logger, window, this.globalAuctionContext);
         }
     }
+    refreshInfiniteAdSlots(infiniteSlots, config, runtimeConfig) {
+        if (infiniteSlots.length === 0) {
+            return Promise.resolve();
+        }
+        const availableSlots = this.resolveInfiniteSlots(infiniteSlots, config).filter(isSlotAvailable(this.window));
+        this.logger.debug('AdService', 'refresh infinite ad slots', availableSlots);
+        return this.adPipeline.run(availableSlots, config, runtimeConfig, this.requestAdsCalls);
+    }
     refreshAdSlots(domIds, config, runtimeConfig, options) {
         if (domIds.length === 0) {
             return Promise.resolve();

package/lib/ads/modules/custom/index.js

@@ -6,7 +6,7 @@ const hasConsent = (context, scriptConfig) => {
     }
     switch (scriptConfig.consent.cmpApi) {
         case 'tcf':
-            return (!context.tcData__.gdprApplies ||
+            return Boolean(!context.tcData__.gdprApplies ||
                 context.tcData__.vendor.consents[scriptConfig.consent.vendorId]);
     }
 };
@@ -32,15 +32,17 @@ export const customModule = () => {
                 .forEach(scriptConfig => {
                 try {
                     const script = context.window__.document.createElement('script');
-                    script.type = 'text/javascript';
-                    script.src = scriptConfig.src;
+                    if (scriptConfig.src) {
+                        script.type = 'text/javascript';
+                        script.src = scriptConfig.src;
+                    }
                     if (scriptConfig.attributes) {
                         Object.entries(scriptConfig.attributes).forEach(([key, value]) => {
                             script.setAttribute(key, value);
                         });
                     }
                     context.window__.document.head.appendChild(script);
-                    context.logger__?.info(name, `Injected script from URL: ${scriptConfig.src}`);
+                    context.logger__?.info(name, `Injected script from URL: ${scriptConfig.src ?? '(attribute-driven)'}`);
                 }
                 catch (e) {
                     context.logger__?.error(name, 'Failed to inject script from config', scriptConfig, e);

package/lib/ads/moli.js

@@ -1,6 +1,5 @@
 import { AssetLoadMethod, createAssetLoaderService } from '../util/assetLoaderService';
 import { getLogger } from '../util/logging';
-import { addNewInfiniteSlotToConfig } from '../util/addNewInfiniteSlotToConfig';
 import { AdService } from './adService';
 import { createEventService } from './eventService';
 import { getAbTestValues, getActiveEnvironmentOverride, setEnvironmentOverrideInStorage } from '../util/environmentOverride';
@@ -25,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';
@@ -231,16 +185,6 @@ export const createMoliTag = (window) => {
         }
         return Promise.resolve(null);
     }
-    function refreshQueuedInfiniteSlots(config, runtimeConfig) {
-        const { refreshInfiniteSlots } = runtimeConfig;
-        if (refreshInfiniteSlots.length === 0) {
-            return config;
-        }
-        const log = getLogger(runtimeConfig, window);
-        const configWithInfiniteSlots = refreshInfiniteSlots.reduce((currentConfig, slot) => addNewInfiniteSlotToConfig(currentConfig, slot.idOfConfiguredSlot, slot.artificialDomId, log), config);
-        adService.refreshAdSlots(refreshInfiniteSlots.map(slot => slot.artificialDomId), configWithInfiniteSlots, runtimeConfig);
-        return configWithInfiniteSlots;
-    }
     function requestAds() {
         switch (state.state) {
             case 'configurable': {
@@ -296,13 +240,7 @@ export const createMoliTag = (window) => {
                         getLogger(state.runtimeConfig, window).error('MoliGlobal', `failed to configure ${module.moduleType} module ${module.name}`, e);
                     }
                 });
-                const { refreshInfiniteSlots } = state.runtimeConfig;
-                let config = state.config;
-                if (refreshInfiniteSlots.length > 0) {
-                    refreshInfiniteSlots.forEach(slot => {
-                        config = addNewInfiniteSlotToConfig(config, slot.idOfConfiguredSlot, slot.artificialDomId, getLogger(state.runtimeConfig, window));
-                    });
-                }
+                const config = state.config;
                 const log = getLogger(state.runtimeConfig, window);
                 if (state.runtimeConfig.hooks && state.runtimeConfig.hooks.beforeRequestAds) {
                     state.runtimeConfig.hooks.beforeRequestAds.forEach(hook => {
@@ -334,8 +272,8 @@ export const createMoliTag = (window) => {
                         const validateLocation = config.spa?.validateLocation ?? 'href';
                         if (state.state === 'spa-requestAds' &&
                             allowRefreshAdSlot(validateLocation, state.href, window.location)) {
-                            const { runtimeConfig } = state;
-                            const config = refreshQueuedInfiniteSlots(state.config, runtimeConfig);
+                            const { runtimeConfig, config } = state;
+                            adService.refreshInfiniteAdSlots(runtimeConfig.refreshInfiniteSlots, config, runtimeConfig);
                             if (state.runtimeConfig.refreshSlots.length > 0) {
                                 adService.refreshAdSlots(runtimeConfig.refreshSlots, config, runtimeConfig);
                             }
@@ -446,7 +384,8 @@ export const createMoliTag = (window) => {
                 })
                     .then(requestedConfig => {
                     const runtimeConfig = state.runtimeConfig;
-                    const config = refreshQueuedInfiniteSlots(requestedConfig, runtimeConfig);
+                    const config = requestedConfig;
+                    adService.refreshInfiniteAdSlots(runtimeConfig.refreshInfiniteSlots, config, runtimeConfig);
                     if (state.runtimeConfig.refreshSlots.length > 0) {
                         adService.refreshAdSlots(state.runtimeConfig.refreshSlots, config, state.runtimeConfig);
                     }
@@ -535,16 +474,12 @@ export const createMoliTag = (window) => {
             case 'spa-finished':
                 const validateLocation = state.config.spa?.validateLocation ?? 'href';
                 if (allowRefreshAdSlot(validateLocation, state.href, window.location)) {
-                    state = {
-                        ...state,
-                        config: addNewInfiniteSlotToConfig(state.config, idOfConfiguredSlot, domId, getLogger(state.runtimeConfig, window))
-                    };
                     return adService
-                        .refreshAdSlots([domId], state.config, state.runtimeConfig)
+                        .refreshInfiniteAdSlots([{ artificialDomId: domId, idOfConfiguredSlot: idOfConfiguredSlot }], state.config, state.runtimeConfig)
                         .then(() => 'refreshed');
                 }
                 else {
-                    state.runtimeConfig.refreshInfiniteSlots.push({
+                    state.nextRuntimeConfig.refreshInfiniteSlots.push({
                         artificialDomId: domId,
                         idOfConfiguredSlot: idOfConfiguredSlot
                     });
@@ -552,12 +487,8 @@ export const createMoliTag = (window) => {
                 }
             case 'finished':
             case 'requestAds': {
-                state = {
-                    ...state,
-                    config: addNewInfiniteSlotToConfig(state.config, idOfConfiguredSlot, domId, getLogger(state.runtimeConfig, window))
-                };
                 return adService
-                    .refreshAdSlots([domId], state.config, state.runtimeConfig)
+                    .refreshInfiniteAdSlots([{ artificialDomId: domId, idOfConfiguredSlot: idOfConfiguredSlot }], state.config, state.runtimeConfig)
                     .then(() => 'refreshed');
             }
             default: {
@@ -664,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;
             }
         }
@@ -751,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.0'
+    version: '5.13.0'
 };

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/lib/util/mkInfiniteSlot.js

@@ -0,0 +1,4 @@
+export const mkInfiniteSlot = (configuredSlot, artificialDomId) => ({
+    ...configuredSlot,
+    domId: artificialDomId
+});

package/package.json

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

package/lib/util/addNewInfiniteSlotToConfig.js

@@ -1,11 +0,0 @@
-export const addNewInfiniteSlotToConfig = (config, idOfConfiguredSlot, artificialIdOfNewSlot, logger) => {
-    const configuredInfiniteAdSlot = config.slots.find(configSlot => configSlot.domId === idOfConfiguredSlot);
-    if (configuredInfiniteAdSlot) {
-        const newAdSlot = { ...configuredInfiniteAdSlot, domId: artificialIdOfNewSlot };
-        return { ...config, slots: [...config.slots, newAdSlot] };
-    }
-    else {
-        logger.error('MoliGlobal', `no infinite ad slot configured!`, config);
-        return config;
-    }
-};