@highfivve/ad-tag 5.11.10 → 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/modules/inline-ai/index.js

@@ -0,0 +1,114 @@
+import { AssetLoadMethod } from 'ad-tag/util/assetLoaderService';
+import { mkConfigureStepOncePerRequestAdsCycle, mkInitStep } from 'ad-tag/ads/adPipeline';
+const name = 'inline-ai';
+export const createInlineAi = () => {
+    let inlineAiConfig = null;
+    let scriptLoaded = false;
+    const config__ = () => inlineAiConfig;
+    const configure__ = (moduleConfig) => {
+        if (moduleConfig?.inlineAi?.enabled) {
+            inlineAiConfig = moduleConfig.inlineAi;
+        }
+    };
+    const hasConsent = (context) => !context.tcData__.gdprApplies || !!context.tcData__.purpose.consents['1'];
+    const isPlacementActive = (context, placement) => !placement.labelCondition ||
+        context.labelConfigService__.isLabelConditionMet(placement.labelCondition);
+    const mountCommand = (placement) => {
+        switch (placement.type) {
+            case 'widget':
+                return ['mount', placement.type];
+            case 'search-fab':
+                return placement.options
+                    ? ['mount', placement.type, undefined, placement.options]
+                    : ['mount', placement.type];
+            case 'search-embed':
+            case 'search-icon':
+                return placement.options
+                    ? ['mount', placement.type, placement.target, placement.options]
+                    : ['mount', placement.type, placement.target];
+            case 'key-takeaways':
+            case 'single-question':
+            case 'basic-embed':
+                return ['mount', placement.type, placement.target];
+        }
+    };
+    const mountPlacements = (context, cmd, config) => {
+        (config.placements ?? [])
+            .filter(placement => isPlacementActive(context, placement))
+            .forEach(placement => cmd.push(mountCommand(placement)));
+    };
+    const applyMode = (context, cmd, config) => {
+        switch (config.mode) {
+            case 'auto':
+                return;
+            case 'programmatic':
+                cmd.push(['init', { publisherId: config.publisherId }]);
+                mountPlacements(context, cmd, config);
+                return;
+            case 'hybrid':
+                mountPlacements(context, cmd, config);
+                return;
+        }
+    };
+    const loadScript = (context, config) => {
+        if (scriptLoaded) {
+            return;
+        }
+        scriptLoaded = true;
+        context.assetLoaderService__
+            .loadScript({
+            name,
+            loadMethod: AssetLoadMethod.TAG,
+            assetUrl: `${config.scriptUrl}?key=${config.publisherId}`,
+            type: 'module'
+        })
+            .catch(error => context.logger__.error(name, 'failed to load InlineAI script', error));
+    };
+    const isFirstRun = (context) => context.requestAdsCalls__ === 1;
+    const runInlineAi = (context, config) => {
+        if (context.env__ === 'test') {
+            return Promise.resolve();
+        }
+        if (!hasConsent(context)) {
+            context.logger__.warn(name, 'no gdpr consent, InlineAI will not be loaded');
+            return Promise.resolve();
+        }
+        if (config.mode !== 'auto') {
+            context.window__.InlineAI = context.window__.InlineAI || { cmd: [] };
+            const cmd = context.window__.InlineAI.cmd;
+            if (!isFirstRun(context)) {
+                cmd.push(['destroy']);
+            }
+            applyMode(context, cmd, config);
+        }
+        loadScript(context, config);
+        return Promise.resolve();
+    };
+    const initSteps__ = () => {
+        const config = inlineAiConfig;
+        return config
+            ? [
+                mkInitStep('inline-ai-init', context => context.config__.spa?.enabled ? Promise.resolve() : runInlineAi(context, config))
+            ]
+            : [];
+    };
+    const configureSteps__ = () => {
+        const config = inlineAiConfig;
+        return config
+            ? [
+                mkConfigureStepOncePerRequestAdsCycle('inline-ai-configure', context => context.config__.spa?.enabled ? runInlineAi(context, config) : Promise.resolve())
+            ]
+            : [];
+    };
+    return {
+        name,
+        configKey: 'inlineAi',
+        description: 'loads the InlineAI SDK and drives placement rendering',
+        moduleType: 'engagement',
+        config__,
+        configure__,
+        initSteps__,
+        configureSteps__,
+        prepareRequestAdsSteps__: () => []
+    };
+};

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/bundle/inline-ai.js

@@ -0,0 +1,2 @@
+import { createInlineAi } from '../ads/modules/inline-ai';
+window.moli.registerModule(createInlineAi());

package/lib/console/components/moduleConfigs.js

@@ -323,6 +323,15 @@ const MoliAnalyticsModule = ({ config }) => (React.createElement(React.Fragment,
             "ms"))));
 const StylesModule = ({ config }) => (React.createElement(Row, { label: "Stylesheet" },
     React.createElement(Tag, null, config.href)));
+const InlineAiModule = ({ config }) => (React.createElement(React.Fragment, null,
+    React.createElement(Row, { label: "Publisher ID" },
+        React.createElement(Tag, null, config.publisherId)),
+    React.createElement(Row, { label: "Mode" },
+        React.createElement(Tag, null, config.mode)),
+    React.createElement(Row, { label: "Script URL" },
+        React.createElement(Tag, { variant: "grey" }, config.scriptUrl)),
+    React.createElement(Row, { label: "Placements" },
+        React.createElement(ListTags, { values: config.placements?.map(placement => placement.name) }))));
 const GenericModule = ({ config, subEntry }) => (React.createElement(React.Fragment, null, Object.entries(config)
     .filter(([key]) => key !== 'enabled')
     .map(([key, value]) => (React.createElement(TagContainer, { key: key, subEntry: subEntry },
@@ -338,6 +347,7 @@ const moduleComponents = {
     emetriq: EmetriqModule,
     geoedge: GeoEdgeModule,
     identitylink: IdentityLinkModule,
+    inlineAi: InlineAiModule,
     pubstack: PubstackModule,
     skin: SkinModule,
     styles: StylesModule,

package/lib/gen/packageJson.js

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