@highfivve/ad-tag 5.5.4

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

@@ -0,0 +1,93 @@
+const adStickyContainerDataRef = '[data-ref=sticky-ad]';
+const adStickyCloseButtonDataRef = '[data-ref=sticky-ad-close]';
+const adVisibleClass = 'h5-sticky-ad--visible';
+const hideAdSlot = (adSticky) => {
+    adSticky.style.setProperty('display', 'none');
+    adSticky.classList.remove(adVisibleClass);
+};
+const showAdSlot = (adSticky) => {
+    adSticky.style.setProperty('display', 'block');
+    adSticky.classList.add(adVisibleClass);
+};
+const stickyRenderedEvent = (adSticky, mobileStickyDomId, disallowedAdvertiserIds, window) => new Promise(resolve => {
+    const listener = (event) => {
+        if (event.slot.getSlotElementId() !== mobileStickyDomId) {
+            return;
+        }
+        if (event.isEmpty) {
+            if (adSticky) {
+                hideAdSlot(adSticky);
+            }
+            resolve('empty');
+        }
+        else if (!!event.advertiserId && disallowedAdvertiserIds.includes(event.advertiserId)) {
+            resolve('disallowed');
+        }
+        else {
+            resolve('standard');
+        }
+        window.googletag.pubads().removeEventListener('slotRenderEnded', listener);
+    };
+    window.googletag.cmd.push(() => {
+        window.googletag.pubads().addEventListener('slotRenderEnded', listener);
+    });
+});
+const stickyOnLoadEvent = (mobileStickyDomId, window) => new Promise(resolve => {
+    const listener = (event) => {
+        if (event.slot.getSlotElementId() !== mobileStickyDomId) {
+            return;
+        }
+        resolve();
+        window.googletag.pubads().removeEventListener('slotOnload', listener);
+    };
+    window.googletag.pubads().addEventListener('slotOnload', listener);
+});
+export const initMobileAdSticky = (window, env, log, mobileStickyDomId, disallowedAdvertiserIds, initiallyHidden) => {
+    const adSticky = window.document.querySelector(adStickyContainerDataRef);
+    const closeButton = window.document.querySelector(adStickyCloseButtonDataRef);
+    if (adSticky && closeButton) {
+        log.debug('mobile-sticky-ad', 'Running initAdSticky with defined sticky container and close button');
+        if (!initiallyHidden) {
+            showAdSlot(adSticky);
+        }
+        closeButton.addEventListener('click', () => {
+            hideAdSlot(adSticky);
+            const slot = window.googletag
+                .pubads()
+                .getSlots()
+                .find(slot => slot.getSlotElementId() === mobileStickyDomId);
+            if (slot) {
+                window.googletag.destroySlots([slot]);
+            }
+        }, { once: true, passive: true });
+        if (env === 'production') {
+            const onRenderResult = ([renderResult]) => {
+                log.debug('mobile-sticky-ad', `result ${renderResult}`);
+                if (renderResult === 'disallowed') {
+                    log.debug('mobile-sticky-ad', 'hide mobile sticky container');
+                    if (adSticky) {
+                        hideAdSlot(adSticky);
+                    }
+                    return Promise.resolve();
+                }
+                else if (renderResult === 'standard') {
+                    if (initiallyHidden) {
+                        showAdSlot(adSticky);
+                    }
+                    return Promise.all([
+                        stickyRenderedEvent(adSticky, mobileStickyDomId, disallowedAdvertiserIds, window),
+                        stickyOnLoadEvent(mobileStickyDomId, window)
+                    ]).then(onRenderResult);
+                }
+                return Promise.resolve();
+            };
+            Promise.all([
+                stickyRenderedEvent(adSticky, mobileStickyDomId, disallowedAdvertiserIds, window),
+                stickyOnLoadEvent(mobileStickyDomId, window)
+            ]).then(onRenderResult);
+        }
+    }
+    else {
+        log.warn('[mobile-sticky]', `Could not find adSticky container ${adStickyContainerDataRef} or closeButton ${adStickyCloseButtonDataRef}`, adSticky, closeButton);
+    }
+};

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

