@highfivve/ad-tag 5.5.4

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

@@ -0,0 +1,93 @@
+import { mkPrepareRequestAdsStep, HIGH_PRIORITY, mkConfigureStepOncePerRequestAdsCycle } from 'ad-tag/ads/adPipeline';
+export class Cleanup {
+    constructor() {
+        this.name = 'cleanup';
+        this.description = 'cleanup out-of-page formats on navigation or ad-reload';
+        this.moduleType = 'creatives';
+        this.cleanupConfig = null;
+        this.cleanUp = (context, configs) => {
+            configs.forEach(config => {
+                if ('cssSelectors' in config.deleteMethod) {
+                    config.deleteMethod.cssSelectors.forEach((selector) => {
+                        const elements = context.window__.document.querySelectorAll(selector);
+                        context.logger__.debug('Cleanup Module', `Remove elements with selector ${selector} from dom`, elements);
+                        elements.forEach((element) => {
+                            try {
+                                element.remove();
+                            }
+                            catch (e) {
+                                context.logger__.error('Cleanup Module', `Error removing element with selector ${selector}`, e);
+                            }
+                        });
+                    });
+                }
+                else {
+                    config.deleteMethod.jsAsString.forEach(jsLineAsString => {
+                        try {
+                            context.logger__.debug('Cleanup Module', `Try to execute string as JS: '${jsLineAsString}'`);
+                            const jsFunction = new Function(jsLineAsString);
+                            jsFunction();
+                        }
+                        catch (e) {
+                            context.logger__.error('Cleanup Module', `Error executing JS string: '${jsLineAsString}'`, e);
+                        }
+                    });
+                }
+            });
+        };
+        this.hasBidderWonLastAuction = (context, config) => {
+            const prebidWinningBids = context.window__.pbjs.getAllWinningBids();
+            const bidderThatWonLastAuctionOnSlot = prebidWinningBids
+                .filter(bid => bid.adUnitCode === config.domId)
+                .at(-1)?.bidder;
+            return bidderThatWonLastAuctionOnSlot === config.bidder;
+        };
+    }
+    configure__(modulesConfig) {
+        if (modulesConfig?.cleanup && modulesConfig.cleanup.enabled) {
+            this.cleanupConfig = modulesConfig.cleanup;
+        }
+    }
+    config__() {
+        return this.cleanupConfig;
+    }
+    initSteps__() {
+        return [];
+    }
+    configureSteps__() {
+        const config = this.cleanupConfig;
+        return config
+            ? [
+                mkConfigureStepOncePerRequestAdsCycle('destroy-out-of-page-ad-format', (context) => {
+                    if (context.runtimeConfig__.environment === 'test') {
+                        return Promise.resolve();
+                    }
+                    context.window__.pbjs.que.push(() => {
+                        const configsOfDomIdsThatNeedToBeCleaned = config.configs.filter(config => this.hasBidderWonLastAuction(context, config));
+                        this.cleanUp(context, configsOfDomIdsThatNeedToBeCleaned);
+                    });
+                    return Promise.resolve();
+                })
+            ]
+            : [];
+    }
+    prepareRequestAdsSteps__() {
+        const config = this.cleanupConfig;
+        return config
+            ? [
+                mkPrepareRequestAdsStep('cleanup-before-ad-reload', HIGH_PRIORITY, (context, slots) => {
+                    if (context.runtimeConfig__.environment === 'test') {
+                        return Promise.resolve();
+                    }
+                    context.window__.pbjs.que.push(() => {
+                        const configsOfDomIdsThatNeedToBeCleaned = config.configs
+                            .filter(config => slots.map(slot => slot.moliSlot.domId).includes(config.domId))
+                            .filter(config => this.hasBidderWonLastAuction(context, config));
+                        this.cleanUp(context, configsOfDomIdsThatNeedToBeCleaned);
+                    });
+                    return Promise.resolve();
+                })
+            ]
+            : [];
+    }
+}

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

