@highfivve/ad-tag 5.5.4

package/lib/ads/auctions/frequencyCapping.js

@@ -0,0 +1,189 @@
+import { remainingTime } from './resume';
+import { resolveAdUnitPath } from '../adUnitPath';
+import { formatKey } from 'ad-tag/ads/keyValues';
+import { isGamInterstitial } from 'ad-tag/ads/auctions/interstitialContext';
+const sessionStorageKey = 'h5v-fc';
+const hasPacingInterval = (config) => !!config.conditions && !!config.conditions.pacingInterval;
+export const createFrequencyCapping = (config, _window, now, logger) => {
+    const positionImpSchedules = new Map();
+    const positionLastImpressionNumberOfAdRequests = new Map();
+    const bidderImpSchedules = new Map();
+    const positionAdRequests = new Map();
+    let numAdRequests = 0;
+    const pacingIntervalConfigs = config.bidders?.filter(hasPacingInterval) ?? [];
+    const bidWonConfigs = pacingIntervalConfigs.filter(config => !config.conditions.pacingInterval?.events ||
+        config.conditions.pacingInterval?.events?.includes('bidWon')) ?? [];
+    const bidRequestedConfigs = pacingIntervalConfigs.filter(config => config.conditions.pacingInterval?.events?.includes('bidRequested')) ?? [];
+    let resolvedAdUnitPathPositionConfigs = config.positions || [];
+    const persist = () => {
+        if (config.persistent === true) {
+            const data = {
+                bCaps: Array.from(bidderImpSchedules.entries()).reduce((acc, [key, schedules]) => ({ ...acc, [key]: schedules }), {}),
+                pCaps: Array.from(positionImpSchedules.entries()).reduce((acc, [adUnitPath, schedules]) => ({ ...acc, [adUnitPath]: schedules }), {}),
+                pLastImpAdRequests: Array.from(positionLastImpressionNumberOfAdRequests.entries()).reduce((acc, [adUnitPath, numAdRequests]) => ({ ...acc, [adUnitPath]: numAdRequests }), {}),
+                requestAds: numAdRequests
+            };
+            _window.sessionStorage.setItem(sessionStorageKey, JSON.stringify(data));
+        }
+    };
+    const cap = (startTimestamp, config, intervalInMs, bid) => {
+        const bidders = config.bidders;
+        if ((!bidders || bidders.includes(bid.bidder)) && config.domId === bid.adUnitCode) {
+            const key = `${bid.adUnitCode}:${bid.bidder}`;
+            const currentSchedules = bidderImpSchedules.get(key) ?? [];
+            currentSchedules.push({
+                ts: startTimestamp,
+                wait: intervalInMs
+            });
+            bidderImpSchedules.set(key, currentSchedules);
+            _window.setTimeout(() => {
+                logger.debug('fc', `removing ${key} at ${startTimestamp}`);
+                const schedules = bidderImpSchedules.get(key);
+                if (schedules) {
+                    bidderImpSchedules.set(key, schedules.filter(s => s.ts !== startTimestamp));
+                }
+            }, intervalInMs);
+            persist();
+        }
+    };
+    const capPosition = (startTimestamp, adUnitPath, pacingInterval) => {
+        const currentSchedules = positionImpSchedules.get(adUnitPath) ?? [];
+        currentSchedules.push({ ts: startTimestamp, wait: pacingInterval.intervalInMs });
+        positionImpSchedules.set(adUnitPath, currentSchedules);
+        _window.setTimeout(() => {
+            const schedules = positionImpSchedules.get(adUnitPath);
+            if (schedules) {
+                positionImpSchedules.set(adUnitPath, schedules.filter(s => s.ts !== startTimestamp));
+            }
+        }, pacingInterval.intervalInMs);
+        persist();
+    };
+    const onSlotRenderEndedOrImpressionViewable = (adUnitPath) => {
+        resolvedAdUnitPathPositionConfigs
+            .filter(config => config.adUnitPath === adUnitPath)
+            .forEach(config => {
+            if (config.conditions.pacingInterval) {
+                capPosition(now(), adUnitPath, config.conditions.pacingInterval);
+            }
+            if (config.conditions.pacingRequestAds) {
+                positionLastImpressionNumberOfAdRequests.set(adUnitPath, numAdRequests);
+                persist();
+            }
+        });
+    };
+    if (config.persistent === true) {
+        const storedData = _window.sessionStorage.getItem(sessionStorageKey);
+        if (storedData) {
+            try {
+                const parsedData = JSON.parse(storedData);
+                numAdRequests = parsedData.requestAds;
+                Object.entries(parsedData.bCaps).forEach(([adUnitBidderKey, schedules]) => {
+                    schedules?.forEach(schedule => {
+                        const [adUnitCode, bidder] = adUnitBidderKey.split(':');
+                        const blockedForMs = remainingTime(schedule, now());
+                        cap(now(), { domId: adUnitCode, bidders: [bidder] }, blockedForMs, {
+                            bidder,
+                            adUnitCode
+                        });
+                    });
+                });
+                Object.entries(parsedData.pCaps).forEach(([adUnitPath, schedules]) => {
+                    schedules?.forEach(schedule => {
+                        const blockedForMs = remainingTime(schedule, now());
+                        capPosition(schedule.ts, adUnitPath, { intervalInMs: blockedForMs });
+                    });
+                });
+            }
+            catch (e) {
+                logger.error('fc', 'failed to parse fc state', e);
+            }
+        }
+    }
+    return {
+        onSlotRequested(event) {
+            resolvedAdUnitPathPositionConfigs
+                .filter(config => config.adUnitPath === event.slot.getAdUnitPath())
+                .forEach(config => {
+                if (config.conditions.adRequestLimit) {
+                    const adUnitPath = config.adUnitPath;
+                    const currentAdRequests = positionAdRequests.get(adUnitPath) ?? 0;
+                    positionAdRequests.set(adUnitPath, currentAdRequests + 1);
+                }
+            });
+        },
+        onAuctionEnd(auction) {
+            bidRequestedConfigs.forEach(config => {
+                auction.bidderRequests?.forEach(bidderRequests => {
+                    bidderRequests?.bids?.forEach(bid => {
+                        cap(now(), config, config.conditions.pacingInterval.intervalInMs, bid);
+                    });
+                });
+            });
+            persist();
+        },
+        onBidWon(bid) {
+            bidWonConfigs.forEach(config => cap(now(), config, config.conditions.pacingInterval.intervalInMs, bid));
+            persist();
+        },
+        onSlotRenderEnded(event) {
+            const [format] = event.slot.getTargeting(formatKey);
+            if (!event.isEmpty &&
+                format !== 5..toString()) {
+                onSlotRenderEndedOrImpressionViewable(event.slot.getAdUnitPath());
+            }
+        },
+        onImpressionViewable(event) {
+            const [format] = event.slot.getTargeting(formatKey);
+            if (format === 5..toString()) {
+                onSlotRenderEndedOrImpressionViewable(event.slot.getAdUnitPath());
+            }
+        },
+        beforeRequestAds() {
+            positionAdRequests.clear();
+        },
+        afterRequestAds() {
+            numAdRequests++;
+            persist();
+        },
+        updateAdUnitPaths(adUnitPathVariables) {
+            resolvedAdUnitPathPositionConfigs = (config.positions ?? []).map(config => {
+                return { ...config, adUnitPath: resolveAdUnitPath(config.adUnitPath, adUnitPathVariables) };
+            });
+        },
+        isAdUnitCapped(slot) {
+            const adUnitPath = slot.getAdUnitPath();
+            const isGamInst = isGamInterstitial(slot, _window);
+            return resolvedAdUnitPathPositionConfigs
+                .filter(config => config.adUnitPath === adUnitPath)
+                .some(positionConfig => {
+                return ((positionConfig.adUnitPath === adUnitPath &&
+                    positionConfig.conditions.delay &&
+                    numAdRequests <
+                        positionConfig.conditions.delay.minRequestAds - (isGamInst ? 1 : 0)) ||
+                    (positionConfig.conditions.pacingRequestAds &&
+                        positionLastImpressionNumberOfAdRequests.has(adUnitPath) &&
+                        numAdRequests - (positionLastImpressionNumberOfAdRequests.get(adUnitPath) ?? 0) <
+                            positionConfig.conditions.pacingRequestAds.requestAds) ||
+                    (positionConfig.conditions.pacingInterval &&
+                        (positionImpSchedules.get(adUnitPath) ?? []).length >=
+                            positionConfig.conditions.pacingInterval.maxImpressions) ||
+                    (positionConfig.conditions.adRequestLimit &&
+                        (positionAdRequests.get(adUnitPath) ?? 0) >=
+                            positionConfig.conditions.adRequestLimit.maxAdRequests));
+            });
+        },
+        isBidderCapped(slotId, bidder) {
+            if (!config.bidders) {
+                return false;
+            }
+            return config.bidders
+                .filter(c => c.domId === slotId && (!c.bidders || c.bidders.includes(bidder)))
+                .some(({ conditions: { pacingInterval, delay } }) => {
+                return ((pacingInterval &&
+                    (bidderImpSchedules.get(`${slotId}:${bidder}`) ?? []).length >=
+                        pacingInterval.maxImpressions) ||
+                    (delay && numAdRequests < delay.minRequestAds));
+            });
+        }
+    };
+};