@@ -0,0 +1,118 @@
+const adStickyContainerDataRef = '[data-ref=h5v-sticky-ad]';
+const adStickyCloseButtonDataRef = '[data-ref=h5v-sticky-ad-close]';
+const adStickyCloseButtonContent = '.h5v-closeButtonContent';
+const adStickyHidingClass = 'h5v-footerAd--hidden';
+const desktopInitialHidingClass = 'h5v-footerAd--hidden-d';
+const mobileInitialHidingClass = 'h5v-footerAd--hidden-m';
+const stickyRenderedEvent = (mobileStickyDomId, disallowedAdvertiserIds, window) => new Promise(resolve => {
+    const listener = (event) => {
+        if (event.slot.getSlotElementId() !== mobileStickyDomId) {
+            return;
+        }
+        if (event.isEmpty) {
+            resolve('empty');
+        }
+        else if (event.advertiserId && disallowedAdvertiserIds.includes(event.advertiserId)) {
+            resolve('disallowed');
+        }
+        else {
+            resolve('standard');
+        }
+        window.googletag.pubads().removeEventListener('slotRenderEnded', listener);
+    };
+    window.googletag.cmd.push(() => {
+        window.googletag.pubads().addEventListener('slotRenderEnded', listener);
+    });
+});
+const stickyOnLoadEvent = (footerStickyDomId, window) => new Promise(resolve => {
+    const listener = (event) => {
+        if (event.slot.getSlotElementId() !== footerStickyDomId) {
+            return;
+        }
+        resolve();
+        window.googletag.pubads().removeEventListener('slotOnload', listener);
+    };
+    window.googletag.pubads().addEventListener('slotOnload', listener);
+});
+const hideAdSlot = (element) => {
+    element.classList.add(adStickyHidingClass);
+};
+const showAdSlot = (element) => {
+    element.classList.remove(adStickyHidingClass, desktopInitialHidingClass, mobileInitialHidingClass);
+};
+export const initAdSticky = (window, env, log, footerStickyDomId, disallowedAdvertiserIds, closingButtonText) => {
+    const stickyAd = 'sticky-ad';
+    const adSticky = window.document.querySelector(adStickyContainerDataRef);
+    const closeButton = window.document.querySelector(adStickyCloseButtonDataRef);
+    const closeButtonContent = window.document.querySelector(adStickyCloseButtonContent);
+    if (adSticky && closeButton) {
+        log.debug(stickyAd, 'Running initAdSticky with defined sticky container and close button');
+        if (!closeButtonContent) {
+            if (!closingButtonText) {
+                if (!closeButton.querySelector('svg')) {
+                    const closeButtonSvg = window.document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+                    closeButtonSvg.setAttribute('width', '24');
+                    closeButtonSvg.setAttribute('height', '24');
+                    const closeButtonPath = window.document.createElementNS('http://www.w3.org/2000/svg', 'path');
+                    closeButtonPath.classList.add(adStickyCloseButtonContent);
+                    closeButtonPath.setAttribute('d', 'M7 10l5 5 5-5z');
+                    closeButtonSvg.appendChild(closeButtonPath);
+                    closeButton.appendChild(closeButtonSvg);
+                }
+            }
+            else {
+                closeButton.textContent = closingButtonText;
+            }
+        }
+        closeButton.addEventListener('click', () => {
+            adSticky.addEventListener('transitionend', function () {
+                adSticky.remove();
+                const slot = window.googletag
+                    ?.pubads()
+                    .getSlots()
+                    .find(slot => slot.getSlotElementId() === footerStickyDomId);
+                if (slot) {
+                    window.googletag.destroySlots([slot]);
+                }
+            }, { once: true });
+            hideAdSlot(adSticky);
+        });
+        const onRenderResult = (renderResult) => {
+            log.debug(stickyAd, `result ${renderResult}`);
+            if (renderResult === 'disallowed' || renderResult === 'empty') {
+                log.debug(stickyAd, 'stickyFooter container');
+                hideAdSlot(adSticky);
+                return Promise.resolve();
+            }
+            else if (renderResult === 'standard') {
+                showAdSlot(adSticky);
+                const stickyOnLoadEventPromise = stickyOnLoadEvent(footerStickyDomId, window);
+                return stickyRenderedEvent(footerStickyDomId, disallowedAdvertiserIds, window)
+                    .then(result => result === 'empty' || result === 'disallowed'
+                    ? Promise.resolve(result)
+                    : stickyOnLoadEventPromise.then(() => result))
+                    .then(onRenderResult);
+            }
+            return Promise.resolve();
+        };
+        if (env === 'production') {
+            if (footerStickyDomId) {
+                const stickyOnLoadEventPromise = stickyOnLoadEvent(footerStickyDomId, window);
+                stickyRenderedEvent(footerStickyDomId, disallowedAdvertiserIds, window)
+                    .then(result => result === 'empty' || result === 'disallowed'
+                    ? Promise.resolve(result)
+                    : stickyOnLoadEventPromise.then(() => result))
+                    .then(onRenderResult);
+            }
+            else {
+                log.warn('[sticky-footer-ad]', `Could not find adSticky container ${adStickyContainerDataRef} or closeButton ${adStickyCloseButtonDataRef}`, adSticky, closeButton);
+            }
+        }
+        else {
+            onRenderResult('standard');
+        }
+    }
+    else {
+        log.warn('[sticky-footer-ad]', `Could not find adSticky container ${adStickyContainerDataRef} or closeButton ${adStickyCloseButtonDataRef}`, adSticky, closeButton);
+    }
+};

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

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

