@highfivve/ad-tag 5.8.17 → 5.8.21

package/lib/ads/modules/moli-analytics/index.js

@@ -0,0 +1,161 @@
+import { mkInitStep } from 'ad-tag/ads/adPipeline';
+import { uuidV4 } from 'ad-tag/util/uuid';
+import { createSession } from 'ad-tag/ads/modules/moli-analytics/session';
+import { createEventTracker } from 'ad-tag/ads/modules/moli-analytics/eventTracker';
+import { eventMapper } from 'ad-tag/ads/modules/moli-analytics/events';
+import { extractPubstackAbTestCohort } from '../pubstack/abTest';
+const SESSION_TTL_MIN = 30;
+export const DEFAULT_CONFIG = {
+    batchSize: 4,
+    batchDelay: 1000
+};
+export const MoliAnalytics = () => {
+    let config;
+    let eventContext;
+    let eventTracker;
+    let adUnitsMap = new Map();
+    const generatePageViewId = (adPipelineContext) => `pv-${uuidV4(adPipelineContext.window__)}`;
+    const handleAuctionEnd = (event, adPipelineContext) => {
+        const auctionEnd = eventMapper.prebid.auctionEnd(event, eventContext, adPipelineContext);
+        for (const adUnit of auctionEnd.data.adUnits) {
+            adUnitsMap.set(adUnit.code, {
+                auctionId: auctionEnd.data.auctionId,
+                adUnitName: adUnit.adUnitName,
+                gpid: adUnit.gpid
+            });
+        }
+        eventTracker.track(auctionEnd);
+    };
+    const handleBidWon = (event, adPipelineContext) => {
+        const adUnitData = adUnitsMap.get(event.adUnitCode);
+        eventTracker.track(eventMapper.prebid.bidWon(event, {
+            ...eventContext,
+            gpid: adUnitData?.gpid || ''
+        }, adPipelineContext));
+    };
+    const handleSlotRenderEnded = (event, adPipelineContext) => {
+        const adUnitCode = event.slot.getSlotElementId();
+        const adUnitData = adUnitsMap.get(adUnitCode);
+        eventTracker.track(eventMapper.gpt.slotRenderEnded(event, {
+            ...eventContext,
+            auctionId: adUnitData?.auctionId || '',
+            adUnitName: adUnitData?.adUnitName || adUnitCode,
+            gpid: adUnitData?.gpid || ''
+        }, adPipelineContext));
+    };
+    const handlePageView = (adPipelineContext) => {
+        eventContext.pageViewId = generatePageViewId(adPipelineContext);
+        eventTracker.track(eventMapper.page.view(eventContext, adPipelineContext));
+    };
+    const configValid = (config, logger) => {
+        if (!config) {
+            logger.error('moli-analytics: not configured');
+            return false;
+        }
+        if (!config.publisher) {
+            logger.error('moli-analytics: publisher is required');
+            return false;
+        }
+        if (!config.url) {
+            logger.error('moli-analytics: url is required');
+            return false;
+        }
+        if (!config.batchSize || config.batchSize < 1) {
+            logger.error('moli-analytics: batchSize must be greater than 0');
+            return false;
+        }
+        if (!config.batchDelay || config.batchDelay < 1) {
+            logger.error('moli-analytics: batchDelay must be greater than 0');
+            return false;
+        }
+        return true;
+    };
+    const initMoliAnalytics = async (adPipelineContext) => {
+        if (!configValid(config, adPipelineContext.logger__)) {
+            return Promise.reject('failed to initialize moli analytics: invalid configuration');
+        }
+        eventContext = {
+            publisher: config.publisher,
+            session: createSession(adPipelineContext.window__, SESSION_TTL_MIN),
+            pageViewId: generatePageViewId(adPipelineContext),
+            analyticsLabels: null
+        };
+        eventTracker = createEventTracker(config.url, config.batchSize, config.batchDelay, adPipelineContext.logger__);
+        if (adPipelineContext.config__.configVersion?.identifier ||
+            adPipelineContext.config__.configVersion?.versionVariant) {
+            eventContext.analyticsLabels = {
+                ab_test: adPipelineContext.config__.configVersion?.identifier || null,
+                variant: adPipelineContext.config__.configVersion?.versionVariant || null
+            };
+        }
+        if (adPipelineContext.config__.spa?.enabled) {
+            adPipelineContext.window__.moli.addEventListener('afterRequestAds', event => {
+                if (event.state === 'spa-finished' || event.state === 'finished') {
+                    handlePageView(adPipelineContext);
+                }
+            });
+        }
+        const setupPrebid = async () => {
+            if (typeof adPipelineContext.window__.pbjs.getUserIdsAsync === 'function') {
+                await adPipelineContext.window__.pbjs.getUserIdsAsync();
+            }
+            handlePageView(adPipelineContext);
+            adPipelineContext.window__.pbjs.onEvent('auctionEnd', (event) => handleAuctionEnd(event, adPipelineContext));
+            adPipelineContext.window__.pbjs.onEvent('bidWon', (event) => handleBidWon(event, adPipelineContext));
+        };
+        if (typeof adPipelineContext.window__.pbjs.onEvent === 'function') {
+            await setupPrebid();
+        }
+        else {
+            adPipelineContext.window__.pbjs.que.push(setupPrebid);
+        }
+        const setupGPT = () => {
+            adPipelineContext.window__.googletag
+                .pubads()
+                .addEventListener('slotRenderEnded', (event) => handleSlotRenderEnded(event, adPipelineContext));
+        };
+        if (typeof adPipelineContext.window__.googletag.pubads === 'function') {
+            setupGPT();
+        }
+        else {
+            adPipelineContext.window__.googletag.cmd.push(setupGPT);
+        }
+        return Promise.resolve();
+    };
+    const setAnalyticsLabels = (ctx) => {
+        const pubstackAbTestCohort = extractPubstackAbTestCohort(ctx);
+        const moliConfigVariant = ctx.config__.configVersion?.versionVariant;
+        ctx.window__.pbjs.que.push(() => ctx.window__.pbjs.mergeConfig({
+            analyticsLabels: {
+                pubstackAbCohort: pubstackAbTestCohort,
+                configVariant: moliConfigVariant
+            }
+        }));
+        return Promise.resolve();
+    };
+    return {
+        name: 'moli-analytics',
+        description: 'ad events tracking and analytics module',
+        moduleType: 'reporting',
+        config__() {
+            return config;
+        },
+        configure__(moduleConfig) {
+            if (moduleConfig?.moliAnalytics?.enabled) {
+                config = { ...DEFAULT_CONFIG, ...moduleConfig.moliAnalytics };
+            }
+        },
+        configureSteps__() {
+            return [];
+        },
+        initSteps__() {
+            return [
+                mkInitStep('moli-analytics-init', (context) => initMoliAnalytics(context)),
+                mkInitStep('set-analytics-labels', (context) => setAnalyticsLabels(context))
+            ];
+        },
+        prepareRequestAdsSteps__() {
+            return [];
+        }
+    };
+};