package/lib/ads/auctions/interstitialContext.js

@@ -0,0 +1,92 @@
+import { resolveAdUnitPath } from 'ad-tag/ads/adUnitPath';
+import { formatKey } from 'ad-tag/ads/keyValues';
+export const isGamInterstitial = (slot, window) => {
+    const [value] = slot.getTargeting(formatKey);
+    return !!value && value === window.googletag.enums.OutOfPageFormat.INTERSTITIAL.toString();
+};
+export const createInterstitialContext = (config, window__, now, logger) => {
+    const sessionStorageKey = 'h5v_intstl';
+    const sessionStorageTimeToLive = config.ttlStorage ?? 30 * 60 * 1000;
+    const currentTime = now();
+    let interstitialAdUnitPath = config.adUnitPath;
+    let currentInterstitialState = {
+        priority: config.priority,
+        updatedAt: currentTime
+    };
+    try {
+        const sessionState = window__.sessionStorage.getItem(sessionStorageKey);
+        if (sessionState) {
+            const parsedState = JSON.parse(sessionState);
+            if (currentTime - parsedState.updatedAt < sessionStorageTimeToLive) {
+                currentInterstitialState = parsedState;
+            }
+            else {
+                currentInterstitialState.updatedAt = currentTime;
+            }
+        }
+    }
+    catch (e) {
+        logger.error('interstitial', 'failed to load interstitial state from session storage', e);
+    }
+    if (config.priority.length === 0) {
+        logger.error('interstitial', 'no interstitial priority configured');
+    }
+    const persistInterstitialState = () => {
+        currentInterstitialState.updatedAt = now();
+        try {
+            window.sessionStorage.setItem(sessionStorageKey, JSON.stringify(currentInterstitialState));
+        }
+        catch (e) {
+            logger.error('interstitial', 'failed to persist interstitial state to session storage', e);
+        }
+    };
+    const shiftDemandPriority = (arr) => {
+        if (arr.length === 0) {
+            return [];
+        }
+        return [...arr.slice(1), arr[0]];
+    };
+    const onSlotRenderEnded = (event) => {
+        if (event.slot.getAdUnitPath() !== interstitialAdUnitPath) {
+            return;
+        }
+        if (event.isEmpty) {
+            currentInterstitialState.priority = shiftDemandPriority(currentInterstitialState.priority);
+            persistInterstitialState();
+        }
+    };
+    const onImpressionViewable = (event) => {
+        if (event.slot.getAdUnitPath() !== interstitialAdUnitPath) {
+            return;
+        }
+        if (isGamInterstitial(event.slot, window__)) {
+            currentInterstitialState.priority = shiftDemandPriority(currentInterstitialState.priority);
+            persistInterstitialState();
+        }
+    };
+    const onAuctionEnd = (event) => {
+        if (!event.adUnitCodes.includes(config.domId)) {
+            return;
+        }
+        const interstitialBids = event.bidsReceived?.filter(bid => bid.adUnitCode === config.domId);
+        if ((interstitialBids?.length ?? 0) === 0) {
+            currentInterstitialState.priority = shiftDemandPriority(currentInterstitialState.priority);
+            persistInterstitialState();
+        }
+    };
+    const interstitialChannel = () => {
+        return currentInterstitialState.priority[0];
+    };
+    return {
+        interstitialChannel,
+        onSlotRenderEnded,
+        onImpressionViewable,
+        onAuctionEnd,
+        interstitialState: () => {
+            return currentInterstitialState;
+        },
+        updateAdUnitPaths: (variables) => {
+            interstitialAdUnitPath = resolveAdUnitPath(config.adUnitPath, variables);
+        }
+    };
+};