package/lib/ads/modules/sticky-header-ad/fadeOutCallback.js

@@ -0,0 +1,25 @@
+export const intersectionObserverFadeOutCallback = (container, target, adRenderResult, navbar, navbarHiddenClass, fadeOutClassName) => entries => {
+    entries.forEach(entry => {
+        if (target && entry.target === target) {
+            adRenderResult.then(result => {
+                if (entry.isIntersecting ||
+                    (!entry.isIntersecting && entry.boundingClientRect.y < 0) ||
+                    result === 'empty' ||
+                    result === 'disallowed') {
+                    container.classList.add(fadeOutClassName);
+                }
+                else if (entry.boundingClientRect.y >= 0 && result === 'standard') {
+                    container.classList.remove(fadeOutClassName);
+                }
+            });
+        }
+        else if (entry.target === navbar && navbarHiddenClass) {
+            if (entry.isIntersecting) {
+                container.classList.remove(navbarHiddenClass);
+            }
+            else {
+                container.classList.add(navbarHiddenClass);
+            }
+        }
+    });
+};

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

@@ -0,0 +1,103 @@
+import { intersectionObserverFadeOutCallback } from './fadeOutCallback';
+import { adRenderResult } from './renderResult';
+import { LOW_PRIORITY, mkConfigureStepOncePerRequestAdsCycle, mkPrepareRequestAdsStep } from 'ad-tag/ads/adPipeline';
+export class StickyHeaderAd {
+    constructor() {
+        this.name = 'sticky-header-ads';
+        this.description = 'sticky header ad creatives';
+        this.moduleType = 'creatives';
+        this.containerSelector = '[data-ref="header-ad"]';
+        this.buttonSelector = '[data-ref="header-ad-close-button"]';
+        this.navbarHiddenClassName = 'h5v-header-ad--navbarHidden';
+        this.observer = null;
+        this.stickyHeaderAdConfig = null;
+    }
+    configure__(moduleConfig) {
+        if (moduleConfig?.stickyHeaderAd?.enabled) {
+            this.stickyHeaderAdConfig = moduleConfig.stickyHeaderAd;
+        }
+    }
+    config__() {
+        return this.stickyHeaderAdConfig;
+    }
+    initSteps__() {
+        return [];
+    }
+    configureSteps__() {
+        const config = this.stickyHeaderAdConfig;
+        return config
+            ? [
+                mkConfigureStepOncePerRequestAdsCycle('sticky-header-ads:cleanup', () => {
+                    if (this.observer) {
+                        this.observer.disconnect();
+                        this.observer = null;
+                    }
+                    return Promise.resolve();
+                })
+            ]
+            : [];
+    }
+    prepareRequestAdsSteps__() {
+        const config = this.stickyHeaderAdConfig;
+        return config
+            ? [
+                mkPrepareRequestAdsStep(this.name, LOW_PRIORITY, (ctx, slots) => {
+                    if (this.observer) {
+                        return Promise.resolve();
+                    }
+                    const headerSlot = slots.find(slot => slot.moliSlot.domId === config.headerAdDomId);
+                    if (!headerSlot) {
+                        return Promise.resolve();
+                    }
+                    const container = ctx.window__.document.querySelector(this.containerSelector);
+                    if (!container) {
+                        ctx.logger__.warn(this.name, `Could not find sticky header container with selector '${this.containerSelector}'`);
+                        return Promise.resolve();
+                    }
+                    const minVisibleDuration = config.minVisibleDurationMs ?? 0;
+                    if (config.fadeOutTrigger !== false) {
+                        const options = config.fadeOutTrigger.options ?? {
+                            rootMargin: '0px'
+                        };
+                        const targets = ctx.window__.document.querySelectorAll(config.fadeOutTrigger.selector);
+                        const target = targets.length > 0 ? targets.item(0) : null;
+                        const navbarConfig = config.navbarConfig;
+                        const navbarHiddenClass = navbarConfig?.navbarHiddenClassName ?? this.navbarHiddenClassName;
+                        const navbar = navbarConfig
+                            ? ctx.window__.document.querySelector(navbarConfig.selector)
+                            : null;
+                        if (target) {
+                            const adRenderResultPromise = adRenderResult(ctx, headerSlot.moliSlot, config.disallowedAdvertiserIds, minVisibleDuration);
+                            this.observer = new IntersectionObserver(intersectionObserverFadeOutCallback(container, target, adRenderResultPromise, navbar, navbarHiddenClass, config.fadeOutClassName), options);
+                            this.observer.observe(target);
+                            if (navbar) {
+                                this.observer.observe(navbar);
+                            }
+                        }
+                        else {
+                            ctx.logger__.error(this.name, `No DOM element found for selector ${config.fadeOutTrigger.selector}. Sticky header may never fade out`);
+                        }
+                    }
+                    const closeButton = ctx.window__.document.querySelector(this.buttonSelector);
+                    if (closeButton) {
+                        closeButton.addEventListener('click', () => {
+                            container.classList.add(config.fadeOutClassName);
+                            if (this.observer) {
+                                this.observer.disconnect();
+                            }
+                            if (ctx.env__ === 'production') {
+                                ctx.window__.googletag.destroySlots([headerSlot.adSlot]);
+                            }
+                            if (config.destroySlot) {
+                                if (container) {
+                                    container.remove();
+                                }
+                            }
+                        });
+                    }
+                    return Promise.resolve();
+                })
+            ]
+            : [];
+    }
+}

