@highfivve/ad-tag 5.5.4

package/lib/ads/modules/interstitial/interstitialAd.js

@@ -0,0 +1,111 @@
+import { getBrowserStorageValue } from 'ad-tag/util/localStorage';
+const interstitialContainerSelector = '[data-ref="h5v-interstitial"]';
+const interstitialCloseButtonSelector = '[data-ref="h5v-interstitial-close"]';
+const interstitialHidingClass = 'h5v-interstitial--hidden';
+const interstitialRenderedEvent = (interstitialDomId, disallowedAdvertiserIds, window) => new Promise(resolve => {
+    const listener = (event) => {
+        if (event.slot.getSlotElementId() !== interstitialDomId) {
+            return;
+        }
+        if (event.isEmpty) {
+            resolve('empty');
+        }
+        else if (event.advertiserId && disallowedAdvertiserIds.includes(event.advertiserId)) {
+            resolve('disallowed');
+        }
+        else {
+            event.slot.setConfig({ safeFrame: { forceSafeFrame: true } });
+            resolve('standard');
+        }
+        window.googletag.pubads().removeEventListener('slotRenderEnded', listener);
+    };
+    window.googletag.cmd.push(() => {
+        window.googletag.pubads().addEventListener('slotRenderEnded', listener);
+    });
+});
+const interstitialOnLoadEvent = (interstitialDomId, window) => new Promise(resolve => {
+    const listener = (event) => {
+        if (event.slot.getSlotElementId() !== interstitialDomId) {
+            return;
+        }
+        resolve();
+        window.googletag.pubads().removeEventListener('slotOnload', listener);
+    };
+    window.googletag.pubads().addEventListener('slotOnload', listener);
+});
+const hideAdSlot = (element) => {
+    element.classList.add(interstitialHidingClass);
+};
+const showAdSlot = (element) => {
+    element.classList.remove(interstitialHidingClass);
+};
+let timeoutToBeClearedWhenModuleIsInitialized;
+export const initInterstitialModule = (window, env, log, interstitialDomId, disallowedAdvertiserIds, closeAutomaticallyAfterMs) => {
+    clearTimeout(timeoutToBeClearedWhenModuleIsInitialized);
+    const interstitial = 'interstitial-module';
+    const interstitialAdContainer = window.document.querySelector(interstitialContainerSelector);
+    const closeButton = window.document.querySelector(interstitialCloseButtonSelector);
+    if (closeButton && interstitialAdContainer) {
+        log.debug(interstitial, 'Running interstitial module with defined container and close button');
+        const closeInterstitial = () => {
+            hideAdSlot(interstitialAdContainer);
+            const slot = window.googletag
+                ?.pubads()
+                .getSlots()
+                .find(slot => slot.getSlotElementId() === interstitialDomId);
+            if (slot) {
+                window.googletag.destroySlots([slot]);
+            }
+        };
+        closeButton.addEventListener('click', () => {
+            closeInterstitial();
+        });
+        const onRenderResult = (renderResult) => {
+            log.debug(interstitial, `result ${renderResult}`);
+            if (renderResult === 'disallowed' || renderResult === 'empty') {
+                log.debug(interstitial, 'hide interstitial container');
+                hideAdSlot(interstitialAdContainer);
+                return Promise.resolve();
+            }
+            else if (renderResult === 'standard') {
+                showAdSlot(interstitialAdContainer);
+                if (closeAutomaticallyAfterMs) {
+                    timeoutToBeClearedWhenModuleIsInitialized = window.setTimeout(() => {
+                        closeInterstitial();
+                    }, closeAutomaticallyAfterMs);
+                }
+                const interstitialOnLoadEventPromise = interstitialOnLoadEvent(interstitialDomId, window);
+                return interstitialRenderedEvent(interstitialDomId, disallowedAdvertiserIds, window)
+                    .then(result => result === 'empty' || result === 'disallowed'
+                    ? Promise.resolve(result)
+                    : interstitialOnLoadEventPromise.then(() => result))
+                    .then(onRenderResult);
+            }
+            return Promise.resolve();
+        };
+        switch (env) {
+            case 'production':
+                const interstitialOnLoadEventPromise = interstitialOnLoadEvent(interstitialDomId, window);
+                interstitialRenderedEvent(interstitialDomId, disallowedAdvertiserIds, window)
+                    .then(result => result === 'empty' || result === 'disallowed'
+                    ? Promise.resolve(result)
+                    : interstitialOnLoadEventPromise.then(() => result))
+                    .then(onRenderResult);
+                break;
+            case 'test':
+                if (!!getBrowserStorageValue('test-interstitial', localStorage)) {
+                    onRenderResult('standard');
+                }
+                else {
+                    onRenderResult('empty');
+                }
+                break;
+            default:
+                log.warn(interstitial, `Unknown environment: ${env}`);
+                break;
+        }
+    }
+    else {
+        log.warn('[interstitial-module]', `Could not find interstitial container ${interstitialContainerSelector} or closeButton ${interstitialCloseButtonSelector}`, interstitial, closeButton);
+    }
+};