package/lib/ads/modules/moli-analytics/session.js

@@ -0,0 +1,60 @@
+import { UserActivityService } from 'ad-tag/ads/modules/ad-reload/userActivityService';
+import { BrowserStorageKeys } from 'ad-tag/util/browserStorageKeys';
+import { uuidV4 } from 'ad-tag/util/uuid';
+export const createSession = (window, ttl) => {
+    const userActivityService = new UserActivityService(window, {
+        level: 'strict'
+    });
+    const ttlMs = ttl * 60000;
+    const loadJSON = (k, d = null) => {
+        try {
+            return JSON.parse(window.localStorage.getItem(k) || '') ?? d;
+        }
+        catch {
+            return d;
+        }
+    };
+    const saveJSON = (k, v) => window.localStorage.setItem(k, JSON.stringify(v));
+    const getSession = () => {
+        const now = Date.now();
+        let session = loadJSON(BrowserStorageKeys.molyAnalyticsSession);
+        if (!session || !session.id || !session.createdAt || !session.lastActivityAt) {
+            session = createSession();
+        }
+        else {
+            const idleMs = now - session.lastActivityAt;
+            const isIdle = idleMs > ttlMs;
+            if (isIdle) {
+                session = createSession();
+            }
+        }
+        return session;
+    };
+    const createSession = () => {
+        const now = Date.now();
+        const session = {
+            id: `sess-${uuidV4(window)}`,
+            createdAt: now,
+            lastActivityAt: now
+        };
+        saveJSON(BrowserStorageKeys.molyAnalyticsSession, session);
+        return session;
+    };
+    const touchSession = () => {
+        const session = getSession();
+        session.lastActivityAt = Date.now();
+        saveJSON(BrowserStorageKeys.molyAnalyticsSession, session);
+    };
+    const getId = () => {
+        return getSession().id;
+    };
+    userActivityService.addUserActivityChangedListener((isActive) => {
+        if (isActive) {
+            touchSession();
+        }
+    });
+    getSession();
+    return {
+        getId
+    };
+};