package/lib/ads/auctions/previousBidCpms.js

@@ -0,0 +1,33 @@
+export const createPreviousBidCpms = () => {
+    const lastBidCpms = new Map();
+    const groupReceivedBidsByAdUnitCode = (bidsReceived) => {
+        return bidsReceived.reduce((result, current) => {
+            const { adUnitCode, cpm } = current;
+            if (!result[adUnitCode]) {
+                result[adUnitCode] = [];
+            }
+            result[adUnitCode].push(cpm);
+            return result;
+        }, {});
+    };
+    const onAuctionEnd = (bidsReceived) => {
+        const bidsOfLastAuction = groupReceivedBidsByAdUnitCode(bidsReceived);
+        lastBidCpms.forEach((_, key) => {
+            if (!bidsOfLastAuction[key]) {
+                lastBidCpms.delete(key);
+            }
+        });
+        Object.entries(bidsOfLastAuction).forEach(([adUnitCode, cpmsOfLastAuction]) => {
+            const earlierCpmsOnPosition = getLastBidCpms(adUnitCode) ?? [];
+            lastBidCpms.set(adUnitCode, Array.from(new Set([...cpmsOfLastAuction, ...earlierCpmsOnPosition])));
+        });
+    };
+    const getLastBidCpms = (adUnitCode) => {
+        return lastBidCpms.get(adUnitCode) ?? null;
+    };
+    return {
+        groupReceivedBidsByAdUnitCode,
+        onAuctionEnd,
+        getLastBidCpms
+    };
+};