package/lib/ads/modules/sticky-header-ad/renderResult.js

@@ -0,0 +1,24 @@
+export const adRenderResult = (ctx, headerSlot, disallowedAdvertiserIds, minVisibleDuration) => new Promise(resolve => {
+    if (ctx.env__ === 'test') {
+        resolve('standard');
+        return;
+    }
+    const listener = event => {
+        if (event.slot.getSlotElementId() !== headerSlot.domId) {
+            return;
+        }
+        if (event.advertiserId && disallowedAdvertiserIds.includes(event.advertiserId)) {
+            resolve('disallowed');
+        }
+        else if (event.isEmpty) {
+            resolve('empty');
+        }
+        else {
+            minVisibleDuration > 0
+                ? ctx.window__.setTimeout(() => resolve('standard'), minVisibleDuration)
+                : resolve('standard');
+        }
+        ctx.window__.googletag.pubads().removeEventListener('slotRenderEnded', listener);
+    };
+    ctx.window__.googletag.pubads().addEventListener('slotRenderEnded', listener);
+});

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

@@ -0,0 +1,79 @@
+import { tcfapi } from 'ad-tag/types/tcfapi';
+import { mkInitStep } from 'ad-tag/ads/adPipeline';
+import { AssetLoadMethod } from 'ad-tag/util/assetLoaderService';
+const requiredPurposeIds = [
+    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,
+    tcfapi.responses.TCPurpose.USE_LIMITED_DATA_TO_SElECT_CONTENT
+];
+export const createUtiq = () => {
+    let utiqConfig = null;
+    let loaded = false;
+    const loadUtiq = (config, context) => {
+        if (context.env__ === 'test') {
+            return Promise.resolve();
+        }
+        if (loaded) {
+            return Promise.resolve();
+        }
+        loaded = true;
+        const utiqWindow = context.window__;
+        utiqWindow.Utiq = utiqWindow.Utiq
+            ? { ...utiqWindow.Utiq, config: { ...utiqWindow.Utiq.config, ...config.options } }
+            : { queue: [], config: config.options };
+        utiqWindow.Utiq.queue = utiqWindow.Utiq.queue || [];
+        if (context.tcData__.gdprApplies &&
+            requiredPurposeIds.some(purposeId => context.tcData__.gdprApplies && !context.tcData__.purpose.consents[purposeId])) {
+            return Promise.resolve();
+        }
+        const minAdRequests = config.delay?.enabled && config.delay.minAdRequests ? config.delay.minAdRequests : 0;
+        if (context.requestAdsCalls__ < minAdRequests) {
+            context.logger__.info('Utiq', `not enough ad requests (${context.requestAdsCalls__}) to load Utiq. ${minAdRequests} required.`);
+            return Promise.resolve();
+        }
+        return context.assetLoaderService__
+            .loadScript({
+            name: 'utiq',
+            loadMethod: AssetLoadMethod.TAG,
+            assetUrl: config.assetUrl
+        })
+            .catch(error => context.logger__.error('failed to load utiq', error));
+    };
+    const hasDelayEnabled = (config) => {
+        return config?.delay?.enabled ?? false;
+    };
+    return {
+        name: 'utiq',
+        description: 'user module',
+        moduleType: 'identity',
+        config__() {
+            return utiqConfig;
+        },
+        configure__(moduleConfig) {
+            if (moduleConfig?.utiq && moduleConfig.utiq.enabled) {
+                utiqConfig = moduleConfig.utiq;
+            }
+        },
+        initSteps__() {
+            return utiqConfig?.enabled && !hasDelayEnabled(utiqConfig)
+                ? [mkInitStep('utiq', ctx => loadUtiq(utiqConfig, ctx))]
+                : [];
+        },
+        configureSteps__() {
+            return utiqConfig?.enabled && hasDelayEnabled(utiqConfig)
+                ? [mkInitStep('utiq', ctx => loadUtiq(utiqConfig, ctx))]
+                : [];
+        },
+        prepareRequestAdsSteps__() {
+            return [];
+        }
+    };
+};

