@highfivve/ad-tag 5.5.4

package/lib/ads/googleAdManager.js

@@ -0,0 +1,380 @@
+import { LOW_PRIORITY, mkConfigureStep, mkConfigureStepOncePerRequestAdsCycle, mkInitStep, mkPrepareRequestAdsStep } from './adPipeline';
+import { SizeConfigService } from './sizeConfigService';
+import { isNotNull } from '../util/arrayUtils';
+import { AssetLoadMethod } from '../util/assetLoaderService';
+import { tcfapi } from '../types/tcfapi';
+import { createTestSlots } from '../util/test-slots';
+import { resolveAdUnitPath } from './adUnitPath';
+import { formatKey } from './keyValues';
+const testAdSlot = (domId, adUnitPath) => ({
+    setCollapseEmptyDiv() {
+        return;
+    },
+    addService(_service) {
+        return;
+    },
+    getSlotElementId() {
+        return domId;
+    },
+    getAdUnitPath() {
+        return adUnitPath;
+    },
+    setTargeting(_key, _value) {
+        return this;
+    },
+    getTargeting(_key) {
+        return [];
+    },
+    getTargetingKeys() {
+        return [];
+    },
+    clearTargeting(_key) {
+        return;
+    },
+    getResponseInformation() {
+        return null;
+    },
+    setConfig(_config) {
+        return;
+    }
+});
+const configureTargeting = (window, runtimeKeyValues, serverSideTargeting) => {
+    const staticKeyValues = serverSideTargeting ? serverSideTargeting.keyValues : {};
+    const excludes = serverSideTargeting?.adManagerExcludes ?? [];
+    [staticKeyValues, runtimeKeyValues].forEach(keyValues => {
+        Object.keys(keyValues)
+            .filter(key => !excludes.includes(key))
+            .forEach(key => {
+            const value = keyValues[key];
+            if (value) {
+                window.googletag.pubads().setTargeting(key, value);
+            }
+        });
+    });
+};
+const useStandardGpt = (tcData, consentConfig) => {
+    if (consentConfig?.useLimitedAds === false) {
+        return true;
+    }
+    return (!tcData.gdprApplies ||
+        (tcData.vendor.consents[755] &&
+            tcData.purpose.consents[tcfapi.responses.TCPurpose.STORE_INFORMATION_ON_DEVICE] &&
+            [
+                tcfapi.responses.TCPurpose.SELECT_BASIC_ADS,
+                tcfapi.responses.TCPurpose.MEASURE_AD_PERFORMANCE,
+                tcfapi.responses.TCPurpose.APPLY_MARKET_RESEARCH,
+                tcfapi.responses.TCPurpose.DEVELOP_IMPROVE_PRODUCTS
+            ].every(purposeId => tcData.purpose.consents[purposeId] || tcData.purpose.legitimateInterests[purposeId])));
+};
+export const gptInit = () => {
+    let result;
+    return mkInitStep('gpt-init', (context) => {
+        if (context.env__ === 'test') {
+            return Promise.resolve();
+        }
+        if (!result) {
+            result = new Promise(resolve => {
+                context.logger__.debug('GAM', 'init googletag stub');
+                context.window__.googletag = context.window__.googletag || {};
+                context.window__.googletag.cmd = context.window__.googletag.cmd || [];
+                context.window__.googletag.cmd.push(resolve);
+                context.assetLoaderService__
+                    .loadScript({
+                    name: 'gpt',
+                    loadMethod: AssetLoadMethod.TAG,
+                    assetUrl: useStandardGpt(context.tcData__, context.config__.consent)
+                        ? 'https://securepubads.g.doubleclick.net/tag/js/gpt.js'
+                        : 'https://pagead2.googlesyndication.com/tag/js/gpt.js'
+                })
+                    .catch(error => context.logger__.error('failed to load gpt.js', error));
+            });
+        }
+        return result;
+    });
+};
+export const gptDestroyAdSlots = () => {
+    let currentRequestAdsCalls = 0;
+    return mkConfigureStep('gpt-destroy-ad-slots', (context, slots) => {
+        if (context.env__ === 'test') {
+            return Promise.resolve();
+        }
+        const cleanup = context.config__.spa?.cleanup ?? { slots: 'all' };
+        const destroySelectedSlots = (slots) => {
+            if (slots.length === 0) {
+                context.logger__.debug('GAM', 'no ad slots to destroy');
+                return Promise.resolve();
+            }
+            context.logger__.debug('GAM', `destroy ${slots.length} ad slots`, slots);
+            context.window__.googletag.destroySlots(slots);
+            return Promise.resolve();
+        };
+        const isNextRequestAdsCall = currentRequestAdsCalls !== context.requestAdsCalls__;
+        currentRequestAdsCalls = context.requestAdsCalls__;
+        context.logger__.debug('GAM', `destroy ${cleanup.slots} ad slots`);
+        switch (cleanup.slots) {
+            case 'all':
+                if (isNextRequestAdsCall) {
+                    context.window__.googletag.destroySlots();
+                }
+                return Promise.resolve();
+            case 'requested':
+                const allGptSlots = context.window__.googletag.pubads().getSlots();
+                const gptSlots = slots
+                    .map(slot => allGptSlots.find(s => s.getSlotElementId() === slot.domId))
+                    .filter(isNotNull);
+                return destroySelectedSlots(gptSlots);
+            case 'excluded':
+                if (isNextRequestAdsCall) {
+                    const destroyableSlots = context.window__.googletag
+                        .pubads()
+                        .getSlots()
+                        .filter(slot => !cleanup.slotIds.includes(slot.getSlotElementId()));
+                    return destroySelectedSlots(destroyableSlots);
+                }
+                return Promise.resolve();
+            default:
+                return Promise.resolve();
+        }
+    });
+};
+export const gptResetTargeting = () => mkConfigureStepOncePerRequestAdsCycle('gpt-reset-targeting', (context) => new Promise(resolve => {
+    if (context.env__ === 'production') {
+        context.logger__.debug('GAM', 'reset top level targeting');
+        context.window__.googletag.pubads().clearTargeting();
+        configureTargeting(context.window__, context.runtimeConfig__.keyValues, context.config__.targeting);
+    }
+    resolve();
+}));
+export const gptConfigure = () => {
+    let result;
+    return mkConfigureStep('gpt-configure', (context, _slots) => {
+        if (!result) {
+            result = new Promise(resolve => {
+                const env = context.runtimeConfig__.environment || 'production';
+                context.logger__.debug('GAM', 'configure googletag');
+                switch (env) {
+                    case 'production':
+                        configureTargeting(context.window__, context.runtimeConfig__.keyValues, context.config__.targeting);
+                        context.window__.googletag.pubads().enableAsyncRendering();
+                        context.window__.googletag.pubads().disableInitialLoad();
+                        context.window__.googletag.pubads().enableSingleRequest();
+                        if (context.config__.gpt?.pageSettingsConfig) {
+                            context.window__.googletag.setConfig(context.config__.gpt.pageSettingsConfig);
+                        }
+                        const limitedAds = !useStandardGpt(context.tcData__, context.config__.consent);
+                        context.logger__.debug('GAM', `use limited ads`, limitedAds);
+                        context.window__.googletag.pubads().setPrivacySettings({
+                            limitedAds
+                        });
+                        context.window__.googletag.enableServices();
+                        resolve();
+                        return;
+                    case 'test':
+                        resolve();
+                        return;
+                }
+            });
+        }
+        return result;
+    });
+};
+export const gptLDeviceLabelKeyValue = () => mkPrepareRequestAdsStep('gpt-device-label-keyValue', LOW_PRIORITY, ctx => {
+    if (ctx.env__ === 'test') {
+        return Promise.resolve();
+    }
+    return new Promise(resolve => {
+        const deviceLabel = ctx.labelConfigService__.getDeviceLabel();
+        ctx.logger__.debug('GAM', 'adding "device_label" key-value with values', deviceLabel);
+        ctx.window__.googletag.pubads().setTargeting('device_label', deviceLabel);
+        resolve();
+    });
+});
+export const gptConsentKeyValue = () => mkPrepareRequestAdsStep('gpt-consent-keyValue', LOW_PRIORITY, ctx => {
+    if (ctx.env__ === 'test') {
+        return Promise.resolve();
+    }
+    return new Promise(resolve => {
+        const tcData = ctx.tcData__;
+        const fullConsent = !tcData.gdprApplies ||
+            [
+                tcfapi.responses.TCPurpose.STORE_INFORMATION_ON_DEVICE,
+                tcfapi.responses.TCPurpose.SELECT_BASIC_ADS,
+                tcfapi.responses.TCPurpose.CREATE_PERSONALISED_ADS_PROFILE,
+                tcfapi.responses.TCPurpose.SELECT_PERSONALISED_ADS,
+                tcfapi.responses.TCPurpose.CREATE_PERSONALISED_CONTENT_PROFILE,
+                tcfapi.responses.TCPurpose.SELECT_PERSONALISED_CONTENT,
+                tcfapi.responses.TCPurpose.MEASURE_AD_PERFORMANCE,
+                tcfapi.responses.TCPurpose.MEASURE_CONTENT_PERFORMANCE,
+                tcfapi.responses.TCPurpose.APPLY_MARKET_RESEARCH,
+                tcfapi.responses.TCPurpose.DEVELOP_IMPROVE_PRODUCTS
+            ].every(purpose => tcData.purpose.consents[purpose]);
+        ctx.window__.googletag.pubads().setTargeting('consent', fullConsent ? 'full' : 'none');
+        resolve();
+    });
+});
+export const gptDefineSlots = () => (context, slots) => {
+    const slotDefinitions = slots.map(moliSlot => {
+        const sizeConfigService = new SizeConfigService(moliSlot.sizeConfig, context.labelConfigService__.getSupportedLabels(), context.window__);
+        const filterSupportedSizes = sizeConfigService.filterSupportedSizes;
+        if (!(sizeConfigService.filterSlot(moliSlot) &&
+            context.labelConfigService__.filterSlot(moliSlot))) {
+            return Promise.resolve(null);
+        }
+        const sizes = filterSupportedSizes(moliSlot.sizes);
+        const resolvedAdUnitPath = resolveAdUnitPath(moliSlot.adUnitPath, context.adUnitPathVariables__);
+        const createDivIfMissing = (domId) => {
+            if (!context.window__.document.getElementById(domId)) {
+                const slot = context.window__.document.createElement('div');
+                slot.id = domId;
+                slot.setAttribute('data-h5v-position', moliSlot.position);
+                slot.style.setProperty('display', 'none');
+                context.window__.document.body.appendChild(slot);
+            }
+        };
+        const defineAdSlot = () => {
+            switch (moliSlot.position) {
+                case 'in-page':
+                    return [
+                        context.window__.googletag.defineSlot(resolvedAdUnitPath, sizes, moliSlot.domId),
+                        null
+                    ];
+                case 'interstitial':
+                    createDivIfMissing(moliSlot.domId);
+                    switch (context.auction__.interstitialChannel()) {
+                        case 'gam':
+                            return [
+                                context.window__.googletag.defineOutOfPageSlot(resolvedAdUnitPath, context.window__.googletag.enums.OutOfPageFormat.INTERSTITIAL),
+                                context.window__.googletag.enums.OutOfPageFormat.INTERSTITIAL
+                            ];
+                        case 'c':
+                        default:
+                            return [
+                                context.window__.googletag.defineSlot(resolvedAdUnitPath, sizes, moliSlot.domId),
+                                null
+                            ];
+                    }
+                case 'out-of-page':
+                    createDivIfMissing(moliSlot.domId);
+                    return [
+                        context.window__.googletag.defineOutOfPageSlot(resolvedAdUnitPath, moliSlot.domId),
+                        null
+                    ];
+                case 'out-of-page-interstitial':
+                    return [
+                        context.window__.googletag.defineOutOfPageSlot(resolvedAdUnitPath, context.window__.googletag.enums.OutOfPageFormat.INTERSTITIAL),
+                        context.window__.googletag.enums.OutOfPageFormat.INTERSTITIAL
+                    ];
+                case 'out-of-page-bottom-anchor':
+                    return [
+                        context.window__.googletag.defineOutOfPageSlot(resolvedAdUnitPath, context.window__.googletag.enums.OutOfPageFormat.BOTTOM_ANCHOR),
+                        context.window__.googletag.enums.OutOfPageFormat.BOTTOM_ANCHOR
+                    ];
+                case 'out-of-page-top-anchor':
+                    return [
+                        context.window__.googletag.defineOutOfPageSlot(resolvedAdUnitPath, context.window__.googletag.enums.OutOfPageFormat.TOP_ANCHOR),
+                        context.window__.googletag.enums.OutOfPageFormat.TOP_ANCHOR
+                    ];
+            }
+        };
+        const defineAndDisplayAdSlot = () => {
+            if (context.env__ === 'test') {
+                return null;
+            }
+            const [adSlot, format] = defineAdSlot();
+            if (adSlot) {
+                if (format) {
+                    adSlot.setTargeting(formatKey, format.toString());
+                }
+                else {
+                    adSlot.clearTargeting(formatKey);
+                }
+                context.window__.googletag.display(adSlot);
+            }
+            return adSlot;
+        };
+        const allSlots = context.env__ === 'test' ? [] : context.window__.googletag.pubads().getSlots();
+        const existingSlot = allSlots.find(s => s.getSlotElementId() === moliSlot.domId);
+        const adSlot = existingSlot
+            ? existingSlot
+            : defineAndDisplayAdSlot();
+        switch (context.env__) {
+            case 'production':
+                if (adSlot) {
+                    if (moliSlot.gpt) {
+                        adSlot.setConfig(moliSlot.gpt);
+                        context.logger__.debug('GAM', `Add slot settings: [AdSlot] ${adSlot} [Settings] ${moliSlot.gpt}`);
+                    }
+                    adSlot.setCollapseEmptyDiv(moliSlot.gpt?.collapseEmptyDiv !== false);
+                    adSlot.addService(context.window__.googletag.pubads());
+                    context.logger__.debug('GAM', `Register slot: [DomID] ${moliSlot.domId} [AdUnitPath] ${moliSlot.adUnitPath}`);
+                    return Promise.resolve({
+                        moliSlot,
+                        adSlot,
+                        filterSupportedSizes
+                    });
+                }
+                else if (moliSlot.position === 'out-of-page-interstitial' ||
+                    moliSlot.position === 'out-of-page-top-anchor' ||
+                    moliSlot.position === 'out-of-page-bottom-anchor') {
+                    context.logger__.warn('GAM', `${moliSlot.position} is not supported`);
+                    return Promise.resolve(null);
+                }
+                else {
+                    const error = `Slot: [DomID] ${moliSlot.domId} [AdUnitPath] ${moliSlot.adUnitPath} is already defined. You may have called requestAds() multiple times`;
+                    context.logger__.error('GAM', error);
+                    return Promise.reject(new Error(error));
+                }
+            case 'test':
+                return Promise.resolve({
+                    moliSlot,
+                    adSlot: testAdSlot(moliSlot.domId, moliSlot.adUnitPath),
+                    filterSupportedSizes
+                });
+            default:
+                return Promise.reject(`invalid environment: ${context.runtimeConfig__.environment}`);
+        }
+    });
+    return Promise.all(slotDefinitions).then(slots => slots.filter(isNotNull));
+};
+const checkAndSwitchToWebInterstitial = (slotsToRefresh, context) => {
+    const interstitialSlot = slotsToRefresh.find(({ moliSlot }) => moliSlot.position === 'interstitial');
+    if (interstitialSlot && context.auction__.interstitialChannel() === 'gam') {
+        context.window__.googletag.destroySlots([interstitialSlot.adSlot]);
+        const gamWebInterstitial = context.window__.googletag.defineOutOfPageSlot(resolveAdUnitPath(interstitialSlot.moliSlot.adUnitPath, context.adUnitPathVariables__), context.window__.googletag.enums.OutOfPageFormat.INTERSTITIAL);
+        if (gamWebInterstitial) {
+            context.logger__.debug('GAM', 'Display out-of-page-interstitial slot');
+            gamWebInterstitial.addService(context.window__.googletag.pubads());
+            gamWebInterstitial.setTargeting(formatKey, context.window__.googletag.enums.OutOfPageFormat.INTERSTITIAL.toString());
+            context.window__.googletag.display(gamWebInterstitial);
+            return [
+                ...slotsToRefresh.filter(({ moliSlot }) => moliSlot.position !== 'interstitial'),
+                { ...interstitialSlot, adSlot: gamWebInterstitial }
+            ];
+        }
+        else {
+            context.logger__.error('GAM', 'Failed to define out-of-page-interstitial slot');
+        }
+    }
+    return slotsToRefresh;
+};
+export const gptRequestAds = () => (context, slots) => new Promise(resolve => {
+    context.logger__.debug('GAM', 'requestAds');
+    switch (context.env__) {
+        case 'test':
+            createTestSlots(context, slots);
+            break;
+        case 'production':
+            const slotsToRefresh = slots.filter(({ adSlot }) => !context.auction__.isSlotThrottled(adSlot));
+            if (slotsToRefresh.length === 0) {
+                break;
+            }
+            const updatedSlots = checkAndSwitchToWebInterstitial(slotsToRefresh, context);
+            context.window__.googletag.pubads().refresh(updatedSlots.map(({ adSlot }) => adSlot));
+            const debugMessage = updatedSlots
+                .map(({ moliSlot }) => `[DomID] ${moliSlot.domId} [AdUnitPath] ${moliSlot.adUnitPath}`)
+                .join('\n');
+            context.logger__.debug('GAM', `Refresh ${slots.length} slot(s):\n${debugMessage}`);
+            break;
+    }
+    resolve();
+});