package/lib/ads/auctions/resume.js

@@ -0,0 +1,3 @@
+export const remainingTime = (data, now) => {
+    return Math.max(data.wait - (now - data.ts), 0);
+};

package/lib/ads/bridge/bridge.js

@@ -0,0 +1,62 @@
+import { mkInitStep } from 'ad-tag/ads/adPipeline';
+import { isPlainObject } from 'ad-tag/util/objectUtils';
+const findAdSlot = (message, googletag) => googletag
+    .pubads()
+    .getSlots()
+    .find(slot => slot.getSlotElementId() === message.domId || slot.getAdUnitPath() === message.adUnitPath);
+const parseMessageData = (data) => {
+    try {
+        const message = typeof data === 'string' ? JSON.parse(data) : isPlainObject(data) ? data : null;
+        switch (message?.event) {
+            case 'h5.adunit.passback':
+                return message.passbackOrigin && (message.domId || message.adUnitPath) ? message : null;
+            case 'h5.adunit.refresh':
+                return message;
+            default:
+                return null;
+        }
+    }
+    catch (err) {
+        return null;
+    }
+};
+const handleRefresh = (message, context) => {
+    const backfillMoliSlot = context.config__.slots.find(slot => slot.domId === message.domId && slot.behaviour.loaded === 'backfill');
+    const adSlot = findAdSlot(message, context.window__.googletag);
+    if (backfillMoliSlot && adSlot) {
+        context.logger__.debug('bridge', `Refresh ad slot ${message.domId}`);
+        context.window__.googletag.destroySlots([adSlot]);
+        context.window__.moli
+            .refreshAdSlot(message.domId, { loaded: 'backfill' })
+            .catch(e => context.logger__.error('bridge', `failed to refresh ${message.domId}`, e));
+    }
+};
+const handlePassback = (message, context) => {
+    const adSlot = findAdSlot(message, context.window__.googletag);
+    const passbackKey = 'passback';
+    if (adSlot && adSlot.getTargeting(passbackKey).length === 0) {
+        context.logger__.debug('passback', `Process passback for ad slot ${adSlot.getAdUnitPath()}`);
+        adSlot.setTargeting(passbackKey, 'true');
+        adSlot.setTargeting('passbackOrigin', message.passbackOrigin);
+        context.window__.googletag.pubads().refresh([adSlot]);
+    }
+};
+export const bridgeInitStep = () => mkInitStep('bridge', (context) => {
+    if (context.config__.bridge?.enabled) {
+        context.logger__.debug('bridge', 'add message listener');
+        context.window__.addEventListener('message', (event) => {
+            const message = parseMessageData(event.data);
+            if (message) {
+                switch (message.event) {
+                    case 'h5.adunit.passback':
+                        handlePassback(message, context);
+                        break;
+                    case 'h5.adunit.refresh':
+                        handleRefresh(message, context);
+                        break;
+                }
+            }
+        });
+    }
+    return Promise.resolve();
+});