package/lib/ads/modules/moli-analytics/types.js

@@ -0,0 +1 @@
+export {};

package/lib/ads/modules/prebid-first-party-data/index.js

@@ -2,35 +2,21 @@ import { mkConfigureStep } from 'ad-tag/ads/adPipeline';
 import { uniquePrimitiveFilter } from 'ad-tag/util/arrayUtils';
 import { mergeDeep } from 'ad-tag/util/objectUtils';
 import { extractTopPrivateDomainFromHostname } from 'ad-tag/util/extractTopPrivateDomainFromHostname';
-export class PrebidFirstPartyDataModule {
-    constructor() {
-        this.description = 'Module for passing first party data to prebid auctions';
-        this.moduleType = 'prebid';
-        this.name = 'prebid-first-party-data';
-        this.moduleConfig = null;
-        this._configureSteps = [];
-    }
-    config__() {
-        return this.moduleConfig;
-    }
-    configure__(moduleConfig) {
-        if (moduleConfig?.prebidFirstPartyData?.enabled) {
-            const config = moduleConfig.prebidFirstPartyData;
-            this._configureSteps = [
-                mkConfigureStep('prebid-fpd-module-configure', context => PrebidFirstPartyDataModule.setPrebidFpdConfig(context, config, context.logger__))
-            ];
+export const createPrebidFirstPartyDataModule = () => {
+    const name = 'prebid-first-party-data';
+    let moduleConfig = null;
+    let configureStepsArr = [];
+    const config__ = () => moduleConfig;
+    const extractKeyValueArray = (key, keyValues) => {
+        const value = keyValues[key];
+        if (value) {
+            return typeof value === 'string' ? [value] : value;
+        }
+        else {
+            return [];
         }
-    }
-    initSteps__() {
-        return [];
-    }
-    configureSteps__() {
-        return this._configureSteps;
-    }
-    prepareRequestAdsSteps__() {
-        return [];
-    }
-    static setPrebidFpdConfig(context, config, log) {
+    };
+    const setPrebidFpdConfig = (context, config, log) => {
         if (context.config__.prebid) {
             const keyValues = context.config__.targeting?.keyValues || {};
             const gptTargeting = config.gptTargetingMappings;
@@ -45,16 +31,16 @@ export class PrebidFirstPartyDataModule {
                         ...ortb2FromKeyValues.site
                     };
                     if (gptTargeting.cat) {
-                        const keyValueData = PrebidFirstPartyDataModule.extractKeyValueArray(gptTargeting.cat, keyValues);
+                        const keyValueData = extractKeyValueArray(gptTargeting.cat, keyValues);
                         site.cat?.push(...keyValueData);
                         site.pagecat?.push(...keyValueData);
                         site.sectioncat?.push(...keyValueData);
                     }
                     if (gptTargeting.sectionCat) {
-                        site.sectioncat = PrebidFirstPartyDataModule.extractKeyValueArray(gptTargeting.sectionCat, keyValues);
+                        site.sectioncat = extractKeyValueArray(gptTargeting.sectionCat, keyValues);
                     }
                     if (gptTargeting.pageCat) {
-                        site.pagecat = PrebidFirstPartyDataModule.extractKeyValueArray(gptTargeting.pageCat, keyValues);
+                        site.pagecat = extractKeyValueArray(gptTargeting.pageCat, keyValues);
                     }
                     if (site.cat) {
                         site.cat = site.cat.filter(uniquePrimitiveFilter);
@@ -75,7 +61,7 @@ export class PrebidFirstPartyDataModule {
                         data: site.content?.data?.filter(data => data.name !== provider) ?? []
                     };
                     if (gptTargeting.iabV2 && provider) {
-                        const iabV2Ids = PrebidFirstPartyDataModule.extractKeyValueArray(gptTargeting.iabV2, keyValues);
+                        const iabV2Ids = extractKeyValueArray(gptTargeting.iabV2, keyValues);
                         const publisherContentData = {
                             name: provider,
                             ext: {
@@ -86,7 +72,7 @@ export class PrebidFirstPartyDataModule {
                         site.content.data?.push(publisherContentData);
                     }
                     if (gptTargeting.iabV3 && provider) {
-                        const iabV3Ids = PrebidFirstPartyDataModule.extractKeyValueArray(gptTargeting.iabV3, keyValues);
+                        const iabV3Ids = extractKeyValueArray(gptTargeting.iabV3, keyValues);
                         const publisherContentData = {
                             name: provider,
                             ext: {
@@ -102,14 +88,26 @@ export class PrebidFirstPartyDataModule {
             });
         }
         return Promise.resolve();
-    }
-    static extractKeyValueArray(key, keyValues) {
-        const value = keyValues[key];
-        if (value) {
-            return typeof value === 'string' ? [value] : value;
-        }
-        else {
-            return [];
+    };
+    const configure__ = (mConfig) => {
+        if (mConfig?.prebidFirstPartyData?.enabled) {
+            const config = mConfig.prebidFirstPartyData;
+            configureStepsArr = [
+                mkConfigureStep('prebid-fpd-module-configure', context => setPrebidFpdConfig(context, config, context.logger__))
+            ];
         }
-    }
-}
+    };
+    const initSteps__ = () => [];
+    const configureSteps__ = () => configureStepsArr;
+    const prepareRequestAdsSteps__ = () => [];
+    return {
+        name,
+        description: 'Module for passing first party data to prebid auctions',
+        moduleType: 'prebid',
+        config__,
+        configure__,
+        initSteps__,
+        configureSteps__,
+        prepareRequestAdsSteps__
+    };
+};

package/lib/ads/modules/pubstack/abTest.js

@@ -0,0 +1,11 @@
+export const extractPubstackAbTestCohort = (ctx) => {
+    const pubstackABTestValues = ['0', '1', '2', '3'];
+    if (ctx.env__ === 'test') {
+        return null;
+    }
+    const meta = ctx.window__.document.head.querySelector('meta[name="pbstck_context:pbstck_ab_test"]');
+    if (meta && meta.content && pubstackABTestValues.includes(meta.content)) {
+        return meta.content;
+    }
+    return null;
+};

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

@@ -1,22 +1,17 @@
 import { AssetLoadMethod } from 'ad-tag/util/assetLoaderService';
 import { mkConfigureStep, mkInitStep } from '../../adPipeline';
-export class Pubstack {
-    constructor() {
-        this.name = 'pubstack';
-        this.description = 'prebid analytics integration';
-        this.moduleType = 'reporting';
-        this.pubstackConfig = null;
-    }
-    config__() {
-        return this.pubstackConfig;
-    }
-    configure__(moduleConfig) {
+import { extractPubstackAbTestCohort } from './abTest';
+export const createPubstack = () => {
+    const name = 'pubstack';
+    let pubstackConfig = null;
+    const config__ = () => pubstackConfig;
+    const configure__ = (moduleConfig) => {
         if (moduleConfig?.pubstack && moduleConfig.pubstack.enabled) {
-            this.pubstackConfig = moduleConfig.pubstack;
+            pubstackConfig = moduleConfig.pubstack;
         }
-    }
-    initSteps__() {
-        const config = this.pubstackConfig;
+    };
+    const initSteps__ = () => {
+        const config = pubstackConfig;
         return config
             ? [
                 mkInitStep('pubstack-init', ctx => {
@@ -25,7 +20,7 @@ export class Pubstack {
                     }
                     ctx.assetLoaderService__
                         .loadScript({
-                        name: 'pubstack',
+                        name,
                         loadMethod: AssetLoadMethod.TAG,
                         assetUrl: `https://boot.pbstck.com/v1/tag/${config.tagId}`
                     })
@@ -34,26 +29,33 @@ export class Pubstack {
                 })
             ]
             : [];
-    }
-    configureSteps__() {
-        const config = this.pubstackConfig;
+    };
+    const configureSteps__ = () => {
+        const config = pubstackConfig;
         return config
             ? [
                 mkConfigureStep('pubstack-configure', ctx => {
                     if (ctx.env__ === 'test') {
                         return Promise.resolve();
                     }
-                    const validABTestValues = ['0', '1', '2', '3'];
-                    const meta = ctx.window__.document.head.querySelector('meta[name="pbstck_context:pbstck_ab_test"]');
-                    if (meta && meta.content && validABTestValues.includes(meta.content)) {
-                        ctx.window__.googletag.pubads().setTargeting('pbstck_ab_test', meta.content);
+                    const pubstackAbTestCohort = extractPubstackAbTestCohort(ctx);
+                    if (pubstackAbTestCohort) {
+                        ctx.window__.googletag.pubads().setTargeting('pbstck_ab_test', pubstackAbTestCohort);
                     }
                     return Promise.resolve();
                 })
             ]
             : [];
-    }
-    prepareRequestAdsSteps__() {
-        return [];
-    }
-}
+    };
+    const prepareRequestAdsSteps__ = () => [];
+    return {
+        name,
+        description: 'prebid analytics integration',
+        moduleType: 'reporting',
+        config__,
+        configure__,
+        initSteps__,
+        configureSteps__,
+        prepareRequestAdsSteps__
+    };
+};

package/lib/ads/modules/sticky-footer-ad/index.js

@@ -1,28 +1,22 @@
 import { LOW_PRIORITY, mkPrepareRequestAdsStep } from 'ad-tag/ads/adPipeline';
 import { setupFooterAdListener } from './desktopFloorAd';
 import { initMobileAdSticky } from './mobileSticky';
-export class StickyFooterAd {
-    constructor() {
-        this.name = 'sticky-footer-ads';
-        this.description = 'sticky footer ad creatives';
-        this.moduleType = 'creatives';
-        this.stickyFooterAdConfig = null;
-    }
-    config__() {
-        return this.stickyFooterAdConfig;
-    }
-    configure__(moduleConfig) {
+export const createStickyFooterAd = () => {
+    const name = 'sticky-footer-ads';
+    let stickyFooterAdConfig = null;
+    const config__ = () => stickyFooterAdConfig;
+    const configure__ = (moduleConfig) => {
         if (moduleConfig?.stickyFooterAd?.enabled) {
-            this.stickyFooterAdConfig = moduleConfig.stickyFooterAd;
+            stickyFooterAdConfig = moduleConfig.stickyFooterAd;
         }
-    }
-    prepareRequestAdsSteps__() {
-        const config = this.stickyFooterAdConfig;
+    };
+    const prepareRequestAdsSteps__ = () => {
+        const config = stickyFooterAdConfig;
         return config
             ? [
-                mkPrepareRequestAdsStep(this.name, LOW_PRIORITY, (ctx, slots) => {
+                mkPrepareRequestAdsStep(name, LOW_PRIORITY, (ctx, slots) => {
                     if (config.mobileStickyDomId &&
-                        slots.some(slot => slot.moliSlot.domId === this.stickyFooterAdConfig?.mobileStickyDomId)) {
+                        slots.some(slot => slot.moliSlot.domId === config.mobileStickyDomId)) {
                         initMobileAdSticky(ctx.window__, ctx.env__, ctx.logger__, config.mobileStickyDomId, config.disallowedAdvertiserIds, config.initiallyHidden ?? false);
                     }
                     if (config.desktopFloorAdDomId &&
@@ -33,11 +27,17 @@ export class StickyFooterAd {
                 })
             ]
             : [];
-    }
-    configureSteps__() {
-        return [];
-    }
-    initSteps__() {
-        return [];
-    }
-}
+    };
+    const configureSteps__ = () => [];
+    const initSteps__ = () => [];
+    return {
+        name,
+        description: 'sticky footer ad creatives',
+        moduleType: 'creatives',
+        config__,
+        configure__,
+        prepareRequestAdsSteps__,
+        configureSteps__,
+        initSteps__
+    };
+};

package/lib/ads/modules/sticky-footer-ad-v2/index.js

@@ -1,30 +1,24 @@
 import { LOW_PRIORITY, mkPrepareRequestAdsStep } from 'ad-tag/ads/adPipeline';
 import { initAdSticky } from './footerStickyAd';
-export class StickyFooterAdsV2 {
-    constructor() {
-        this.name = 'sticky-footer-ads-v2';
-        this.description = 'sticky footer ad creatives';
-        this.moduleType = 'creatives';
-        this.stickyFooterAdConfig = null;
-    }
-    config__() {
-        return this.stickyFooterAdConfig;
-    }
-    configure__(moduleConfig) {
+export const createStickyFooterAdsV2 = () => {
+    const name = 'sticky-footer-ads-v2';
+    let stickyFooterAdConfig = null;
+    const config__ = () => stickyFooterAdConfig;
+    const configure__ = (moduleConfig) => {
         if (moduleConfig?.stickyFooterAdV2 && moduleConfig.stickyFooterAdV2.enabled) {
-            this.stickyFooterAdConfig = moduleConfig.stickyFooterAdV2;
+            stickyFooterAdConfig = moduleConfig.stickyFooterAdV2;
         }
-    }
-    prepareRequestAdsSteps__() {
-        const config = this.stickyFooterAdConfig;
+    };
+    const prepareRequestAdsSteps__ = () => {
+        const config = stickyFooterAdConfig;
         return config
             ? [
-                mkPrepareRequestAdsStep(this.name, LOW_PRIORITY, (ctx, slots) => {
+                mkPrepareRequestAdsStep(name, LOW_PRIORITY, (ctx, slots) => {
                     const desktopSlot = slots.find(slot => slot.moliSlot.domId === config.stickyFooterDomIds.desktop);
                     const mobileSlot = slots.find(slot => slot.moliSlot.domId === config.stickyFooterDomIds.mobile);
                     const footerAdSlot = mobileSlot ? mobileSlot : desktopSlot;
                     if (mobileSlot && desktopSlot) {
-                        ctx.logger__.warn(this.name, 'mobile and desktop sticky footer are called!');
+                        ctx.logger__.warn(name, 'mobile and desktop sticky footer are called!');
                     }
                     if (footerAdSlot) {
                         initAdSticky(ctx.window__, ctx.env__, ctx.logger__, footerAdSlot.moliSlot.domId, config.disallowedAdvertiserIds, config.closingButtonText);
@@ -33,11 +27,17 @@ export class StickyFooterAdsV2 {
                 })
             ]
             : [];
-    }
-    configureSteps__() {
-        return [];
-    }
-    initSteps__() {
-        return [];
-    }
-}
+    };
+    const configureSteps__ = () => [];
+    const initSteps__ = () => [];
+    return {
+        name,
+        description: 'sticky footer ad creatives',
+        moduleType: 'creatives',
+        config__,
+        configure__,
+        prepareRequestAdsSteps__,
+        configureSteps__,
+        initSteps__
+    };
+};