@@ -0,0 +1,47 @@
+import { AssetLoadMethod } from 'ad-tag/util/assetLoaderService';
+import { mkInitStep } from 'ad-tag/ads/adPipeline';
+export class Confiant {
+    constructor() {
+        this.name = 'confiant';
+        this.description = 'ad fraud detection and protection module';
+        this.moduleType = 'ad-fraud';
+        this.gvlid = '56';
+        this.confiantConfig = null;
+    }
+    config__() {
+        return this.confiantConfig;
+    }
+    configure__(moduleConfig) {
+        if (moduleConfig?.confiant && moduleConfig.confiant.enabled) {
+            this.confiantConfig = moduleConfig.confiant;
+        }
+    }
+    initSteps__() {
+        const config = this.confiantConfig;
+        return config ? [mkInitStep('confiant-init', ctx => this.loadConfiant(ctx, config))] : [];
+    }
+    loadConfiant(context, config) {
+        if (context.env__ === 'test') {
+            return Promise.resolve();
+        }
+        if (context.tcData__.gdprApplies &&
+            (!context.tcData__.purpose.consents['1'] ||
+                !(!this.confiantConfig?.checkGVLID || context.tcData__.vendor.consents[this.gvlid]))) {
+            return Promise.resolve();
+        }
+        context.assetLoaderService__
+            .loadScript({
+            name: this.name,
+            loadMethod: AssetLoadMethod.TAG,
+            assetUrl: config.assetUrl
+        })
+            .catch(error => context.logger__.error('failed to load confiant', error));
+        return Promise.resolve();
+    }
+    configureSteps__() {
+        return [];
+    }
+    prepareRequestAdsSteps__() {
+        return [];
+    }
+}

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

@@ -0,0 +1,154 @@
+import { AssetLoadMethod } from 'ad-tag/util/assetLoaderService';
+import { trackInApp } from './trackInApp';
+import { shouldTrackLoginEvent, trackLoginEvent } from './trackLoginEvent';
+import { mkConfigureStepOncePerRequestAdsCycle, mkInitStep } from 'ad-tag/ads/adPipeline';
+export class Emetriq {
+    constructor() {
+        this.name = 'emetriq';
+        this.description = 'Provides Emetriq data collection functionality to Moli.';
+        this.moduleType = 'dmp';
+        this.gvlid = '213';
+        this.emetriqConfig = null;
+    }
+    config__() {
+        return this.emetriqConfig;
+    }
+    configure__(moduleConfig) {
+        if (moduleConfig?.emetriq && moduleConfig.emetriq.enabled) {
+            this.emetriqConfig = moduleConfig.emetriq;
+        }
+    }
+    initSteps__() {
+        const config = this.emetriqConfig;
+        return config
+            ? [
+                mkInitStep('load-emetriq', ctx => {
+                    const customParams = Emetriq.staticCustomParams({ ...ctx.config__.targeting?.keyValues, ...ctx.runtimeConfig__.keyValues }, config.customMappingDefinition);
+                    if (ctx.env__ === 'test') {
+                        return Promise.resolve();
+                    }
+                    if (this.checkIfConsentIsMissing(ctx)) {
+                        return Promise.resolve();
+                    }
+                    Emetriq.syncDelay(ctx, config.syncDelay).then(additionalIdentifier => {
+                        switch (config.os) {
+                            case 'web':
+                                this.loadEmetriqScript(ctx, config, additionalIdentifier, customParams);
+                                break;
+                        }
+                    });
+                    return Promise.resolve();
+                })
+            ]
+            : [];
+    }
+    configureSteps__() {
+        const config = this.emetriqConfig;
+        return config
+            ? [
+                mkConfigureStepOncePerRequestAdsCycle('track-emetriq', ctx => {
+                    const customParams = Emetriq.staticCustomParams({ ...ctx.config__.targeting?.keyValues, ...ctx.runtimeConfig__.keyValues }, config.customMappingDefinition);
+                    if (ctx.env__ === 'test') {
+                        return Promise.resolve();
+                    }
+                    if (this.checkIfConsentIsMissing(ctx)) {
+                        return Promise.resolve();
+                    }
+                    if (config.login &&
+                        shouldTrackLoginEvent(ctx.window__.sessionStorage, Date.now(), ctx.logger__)) {
+                        trackLoginEvent(ctx, config, ctx.window__.document, ctx.logger__);
+                    }
+                    Emetriq.syncDelay(ctx, config.syncDelay).then(additionalIdentifier => {
+                        switch (config.os) {
+                            case 'android':
+                            case 'ios':
+                                trackInApp(ctx, config, additionalIdentifier, customParams, ctx.window__.document);
+                                break;
+                        }
+                    });
+                    return Promise.resolve();
+                })
+            ]
+            : [];
+    }
+    prepareRequestAdsSteps__() {
+        return [];
+    }
+    checkIfConsentIsMissing(ctx) {
+        if (ctx.tcData__.gdprApplies && !ctx.tcData__.vendor.consents[this.gvlid]) {
+            ctx.logger__.warn(this.name, 'missing consent');
+            return true;
+        }
+        return false;
+    }
+    loadEmetriqScript(context, webConfig, additionalIdentifier, additionalCustomParams) {
+        const window = context.window__;
+        window._enqAdpParam = {
+            ...webConfig._enqAdpParam,
+            ...additionalIdentifier,
+            ...additionalCustomParams
+        };
+        return context.assetLoaderService__
+            .loadScript({
+            name: this.name,
+            loadMethod: AssetLoadMethod.TAG,
+            assetUrl: `https://ups.xplosion.de/loader/${webConfig._enqAdpParam.sid}/default.js`
+        })
+            .catch(error => context.logger__.error('failed to load emetriq', error));
+    }
+    static syncDelay(ctx, delay) {
+        if (delay) {
+            if (typeof delay === 'number') {
+                return new Promise(resolve => ctx.window__.setTimeout(() => resolve({}), delay));
+            }
+            else {
+                if (ctx.window__.pbjs) {
+                    return new Promise(resolve => {
+                        ctx.window__.pbjs.que.push(() => {
+                            const listener = () => {
+                                resolve(Emetriq.prebidIdentifiers(ctx));
+                                ctx.window__.pbjs.offEvent('auctionEnd', listener);
+                            };
+                            ctx.window__.pbjs.onEvent('auctionEnd', listener);
+                        });
+                    });
+                }
+                else {
+                    ctx.logger__.error('emetriq', 'No sync delay, because window.pbjs is not defined!');
+                    return Promise.resolve({});
+                }
+            }
+        }
+        return Promise.resolve({});
+    }
+    static staticCustomParams(targeting, mappings) {
+        let additionalCustomParams = {};
+        (mappings ?? []).forEach(({ param, key }) => {
+            const value = targeting[key];
+            if (value) {
+                additionalCustomParams[param] = typeof value === 'string' ? value : value.join(',');
+            }
+        });
+        return additionalCustomParams;
+    }
+    static prebidIdentifiers(ctx) {
+        const identifier = {};
+        const userIds = ctx.window__.pbjs.getUserIds();
+        if (userIds.amxId) {
+            identifier.id_amxid = userIds.amxId;
+        }
+        if (userIds.idl_env) {
+            identifier.id_liveramp = userIds.idl_env;
+        }
+        if (userIds.IDP) {
+            identifier.id_zeotap = userIds.IDP;
+        }
+        if (userIds.pubcid) {
+            identifier.id_sharedid = userIds.pubcid;
+        }
+        if (userIds.id5id) {
+            identifier.id_id5 = userIds.id5id.uid;
+        }
+        return identifier;
+    }
+}