package/lib/ads/modules/lazy-load/index.js

@@ -0,0 +1,191 @@
+import { LOW_PRIORITY, mkPrepareRequestAdsStep } from 'ad-tag/ads/adPipeline';
+import { mkConfigureStepOncePerRequestAdsCycle } from 'ad-tag/ads/adPipeline';
+import { selectInfiniteSlot } from './selectInfiniteSlot';
+export const createLazyLoad = () => {
+    let initialized = false;
+    const observers = [];
+    let lazyloadConfig = null;
+    const name = 'moli-lazy-load';
+    const description = 'Moli implementation of an ad lazy load module.';
+    const moduleType = 'lazy-load';
+    const config__ = () => lazyloadConfig;
+    const configure__ = (moduleConfig) => {
+        if (moduleConfig?.lazyload && moduleConfig.lazyload.enabled) {
+            lazyloadConfig = moduleConfig.lazyload;
+        }
+    };
+    const initSteps__ = () => {
+        return [];
+    };
+    const configureSteps__ = () => {
+        const config = lazyloadConfig;
+        return config
+            ? [
+                mkConfigureStepOncePerRequestAdsCycle('lazy-module-configuration', context => {
+                    initialized = false;
+                    observers.forEach(observer => observer.disconnect());
+                    observers.length = 0;
+                    registerIntersectionObservers(context, config);
+                    return Promise.resolve();
+                })
+            ]
+            : [];
+    };
+    const prepareRequestAdsSteps__ = () => {
+        return [
+            mkPrepareRequestAdsStep('lazy-module-delay', LOW_PRIORITY, (context, slots) => {
+                return new Promise((resolve, reject) => {
+                    const delay = context.options__?.options?.delay;
+                    if (delay) {
+                        context.logger__?.debug(name, 'delaying slots', slots);
+                        const delayTrigger = new Promise(resolve => {
+                            context.window__.addEventListener('h5v.trigger-delay', () => resolve(true), {
+                                once: true
+                            });
+                        });
+                        const timeout = new Promise(resolve => {
+                            context.window__.setTimeout(() => resolve(false), delay.timeoutMs ?? 30000);
+                        });
+                        return Promise.race([delayTrigger, timeout]).then(triggered => {
+                            return triggered ? resolve() : reject(new Error('Delay timeout exceeded'));
+                        });
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            })
+        ];
+    };
+    const registerIntersectionObservers = (context, moduleConfig) => {
+        if (initialized) {
+            return;
+        }
+        initialized = true;
+        context.logger__?.debug(name, 'initialize moli lazy load module');
+        const slotsConfig = moduleConfig.slots;
+        const bucketsConfig = moduleConfig.buckets;
+        const infiniteSlotsConfig = moduleConfig.infiniteSlots;
+        const window = context.window__;
+        slotsConfig.forEach(config => {
+            const observer = new window.IntersectionObserver(entries => {
+                context.logger__?.debug(name, 'lazy-load slots called with', entries);
+                entries.forEach((entry) => {
+                    if (entry.isIntersecting) {
+                        context.logger__?.debug(name, `Trigger ad slot with DOM ID ${entry.target.id}`);
+                        window.moli.refreshAdSlot(entry.target.id);
+                        observer.unobserve(entry.target);
+                    }
+                });
+            }, {
+                root: config.options.rootId
+                    ? window.document.getElementById(config.options.rootId)
+                    : null,
+                threshold: config.options.threshold,
+                rootMargin: config.options.rootMargin
+            });
+            observers.push(observer);
+            config.domIds.forEach(domId => {
+                const slot = context.config__.slots.find(slot => slot.domId === domId);
+                if (!slot) {
+                    context.logger__?.warn(name, `Lazy-load non-existing slot with domID ${domId}`);
+                }
+                else if (slot.behaviour.loaded !== 'manual') {
+                    context.logger__?.warn(name, `Lazy-load configured for slot without manual loading behaviour. ${domId}`);
+                }
+                else if (slot.behaviour.loaded === 'manual') {
+                    const elementToObserve = window.document.getElementById(domId);
+                    elementToObserve && observer.observe(elementToObserve);
+                }
+            });
+        });
+        bucketsConfig.forEach(config => {
+            const observer = new window.IntersectionObserver(entries => {
+                entries.forEach((entry) => {
+                    if (entry.isIntersecting && entry.target.id === config.observedDomId) {
+                        const correspondingBucket = context.config__.slots.find(slot => slot.domId === config.observedDomId)?.behaviour.bucket;
+                        if (correspondingBucket !== config.bucket) {
+                            context.logger__?.warn(name, `${config.observedDomId} doesn't belong to ${config.bucket}`);
+                        }
+                        else {
+                            const domIdsInCorrespondingBucket = context.config__.slots
+                                .filter(slot => slot.behaviour.bucket === config.bucket)
+                                .map(slot => slot.domId);
+                            context.logger__?.debug(`Refresh ${config.bucket}`, `Trigger ad slots with DOM IDs [${domIdsInCorrespondingBucket.join(', ')}]`);
+                            window.moli.refreshBucket(config.bucket);
+                            observer.unobserve(entry.target);
+                        }
+                    }
+                });
+            }, {
+                root: config.options.rootId
+                    ? window.document.getElementById(config.options.rootId)
+                    : null,
+                threshold: config.options.threshold,
+                rootMargin: config.options.rootMargin
+            });
+            observers.push(observer);
+            if (!context.config__.buckets?.enabled) {
+                context.logger__?.warn(name, "GlobalBucket config isn't enabled");
+            }
+            if (!(context.config__.buckets?.bucket && context.config__.buckets.bucket[config.bucket])) {
+                context.logger__?.error(name, `Lazy-load non-existing bucket with name ${config.bucket}`);
+            }
+            else {
+                const elementToObserve = window.document.getElementById(config.observedDomId);
+                elementToObserve && observer.observe(elementToObserve);
+            }
+        });
+        const { configuredInfiniteSlots, findSlot } = selectInfiniteSlot(context.config__.slots);
+        (infiniteSlotsConfig || []).forEach(config => {
+            const serialNumberLabel = 'data-h5-serial-number';
+            if (configuredInfiniteSlots.length > 0) {
+                const observer = new window.IntersectionObserver(entries => {
+                    entries.forEach((entry) => {
+                        if (entry.isIntersecting) {
+                            const { configuredInfiniteSlot, configSlotDomId } = findSlot(entry.target);
+                            if (configuredInfiniteSlot) {
+                                const serialNumber = entry.target.attributes?.getNamedItem(serialNumberLabel)?.value;
+                                const createdDomId = `${configuredInfiniteSlot.domId}-${serialNumber}`;
+                                entry.target.setAttribute('id', createdDomId);
+                                context.logger__?.debug(name, `Trigger ad slot with newly created DOM ID ${createdDomId}`);
+                                window.moli.refreshInfiniteAdSlot(createdDomId, configuredInfiniteSlot.domId);
+                                observer.unobserve(entry.target);
+                            }
+                            else {
+                                context.logger__?.error(name, `No infinite-scrolling slot configured for ${configSlotDomId}`);
+                                observer.unobserve(entry.target);
+                            }
+                        }
+                    });
+                }, {
+                    root: config.options.rootId
+                        ? window.document.getElementById(config.options.rootId)
+                        : null,
+                    threshold: config.options.threshold,
+                    rootMargin: config.options.rootMargin
+                });
+                observers.push(observer);
+                const infiniteElements = window.document.querySelectorAll(config.selector);
+                infiniteElements.forEach((element, index) => {
+                    element.setAttribute(serialNumberLabel, `${index + 1}`);
+                    element && observer.observe(element);
+                });
+            }
+            else {
+                context.logger__?.warn(name, `No infinite-scrolling slots configured!`);
+            }
+        });
+    };
+    return {
+        name,
+        description,
+        moduleType,
+        config__,
+        configure__,
+        initSteps__,
+        configureSteps__,
+        prepareRequestAdsSteps__,
+        registerIntersectionObservers
+    };
+};

package/lib/ads/modules/lazy-load/selectInfiniteSlot.js

@@ -0,0 +1,11 @@
+export const selectInfiniteSlot = (slots) => {
+    const configuredInfiniteSlots = slots.filter(slot => slot.behaviour.loaded === 'infinite');
+    const findSlot = (target) => {
+        const configSlotDomId = target.getAttribute('data-h5-slot-dom-id');
+        const configuredInfiniteSlot = configSlotDomId
+            ? configuredInfiniteSlots.find(slot => slot.domId === configSlotDomId)
+            : configuredInfiniteSlots[0];
+        return { configuredInfiniteSlot, configSlotDomId };
+    };
+    return { configuredInfiniteSlots, findSlot };
+};

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

@@ -0,0 +1,115 @@
+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__))
+            ];
+        }
+    }
+    initSteps__() {
+        return [];
+    }
+    configureSteps__() {
+        return this._configureSteps;
+    }
+    prepareRequestAdsSteps__() {
+        return [];
+    }
+    static setPrebidFpdConfig(context, config, log) {
+        if (context.config__.prebid) {
+            const keyValues = context.config__.targeting?.keyValues || {};
+            const gptTargeting = config.gptTargetingMappings;
+            context.window__.pbjs.que.push(() => {
+                const existingFpd = context.window__.pbjs.readConfig().ortb2 || {};
+                const ortb2FromKeyValues = mergeDeep({}, config.staticPrebidFirstPartyData, existingFpd);
+                if (gptTargeting) {
+                    const site = {
+                        cat: [],
+                        sectioncat: [],
+                        pagecat: [],
+                        ...ortb2FromKeyValues.site
+                    };
+                    if (gptTargeting.cat) {
+                        const keyValueData = PrebidFirstPartyDataModule.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);
+                    }
+                    if (gptTargeting.pageCat) {
+                        site.pagecat = PrebidFirstPartyDataModule.extractKeyValueArray(gptTargeting.pageCat, keyValues);
+                    }
+                    if (site.cat) {
+                        site.cat = site.cat.filter(uniquePrimitiveFilter);
+                    }
+                    if (site.sectioncat) {
+                        site.sectioncat = site.sectioncat.filter(uniquePrimitiveFilter);
+                    }
+                    if (site.pagecat) {
+                        site.pagecat = site.pagecat.filter(uniquePrimitiveFilter);
+                    }
+                    const provider = config.iabDataProviderName ??
+                        extractTopPrivateDomainFromHostname(context.window__.location.hostname);
+                    if (!config.iabDataProviderName && (gptTargeting.iabV2 || gptTargeting.iabV3)) {
+                        log.debug('PrebidFirstPartyDataModule', 'Targeting for iabV2 or iabV3 was defined, but iabDataProviderName was not configured. Use tld as fallback', provider);
+                    }
+                    site.content = {
+                        ...site.content,
+                        data: site.content?.data?.filter(data => data.name !== provider) ?? []
+                    };
+                    if (gptTargeting.iabV2 && provider) {
+                        const iabV2Ids = PrebidFirstPartyDataModule.extractKeyValueArray(gptTargeting.iabV2, keyValues);
+                        const publisherContentData = {
+                            name: provider,
+                            ext: {
+                                segtax: 6
+                            },
+                            segment: iabV2Ids.map(iabV2Id => ({ id: iabV2Id })).filter(uniquePrimitiveFilter)
+                        };
+                        site.content.data?.push(publisherContentData);
+                    }
+                    if (gptTargeting.iabV3 && provider) {
+                        const iabV3Ids = PrebidFirstPartyDataModule.extractKeyValueArray(gptTargeting.iabV3, keyValues);
+                        const publisherContentData = {
+                            name: provider,
+                            ext: {
+                                segtax: 7
+                            },
+                            segment: iabV3Ids.map(iabV3Id => ({ id: iabV3Id })).filter(uniquePrimitiveFilter)
+                        };
+                        site.content.data?.push(publisherContentData);
+                    }
+                    ortb2FromKeyValues.site = site;
+                }
+                context.window__.pbjs.setConfig({ ortb2: ortb2FromKeyValues });
+            });
+        }
+        return Promise.resolve();
+    }
+    static extractKeyValueArray(key, keyValues) {
+        const value = keyValues[key];
+        if (value) {
+            return typeof value === 'string' ? [value] : value;
+        }
+        else {
+            return [];
+        }
+    }
+}

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