package/lib/ads/modules/yield-optimization/dynamicFloorPrice.js

@@ -0,0 +1,86 @@
+const previousMaxCpm = (cpms) => {
+    if (cpms.length === 0) {
+        return null;
+    }
+    else {
+        const maxBid = Math.max(...cpms);
+        return Math.round(maxBid * 100);
+    }
+};
+const previousMinCpm = (cpms) => {
+    if (cpms.length === 0) {
+        return null;
+    }
+    else {
+        const minBid = Math.min(...cpms);
+        return Math.round(minBid * 100);
+    }
+};
+const previousSecondHighestCpm = (cpms) => {
+    if (!cpms || cpms.length === 0) {
+        return null;
+    }
+    else if (cpms.length === 1) {
+        return Math.round(cpms[0] * 100);
+    }
+    else {
+        const secondHighestBid = cpms.sort()[cpms.length - 2];
+        return Math.round(secondHighestBid * 100);
+    }
+};
+const calculateDynamicFloorPrice = (strategy, previousCpms) => {
+    switch (strategy) {
+        case 'max':
+            return previousMaxCpm(previousCpms);
+        case 'min':
+            return previousMinCpm(previousCpms);
+        case 'second-highest':
+            return previousSecondHighestCpm(previousCpms);
+        default:
+            return null;
+    }
+};
+const roundDownToInteger = (num) => {
+    return Math.floor(num);
+};
+const roundDownPrice = (args) => {
+    const priceInCents = roundDownToInteger(args.priceInCents);
+    const roundingStepsInCents = roundDownToInteger(args.roundingStepsInCents);
+    const maxPriceRuleInCents = args.maxPriceRuleInCents !== undefined
+        ? roundDownToInteger(args.maxPriceRuleInCents)
+        : undefined;
+    const minPriceRuleInCents = args.minPriceRuleInCents !== undefined
+        ? roundDownToInteger(args.minPriceRuleInCents)
+        : undefined;
+    const roundedPriceInCents = Math.floor(priceInCents / roundingStepsInCents) * roundingStepsInCents;
+    if (maxPriceRuleInCents !== undefined && roundedPriceInCents > maxPriceRuleInCents) {
+        return maxPriceRuleInCents;
+    }
+    if (minPriceRuleInCents !== undefined && roundedPriceInCents < minPriceRuleInCents) {
+        return minPriceRuleInCents;
+    }
+    return roundedPriceInCents;
+};
+export const calculateDynamicPriceRule = ({ strategy, previousCpms, standardRule, roundingStepsInCents = 5, maxPriceRuleInCents = 500, minPriceRuleInCents = 5 }) => {
+    const validPreviousCpms = Array.isArray(previousCpms)
+        ? previousCpms?.filter(cpm => cpm > 0 && !isNaN(cpm))
+        : [];
+    if (!validPreviousCpms || validPreviousCpms.length === 0 || !strategy) {
+        return standardRule;
+    }
+    const calculatedFloorPrice = calculateDynamicFloorPrice(strategy, validPreviousCpms);
+    if (calculatedFloorPrice === null) {
+        return standardRule;
+    }
+    const roundedPriceRuleIdInCents = roundDownPrice({
+        priceInCents: calculatedFloorPrice,
+        roundingStepsInCents,
+        maxPriceRuleInCents,
+        minPriceRuleInCents
+    });
+    return {
+        ...standardRule,
+        floorprice: roundedPriceRuleIdInCents / 100,
+        priceRuleId: roundedPriceRuleIdInCents
+    };
+};