package/lib/ads/modules/emetriq/trackInApp.js

@@ -0,0 +1,34 @@
+const extractDeviceIdParam = (context, advertiserIdKey) => {
+    const deviceId = context.config__.targeting?.keyValues[advertiserIdKey];
+    if (deviceId) {
+        return `&device_id=${typeof deviceId === 'string' ? deviceId : deviceId[0]}`;
+    }
+    return '';
+};
+export const trackInApp = (context, appConfig, additionalIdentifier, additionalCustomParams, document) => {
+    const deviceIdParam = extractDeviceIdParam(context, appConfig.advertiserIdKey);
+    const consentString = context.tcData__.gdprApplies
+        ? `gdpr=1&gdpr_consent=${context.tcData__.tcString}`
+        : 'gdpr=0';
+    const linkParam = appConfig.linkOrKeyword.link
+        ? `&link=${encodeURIComponent(appConfig.linkOrKeyword.link)}`
+        : '';
+    const keywordsParam = appConfig.linkOrKeyword.keywords
+        ? `&keywords=${encodeURIComponent(appConfig.linkOrKeyword.keywords)}`
+        : '';
+    let additionalIdsParam = '';
+    const identifiers = { ...appConfig.additionalIdentifier, ...additionalIdentifier };
+    Object.entries(identifiers).forEach(([key, value]) => {
+        additionalIdsParam += `&${key}=${encodeURIComponent(value)}`;
+    });
+    let additionalCustomParam = '';
+    const customParams = { ...appConfig.customKeywords, ...additionalCustomParams };
+    Object.entries(customParams).forEach(([key, value]) => {
+        additionalCustomParam += `&${key}=${encodeURIComponent(value)}`;
+    });
+    const pixel = document.createElement('img');
+    pixel.src = `https://aps.xplosion.de/data?sid=${appConfig.sid}${deviceIdParam}&os=${appConfig.os}&app_id=${appConfig.appId}${keywordsParam}${linkParam}${additionalIdsParam}${additionalCustomParam}&${consentString}`;
+    pixel.width = 1;
+    pixel.height = 1;
+    document.body.append(pixel);
+};