package/lib/ads/keyValues.js

@@ -0,0 +1 @@
+export const formatKey = 'f';

package/lib/ads/labelConfigService.js

@@ -0,0 +1,42 @@
+import { flatten, uniquePrimitiveFilter } from '../util/arrayUtils';
+const possibleDevices = ['mobile', 'desktop', 'android', 'ios'];
+export const createLabelConfigService = (labelSizeConfig, extraLabels, window) => {
+    const isPublisherDeviceDefined = extraLabels.some((label) => possibleDevices.indexOf(label) > -1);
+    const supportedLabelSizeConfigs = labelSizeConfig.filter(conf => window.matchMedia(conf.mediaQuery).matches);
+    const supportedLabels = [
+        ...(isPublisherDeviceDefined
+            ? []
+            : flatten(supportedLabelSizeConfigs.map(conf => conf.labelsSupported))),
+        ...extraLabels
+    ].filter(uniquePrimitiveFilter);
+    const filterSlot = (slot) => {
+        let labelsMatching = true;
+        if (supportedLabels.length && slot.labelAll?.length) {
+            labelsMatching = slot.labelAll.every(label => supportedLabels.indexOf(label) > -1);
+        }
+        if (supportedLabels.length && slot.labelAny && !slot.labelAll?.length) {
+            labelsMatching = slot.labelAny.some(label => supportedLabels.indexOf(label) > -1);
+        }
+        return labelsMatching;
+    };
+    const getSupportedLabels = () => {
+        return supportedLabels;
+    };
+    const getDeviceLabel = () => {
+        return (supportedLabels.find((label) => possibleDevices.indexOf(label) > -1) || 'mobile');
+    };
+    const addLabel = (label) => {
+        if (!possibleDevices.includes(label)) {
+            supportedLabels.push(label);
+        }
+    };
+    return {
+        filterSlot,
+        getSupportedLabels,
+        getDeviceLabel,
+        addLabel
+    };
+};
+export const getDeviceLabel = (window, runtimeConfig, labelSizeConfig, targeting) => {
+    return createLabelConfigService(labelSizeConfig ?? [], [...(targeting?.labels || []), ...runtimeConfig.labels], window).getDeviceLabel();
+};