@@ -0,0 +1,59 @@
+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) {
+        if (moduleConfig?.pubstack && moduleConfig.pubstack.enabled) {
+            this.pubstackConfig = moduleConfig.pubstack;
+        }
+    }
+    initSteps__() {
+        const config = this.pubstackConfig;
+        return config
+            ? [
+                mkInitStep('pubstack-init', ctx => {
+                    if (ctx.env__ === 'test') {
+                        return Promise.resolve();
+                    }
+                    ctx.assetLoaderService__
+                        .loadScript({
+                        name: 'pubstack',
+                        loadMethod: AssetLoadMethod.TAG,
+                        assetUrl: `https://boot.pbstck.com/v1/tag/${config.tagId}`
+                    })
+                        .catch(error => ctx.logger__.error('failed to load pubstack', error));
+                    return Promise.resolve();
+                })
+            ]
+            : [];
+    }
+    configureSteps__() {
+        const config = this.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);
+                    }
+                    return Promise.resolve();
+                })
+            ]
+            : [];
+    }
+    prepareRequestAdsSteps__() {
+        return [];
+    }
+}

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

@@ -0,0 +1,63 @@
+const closeButtonDataRef = 'footer-ad-close-button';
+const containerDataRefSelector = '[data-ref=h5-footer-ad-container]';
+const closeButtonDataRefSelector = `[data-ref=${closeButtonDataRef}]`;
+const css = {
+    adSlot: 'h5-footer-ad',
+    container: 'h5-footer-ad-container',
+    footerAdClose: 'h5-footer-ad-close',
+    isShiftedBottom: 'is-shifted-bottom'
+};
+const renderFooterAd = (window, floorAdDomId, disallowedAdvertiserIds, log) => (event) => {
+    const slot = event.slot;
+    const footerAdContainerElement = window.document.body.querySelector(containerDataRefSelector);
+    const footerAdElement = window.document.getElementById(floorAdDomId);
+    const removeFooterAd = () => {
+        if (slot.getSlotElementId() === floorAdDomId && footerAdContainerElement) {
+            window.googletag?.destroySlots([slot]);
+            footerAdContainerElement.remove();
+        }
+    };
+    if (!footerAdContainerElement ||
+        !footerAdElement ||
+        slot.getSlotElementId() !== floorAdDomId ||
+        event.isEmpty ||
+        (!!event.advertiserId && disallowedAdvertiserIds.includes(event.advertiserId)) ||
+        window.matchMedia('(max-width: 767px)').matches) {
+        log.debug('[footer-ad]', 'remove footer ad container');
+        return;
+    }
+    if (window.document.body.querySelector(closeButtonDataRefSelector)) {
+        return;
+    }
+    const footerAdElementClose = document.createElement('button');
+    footerAdElementClose.classList.add(css.footerAdClose);
+    footerAdElementClose.setAttribute('aria-label', 'Anzeige entfernen');
+    footerAdElementClose.setAttribute('data-ref', closeButtonDataRef);
+    footerAdElement.classList.add(css.adSlot);
+    if (Array.isArray(event.size) &&
+        event.size[1] > 200 &&
+        window.matchMedia('(max-height: 800px)').matches) {
+        footerAdElement.classList.add(css.isShiftedBottom);
+    }
+    footerAdContainerElement.classList.add(css.container);
+    footerAdContainerElement.style.setProperty('display', 'block');
+    footerAdContainerElement.appendChild(footerAdElementClose);
+    footerAdElementClose.addEventListener('click', () => removeFooterAd());
+};
+export const setupFooterAdListener = (window, env, log, floorAdDomId, disallowedAdvertiserIds) => {
+    if (env === 'production') {
+        window.googletag
+            .pubads()
+            .addEventListener('slotRenderEnded', renderFooterAd(window, floorAdDomId, disallowedAdvertiserIds, log));
+    }
+    else {
+        renderFooterAd(window, floorAdDomId, disallowedAdvertiserIds, log)({
+            advertiserId: 1,
+            size: [728, 90],
+            isEmpty: false,
+            slot: {
+                getSlotElementId: () => floorAdDomId
+            }
+        });
+    }
+};

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