package/lib/ads/modules/emetriq/trackLoginEvent.js

@@ -0,0 +1,59 @@
+const extractAdIdOrIdfa = (context, moduleConfig) => {
+    if (moduleConfig.os === 'web') {
+        return;
+    }
+    const deviceId = context.config__.targeting?.keyValues[moduleConfig.advertiserIdKey];
+    if (deviceId) {
+        return typeof deviceId === 'string' ? deviceId : deviceId[0];
+    }
+    return;
+};
+export const shouldTrackLoginEvent = (storage, currentDate, logger) => {
+    try {
+        const oneDayMilliseconds = 86400000;
+        const key = 'moli_emetriq';
+        const value = storage.getItem(key);
+        const storedDate = value ? Number.parseInt(value, 10) : 0;
+        const shouldTrack = currentDate - oneDayMilliseconds > storedDate;
+        if (shouldTrack) {
+            storage.setItem(key, currentDate.toString());
+            logger.debug('emetriq', `eligible for login event tracking. Last tracked at ${new Date(storedDate)}`);
+        }
+        return shouldTrack;
+    }
+    catch (e) {
+        logger.error('emetriq', 'could not access session storage', e);
+        return false;
+    }
+};
+export const trackLoginEvent = (context, moduleConfig, document, logger) => {
+    if (!moduleConfig.login) {
+        logger.warn('emetriq', 'login configuration missing!');
+        return;
+    }
+    const url = new URL(`https://xdn-ttp.de/lns/import-event-${moduleConfig.login.partner}`);
+    url.searchParams.append('guid', moduleConfig.login.guid);
+    if (context.tcData__.gdprApplies) {
+        url.searchParams.append('gdpr', '1');
+        url.searchParams.append('gdpr_consent', context.tcData__.tcString);
+    }
+    else {
+        url.searchParams.append('gdpr', '0');
+    }
+    const adIdOrIdfa = extractAdIdOrIdfa(context, moduleConfig);
+    if (adIdOrIdfa) {
+        switch (moduleConfig.os) {
+            case 'android':
+                url.searchParams.append('adid', adIdOrIdfa);
+                break;
+            case 'ios':
+                url.searchParams.append('idfa', adIdOrIdfa);
+                break;
+        }
+    }
+    const pixel = document.createElement('img');
+    pixel.src = url.href;
+    pixel.width = 1;
+    pixel.height = 1;
+    document.body.append(pixel);
+};

package/lib/ads/modules/generic-skin/index.js