package/lib/ads/consent.js

@@ -0,0 +1,63 @@
+import { tcfapi } from '../types/tcfapi';
+var EventStatus = tcfapi.status.EventStatus;
+var CmpStatus = tcfapi.status.CmpStatus;
+const allPurposes = [
+    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
+];
+export const missingPurposeConsent = (tcData) => {
+    return (!!tcData.gdprApplies &&
+        allPurposes.some(p => !tcData.purpose.consents[p]));
+};
+export const consentReady = (consentConfig, window, log, env) => {
+    if (env === 'test') {
+        log.info('gdprApplies is set to false in test mode!');
+    }
+    if (env === 'test' || consentConfig.enabled === false) {
+        return Promise.resolve({
+            gdprApplies: false,
+            eventStatus: EventStatus.TC_LOADED,
+            cmpStatus: CmpStatus.LOADED,
+            cmpId: 0,
+            cmpVersion: 0,
+            tcfPolicyVersion: undefined,
+            listenerId: null
+        });
+    }
+    return new Promise((resolve, reject) => {
+        if (window.__tcfapi) {
+            const listener = (tcData) => {
+                if (tcData.cmpStatus === 'error') {
+                    reject(tcData);
+                }
+                else if (tcData.eventStatus === 'useractioncomplete' ||
+                    tcData.eventStatus === 'tcloaded') {
+                    log.debug('Consent', 'consent ready', tcData);
+                    if (consentConfig.disableLegitimateInterest && missingPurposeConsent(tcData)) {
+                        reject('user consent is missing for some purposes');
+                    }
+                    else {
+                        resolve(tcData);
+                    }
+                    if (tcData.listenerId) {
+                        window.__tcfapi('removeEventListener', 2, () => {
+                            return;
+                        }, tcData.listenerId);
+                    }
+                }
+            };
+            window.__tcfapi('addEventListener', 2, listener);
+        }
+        else {
+            reject('window.__tcfapi is not defined. Make sure that the stub code is inlined in the head tag');
+        }
+    });
+};

package/lib/ads/eventService.js

@@ -0,0 +1,44 @@
+export const createEventService = () => {
+    const eventListeners = new Map();
+    const oneTimeListeners = new Map();
+    return {
+        addEventListener(event, listener, options = {}) {
+            const targetMap = options.once ? oneTimeListeners : eventListeners;
+            if (!targetMap.has(event)) {
+                targetMap.set(event, new Set());
+            }
+            targetMap.get(event)?.add(listener);
+        },
+        removeEventListener(event, listener) {
+            eventListeners.get(event)?.delete(listener);
+            oneTimeListeners.get(event)?.delete(listener);
+        },
+        emit(event, data) {
+            eventListeners.get(event)?.forEach(listener => {
+                try {
+                    listener(data);
+                }
+                catch (error) {
+                    console.error(`Error in event listener for ${String(event)}:`, error);
+                }
+            });
+            const oneTimeListenersForEvent = oneTimeListeners.get(event);
+            if (oneTimeListenersForEvent) {
+                oneTimeListenersForEvent.forEach(listener => {
+                    try {
+                        listener(data);
+                    }
+                    catch (error) {
+                        console.error(`Error in one-time event listener for ${String(event)}:`, error);
+                    }
+                    finally {
+                        oneTimeListenersForEvent.delete(listener);
+                    }
+                });
+                if (oneTimeListenersForEvent.size === 0) {
+                    oneTimeListeners.delete(event);
+                }
+            }
+        }
+    };
+};

package/lib/ads/globalAuctionContext.js