@@ -0,0 +1,43 @@
+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) {
+        if (moduleConfig?.stickyFooterAd?.enabled) {
+            this.stickyFooterAdConfig = moduleConfig.stickyFooterAd;
+        }
+    }
+    prepareRequestAdsSteps__() {
+        const config = this.stickyFooterAdConfig;
+        return config
+            ? [
+                mkPrepareRequestAdsStep(this.name, LOW_PRIORITY, (ctx, slots) => {
+                    if (config.mobileStickyDomId &&
+                        slots.some(slot => slot.moliSlot.domId === this.stickyFooterAdConfig?.mobileStickyDomId)) {
+                        initMobileAdSticky(ctx.window__, ctx.env__, ctx.logger__, config.mobileStickyDomId, config.disallowedAdvertiserIds, config.initiallyHidden ?? false);
+                    }
+                    if (config.desktopFloorAdDomId &&
+                        slots.some(slot => slot.moliSlot.domId === config.desktopFloorAdDomId)) {
+                        setupFooterAdListener(ctx.window__, ctx.env__, ctx.logger__, config.desktopFloorAdDomId, config.disallowedAdvertiserIds);
+                    }
+                    return Promise.resolve();
+                })
+            ]
+            : [];
+    }
+    configureSteps__() {
+        return [];
+    }
+    initSteps__() {
+        return [];
+    }
+}