@@ -0,0 +1,150 @@
+import { prebidjs } from 'ad-tag/types/prebidjs';
+import { flatten, isNotNull, uniquePrimitiveFilter } from 'ad-tag/util/arrayUtils';
+export const filterHighestNonSkinBid = (bidResponses, blockedAdSlotDomIds) => {
+    const adSlotIds = Object.keys(bidResponses);
+    return flatten(adSlotIds
+        .map(domId => ({ adSlotId: domId, ...bidResponses[domId] }))
+        .filter(bidObject => blockedAdSlotDomIds.indexOf(bidObject.adSlotId) > -1)
+        .filter(bidObject => isNotNull(bidObject.bids))
+        .map(bidObject => bidObject
+        .bids
+        .sort((bid1, bid2) => bid2.cpm - bid1.cpm)
+        .slice(0, 1)));
+};
+export class Skin {
+    constructor() {
+        this.name = 'skin';
+        this.description = 'Block other ad slots if a wallpaper has won the auction';
+        this.moduleType = 'prebid';
+        this.skinModuleConfig = null;
+        this.bidsBackHandler = [];
+        this.getConfigEffect = (config, bidResponses, log) => {
+            const skinBidResponse = bidResponses[config.skinAdSlotDomId];
+            const isSkinBid = (bid) => {
+                const oneFilterApplied = config.formatFilter.some(filter => {
+                    switch (filter.bidder) {
+                        case '*':
+                            return true;
+                        case 'gumgum':
+                            return (bid.bidder === prebidjs.GumGum &&
+                                (filter.auid === undefined ||
+                                    (typeof bid.ad !== 'string' && bid.ad.auid === filter.auid)));
+                        default:
+                            return bid.bidder === filter.bidder;
+                    }
+                });
+                return bid.cpm > 0 && oneFilterApplied;
+            };
+            const nonSkinBids = filterHighestNonSkinBid(bidResponses, config.blockedAdSlotDomIds);
+            const combinedNonSkinCpm = nonSkinBids.reduce((prev, current) => prev + current.cpm, 0);
+            const skinBids = skinBidResponse
+                ?
+                    skinBidResponse.bids.filter(isSkinBid).sort((bid1, bid2) => bid2.cpm - bid1.cpm)
+                : [];
+            const skinConfigEffect = skinBids.length > 0
+                ? skinBids[0].cpm > combinedNonSkinCpm
+                    ?
+                        "BlockOtherSlots"
+                    :
+                        "BlockSkinSlot"
+                :
+                    "NoBlocking";
+            log.debug(this.name, 'nonSkinBids', nonSkinBids);
+            log.debug(this.name, 'skinBids', skinBids);
+            if (config.enableCpmComparison) {
+                return skinConfigEffect;
+            }
+            return skinBids.length > 0 ? "BlockOtherSlots" : "NoBlocking";
+        };
+        this.selectConfig = (skinModuleConfig, bidResponses, log) => skinModuleConfig.configs
+            .map(config => ({
+            skinConfig: config,
+            configEffect: this.getConfigEffect(config, bidResponses, log)
+        }))
+            .find(({ configEffect }) => configEffect !== "NoBlocking");
+        this.destroyAdSlot = (slotDefinitions, gWindow) => (adSlotDomId) => {
+            const adSlots = slotDefinitions
+                .map(slot => slot.adSlot)
+                .filter((slot) => slot.getSlotElementId() === adSlotDomId);
+            gWindow.googletag.destroySlots(adSlots);
+        };
+        this.runSkinConfigs = (skinModuleConfig) => (ctx, bidResponses, slotDefinitions) => {
+            const skinConfigWithEffect = this.selectConfig(skinModuleConfig, bidResponses, ctx.logger__);
+            if (skinConfigWithEffect) {
+                const { skinConfig, configEffect } = skinConfigWithEffect;
+                if (configEffect === "BlockOtherSlots") {
+                    ctx.logger__.debug('SkinModule', 'Skin configuration applied', skinConfig);
+                    skinConfig.blockedAdSlotDomIds.forEach(this.destroyAdSlot(slotDefinitions, ctx.window__));
+                    if (skinConfig.hideBlockedSlots) {
+                        skinConfig.blockedAdSlotDomIds.forEach(this.hideAdSlot(ctx.window__, ctx.logger__));
+                    }
+                    if (skinConfig.hideSkinAdSlot) {
+                        this.hideAdSlot(ctx.window__, ctx.logger__)(skinConfig.skinAdSlotDomId);
+                    }
+                    if (skinConfig.hideBlockedSlotsSelector) {
+                        ctx.window__.document
+                            .querySelectorAll(skinConfig.hideBlockedSlotsSelector)
+                            .forEach(node => {
+                            ctx.logger__.debug('SkinModule', `Set display:none for container with selector ${skinConfig.hideBlockedSlotsSelector}`);
+                            node.style.setProperty('display', 'none');
+                        });
+                    }
+                    if (skinConfig.targeting) {
+                        try {
+                            ctx.window__.googletag
+                                .pubads()
+                                .setTargeting(skinConfig.targeting.key, skinConfig.targeting.value ?? '1');
+                        }
+                        catch (e) {
+                            ctx.logger__.error('SkinModule', e);
+                        }
+                    }
+                }
+                else if (skinConfig.enableCpmComparison) {
+                    ctx.logger__.debug('SkinModule', 'Skin configuration ignored because cpm was low', skinConfig);
+                    this.destroyAdSlot(slotDefinitions, ctx.window__)(skinConfig.skinAdSlotDomId);
+                }
+            }
+            else {
+                skinModuleConfig.configs
+                    .filter(skinConfig => skinConfig.destroySkinSlot)
+                    .map(skinConfig => skinConfig.skinAdSlotDomId)
+                    .filter(uniquePrimitiveFilter)
+                    .forEach(this.destroyAdSlot(slotDefinitions, ctx.window__));
+            }
+        };
+        this.hideAdSlot = (_window, log) => (domId) => {
+            const element = _window.document.getElementById(domId);
+            try {
+                if (element) {
+                    log.debug('SkinModule', `Set display:none for ${domId}`);
+                    element.style.setProperty('display', 'none');
+                }
+            }
+            catch (e) {
+                log.error('SkinModule', `Couldn't set the the wallpaper div ${domId} to display:none;`, e);
+            }
+        };
+    }
+    config__() {
+        return this.skinModuleConfig;
+    }
+    configure__(moduleConfig) {
+        if (moduleConfig?.skin && moduleConfig.skin.enabled) {
+            this.skinModuleConfig = moduleConfig.skin;
+            this.bidsBackHandler.push(this.runSkinConfigs(moduleConfig.skin));
+        }
+    }
+    initSteps__() {
+        return [];
+    }
+    configureSteps__() {
+        return [];
+    }
+    prepareRequestAdsSteps__() {
+        return [];
+    }
+    prebidBidsBackHandler__() {
+        return this.bidsBackHandler;
+    }
+}

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