package/lib/ads/modules/yield-optimization/index.js

@@ -0,0 +1,57 @@
+import { createYieldOptimizationService } from './yieldOptimizationService';
+import { HIGH_PRIORITY, mkInitStep, mkPrepareRequestAdsStep } from 'ad-tag/ads/adPipeline';
+import { uniquePrimitiveFilter } from 'ad-tag/util/arrayUtils';
+export const YieldOptimization = (testYieldOptimizationService) => {
+    const name = 'YieldOptimization';
+    const description = 'Provides floors and UPR ids';
+    const moduleType = 'yield';
+    let yieldModuleConfig = null;
+    const _initSteps = [];
+    const _prepareRequestAdsSteps = [];
+    const config__ = () => yieldModuleConfig;
+    const configure__ = (moduleConfig) => {
+        if (moduleConfig?.yieldOptimization?.enabled) {
+            yieldModuleConfig = moduleConfig.yieldOptimization;
+            const yieldOptimizationService = testYieldOptimizationService ??
+                createYieldOptimizationService(moduleConfig.yieldOptimization);
+            _initSteps.push(yieldOptimizationInit(yieldOptimizationService));
+            _prepareRequestAdsSteps.push(yieldOptimizationPrepareRequestAds(yieldOptimizationService));
+        }
+    };
+    const initSteps__ = () => _initSteps;
+    const configureSteps__ = () => [];
+    const prepareRequestAdsSteps__ = () => _prepareRequestAdsSteps;
+    const yieldOptimizationInit = (yieldOptimizationService) => mkInitStep('yield-optimization-init', context => {
+        const adUnitPaths = context.config__.slots
+            .filter(slot => context.labelConfigService__.filterSlot(slot))
+            .map(slot => slot.adUnitPath)
+            .filter(uniquePrimitiveFilter);
+        return yieldOptimizationService.init(context.labelConfigService__.getDeviceLabel(), context.adUnitPathVariables__, adUnitPaths, context.window__.fetch, context.logger__);
+    });
+    const yieldOptimizationPrepareRequestAds = (yieldOptimizationService) => mkPrepareRequestAdsStep('yield-optimization', HIGH_PRIORITY, (context, slots) => {
+        context.logger__.debug('YieldOptimizationService', context.requestId__, 'applying price rules');
+        const adServer = context.config__.adServer || 'gam';
+        const slotsWithPriceRule = slots.map(slot => {
+            return yieldOptimizationService
+                .setTargeting(slot.adSlot, adServer, context.logger__, yieldModuleConfig, context.auction__)
+                .then(priceRule => (slot.priceRule = priceRule));
+        });
+        return Promise.all(slotsWithPriceRule)
+            .then(() => yieldOptimizationService.getBrowser())
+            .then(browser => {
+            if (context.env__ === 'production' && adServer === 'gam') {
+                context.window__.googletag.pubads().setTargeting('upr_browser', browser);
+            }
+        });
+    });
+    return {
+        name,
+        description,
+        moduleType,
+        config__,
+        configure__,
+        initSteps__,
+        configureSteps__,
+        prepareRequestAdsSteps__
+    };
+};

package/lib/ads/modules/yield-optimization/isYieldOptimizationConfigDynamic.js

@@ -0,0 +1,6 @@
+export const isYieldConfigDynamic = (config) => {
+    return config
+        ? config.dynamicFloorPrices
+            ?.strategy !== undefined
+        : false;
+};