@@ -0,0 +1,98 @@
+import { createBiddersDisabling } from './auctions/biddersDisabling';
+import { createAdRequestThrottling } from './auctions/adRequestThrottling';
+import { createFrequencyCapping } from './auctions/frequencyCapping';
+import { createPreviousBidCpms } from './auctions/previousBidCpms';
+import { mkConfigureStep } from './adPipeline';
+import { createInterstitialContext } from 'ad-tag/ads/auctions/interstitialContext';
+export const createGlobalAuctionContext = (window, logger, eventService, config = {}) => {
+    const biddersDisabling = config.biddersDisabling?.enabled
+        ? createBiddersDisabling(config.biddersDisabling, window)
+        : undefined;
+    const adRequestThrottling = config.adRequestThrottling?.enabled
+        ? createAdRequestThrottling(config.adRequestThrottling, window)
+        : undefined;
+    const frequencyCapping = config.frequencyCap?.enabled
+        ? createFrequencyCapping(config.frequencyCap, window, window.Date.now, logger)
+        : undefined;
+    const previousBidCpms = config.previousBidCpms?.enabled ? createPreviousBidCpms() : undefined;
+    const interstitial = config.interstitial?.enabled
+        ? createInterstitialContext(config.interstitial, window, window.Date.now, logger)
+        : undefined;
+    window.pbjs = window.pbjs || { que: [] };
+    window.googletag = window.googletag || {};
+    window.googletag.cmd = window.googletag.cmd || [];
+    if (config.biddersDisabling?.enabled ||
+        config.previousBidCpms?.enabled ||
+        config.frequencyCap?.enabled ||
+        config.interstitial?.enabled) {
+        window.pbjs.que.push(() => {
+            window.pbjs.onEvent('auctionEnd', auction => {
+                biddersDisabling?.onAuctionEnd(auction);
+                interstitial?.onAuctionEnd(auction);
+                if (config.previousBidCpms?.enabled && auction.bidsReceived) {
+                    previousBidCpms?.onAuctionEnd(auction.bidsReceived);
+                }
+                frequencyCapping?.onAuctionEnd(auction);
+            });
+        });
+    }
+    if (config.adRequestThrottling?.enabled || config.frequencyCap?.enabled) {
+        window.googletag.cmd.push(() => {
+            window.googletag.pubads().addEventListener('slotRequested', event => {
+                adRequestThrottling?.onSlotRequested(event);
+                frequencyCapping?.onSlotRequested(event);
+            });
+        });
+    }
+    if (config.frequencyCap?.enabled) {
+        window.pbjs.que.push(() => {
+            window.pbjs.onEvent('bidWon', bid => {
+                if (config.frequencyCap) {
+                    frequencyCapping?.onBidWon(bid);
+                }
+            });
+        });
+        eventService.addEventListener('beforeRequestAds', () => {
+            frequencyCapping?.beforeRequestAds();
+        });
+        eventService.addEventListener('afterRequestAds', () => {
+            frequencyCapping?.afterRequestAds();
+        });
+    }
+    if (config.frequencyCap?.enabled || config.interstitial?.enabled) {
+        window.googletag.cmd.push(() => {
+            window.googletag.pubads().addEventListener('slotRenderEnded', event => {
+                frequencyCapping?.onSlotRenderEnded(event);
+                interstitial?.onSlotRenderEnded(event);
+            });
+            window.googletag.pubads().addEventListener('impressionViewable', event => {
+                frequencyCapping?.onImpressionViewable(event);
+            });
+        });
+    }
+    const configureStep = mkConfigureStep('GlobalAuctionContext', context => {
+        frequencyCapping?.updateAdUnitPaths(context.adUnitPathVariables__);
+        return Promise.resolve();
+    });
+    return {
+        isSlotThrottled(slot) {
+            return !!(adRequestThrottling?.isThrottled(slot.getSlotElementId()) ||
+                frequencyCapping?.isAdUnitCapped(slot));
+        },
+        isBidderFrequencyCappedOnSlot(slotId, bidder) {
+            return frequencyCapping?.isBidderCapped(slotId, bidder) ?? false;
+        },
+        getLastBidCpmsOfAdUnit(slotId) {
+            return previousBidCpms?.getLastBidCpms(slotId) ?? [];
+        },
+        isBidderDisabled(domId, bidder) {
+            return biddersDisabling?.isBidderDisabled(domId, bidder) ?? false;
+        },
+        interstitialChannel: () => {
+            return interstitial?.interstitialChannel();
+        },
+        configureStep() {
+            return configureStep;
+        }
+    };
+};