@@ -0,0 +1,58 @@
+import { mkInitStep } from 'ad-tag/ads/adPipeline';
+import { AssetLoadMethod } from 'ad-tag/util/assetLoaderService';
+export class IdentityLink {
+    constructor() {
+        this.name = 'identitylink';
+        this.description = "Provides LiveRamp's ATS (authenticated traffic solution) functionality to Moli.";
+        this.moduleType = 'identity';
+        this.gvlid = '97';
+        this.identityLinkConfig = null;
+    }
+    config__() {
+        return this.identityLinkConfig;
+    }
+    configure__(moduleConfig) {
+        if (moduleConfig?.identitylink && moduleConfig.identitylink.enabled) {
+            this.identityLinkConfig = moduleConfig.identitylink;
+        }
+    }
+    initSteps__() {
+        const config = this.identityLinkConfig;
+        return config
+            ? [
+                mkInitStep(this.name, ctx => {
+                    this.loadAts(ctx, config);
+                    return Promise.resolve();
+                })
+            ]
+            : [];
+    }
+    configureSteps__() {
+        return [];
+    }
+    prepareRequestAdsSteps__() {
+        return [];
+    }
+    loadAts(context, moduleConfig) {
+        if (context.env__ === 'test') {
+            return Promise.resolve();
+        }
+        if (context.tcData__.gdprApplies && !context.tcData__.vendor.consents[this.gvlid]) {
+            return Promise.resolve();
+        }
+        const window = context.window__;
+        window.addEventListener('envelopeModuleReady', () => {
+            window.atsenvelopemodule.setAdditionalData({
+                type: 'emailHashes',
+                id: moduleConfig.hashedEmailAddresses
+            });
+        });
+        return context.assetLoaderService__
+            .loadScript({
+            name: this.name,
+            loadMethod: AssetLoadMethod.TAG,
+            assetUrl: `https://launchpad-wrapper.privacymanager.io/${moduleConfig.launchPadId}/launchpad-liveramp.js`
+        })
+            .catch(error => context.logger__.error('failed to load emetriq', error));
+    }
+}

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

@@ -0,0 +1,38 @@
+import { LOW_PRIORITY, mkPrepareRequestAdsStep } from 'ad-tag/ads/adPipeline';
+import { initInterstitialModule } from 'ad-tag/ads/modules/interstitial/interstitialAd';
+export const createInterstitialModule = () => {
+    let interstitialModuleConfig = null;
+    return {
+        name: 'interstitial-module',
+        description: 'interstitial ad creatives',
+        moduleType: 'creatives',
+        config__() {
+            return interstitialModuleConfig;
+        },
+        configure__(moduleConfig) {
+            if (moduleConfig?.interstitial && moduleConfig.interstitial.enabled) {
+                interstitialModuleConfig = moduleConfig.interstitial;
+            }
+        },
+        prepareRequestAdsSteps__() {
+            const config = interstitialModuleConfig;
+            return config
+                ? [
+                    mkPrepareRequestAdsStep('interstitial-module', LOW_PRIORITY, (ctx, slots) => {
+                        const interstitialSlot = slots.find(slot => slot.moliSlot.domId === config.interstitialDomId);
+                        if (interstitialSlot) {
+                            initInterstitialModule(ctx.window__, ctx.env__, ctx.logger__, interstitialSlot.moliSlot.domId, config.disallowedAdvertiserIds, config.closeAutomaticallyAfterMs);
+                        }
+                        return Promise.resolve();
+                    })
+                ]
+                : [];
+        },
+        configureSteps__() {
+            return [];
+        },
+        initSteps__() {
+            return [];
+        }
+    };
+};