package/lib/ads/modules/ad-reload/adVisibilityService.js

@@ -0,0 +1,158 @@
+export class AdVisibilityService {
+    constructor(userActivityService, refreshInterval, refreshIntervalOverrides, useIntersectionObserver, disableAdVisibilityChecks, viewabilityOverrides, window, logger) {
+        this.userActivityService = userActivityService;
+        this.refreshInterval = refreshInterval;
+        this.refreshIntervalOverrides = refreshIntervalOverrides;
+        this.useIntersectionObserver = useIntersectionObserver;
+        this.disableAdVisibilityChecks = disableAdVisibilityChecks;
+        this.viewabilityOverrides = viewabilityOverrides;
+        this.window = window;
+        this.logger = logger;
+        this.isSlotTracked = (domId) => this.visibilityRecords.has(domId);
+        this.removeSlotTracking = (slot) => {
+            this.logger?.debug('AdVisibilityService', `removing slot visibility tracking for ${slot.getSlotElementId()}`, slot);
+            this.visibilityRecords.delete(slot.getSlotElementId());
+            const observedSlot = this.observedDomElementForSlot(slot);
+            if (this.intersectionObserver && observedSlot) {
+                this.intersectionObserver.unobserve(observedSlot.target);
+            }
+        };
+        this.handleGoogletagAdVisibilityChanged = (event) => {
+            const slot = event.slot;
+            const visibilityRecord = this.visibilityRecordForGoogletagEvent(event);
+            if (visibilityRecord) {
+                this.logger?.debug('AdVisibilityService', `Visibility of slot ${slot.getSlotElementId()} changed. Visible area: ${event.inViewPercentage}%`);
+                this.updateVisibilityRecord(visibilityRecord, event.inViewPercentage / 100);
+            }
+        };
+        this.updateVisibilityRecord = (visibilityRecord, adVisibilityRatio) => {
+            if (visibilityRecord.latestStartVisible) {
+                const addedDuration = this.window.performance.now() - visibilityRecord.latestStartVisible;
+                this.logger?.debug('AdVisibilityService', `added ${Math.round(addedDuration)}ms visibility to ${visibilityRecord.slot.getSlotElementId()}`);
+                visibilityRecord.durationVisibleSum += addedDuration;
+            }
+            if (adVisibilityRatio >= this.minimalAdVisibilityRatio) {
+                visibilityRecord.latestStartVisible = this.window.performance.now();
+                this.logger?.debug('AdVisibilityService', `ad ${visibilityRecord.slot.getSlotElementId()} visible`);
+            }
+            else {
+                visibilityRecord.latestStartVisible = undefined;
+                this.logger?.debug('AdVisibilityService', `ad ${visibilityRecord.slot.getSlotElementId()} not visible`);
+            }
+        };
+        this.visibilityRecordForGoogletagEvent = (event) => this.visibilityRecords.get(event.slot.getSlotElementId());
+        this.minimalAdVisibilityRatio = disableAdVisibilityChecks ? 0 : 0.5;
+        this.visibilityRecords = new Map();
+        const requiredIntersectionObserver = (useIntersectionObserver ||
+            Object.values(viewabilityOverrides).some(entry => entry?.variant === 'css')) &&
+            'IntersectionObserver' in this.window;
+        if (requiredIntersectionObserver) {
+            this.intersectionObserver = new this.window.IntersectionObserver(entries => this.handleObservedAdVisibilityChanged(entries), { threshold: this.minimalAdVisibilityRatio });
+        }
+        if (!useIntersectionObserver) {
+            this.window.googletag.cmd.push(() => {
+                this.window.googletag
+                    .pubads()
+                    .addEventListener('slotVisibilityChanged', this.handleGoogletagAdVisibilityChanged);
+            });
+        }
+        this.userActivityService.addUserActivityChangedListener(state => this.handleUserActivityChanged(state));
+        this.setUpdateTimer(true);
+        this.logger?.debug('AdVisibilityService', 'initialized');
+    }
+    trackSlot(slot, refreshCallback, advertiserId) {
+        const slotDomId = slot.getSlotElementId();
+        const domElement = this.observedDomElementForSlot(slot);
+        if (domElement) {
+            this.logger?.debug('AdVisibilityService', `tracking slot ${slot.getSlotElementId()}`, slot);
+            if (this.isSlotTracked(slotDomId)) {
+                this.removeSlotTracking(slot);
+            }
+            const override = domElement.viewabilityOverride;
+            this.visibilityRecords.set(slot.getSlotElementId(), {
+                slot: slot,
+                latestStartVisible: this.disableAdVisibilityChecks ||
+                    (override?.variant === 'disabled' &&
+                        (override.disableAllAdVisibilityChecks ||
+                            !(override.disabledAdVisibilityCheckAdvertiserIds &&
+                                override.disabledAdVisibilityCheckAdvertiserIds.length > 0 &&
+                                advertiserId) ||
+                            override.disabledAdVisibilityCheckAdvertiserIds.includes(advertiserId)))
+                    ? this.window.performance.now()
+                    : undefined,
+                durationVisibleSum: 0,
+                refreshCallback: refreshCallback
+            });
+            if (this.intersectionObserver &&
+                (domElement.targetOverride || this.useIntersectionObserver)) {
+                this.intersectionObserver.observe(domElement.target);
+            }
+        }
+    }
+    setUpdateTimer(state) {
+        if (state) {
+            this.visibilityUpdateTimer = this.window.setInterval(() => this.updateAdVisibilityDuration(), AdVisibilityService.updateVisibilityInterval);
+        }
+        else {
+            this.window.clearInterval(this.visibilityUpdateTimer);
+            this.visibilityUpdateTimer = undefined;
+        }
+    }
+    updateAdVisibilityDuration() {
+        this.visibilityRecords.forEach(record => {
+            if (record.latestStartVisible) {
+                const now = this.window.performance.now();
+                const addedDuration = Math.round(now - record.latestStartVisible);
+                record.durationVisibleSum += addedDuration;
+                record.latestStartVisible = now;
+                this.logger?.debug('AdVisibilityService', `added ${addedDuration}ms visibility to ${record.slot.getSlotElementId()}, now totalling at ${record.durationVisibleSum}ms`);
+            }
+        });
+        Array.from(this.visibilityRecords.values())
+            .filter(record => {
+            const interval = this.refreshIntervalOverrides[record.slot.getSlotElementId()] || this.refreshInterval;
+            return record.durationVisibleSum > interval;
+        })
+            .forEach(record => {
+            this.logger?.debug('AdVisibilityService', `refreshing ad ${record.slot.getSlotElementId()} after ${record.durationVisibleSum}ms visibility`);
+            record.latestStartVisible = this.window.performance.now();
+            record.durationVisibleSum = -AdVisibilityService.consecutiveDurationToRefresh;
+            record.refreshCallback(record.slot);
+        });
+    }
+    handleObservedAdVisibilityChanged(entries) {
+        entries.forEach(entry => {
+            const visibilityRecord = this.visibilityRecordForEntry(entry);
+            if (visibilityRecord) {
+                this.logger?.debug('AdVisibilityService', `Visibility of slot ${visibilityRecord.slot.getSlotElementId()} changed. Visible area: ${entry.intersectionRatio * 100}%`);
+                this.updateVisibilityRecord(visibilityRecord, entry.intersectionRatio);
+            }
+        });
+    }
+    handleUserActivityChanged(userActivityState) {
+        this.visibilityRecords.forEach(record => {
+            if (record.latestStartVisible) {
+                record.latestStartVisible = this.window.performance.now();
+            }
+        });
+        this.setUpdateTimer(userActivityState);
+    }
+    visibilityRecordForEntry(entry) {
+        return this.visibilityRecords.get(entry.target.id);
+    }
+    observedDomElementForSlot(slot) {
+        const slotDomId = slot.getSlotElementId();
+        const viewabilityOverride = this.viewabilityOverrides[slotDomId];
+        const adSlotElement = this.window.document.getElementById(slotDomId);
+        const overrideElement = viewabilityOverride && viewabilityOverride.variant === 'css'
+            ? this.window.document.querySelector(viewabilityOverride.cssSelector)
+            : null;
+        return overrideElement
+            ? { target: overrideElement, targetOverride: true, viewabilityOverride }
+            : adSlotElement
+                ? { target: adSlotElement, targetOverride: false, viewabilityOverride }
+                : null;
+    }
+}
+AdVisibilityService.updateVisibilityInterval = 1000;
+AdVisibilityService.consecutiveDurationToRefresh = 1500;