@highfivve/ad-tag 5.12.0 → 5.12.1

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';
@@ -231,16 +230,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 +285,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 +317,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 +429,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 +519,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 +532,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: {

package/lib/gen/packageJson.js

@@ -1,3 +1,3 @@
 export const packageJson = {
-    version: '5.12.0'
+    version: '5.12.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.12.1",
   "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;
-    }
-};